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

---

Histogram1dTem.h

Go to the documentation of this file.

#ifndef Impala_Core_Histogram_Histogram1dTem_h
#define Impala_Core_Histogram_Histogram1dTem_h

#include <iostream>
#include "Core/Vector/VectorTem.h"
#include "Core/Array/Element/ArithTypes.h"

namespace Impala
{
namespace Core
{
namespace Histogram
{

template <class ElemT>
class Histogram1dTem : public Vector::VectorTem<ElemT>
{
public:

    Histogram1dTem(ElemT low, ElemT high, int binCount, ElemT* outliers)
        : Vector::VectorTem<ElemT>(binCount)
    {
        mBinCount = binCount;
        SetRange(low, high);
        Vector::VectorTem<ElemT>::operator=(0);
        mOutliers = (outliers) ? outliers : &mLocalOutliers;
    }

    Histogram1dTem(ElemT low, ElemT high, int binCount, ElemT* outliers,
                   ElemT* data)
        : Vector::VectorTem<ElemT>(binCount, data, true)
    {
        mBinCount = binCount;
        SetRange(low, high);
        mOutliers = (outliers) ? outliers : &mLocalOutliers;
    }

    virtual ~Histogram1dTem()
    {
    }

    ElemT
    GetLow()
    {
        return mLow;
    }

    ElemT
    GetHigh()
    {
        return mHigh;
    }

    int
    GetBinCount()
    {
        return mBinCount;
    }

    void
    GetBinRange(int bin, ElemT& low, ElemT& high)
    {
        low = mLow + bin*mBinWidth;
        high = mLow + (bin+1)*mBinWidth;
    }

    void
    SetRange(ElemT low, ElemT high)
    {
        mLow = low;
        mHigh = high;
        mBinWidth = (high-low) / ((ElemT) mBinCount);
    }

    void
    Clear()
    {
        Vector::VectorTem<ElemT>::operator=(0);
        *mOutliers = 0;           
    }

    void
    AddWeight(ElemT value, double weight = 1.)
    {
        Vector::VectorTem<ElemT>::Elem(ValueToBin(value)) += weight;
    }

    void
    AddWeightSafe(ElemT value, double weight = 1.)
    {
        int index = ValueToBin(value);
        if (index<0 || index>=this->Size())
        {
            *mOutliers += weight;
        }
        else
            this->Elem(index) += weight;
    }

    ElemT
    GetWeight(ElemT value)
    {
        return Vector::VectorTem<ElemT>::Elem(ValueToBin(value));
    }

    ElemT
    TotalWeight() const
    {
        ElemT sum = 0;
        for(int i=0 ; i<this->Size() ; i++)
            sum += this->Elem(i);
        return sum;
    }

    void
    Normalize()
    {
        ElemT tot = TotalWeight();
        /* fix for NaN when normalizing an empty histogram */
        if(abs(tot) < 0.0000001) tot = 1;
        for(int i=0 ; i<this->Size() ; i++)
            this->Elem(i) /= tot;
            
        if(*mOutliers != 0){
                *mOutliers = *mOutliers / tot;
        }
    }
    
    void
    MakeCumulative()
    {
        for(int i = 1; i < this->Size(); i++)
            this->Elem(i) += this->Elem(i-1);
    }

    int
    ValueToBin(ElemT value)
    {
        return (int)((value-mLow) / mBinWidth);
    }

    Impala::Real64
    OutlierPercentage()
    {
        if (*mOutliers == 0)
            return 0;
        ElemT sum = TotalWeight() + *mOutliers;
        return ((Impala::Real64) *mOutliers) / ((Impala::Real64) sum) * 100;
    }

    void
    Dump(bool doData)
    {
        std::cout << "hist range [" << mLow << "," << mHigh << "] with "
                  << mBinCount << " bins. Values: " << std::endl;
        if (doData)
            for (int i=0 ; i<mBinCount ; i++)
                std::cout << "h[" << i << "] = " << this->Elem(i) << std::endl;
        std::cout << "Total weight: " << TotalWeight() << ", outlier %: "
                  << OutlierPercentage() << std::endl;
        std::cout << std::endl;
    }

private:

    ElemT  mLow;
    ElemT  mHigh;
    ElemT  mBinWidth;
    int    mBinCount;
    ElemT* mOutliers;
    ElemT  mLocalOutliers;

};

} // namespace Histogram
} // namespace Core
} // namespace Impala

#endif

---