LiftStatistic.cpp

Go to the documentation of this file.

#include "LiftStatistic.h"
#include <sstream>

namespace nCenterFocus
{

FailedLiftStatistic::FailedLiftStatistic
(unsigned int maxLift, unsigned int liftTrials):        failedLiftTrialCount( 0 ),
                                                                        maxLift_m( maxLift ),
                                                                        liftTrials_m( liftTrials ),
                                                                        testFailureCount_m(0)
{
        failedLiftCount_m.clear();
        failedLiftCount_m.resize(maxLift+1, 0 );
}


FailedLiftStatistic::FailedLiftStatistic( ):    failedLiftTrialCount( 0 ),
                                                                maxLift_m( 0 ),
                                                                liftTrials_m( 0 ),
                                                                testFailureCount_m(0)
{
        failedLiftCount_m.clear();
        failedLiftCount_m.resize(maxLift_m+1, 0 );
}


unsigned int FailedLiftStatistic::getMaxLift() const 
{
        return maxLift_m; 
}

unsigned int FailedLiftStatistic::getLiftTrials() const 
{
        return liftTrials_m; 
}

void            FailedLiftStatistic::logFailedLift(int currentLiftNr)
{
        failedLiftCount_m[currentLiftNr]++;
        failedLiftTrialCount++;
        assert(failedLiftTrialCount<=liftTrials_m);
}       


void  FailedLiftStatistic::operator+=(const FailedLiftStatistic & summand)
{
        assert(summand.getMaxLift()==maxLift_m);
        assert(summand.getLiftTrials()==liftTrials_m);
        for (unsigned int currentLiftNr=1; currentLiftNr<=maxLift_m; currentLiftNr++)
        {
                failedLiftCount_m[currentLiftNr]+= summand.failedLiftCount_m[currentLiftNr];
                failedLiftTrialCount += summand.failedLiftCount_m[currentLiftNr];
        }
        testFailureCount_m += summand.testFailureCount_m;
}


int32_t         FailedLiftStatistic::getFailedLiftCount(unsigned int liftNr) const
{
        assert( liftNr <= maxLift_m );
        return failedLiftCount_m[liftNr];
}


void    FailedLiftStatistic::setTestFailureCount() 
{
        assert(failedLiftTrialCount>0);
        assert(liftTrials_m - failedLiftTrialCount>=0);
        testFailureCount_m= liftTrials_m - failedLiftTrialCount;
}


int32_t         FailedLiftStatistic::getTestFailureCount() const
{
 
        return testFailureCount_m;
}

void            FailedLiftStatistic::setFailedLiftCount(unsigned int liftNr, int32_t count)
{
        assert(  liftNr<=maxLift_m);
        failedLiftCount_m[liftNr] = count;
}

unsigned short  FailedLiftStatistic::getMinFailedLiftNr()               const
{
        if (failedLiftCount_m.size()==0)
                return 0;

        size_t minFailedLiftNr=                 failedLiftCount_m.size();

        for (size_t i=1; i<failedLiftCount_m.size(); i++)
        {
                if ( failedLiftCount_m[i]>0  )
                {
                        minFailedLiftNr = i;
                        break;
                }
        }
        if ( minFailedLiftNr== failedLiftCount_m.size() )
                return 0;

        return minFailedLiftNr;
}


void    FailedLiftStatistic::print(std::ostream & os)   const
{
        os << "FailedLiftStatistic = {" << std::endl ;
        os << "-- liftTrials= " << liftTrials_m  << std::endl;
        os << getTestFailureCount() << ", -- Anzahl( Test hat versagt)"   << std::endl;
        bool first=true;
        for (unsigned int i=1; i<=maxLift_m;i++)
        {
                if (failedLiftCount_m[i]>0)
                {
                        if (first)      
                                first=false;
                        else
                                os << "," ;

                        os << "( " << i <<", " <<       failedLiftCount_m[i] << "\t\t )\n";
                }
        }
        os << "};"<< std::endl;
}


//----------------------------------------------------------------------------------------------------------





ExtendedFailedLiftStatistic::ExtendedFailedLiftStatistic(): maxLift_m(0), liftTrials_m(0), bMaxLiftAndLiftTrialsIinitialized_m(false)
{
 
}


 void ExtendedFailedLiftStatistic::printFailedLiftStatistic( std::ostream & os  )       const
        {
                assert(bMaxLiftAndLiftTrialsIinitialized_m);

                os << "ExtFailedLiftStatistic = { \n " ;
        
                std::string rankIndependentLiftStatistic=getFailedLiftStatisticValue( failedLiftStatisticList_m );
        
                // maxLift und liftTrials ist erst nach getFailedLiftStatisticValue initialisiert.
        
                os << "--maxLift = " << maxLift_m  << ";" << std::endl;
                os << "--liftTrials = " << liftTrials_m  << ";" << std::endl;
        
                os << rankIndependentLiftStatistic;
        
        
                for (failedLiftStatisticMapType::const_iterator it=failedLiftStatisticMap_m.begin(); it!=failedLiftStatisticMap_m.end(); it++)
                {
                        if (it!=failedLiftStatisticMap_m.begin() ) 
                                os << ",";
                        else
                                os << " ";
                        os << "{" << (*it).first << ", " << getFailedLiftStatisticValue( (*it).second ) << "}";
                }
        
                os << "};";
        }
        
        
        
        
        void    ExtendedFailedLiftStatistic::printMinLiftPointStatistic( std::ostream & os)     const
        {
        
                assert(bMaxLiftAndLiftTrialsIinitialized_m);
                 
        
                std::vector<int> minLiftInfo = getMinLiftPointStatistic( failedLiftStatisticList_m );
        
                os << "minLiftDepthOccurenceCount = {" ;
        
                os << "--maxLift = " << maxLift_m  << ";" << std::endl;
                os << "--liftTrials = " << liftTrials_m  << ";" << std::endl;
                os << "--Format: (minLift, #Points with this minLift )" << std::endl;
        
                os << getMinLiftPointStatisticValue(minLiftInfo);
                
                for (failedLiftStatisticMapType::const_iterator it=failedLiftStatisticMap_m.begin(); it!=failedLiftStatisticMap_m.end(); it++)
                {
                        if ( it!=failedLiftStatisticMap_m.begin() ) 
                                os << ",";
                        else
                                os << " ";
                        os << "{"<<  (*it).first << "," << std::endl;
                        minLiftInfo= getMinLiftPointStatistic( (*it).second );
                        os << getMinLiftPointStatisticValue(minLiftInfo);
                        os << "}\n";
                }
                os << "};"<< std::endl;
        }
        
        
        
