cValueStats.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cValueStats_H
#define _INC_cValueStats_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cValueRange.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cTimeSys.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cValueStats);
 
        template<typename TYPE = double >
        class GRAYLIB_LINK cValueStats : public cValueRange<TYPE>
        {
 
                typedef cValueRange<TYPE> SUPER_t;
 
        protected:
                const UINT m_uSamplesMax;       
                UINT m_uSamplesQty;                     
                TYPE m_nValAvg;                         
 
        protected:
                void AddStatW(TYPE nVal, TYPE nWeight)
                {
                        if (nWeight >= ((TYPE)1))
                        {
                                m_nValAvg = SUPER_t::m_Lo = SUPER_t::m_Hi = nVal; // InitX()
                        }
                        else
                        {
                                m_nValAvg = (m_nValAvg * (((TYPE)1) - nWeight)) + (nVal * nWeight);
                        }
                }
 
        public:
                cValueStats(TYPE nValAvgStartingEst = 0, UINT uSamplesMax = 100)
                        : cValueRange<TYPE>(nValAvgStartingEst, nValAvgStartingEst)
                        , m_uSamplesMax(uSamplesMax)
                        , m_uSamplesQty(0)
                        , m_nValAvg(nValAvgStartingEst)
                {
                }
 
                TYPE get_ValAvg() const
                {
                        return m_nValAvg;
                }
                void put_ValAvg(TYPE nValAvg)
                {
                        m_nValAvg = nValAvg;
                }
 
                void AddStat(TYPE nVal)
                {
                        if (m_uSamplesQty < m_uSamplesMax)
                        {
                                m_uSamplesQty++;
                        }
                        AddStatW(nVal, ((TYPE)1) / (TYPE)(m_uSamplesQty));
                        this->UnionValue(nVal); // adjust min/max as well
                }
        };
 
        template<typename TYPE = double >
        class GRAYLIB_LINK cValueStatsRate : public cValueStats<TYPE>
        {
 
                typedef cValueStats<TYPE> SUPER_t;
 
        private:
                cTimeSys m_tLast;       
                TYPE m_nLastVal;        
 
        public:
                cValueStatsRate(TYPE nValAvgEst = 0, UINT uSamplesMax = cTimeSys::k_FREQ)       
                        : cValueStats<TYPE>(nValAvgEst, uSamplesMax * cTimeSys::k_FREQ)
                        , m_nLastVal(0)
                {
                        ASSERT(uSamplesMax > 0);
                }
 
                void ResetStatsTime()
                {
                        m_tLast.InitTime();
                        this->m_uSamplesQty = 0;
                }
                bool AddStat(TYPE nVal)
                {
                        cTimeSys tNow = cTimeSys::GetTimeNow();
                        if (m_tLast.isTimeValid()) // first value is useless?
                        {
                                TIMESYSD_t tDiff = tNow.get_TimeSys() - m_tLast.get_TimeSys();
                                if (tDiff <= 0) // 2 values at the same time make no sense.
                                        return false;
                                if (this->m_uSamplesQty < this->m_uSamplesMax)
                                {
                                        this->m_uSamplesQty += tDiff;
                                }
                                else
                                {
                                        // I didn't get a sample for too long!
                                        // Make this value represent the entire time period.
                                        this->m_uSamplesQty = this->m_uSamplesMax;
                                }
                                SUPER_t::AddStatW(nVal, (TYPE)(tDiff) / (TYPE)(this->m_uSamplesQty));
                        }
                        else
                        {
                                this->m_nValAvg = nVal; // First value is only useful like this.
                        }
                        m_tLast = tNow;
                        this->UnionValue(nVal); // min/max should be for the m_nValAvg??
                        return true;
                }
                bool AddStatDiff(TYPE nVal)
                {
                        if (!AddStat(m_tLast.isTimeValid() ? (nVal - m_nLastVal) : 0))
                                return false;
                        m_nLastVal = nVal;
                        return true;
                }
                bool AddStatDiffX(TYPE nVal)
                {
                        if (nVal < m_nLastVal)
                        {
                                m_nLastVal = 0;
                        }
                        return AddStatDiff(nVal);
                }
                UNITTEST2_PREDEF(cValueStats);
        };
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        template class GRAYLIB_LINK cValueStats<float>;
        template class GRAYLIB_LINK cValueStats<double>;
        template class GRAYLIB_LINK cValueStatsRate<double>;
#endif
 
};
#endif // _INC_cValueStats_H