RangStatistik.cpp

Go to the documentation of this file.

// RangStatistik.cpp: Implementierung der Klasse RangStatistik.
//

#include "RangStatistik.h"
#include <stdlib.h>
#include <assert.h>
#include <sstream>
// Konstruktion/Destruktion

namespace nCenterFocus
{


std::string     getMacaulayCompilantObjectName(const std::string &strref)       
{
        std::stringstream testame(strref);
        std::string macaulayCompilantName;
        std::string tmp;
        while (testame >> tmp >> std::ws)
        {
                macaulayCompilantName += tmp;
        }

        if (macaulayCompilantName.length()==0)
                macaulayCompilantName=std::string("fullOrSubRankStatistic");
        assert( macaulayCompilantName.length()>0); 
        return macaulayCompilantName;
}

        

 

const std::string       BaseRankStatistic::fullRankStatisticString("fullRankStatistic");
const std::string       BaseRankStatistic::subRankStatisticString("subRankStatistic");


BaseRankStatistic::BaseRankStatistic(   std::string name,
                                                        int _requestedMinSuccessiveVanishedFocalValues,
                                                        int _maxFocalValuesToCompute,
                                                        int _maxRank
                                                ):
                                                        name_m(name), 
                                                        maxRank(_maxRank), 
                                                        maxFocalValuesToCompute(_maxFocalValuesToCompute), 
                                                        minSuccessiveZeroFocalValues(_requestedMinSuccessiveVanishedFocalValues),
                                                        exactVanishedFocalValuesStatistic_m(new long64[_maxFocalValuesToCompute+1] )
{

        assert(_requestedMinSuccessiveVanishedFocalValues>=0 && _maxFocalValuesToCompute>=0 && _maxRank>=0 );
        init(); 
}


BaseRankStatistic::BaseRankStatistic(const BaseRankStatistic& ref
                                                ):      name_m( ref.name_m ),
                                                        maxRank( ref.maxRank ), 
                                                        maxFocalValuesToCompute( ref.maxFocalValuesToCompute ), 
                                                        minSuccessiveZeroFocalValues( ref.minSuccessiveZeroFocalValues ),
                                                        exactVanishedFocalValuesStatistic_m( new long64[ref.maxFocalValuesToCompute+1] )
{
        init();

        std::copy(      &       (ref.exactVanishedFocalValuesStatistic_m[0]),
                        &       (ref.exactVanishedFocalValuesStatistic_m[ maxFocalValuesToCompute +1]),
                                exactVanishedFocalValuesStatistic_m
                );


                std::copy(      &(ref.jacobianRankCounters_m[0]),
                                &(ref.jacobianRankCounters_m[arrayLength+1]),
                                jacobianRankCounters_m
                );

}




BaseRankStatistic&      BaseRankStatistic::operator=(const BaseRankStatistic& ref) 
{
        if (&ref != this)
        {
                delete[] jacobianRankCounters_m;
                delete[] exactVanishedFocalValuesStatistic_m;
                
                name_m  = ref.name_m;
                maxRank = ref.maxRank; 

                maxFocalValuesToCompute         = ref.maxFocalValuesToCompute;
                minSuccessiveZeroFocalValues    = ref.minSuccessiveZeroFocalValues;
        
                exactVanishedFocalValuesStatistic_m= new long64[maxFocalValuesToCompute+1];
                init();

                std::copy(      &       (ref.exactVanishedFocalValuesStatistic_m[0]),
                                &       (ref.exactVanishedFocalValuesStatistic_m[ maxFocalValuesToCompute+1 ]),
                                exactVanishedFocalValuesStatistic_m
                );

                std::copy(      &( ref.jacobianRankCounters_m[0] ),
                                &( ref.jacobianRankCounters_m[arrayLength+1] ),
                                jacobianRankCounters_m
                );

        }
        return *this;
}


inline  void    BaseRankStatistic::testbounds(int maxbound) const
{
        assert( maxbound<=arrayLength);
}

void BaseRankStatistic::init()
{
        if (maxFocalValuesToCompute-minSuccessiveZeroFocalValues+1<=0)
        {
                std::cerr << "maxFocalValues is smaller than  minSuccessiveZeroFocalValues + 1:" << std::endl;
                std::cerr << "maxFocalValuesToCompute =" << maxFocalValuesToCompute << std::endl;
                std::cerr << "minSuccessiveZeroFocalValues =" << minSuccessiveZeroFocalValues << std::endl;
                exit(0);
        }
        arrayLength = (maxRank+1)*(maxFocalValuesToCompute-minSuccessiveZeroFocalValues+1);
        assert( maxRank>0);
        
        jacobianRankCounters_m =  new long64[ arrayLength+1 ];
        clear();
}

void BaseRankStatistic::clear()
{

        std::fill(      &       (exactVanishedFocalValuesStatistic_m[0]),
                        &       (exactVanishedFocalValuesStatistic_m[ maxFocalValuesToCompute+1 ]),
                        0
        );

        std::fill(      &( jacobianRankCounters_m[0] ),
                        &( jacobianRankCounters_m[arrayLength+1] ),
                        0
        );
}


BaseRankStatistic::~BaseRankStatistic()
{
        delete[] jacobianRankCounters_m;
}


int BaseRankStatistic::getSmallesLoggedNumOfVanishedFocalValues() const
{
        return minSuccessiveZeroFocalValues;
}



int BaseRankStatistic::getHighestLoggedNumOfVanishedFocalValues() const
{
        return maxFocalValuesToCompute;
}


int BaseRankStatistic::getHighestLoggedJacobianRank() const
{
        return maxRank;
}

long64  BaseRankStatistic::getJacobianRankCounter(int index) const
{
        #ifdef SAFE
                testbounds( index );
        #endif
        return jacobianRankCounters_m[index];
}


long64& BaseRankStatistic::getJacobianRankCounterRef(int index)
{
        #ifdef SAFE
                testbounds( index );
        #endif
        return  jacobianRankCounters_m[index];
}
 


int     BaseRankStatistic::getRankStatisticIndex(int successiveVanishedNum, int jacobianRank) const
{
        if (! (jacobianRank<=maxRank && jacobianRank>=0))
        {
                std::cerr << "jacobianRank " << jacobianRank << std::endl;
                std::cerr << "maxRank " << maxRank << std::endl;
                assert(jacobianRank<=maxRank && jacobianRank>=0);
        }
        if (!(successiveVanishedNum<=maxFocalValuesToCompute && 
               successiveVanishedNum>=minSuccessiveZeroFocalValues))
        {
                std::cerr << "successiveVanishedFocalValues "<<successiveVanishedNum << std::endl;
                std::cerr << "maxFocalValuesToCompute "<<maxFocalValuesToCompute <<std::endl;
                std::cerr <<" minSuccessiveZeroFocalValues "<<minSuccessiveZeroFocalValues << std::endl;
        }

        assert(successiveVanishedNum<=maxFocalValuesToCompute && 
               successiveVanishedNum>=minSuccessiveZeroFocalValues);

        return (successiveVanishedNum-minSuccessiveZeroFocalValues)*(maxRank+1)+jacobianRank ;
}


long64 BaseRankStatistic::getOccurenceWithGivenNumOfVanishedFocalValues(int successiveVanishedNum) const
{
        assert(successiveVanishedNum<=maxFocalValuesToCompute && 
               successiveVanishedNum>=minSuccessiveZeroFocalValues);

        return exactVanishedFocalValuesStatistic_m [ successiveVanishedNum ];
}


int BaseRankStatistic::getNumOfOccuredJacobianRank(int successiveVanishedNum, int jacobianRank) const
{
        return getJacobianRankCounter( getRankStatisticIndex(successiveVanishedNum, jacobianRank) );
}


void BaseRankStatistic::addRankStatistic(int successiveVanishedFocalValues, int jacobianRank)
{

        
        assert(successiveVanishedFocalValues<=maxFocalValuesToCompute && 
               successiveVanishedFocalValues>=minSuccessiveZeroFocalValues);

        exactVanishedFocalValuesStatistic_m[ successiveVanishedFocalValues ]++;

        getJacobianRankCounterRef ( getRankStatisticIndex(successiveVanishedFocalValues, jacobianRank)) ++;
}


std::string BaseRankStatistic::getValueAsString() const
{
        std::stringstream ssvalue;
        
        bool firstLine=true;
        ssvalue<< "{ ";
        for (int vanishedFocalValues=getSmallesLoggedNumOfVanishedFocalValues();
                 vanishedFocalValues<= getHighestLoggedNumOfVanishedFocalValues(); 
                vanishedFocalValues++ )
        {
                if (getOccurenceWithGivenNumOfVanishedFocalValues(vanishedFocalValues)>0)
                {
                        if (firstLine)
                        {
                                firstLine=false;
                        }
                        else
                        {
                                ssvalue << ", ";
                        }
                        ssvalue << "\n ";
                        {
                                ssvalue << "{ " << vanishedFocalValues << ", { ";
                                ssvalue << getOccurenceWithGivenNumOfVanishedFocalValues(vanishedFocalValues) << ',';
                                for (int jacobianRank=0; jacobianRank<=maxRank; jacobianRank++)
                                {
                                        if (jacobianRank>0)
                                                ssvalue << ", ";
                                        ssvalue << getNumOfOccuredJacobianRank(vanishedFocalValues,jacobianRank);
                                }
                                ssvalue << " } }";
                        }
                }
        }
        ssvalue << "\n}";
        return ssvalue.str();
}



void BaseRankStatistic::print(std::ostream& os) const
{
        os << getMacaulayCompilantObjectName(name_m);
        os  << " = " << getValueAsString();
        os << "; -- Format: ( number of successive vanished focal values,\
                                         {occurrence count, number of jacobi-matrices with rank 0,\
                                          number of jacobi-matrices with rank  1, ...,  number of jacobi-matrices with rank  'maxRank'} )";
        os << std::endl;
}


//---------------------------------------------------------------
RankAndLiftStatistic::RankAndLiftStatistic(     std::string     name, 
                                                                int     _requestedMinSuccessiveVanishedFocalValues,
                                                                int     _maxFocalValuesToCompute, 
                                                                int     _maxRank                        
                                                                                        
                                                        ) :     name_m(name),
                                                                rankStatisticPair_m( BaseRankStatistic( name+"_passedLiftTest",
                                                                                                                        _requestedMinSuccessiveVanishedFocalValues,
                                                                                                                        _maxFocalValuesToCompute, 
                                                                                                                        _maxRank
                                                                                                                ),
                                                                                                BaseRankStatistic(      name+"_failedLiftTest",
                                                                                                                        _requestedMinSuccessiveVanishedFocalValues,
                                                                                                                        _maxFocalValuesToCompute, 
                                                                                                                        _maxRank
                                                                                                                )
                                                                                        )
{}

RankAndLiftStatistic::~RankAndLiftStatistic()   
{}
                
void    RankAndLiftStatistic::clear()
{       
        rankStatisticPair_m.first.clear();
        rankStatisticPair_m.second.clear();
}

void    RankAndLiftStatistic::addRankStatistic(int successiveVanishedFocalValues, int jacobianRank, bool liftTestPassed)
{
        if (liftTestPassed)
                rankStatisticPair_m.first.addRankStatistic(successiveVanishedFocalValues,jacobianRank);
        else
                rankStatisticPair_m.second.addRankStatistic(successiveVanishedFocalValues,jacobianRank);
}

void RankAndLiftStatistic::print(std::ostream &os) const
{
        os << getMacaulayCompilantObjectName(name_m) << " = {" << rankStatisticPair_m.first.getValueAsString() ;
        os <<  " , " << rankStatisticPair_m.second.getValueAsString() ;
        os <<  " }; -- Format: {RankstatisticforPassedLiftTest,RankstatisticForFailedLiftTest}, \
                                         RankstatisticFormat: ( number of successive vanished focal values, \
                                        {occurrence count, number of jacobi-matrices with rank 0,  \
                                                number of jacobi-matrices with rank  1, ...,  number of jacobi-matrices with rank  'maxRank'} )";
        os << std::endl;
}


};