LiftStatistic.h

Go to the documentation of this file.

#ifndef LIFT_STATISTIC_H
#define LIFT_STATISTIC_H

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <assert.h>
#include <iomanip>
#include <map>

#include <sstream>


 #include <stdint.h>
#include <iostream>
#include <vector>
#include <list>

#include "typedefs.h"

namespace nCenterFocus
{

        class FailedLiftStatistic
        {
        
        private:
        
                std::vector<int32_t> failedLiftCount_m;
        
                int64_t failedLiftTrialCount;

                
        
                unsigned int maxLift_m;
                unsigned int liftTrials_m;

                int64_t         testFailureCount_m;
        
        public:
        
                FailedLiftStatistic(unsigned int maxLift, unsigned int liftTrials);
                FailedLiftStatistic();

                void operator+=(const FailedLiftStatistic & summand);
        
                unsigned int getMaxLift()       const  ;
                unsigned int getLiftTrials()    const  ;
        

                
                void            logFailedLift(int currentLiftNr);

                void            logFailedTests(int count);
        
                int32_t         getFailedLiftCount(unsigned int liftNr) const;

                void            setTestFailureCount();
                int32_t         getTestFailureCount() const;
        
                void            setFailedLiftCount(unsigned int liftNr, int32_t count);
        
                unsigned short  getMinFailedLiftNr()    const;
        
                void    print(std::ostream & os)        const;
                
        };
 

        class EmptyFailedLiftStatistic
        {
                public :
                        inline static void              logFailedLift(int currentLiftNr) {};
        };
        
        
        class ExtendedFailedLiftStatistic
        {
        public:

                typedef std::map<int, std::vector<FailedLiftStatistic >  >  failedLiftStatisticMapType;
        private:
        

                        mutable unsigned short  maxLift_m;
                        mutable unsigned int            liftTrials_m;
                        mutable bool bMaxLiftAndLiftTrialsIinitialized_m;
                        //int maxJacobianRank_m;
                        //std::vector<FailedLiftStatistic > failedLiftStatisticList_m;

                        failedLiftStatisticMapType      failedLiftStatisticMap_m;

                        //std::vector<std::pair<FailedLiftStatistic,int> > failedLiftStatisticList_m;
                
                        //mutable std::vector<FailedLiftStatistic > failedLiftStatisticEvaluatedList_m;
        
                        mutable std::vector<uint64_t> hitLiftInfo_m;

                        mutable std::vector<FailedLiftStatistic >       failedLiftStatisticList_m;
        
                template <class FailedLiftStatisticVector>
                unsigned int getMaxLift(FailedLiftStatisticVector               & failedLiftStatisticList ) const; 

                template <class FailedLiftStatisticVector>
                unsigned int getLiftTrials(FailedLiftStatisticVector            & failedLiftStatisticList ) const;

                inline void initMaxLiftAndLiftTrials() const;

                template <class FailedLiftStatisticVector>
                std::vector<FailedLiftStatistic >     getLiftStatisticEvaluatedList(FailedLiftStatisticVector    & failedLiftStatisticList) const;

                // Auswertung 1: für jeden Punkt minLift. ermitteln. zähle für alle mögliche minLifts, bei wieviel Punkten dieser minLift auftritt.
                
                template <class FailedLiftStatisticVector>
                std::vector<int>        getMinLiftPointStatistic(FailedLiftStatisticVector       & failedLiftStatisticList) const;

                // Auswertung2: zähle Über alle Punkte das Minimum fuer einen aufgetretenen Wert.

                template <class FailedLiftStatisticVector>
                std::vector<int>        getMinLiftAllStatistic(FailedLiftStatisticVector         & failedLiftStatisticList) const;

                template <class FailedLiftStatisticVector>
                std::vector<double>     getAverageLiftAllStatistic(FailedLiftStatisticVector     & failedLiftStatisticList) const;
        
                
                template <class FailedLiftStatisticVector>
                std::string     getFailedLiftStatisticValue(  FailedLiftStatisticVector & failedLiftStatisticList )     const ;
                
                std::string             getMinLiftPointStatisticValue(  std::vector<int> &minLiftInfo    )      const ; 
                std::string             getAverageLiftStatisticValue (  std::vector<double> &averageLiftInfo )  const ;

                //void evaluateHitLiftInfo() const;

        
        public:
                ExtendedFailedLiftStatistic();
        
                        //inline void   logFailedLift(FailedLiftStatistic& failedLiftStatistic);
                        inline void     logFailedLift(FailedLiftStatistic& failedLiftStatistic, int jacobianRank);
                        inline void printFailedLiftStatistic( std::ostream & os)        const;


                         void   printMinLiftPointStatistic( std::ostream & os)  const;
                        //void  printLiftPointStatistic( std::ostream & os)     const;
                
                         void   printSummedMinLiftPointStatistic( std::ostream & os ) const;

                         void   printSummedAverageMinLiftPointStatistic( std::ostream & os ) const;
                
                        //void printHitStatistic        ( std::ostream & os ) const;
        
                         void   print( std::ostream & os )      const;
        
        };


