ajamovingavg.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#ifndef AJA_MOVINGAVG_H
#define AJA_MOVINGAVG_H

//#include "ajabase/common/public.h"
#include "ajabase/system/lock.h"
#include <climits>
#include <cfloat>
#include <deque>
#include <ostream>
#include <typeinfo>
#if defined(AJA_WINDOWS)
    #pragma warning(disable:4056)
#endif


template <typename T> class AJAMovingAvg
{
    public:
        static const size_t kDefaultMaxNumSamples = 10;

    public:
        inline explicit         AJAMovingAvg (const size_t inMaxNumSamples = kDefaultMaxNumSamples)
        {
            reset(inMaxNumSamples);
        }

        inline void             addSample (const T inValue)
        {   AJAAutoLock tmp(&mLock);
            mValues.push_front(inValue);
            if (mValues.size() > mSampleCapacity)
                mValues.pop_back();
            mTotNumSamples++;
            if (inValue < mMinValue)
                mMinValue = inValue;
            if (inValue > mMaxValue)
                mMaxValue = inValue;
        }

        inline void             reset (const size_t inMaxNumSamples = kDefaultMaxNumSamples)
        {   AJAAutoLock tmp(&mLock);
            mValues.clear();
            mSampleCapacity = inMaxNumSamples;
            mTotNumSamples = 0;
            mMinValue = largestPossibleValue();
            mMaxValue = smallestPossibleValue();
        }

        inline size_t           numStoredSamples (void) const   {AJAAutoLock tmp(&mLock);  return mValues.size();}

        inline size_t           sampleCapacity (void) const     {AJAAutoLock tmp(&mLock);  return mSampleCapacity;}

        inline size_t           totalSamples (void) const       {AJAAutoLock tmp(&mLock);  return mTotNumSamples;}

        inline bool             isValid (void) const            {AJAAutoLock tmp(&mLock);  return totalSamples() > 0;}

        inline bool             isEmpty (void) const            {AJAAutoLock tmp(&mLock);  return mValues.empty();}

        inline bool             isFilled (void) const           {AJAAutoLock tmp(&mLock);  return totalSamples() >= sampleCapacity();}

        inline T                average (void) const
        {   AJAAutoLock tmp(&mLock);
            if (isEmpty())
                return 0;
            return sum() / T(numStoredSamples());
        }

        inline double           averageF (void) const
        {   AJAAutoLock tmp(&mLock);
            if (isEmpty())
                return 0.0;
            return double(sum()) / double(numStoredSamples());
        }

        inline T                minimum (void) const            {AJAAutoLock tmp(&mLock);  return mMinValue;}

        inline T                recentMinimum (void) const
        {
            T result(largestPossibleValue());
            AJAAutoLock tmp(&mLock);
            for (auto it(mValues.begin());  it != mValues.end();  ++it)
                if (*it < result)
                    result = *it;
            return result;
        }

        inline T                maximum (void) const            {AJAAutoLock tmp(&mLock);  return mMaxValue;}

        inline T                recentMaximum (void) const
        {
            T result(smallestPossibleValue());
            AJAAutoLock tmp(&mLock);
            for (auto it(mValues.begin());  it != mValues.end();  ++it)
                if (*it > result)
                    result = *it;
            return result;
        }

        inline std::ostream &   Print (std::ostream & oss, const bool inDetailed = false) const
        {
            AJAAutoLock tmp(&mLock);
            if (isValid())
            {
                if (inDetailed)
                    oss << averageF() << " (avg) for last " << numStoredSamples() << " of " << totalSamples() << " samples" << std::endl
                        << recentMinimum() << " (min), " << recentMaximum() << " (max)";
                else oss << averageF();
            }
            else oss << "n/a";
            return oss;
        }

    protected:
        inline T    sum (void) const
        {
            AJAAutoLock tmp(&mLock);
            if (isEmpty())
                return T(0);
            T result = T(0);
            for (auto it(mValues.begin());  it != mValues.end();  ++it)
                result += *it;
            return result;
        }

        static inline T smallestPossibleValue (void)
        {
            if (typeid(T) == typeid(char))
                return SCHAR_MIN;
            else if (typeid(T) == typeid(int8_t))
                return SCHAR_MIN;
            else if (typeid(T) == typeid(uint8_t))
                return 0;
            else if (typeid(T) == typeid(int16_t))
                return T(SHRT_MIN);
            else if (typeid(T) == typeid(uint16_t))
                return 0;
            else if (typeid(T) == typeid(int))
                return T(INT_MIN);
            else if (typeid(T) == typeid(int32_t))
                return T(LONG_MIN);
            else if (typeid(T) == typeid(uint32_t))
                return 0;
            else if (typeid(T) == typeid(int64_t))
                return T(LLONG_MIN);
            else if (typeid(T) == typeid(uint64_t))
                return 0;
            else if (typeid(T) == typeid(float))
                return T(-FLT_MAX);
            else if (typeid(T) == typeid(double))
                return T(-DBL_MAX);
            else if (typeid(T) == typeid(long double))
                return T(-LDBL_MAX);
            return 0;
        }

        static inline T largestPossibleValue (void)
        {
            if (typeid(T) == typeid(char))
                return SCHAR_MAX;
            else if (typeid(T) == typeid(int8_t))
                return SCHAR_MAX;
            else if (typeid(T) == typeid(uint8_t))
                return T(UCHAR_MAX);
            else if (typeid(T) == typeid(int16_t))
                return T(SHRT_MAX);
            else if (typeid(T) == typeid(uint16_t))
                return T(0xFFFF);
            else if (typeid(T) == typeid(int))
                return T(INT_MAX);
            else if (typeid(T) == typeid(int32_t))
                return T(LONG_MAX);
            else if (typeid(T) == typeid(uint32_t))
                return T(0xFFFFFFFF);
            else if (typeid(T) == typeid(int64_t))
                return T(LLONG_MAX);
            else if (typeid(T) == typeid(uint64_t))
                return T(0xFFFFFFFFFFFFFFFF);
            else if (typeid(T) == typeid(float))
                return T(FLT_MAX);
            else if (typeid(T) == typeid(double))
                return T(DBL_MAX);
            else if (typeid(T) == typeid(long double))
                return T(LDBL_MAX);
            return 0;
        }

    private:
        mutable AJALock mLock;
        std::deque<T>   mValues;            
        size_t          mSampleCapacity;    
        size_t          mTotNumSamples;     
        T               mMinValue;          
        T               mMaxValue;          

};  //  AJAMovingAvg


template <typename T> inline std::ostream & operator << (std::ostream & oss,  const AJAMovingAvg<T> & inAvg)
{
    inAvg.Print(oss,true);
    return oss;
}

#endif  //  AJA_MOVINGAVG_H