|| || || || || || || ||

---

Statistics.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Statistics_h
#define Impala_Core_Array_Statistics_h

#include <list>
#include <vector>
#include "Core/Array/Arrays.h"
#include "Core/Array/Set.h"
#include "Core/Array/SetVal.h"
#include "Core/Array/Add.h"
#include "Core/Array/Mul.h"
#include "Core/Array/Abs.h"
#include "Core/Array/Minimum.h"
#include "Core/Array/Maximum.h"
#include "Core/Array/Sub.h"
#include "Core/Array/DivVal.h"
#include "Core/Array/Sqrt.h"
#include "Core/Array/PixStat.h"

namespace Impala
{
namespace Core
{
namespace Array
{


template<class ArrayT>
class Statistics
{
public:

    Statistics(int maxNrSamples = 50, bool running = false)
    {
        mMaxNrSamples = maxNrSamples;
        mRunning = running;

        mDoneInit = false;
        mNum = 0;
        mMinVal = 0;
        mMaxVal = 0;
        mSum = 0;
        mSumSqr = 0;
        mSumAbs = 0;
        mTmp = 0;

        mStatValid = false;
        mMean = 0;
        mVariance = 0;

        mStDevValid = false;
        mStDev = 0;
    }

    ~Statistics()
    {
        if (mMinVal)
        {
            delete mMinVal;
            delete mMaxVal;
            delete mSum;
            delete mSumSqr;
            delete mSumAbs;
            delete mTmp;
        }
        if (mMean)
        {
            delete mMean;
            delete mVariance;
        }
        if (mStDev)
            delete mStDev;
        for (int i=0 ; i<mRunList.size() ; i++)
            delete mRunList[i];
    }

    bool
    IsDoingStat()
    {
        return mNum < mMaxNrSamples;
    }

    void
    DoArray(ArrayT* a)
    {
        if (mRunning)
        {
            ArrayT* newA = 0;
            Set(newA, a);
            if (mNum >= mMaxNrSamples)
            {
                delete mRunList[0];
                mRunList.erase(mRunList.begin());
            }
            else
            {
                mNum++;
            }
            mRunList.push_back(newA);
            mStatValid = false;
            mStDevValid = false;
        }
        else
        {
            if (mNum >= mMaxNrSamples)
                return;
            mStatValid = false;
            mStDevValid = false;
            if (!mDoneInit)
            {
                InitNotRunning(a);
                return;
            }
            mNum++;
            Minimum(mMinVal, mMinVal, a);
            Maximum(mMaxVal, mMaxVal, a);
            Add(mSum, mSum, a);
            Mul(mTmp, a, a);
            Add(mSumSqr, mSumSqr, mTmp);
            Abs(mTmp, a);
            Add(mSumAbs, mSumAbs, mTmp);
        }
    }

    ArrayT*
    GetMinimum()
    {
        if (mRunning)
        {
            Set(mMinVal, mRunList[0]);
            for (int i=1 ; i<mRunList.size() ; i++)
                Minimum(mMinVal, mMinVal, mRunList[i]);
        }
        return mMinVal;
    }

    ArrayT*
    GetMaximum()
    {
        if (mRunning)
        {
            Set(mMaxVal, mRunList[0]);
            for (int i=1 ; i<mRunList.size() ; i++)
                Maximum(mMaxVal, mMaxVal, mRunList[i]);
        }
        return mMaxVal;
    }

    ArrayT*
    GetMean()
    {
        CheckStatValid();
        return mMean;
    }

    ArrayT*
    GetVariance()
    {
        CheckStatValid();
        return mVariance;
    }

    ArrayT*
    GetStDev()
    {
        CheckStDevValid();
        return mStDev;
    }

    void
    Reset()
    {
        mDoneInit = false;
        mStatValid = false;
        mStDevValid = false;
        mNum = 0;
        for (int i=0 ; i<mRunList.size() ; i++)
            delete mRunList[i];
        mRunList.clear();
    }

private:

    void
    InitNotRunning(ArrayT* a)
    {
        mNum = 1;
        Set(mMinVal, a);
        Set(mMaxVal, a);
        Set(mSum, a);
        Mul(mSumSqr, a, a);
        Abs(mSumAbs, a);
        Set(mTmp, a);
        mDoneInit = true;
    }

    void
    CheckStatValid()
    {
        if (mStatValid)
            return;

        typedef typename ArrayT::ArithType ArithT;
        ArithT num = Element::E1Cast(mNum, ArithT());
        ArithT num1 = num - Element::E1Cast(1, ArithT());
        if (mRunning)
        {
            Set(mSum, mRunList[0]);
            Mul(mSumSqr, mSum, mSum);
            Abs(mSumAbs, mSum);
            if (mTmp == 0)
                Set(mTmp, mSum);
            for (int i=1 ; i<mRunList.size() ; i++)
            {
                Add(mSum, mSum, mRunList[i]);
                Mul(mTmp, mRunList[i], mRunList[i]);
                Add(mSumSqr, mSumSqr, mTmp);
                Abs(mTmp, mRunList[i]);
                Add(mSumAbs, mSumAbs, mTmp);
            }
        }
        DivVal(mMean, mSum, num);
        if (mNum == 1)
            SetVal(mVariance, mTmp, Element::E1Cast(0, ArithT()));
        else
        {
            Mul(mTmp, mSum, mSum);
            DivVal(mTmp, mTmp, num);
            Sub(mTmp, mSumSqr, mTmp);
            DivVal(mVariance, mTmp, num1);
        }
        mStatValid = true;
    }

    void
    CheckStDevValid()
    {
        if (mStDevValid)
            return;

        CheckStatValid();
        Sqrt(mStDev, mVariance);
        mStDevValid = true;

        //double meanV;
        //PixStat<Array2dScalarReal64,double>(mStDev, 0, 0, &meanV, 0);
        //std::cout << "mean of stdev : " << meanV << std::endl;
    }

    int     mMaxNrSamples;
    bool    mRunning;

    bool    mDoneInit;
    int     mNum;
    ArrayT* mMinVal;
    ArrayT* mMaxVal;
    ArrayT* mSum;
    ArrayT* mSumSqr;
    ArrayT* mSumAbs;
    ArrayT* mTmp;

    bool    mStatValid;
    ArrayT* mMean;
    ArrayT* mVariance;

    bool    mStDevValid;
    ArrayT* mStDev;

    std::vector<ArrayT*> mRunList;

};

} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---