        inline void     ExtendedFailedLiftStatistic::logFailedLift(FailedLiftStatistic& failedLiftStatistic, int jacobianRank)
        {
                //failedLiftStatisticList_m.push_back(std::pair< failedLiftStatistic, jacobianRank >);
                bMaxLiftAndLiftTrialsIinitialized_m=false;

                failedLiftStatisticMapType::const_iterator it=failedLiftStatisticMap_m.find(jacobianRank);
                if (it == failedLiftStatisticMap_m.end() )
                        failedLiftStatisticMap_m[jacobianRank]=std::vector<FailedLiftStatistic >();
                failedLiftStatisticMap_m[jacobianRank].push_back(  failedLiftStatistic);
        }



        
        // Auswertung1: zähle Über alle Punkte das Minimum fuer einen Aufgetretenen wert.
        // Ausgabe; für alle liftNr gib aus Minimum ( der Anzahl des Auftretens von FailLiftNr <=liftNr ) gebildet über alle Punkte.
        
        // Auswertung 2: für jeden munt minLift. ermitteln. zähle für alle mögliche minLifts, bei wieviel Punkten dieser minLift auftritt.
        
        template <class FailedLiftStatisticVector>
        std::vector<FailedLiftStatistic >    ExtendedFailedLiftStatistic::getLiftStatisticEvaluatedList(FailedLiftStatisticVector       & failedLiftStatisticList) const
        {

                assert(bMaxLiftAndLiftTrialsIinitialized_m);
                std::vector<FailedLiftStatistic >  failedLiftStatisticEvaluatedList ;
                failedLiftStatisticEvaluatedList.clear();
        
                for (size_t i=0;i<failedLiftStatisticList.size(); i++)
                {
                        const FailedLiftStatistic& tmp = failedLiftStatisticList[i];
                        failedLiftStatisticEvaluatedList.push_back(  FailedLiftStatistic( maxLift_m, liftTrials_m ) );
        
                        int32_t failedLiftCount=0;
        
                        for (unsigned int currMaxLift=1; currMaxLift<= tmp.getMaxLift(); currMaxLift++)
                        {
                                failedLiftCount += tmp.getFailedLiftCount( currMaxLift );
                                //std::cerr << "currMaxLift " << currMaxLift << std::endl;
                                //std::cerr << "failedLiftCount " << failedLiftCount << std::endl;
                                // das funktioniert so nicht
                                failedLiftStatisticEvaluatedList[i].setFailedLiftCount(currMaxLift, failedLiftCount );
                        }
                }
                return failedLiftStatisticEvaluatedList;
        }
        
        template <class FailedLiftStatisticVector> 
        unsigned int ExtendedFailedLiftStatistic::getMaxLift(FailedLiftStatisticVector          & failedLiftStatisticList ) const
        {
                unsigned int maxLift=0;
                if (failedLiftStatisticList.size()>0)
                {
                        maxLift=failedLiftStatisticList[0].getMaxLift();
                        #ifdef SAFE
                                for (size_t i=1; i<failedLiftStatisticList.size(); i++ )
                                {
                                        assert( maxLift    == failedLiftStatisticList[i].getMaxLift() );
                                }
                        #endif
                }
                return maxLift;
        }
        
        template <class FailedLiftStatisticVector> 
        unsigned int ExtendedFailedLiftStatistic::getLiftTrials(FailedLiftStatisticVector               & failedLiftStatisticList ) const
        {

                unsigned int liftTrials=0;

                if (failedLiftStatisticList.size()>0)
                {
                        liftTrials=failedLiftStatisticList[0].getLiftTrials();
                        #ifdef SAFE
                                for (size_t i=1; i<failedLiftStatisticList.size(); i++ )
                                {
                                        assert( liftTrials    == failedLiftStatisticList[i].getLiftTrials() );
                                }
                        #endif
                }
                return liftTrials;
        }

        template <class FailedLiftStatisticVector>
        std::vector<int>        ExtendedFailedLiftStatistic::getMinLiftAllStatistic(FailedLiftStatisticVector           & failedLiftStatisticList ) const
        {

                assert(bMaxLiftAndLiftTrialsIinitialized_m);

                std::vector<int> minSumLiftInfo;
                minSumLiftInfo.clear();
        
                if (failedLiftStatisticList.size()==0)
                        return  minSumLiftInfo;
                

                minSumLiftInfo.resize(maxLift_m + 1, 0);
        
                std::vector< FailedLiftStatistic >      evaluatedList=getLiftStatisticEvaluatedList(failedLiftStatisticList  );
                
                for (unsigned int currLift=1; currLift<=maxLift_m; currLift++)
                {
                        short minOccurred=evaluatedList[0].getFailedLiftCount(currLift);
                        for (size_t i=1; i< evaluatedList.size(); i++ )
                        {
                                if (evaluatedList[i].getFailedLiftCount(currLift) < minOccurred)
                                        minOccurred = evaluatedList[i].getFailedLiftCount(currLift);
                        }
                        minSumLiftInfo[currLift] = minOccurred;
                }
                return minSumLiftInfo;
        }
        
