QuadricsStatistic.h

Go to the documentation of this file.

#pragma once

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include "typedefs.h"
#include "RangStatistik.h"
#include <assert.h>
namespace nCenterFocus
{
        

class BaseQuadricsStatistic  
{

public:
        

                BaseQuadricsStatistic(  std::string name, 
                                                        int _permittedMinSuccessiveVanishedFocalValuesNum, 
                                                        int _maxPermittedVanishedFocalValuesNum,
                                                        int _maxPermittedJacobianRank 
                                                );

                BaseQuadricsStatistic(const BaseQuadricsStatistic& ref);

                virtual ~BaseQuadricsStatistic();
        void clear();

                inline void     addQuadricsStatistic(   int successiveVanishedFocalValues,
                                                                        int jacobianRank, 
                                                                        int quadricsRank);
                // get permitted
                inline int getPermittedMinSuccessiveVanishedFocalValues() const         ;
                inline int getPermittedMaxVanishedFocalValuesNum()              const           ;
                inline int getPermittedMaxJacobianRank()                        const           ;
                void            print(std::ostream &f) const;
                void            printValue(std::ostream &os  ) const;
private:

        BaseQuadricsStatistic & operator=(const BaseQuadricsStatistic& ref)
        {       assert(false);  return *this;   }

        
                int      getHighestLoggedQuadricsRank( ) const;

                std::vector<BaseRankStatistic*>         rankStatistics_m;       
        
                std::vector<long64>             expSum_m;
        
                std::string name_m;
        
                int maxQuadricRank_m;                   
                int maxJacobianRank_m;                  
        
                int maxFocalValuesToCompute_m;          
                int minSuccessiveVanishedFocalValues_m;     

};

inline int      BaseQuadricsStatistic::getPermittedMinSuccessiveVanishedFocalValues() const     
{
        return minSuccessiveVanishedFocalValues_m;      
}


inline int      BaseQuadricsStatistic::getPermittedMaxVanishedFocalValuesNum()  const           
{       
        return maxFocalValuesToCompute_m;               
}


inline int      BaseQuadricsStatistic::getPermittedMaxJacobianRank()    const           
{
        return maxJacobianRank_m        ;               
}


class QuadricsStatistic
{

public:
                QuadricsStatistic(      std::string name, 
                                                        int _permittedMinSuccessiveVanishedFocalValuesNum, 
                                                        int _maxPermittedVanishedFocalValuesNum,
                                                        int _maxPermittedJacobianRank 
                                                );
        
                virtual ~QuadricsStatistic();

        void clear();

                inline void addQuadricsStatistic(       int successiveVanishedFocalValues,
                                                                int jacobianRank,
                                                                int quadricsRank,
                                                                 bool liftTestPassed = true);
                void print(std::ostream &f) const;
private:
        std::string name_m;

        std::pair< BaseQuadricsStatistic, BaseQuadricsStatistic >       quadricStatisticPair_m;
        

};


inline void BaseQuadricsStatistic::addQuadricsStatistic(int successiveVanishedFocalValues, int jacobianRank, int quadricsRank)
{
        assert(quadricsRank>=0 && quadricsRank<=maxQuadricRank_m);

        expSum_m[quadricsRank]++;
        rankStatistics_m[quadricsRank]->addRankStatistic( successiveVanishedFocalValues, jacobianRank );
}



inline void QuadricsStatistic::addQuadricsStatistic(int successiveVanishedFocalValues,int jacobianRank, int quadricsRank, bool liftTestPassed )
{
        if (liftTestPassed)
        {
                quadricStatisticPair_m.first.addQuadricsStatistic(successiveVanishedFocalValues, jacobianRank, quadricsRank);
        }
        else
        {
                quadricStatisticPair_m.second.addQuadricsStatistic(successiveVanishedFocalValues, jacobianRank, quadricsRank);
        }
}


class LiftAndQuadricsStatistic
{

public:
        typedef std::map<int, BaseQuadricsStatistic*> BaseQuadricsStatisticMapType;

        LiftAndQuadricsStatistic(       std::string name,
                                                                        int     _minPermittedVanishedFocalValuesNum, 
                                                                        int     _maxPermittedFocalValuesNum, 
                                                                        int     _maxPermittedJacobianRank, 
                                                                        int     exhaustiveMaxLift, 
                                                                        int     exhaustiveLiftTrials
                                                                );

        virtual ~LiftAndQuadricsStatistic();
        

        void clear();

                inline void addLiftAndQuadricsStatistic(int successiveVanishedFocalValues,
                                                                        int jacobianRank, 
                                                                        int quadricsRank, 
                                                                        bool liftTestPassed = true,
                                                                         int mitFailedLiftNr=-1);
        //void printLiftAndQuadricsStatistic(std::ostream &f) const;
                void printValue(std::ostream &f) const;

                void print(std::ostream &f) const;
private:
        std::string name_m;

 
        int exhaustiveMaxLift_m;        
        int exhaustiveLiftTrials_m;     

        std::pair< BaseQuadricsStatistic, BaseQuadricsStatistic >       quadricStatisticPair_m;


        BaseQuadricsStatisticMapType            failedQuadricStatistic_m;
};



inline void LiftAndQuadricsStatistic::addLiftAndQuadricsStatistic(      int successiveVanishedFocalValues, 
                                                                                                int jacobianRank, 
                                                                                                int quadricsRank, 
                                                                                                bool liftTestPassed , 
                                                                                                int minFailedLiftNr)
{

        if (liftTestPassed)
        {
                quadricStatisticPair_m.first.addQuadricsStatistic(successiveVanishedFocalValues, jacobianRank, quadricsRank);
        }
        else
        {
                //assert(minFailedLiftNr>0);
                quadricStatisticPair_m.second.addQuadricsStatistic(successiveVanishedFocalValues, jacobianRank, quadricsRank);

                BaseQuadricsStatisticMapType::const_iterator it=failedQuadricStatistic_m.find(minFailedLiftNr);
                if (it == failedQuadricStatistic_m.end() )
                {
                        failedQuadricStatistic_m[minFailedLiftNr] =  new BaseQuadricsStatistic( name_m+"_failedLiftTest", 
                                                                                                                        quadricStatisticPair_m.first.getPermittedMinSuccessiveVanishedFocalValues(),
                                                                                                                        quadricStatisticPair_m.first.getPermittedMaxVanishedFocalValuesNum(),
                                                                                                                        quadricStatisticPair_m.first.getPermittedMaxJacobianRank() 
                                                                                                                )
                                                                                        ;


                }
                failedQuadricStatistic_m[minFailedLiftNr]->addQuadricsStatistic(successiveVanishedFocalValues, jacobianRank, quadricsRank);
        }
}
 


};