Statistik.cpp

Go to the documentation of this file.

// Statistik.cpp: Implementierung der Klasse Statistik.
//

#include <stdlib.h>


 namespace nCenterFocus
{
        

long64 incrementLong64(long64 i)
{
        return ++i;
}

template <bool safe>
Statistic<safe>::Statistic(     int maxExpectedNumOfVanishedFocalValuesToLog, 
                                        int startAt
                                        )
                                                :       startAt_m       ( startAt ),
                                                        arrayLength     ( maxExpectedNumOfVanishedFocalValuesToLog      +1),
                                                        values ( new long64[maxExpectedNumOfVanishedFocalValuesToLog + 1] )
{
        assert(startAt<=3 && startAt>=0 && startAt<arrayLength);
        assert(maxExpectedNumOfVanishedFocalValuesToLog>=0);
        clear();
}


template <bool safe>
Statistic<safe>::Statistic(const Statistic & st): 
                                                                startAt_m       ( st.startAt_m   ), 
                                                                arrayLength     ( st.arrayLength ),
                                                                values  ( new long64[arrayLength] )
{
        //clear();

        std::copy(      &(st.values[0] ),       & ( st.values[ arrayLength ] ),
                                values);

}


template <bool safe>
inline  void    Statistic<safe>::testbounds(int maxbound)       const
{
        if (safe)
                assert( maxbound<arrayLength && maxbound>=0);
}


template <bool safe>
Statistic<safe> &        Statistic<safe>::operator=(const Statistic & st)
{
        if ( this!=&st )
        {
                assert(&st!=NULL);

                arrayLength      = st.arrayLength;
                startAt_m = st.startAt_m;        
                
                if (values!=NULL) delete[] values;

                values = new long64[arrayLength];

                std::copy(      &(st.values[0] ),       & ( st.values[ arrayLength ] ),
                                values
                );

        }
        return *this;
}


template <bool safe>
void Statistic<safe>::clear()
{
                std::fill(      &(values[0] ),
                                & ( values[ arrayLength ] ),
                                0 
                        );
}

template <bool safe>
inline long64 & Statistic<safe>::getStatisticEntryRef(int index)
{
        if (safe)
                testbounds(index);
        return values[index];
}

template <bool safe>
inline  long64  Statistic<safe>::getStatisticEntry(int index)   const
{
        if (safe)
                testbounds(index);
        return values[index];
}



template <bool safe>
long64 Statistic<safe>::getTrialCountWithGivenNumOfFirstSuccessiveVanishedFocalValues(int FirstSuccessiveVanishedFocalValues)
{
        return getStatisticEntry(FirstSuccessiveVanishedFocalValues);           
}

template <bool safe>
void Statistic<safe>::addStatistic(int successiveStrudelZeroCount)
{
        for (int currentFocalValueIndex = startAt_m; currentFocalValueIndex<= successiveStrudelZeroCount; currentFocalValueIndex++)
                getStatisticEntryRef(currentFocalValueIndex) ++;

        // alternative:
        // if (safe)            testbounds(successiveStrudelZeroCount);
        //std::transform( &values[startAt], &values[ successiveStrudelZeroCount+1 ], incrementLong64 );
}

template <bool safe>
void Statistic<safe>::addFormula1Try(int characteristic)
{        
        if (safe)       
                assert(startAt_m==1);
        
        getStatisticEntryRef(0) += characteristic;
}

template <bool safe>
void Statistic<safe>::addFormula1And2Try(int characteristic)
{       
        if (safe)       
                assert(startAt_m==2);
        
        getStatisticEntryRef(0) += characteristic*characteristic;
        getStatisticEntryRef(1) += characteristic;
}


template <bool safe>
void Statistic<safe>::addFormula1And23Try(int characteristic)
{       
        if (safe)
                assert(startAt_m==3);

        getStatisticEntryRef(0) += characteristic*characteristic*characteristic;
        getStatisticEntryRef(1) += characteristic*characteristic;
}


template <bool safe>
void Statistic<safe>::correctSecondFocalValueStatistic(int vanishedTrials)
{       
        if (safe)
                assert(startAt_m==3);

        this->getStatisticEntryRef(2) += vanishedTrials;
}

 

template <bool safe>
long64  Statistic<safe>::getTrialCount()
{
        return getStatisticEntry(0);
}

template <bool safe>
int  Statistic<safe>::getMaxLoggedSuccessiveVanishedFocalValues()
{
        return arrayLength-1;
}

template <bool safe>
void Statistic<safe>::correctHamiltonComponentStatistic(int focalValueNum, int hamiltonianPointCount    )
{
        assert(getMaxLoggedSuccessiveVanishedFocalValues() >=focalValueNum && focalValueNum>=0);
        for (int currFocalValueNum=0;currFocalValueNum<arrayLength;currFocalValueNum++)
                getStatisticEntryRef(currFocalValueNum) = hamiltonianPointCount;
}


template <bool safe>
void Statistic<safe>::correctNonHamiltonComponentStatistic(int focalValueNum, int vanishedFocalValuesToSubtract )
{
        assert(getMaxLoggedSuccessiveVanishedFocalValues() >=focalValueNum);
        for (int currFocalValueNum=0;currFocalValueNum<focalValueNum;currFocalValueNum++)
                getStatisticEntryRef(currFocalValueNum)-=vanishedFocalValuesToSubtract;
}


template <bool safe>
void Statistic<safe>::print(ostream& o)
{
        o << "Statistic = { ";

        o << this->getTrialCount();

        for (int currentFocalValueIndex=1; currentFocalValueIndex<= getMaxLoggedSuccessiveVanishedFocalValues(); currentFocalValueIndex++)
        {
                o << ", ";
                o << this->getTrialCountWithGivenNumOfFirstSuccessiveVanishedFocalValues(currentFocalValueIndex);
        }
                
        o << " }; -- first number: trial count; i.th number: count of trials where the first i focal values vanished " << std::endl;
}

template <bool safe>
Statistic<safe>::~Statistic()
{
        delete[] values;
}


};