        inline void ExtendedFailedLiftStatistic::initMaxLiftAndLiftTrials() const
        {
                failedLiftStatisticList_m.clear();
                for (failedLiftStatisticMapType::const_iterator it=failedLiftStatisticMap_m.begin(); it!=failedLiftStatisticMap_m.end(); it++)
                {
                                for (size_t i=0;i< (*it).second.size(); i++)
                                        failedLiftStatisticList_m.push_back( (*it).second[i] );
                }

                maxLift_m               =  getMaxLift(failedLiftStatisticList_m);
                liftTrials_m    =  getLiftTrials(failedLiftStatisticList_m);
                bMaxLiftAndLiftTrialsIinitialized_m = true;
        }
        
        
        template <class FailedLiftStatisticVector>
        std::vector<double>     ExtendedFailedLiftStatistic::getAverageLiftAllStatistic(FailedLiftStatisticVector       & failedLiftStatisticList) const
        {
                assert(bMaxLiftAndLiftTrialsIinitialized_m);
                std::vector<double> avereageLiftInfo;
        
                avereageLiftInfo.clear();
                if (failedLiftStatisticList.size()==0)
                        return  avereageLiftInfo;
                

                avereageLiftInfo.resize(maxLift_m+1, 0);
        
                std::vector< FailedLiftStatistic >      evaluatedList=getLiftStatisticEvaluatedList(failedLiftStatisticList);
                
                //std::cerr << "failedLiftStatisticEvaluatedList_m.size() " << failedLiftStatisticEvaluatedList_m.size() << std::endl;
                //std::cerr << "failedLiftStatisticList_m[0].getLiftTrials() " <<failedLiftStatisticList_m[0].getLiftTrials() << std::endl;
        
                for (int currLift=1; currLift<=maxLift_m; currLift++)
                {
                        for (size_t currentNonsmoothPointIdx =0; currentNonsmoothPointIdx < evaluatedList.size(); currentNonsmoothPointIdx++ )
                        {
                                avereageLiftInfo[currLift] += evaluatedList[currentNonsmoothPointIdx].getFailedLiftCount( currLift );
                        }
                        //std::cerr << "currLift  " << currLift << std::endl;
                        //std::cerr << "avereageLiftInfo_m[currLift]  " << avereageLiftInfo_m[currLift] << std::endl;
                        avereageLiftInfo[currLift] /= evaluatedList.size()*1.0;
                        avereageLiftInfo[currLift]/=  failedLiftStatisticList[0].getLiftTrials();
                }
                return avereageLiftInfo;
        }
        
        template <class FailedLiftStatisticVector>
        std::vector<int>        ExtendedFailedLiftStatistic::getMinLiftPointStatistic(FailedLiftStatisticVector  & failedLiftStatisticList) const
        {
                assert(bMaxLiftAndLiftTrialsIinitialized_m);
                std::vector<int> minLiftInfo;
                minLiftInfo.clear(); 
        
                if (failedLiftStatisticList.size()==0) 
                        return minLiftInfo;
                
                std::cerr << "getMinLiftPointStatistic, maxLift" <<  maxLift_m << std::endl;
                
                minLiftInfo.resize( maxLift_m + 1 ,0 );
        
                for (size_t failedLiftPointIdx=0;failedLiftPointIdx<failedLiftStatisticList.size(); failedLiftPointIdx++)
                {
                        assert( failedLiftStatisticList[failedLiftPointIdx].getMinFailedLiftNr() < minLiftInfo.size() );
                        minLiftInfo[ failedLiftStatisticList[failedLiftPointIdx].getMinFailedLiftNr() ] ++;
                }
                return minLiftInfo;
        }

        
        template <class FailedLiftStatisticVector>
        std::string ExtendedFailedLiftStatistic::getFailedLiftStatisticValue(  FailedLiftStatisticVector   & failedLiftStatisticList    )       const
        {

                assert(bMaxLiftAndLiftTrialsIinitialized_m);
                std::stringstream strstream;
        
                if (failedLiftStatisticList.size()==0) 
                        return std::string("{}");
                 
                std::cerr << "getFailedLiftStatisticValue, maxLift" <<  maxLift_m << std::endl;
        
                std::cerr << "getFailedLiftStatisticValue, liftTrials" <<  liftTrials_m << std::endl;

                FailedLiftStatistic localFailedLiftStatistic(maxLift_m, liftTrials_m);
        
                for (size_t i=0;i<failedLiftStatisticList.size();i++)
                {
                        localFailedLiftStatistic += failedLiftStatisticList[i];
                }
        
                strstream << "  {" ;
        
                bool first=true;
        
                for (unsigned int i=1; i<=maxLift_m; i++ )
                {
                        if (localFailedLiftStatistic.getFailedLiftCount(i)      >0 )
                        {
                                if (! first)
                                        strstream << "," ;
                                else
                                        first=false;
                                strstream << "\t( " << std::setw(3) << i <<", " << std::setw(5) <<      localFailedLiftStatistic.getFailedLiftCount(i) << "\t )\n";
                        }
                }
                strstream << "}"<< std::endl;
                return strstream.str();
                }
        
        

}

#endif