        void            ExtendedFailedLiftStatistic::printSummedMinLiftPointStatistic( std::ostream & os ) const
        {

                assert(bMaxLiftAndLiftTrialsIinitialized_m);
 
        
                std::vector<int> minLiftInfo = getMinLiftAllStatistic( failedLiftStatisticList_m );
        
                os << "minFailedTrialsForeachLiftDepth = {\n" ;
        
                os << "--maxLift = " << maxLift_m  << ";" << std::endl;
                os << "--liftTrials = " << liftTrials_m  << ";" << std::endl;
                os << "--Format: (minLift, #minFailedTrials over all points )" << std::endl;
        
                os << getMinLiftPointStatisticValue(minLiftInfo);
                
                for (failedLiftStatisticMapType::const_iterator it=failedLiftStatisticMap_m.begin(); it!=failedLiftStatisticMap_m.end(); it++)
                {
                        if (it!=failedLiftStatisticMap_m.begin() ) 
                                os << ",";
                        else
                                os << " ";

                        os << "{"<<  (*it).first << "," << std::endl;
                        minLiftInfo= getMinLiftAllStatistic( (*it).second );
                        os << getMinLiftPointStatisticValue(minLiftInfo);
                        os << "}\n";
                }
                os << "};"<< std::endl;
        }
        
        
        
        void    ExtendedFailedLiftStatistic::printSummedAverageMinLiftPointStatistic( std::ostream & os ) const
        {
                assert(bMaxLiftAndLiftTrialsIinitialized_m);
                 
        
                std::vector<double> avereageLiftInfo = getAverageLiftAllStatistic( failedLiftStatisticList_m );
        
                os << "averageFailedTrialProbability = { -- for given maxLiftDepth and one liftTrial \n" ;
        
                os << "--maxLift = " << maxLift_m  << ";" << std::endl;
                os << "--liftTrials = " << liftTrials_m  << ";" << std::endl;
                os << "-- average probability of failing to identify a nonsmooth point with X liftrials is prob^X "  << std::endl;
                os << "-- Format : (maxLift, FailedTrialProbability )"  << std::endl;
        
                os << getAverageLiftStatisticValue(avereageLiftInfo);
                
                for (failedLiftStatisticMapType::const_iterator it=failedLiftStatisticMap_m.begin(); it!=failedLiftStatisticMap_m.end(); it++)
                {
                        if (it!=failedLiftStatisticMap_m.begin() ) 
                                os << ",";
                        else
                                os << " ";

                        os << "{"<<  (*it).first << ", -- JacobianRank" << std::endl;
                        avereageLiftInfo= getAverageLiftAllStatistic( (*it).second );
                        os << getAverageLiftStatisticValue(avereageLiftInfo);
                        os << "}\n";
                }
                os << "};"<< std::endl;
        }
        
        
        void            ExtendedFailedLiftStatistic::print( std::ostream & os )         const
        {
                initMaxLiftAndLiftTrials();
                assert(bMaxLiftAndLiftTrialsIinitialized_m);
                printFailedLiftStatistic(os);
                printMinLiftPointStatistic(os);
                printSummedMinLiftPointStatistic(os);
                printSummedAverageMinLiftPointStatistic(os);
        }



std::string     ExtendedFailedLiftStatistic::getMinLiftPointStatisticValue(std::vector<int> &minLiftInfo) const
{
        std::stringstream strstream;

        bool first=true;

        strstream << "{"<< std::endl;
        for (size_t i=0; i<minLiftInfo.size(); i++ )
        {
                if (minLiftInfo[i]>0)
                {
                        if (!first)
                                strstream << "," ;
                        else
                        {
                                strstream << " " ;
                                first=false;
                        }
                                
                        strstream << "\t( " << std::setw(3) << i <<", " << std::setw(5) <<      minLiftInfo[i] << "\t )\n";
                }
        }
        strstream << "}"<< std::endl;

        return strstream.str();
}


std::string     ExtendedFailedLiftStatistic::getAverageLiftStatisticValue(std::vector<double> & averageLiftInfo)        const
{
        std::stringstream strstream;

        bool first=true;

        strstream << "{"<< std::endl;
        for (size_t i=0; i < averageLiftInfo.size(); i++ )
        {
                if (averageLiftInfo[i]>0)
                {
                        if (!first)
                                strstream << "," ;
                        else
                        {
                                strstream << " " ;
                                first=false;
                        }
                                
                        strstream << "( " <<   std::setw(3)<<  i <<", "  << std::setw(10)  <<   1.0- averageLiftInfo[i] << "\t )  -- " << "1 of " << 1.0/(1.0- averageLiftInfo[i] ) << " is not identified \n";
                }
        }
        strstream << "}"<< std::endl;

        return strstream.str();
}       


 


};