ReadCenterFocusParams.h

Go to the documentation of this file.

#ifndef READ_CENTERFOCUS_PARAMS
#define READ_CENTERFOCUS_PARAMS

#include "CoeffList.h"
#include "Parameterlist.h"
#include <time.h>


#include "RangStatistik.h"
#include "Statistik.h"


#include "random.h"

#include "parseTools.h"
#include "xyMonom.h"
#include <fcntl.h> // for open()
#include <cerrno> // for errno 
#include <cstdio> // for perror()


// includes to get user home directory from /etc/passwd file.
#include <pwd.h>
#include <sys/types.h>
#include <cstdio>
#include <iostream>
#include <time.h>

#include "pointFilter.h"






namespace nCenterFocus
{






bool isMonomChar(char a);





//-------------------- spezieller Parser Kram

bool isMonomChar(char a)
{
        if (isdigit(a)||(a == 'A')||(a == '?')||(a == '^')||
                (a == '-')||(a == '*')||(a == 'e')||(a == '+')||isspace(a))
        {
                return true;
        }
        return false;
}

bool isAllMarker(string mo)
{
        string m=eatWS(mo);
        return (m.length()==1 && m.compare("A")==0);
}

bool isRandomMarker(string morig)
{
        string mc=eatWS(morig);
        return (mc.length()==1 && (mc[0]=='?'||mc[0]=='*'));
}









template <class _istream>
void gotoLParamValue(_istream &inputStream, bool parameterNameExpected=true)
{
        bool positionInLValue=false;
        // brauche kein test auf eof/fail, da alle Unterfunktionen diesen Test liefern müssen

        #ifdef DEBUG
                std::cerr << "gotoLParamValue   "  << std::endl;
        #endif
        
        inputStream.clear();
        assert( !inputStream.fail() );
        inputStream.seekg (0, ios::beg);

        char a;
        stringstream cache;
        bool macaulayCode=false;

        while (!positionInLValue)
        {
                assert( !inputStream.eof() );
                assert( !inputStream.fail() );
                if (parameterNameExpected)
                {
                        if ( macaulayCode )  // jump over macaulayCode
                        {
                                inputStream >> std::noskipws >> a;
                                cache  <<  a;
                                size_t found=cache.str().find("fi MacaulayDefinitions");
                                if (found!=string::npos)
                                        macaulayCode=false;
                                continue;
                        }
                        stripComments(inputStream);
                        string paramname=readParamName(inputStream);
                        #ifdef DEBUG
                                std::cerr << std::endl; std::cerr << std::endl;
                                std::cerr << "paramname = " << paramname << std::endl;
                        #endif
                        parameterNameExpected=false;
                        if ( paramname.compare("L") == 0)
                        {
                                extractChar('=',inputStream);
                                positionInLValue=true;
                                return;
                        }
                        else
                        {
                                extractChar('=',inputStream);
                                string paramValue=readParamValue(inputStream, paramname);
                                #ifdef DEBUG
                                        std::cerr << "paramValue =" << paramValue << std::endl;
                                        std::cerr << std::endl;
                                        std::cerr << std::endl; std::cerr << std::endl;
                                #endif
                                extractChar(';',inputStream);
                                readCurrentComment(inputStream);
                                parameterNameExpected=true;

                                if ( paramname.compare("cfMacaulayCode")==0 )
                                {
                                        cache.clear();
                                        macaulayCode=true;
                                        continue;
                                }
                        }
                }
                else
                {
                        throw "gotoLParamValue: not possible!";
                        //seekToParamName(inputStream);
                }               
        }
        throw "gotoLParamValue: file ends unexpectly";
}



template <class _istream>
void readNextPQPolynomStream(_istream &inp, stringstream &polynomData, int &braceLevel)
{
        assert(braceLevel==2);


        extractChar('{',inp);
        polynomData << '{';
        braceLevel++;
        //bool potentialComment=false;
        char a='\0';

        while (!inp.eof())
        {
                inp >> a;

                if      (a=='{')        braceLevel++;

                else if (a=='}')        braceLevel--;

                else if (a==';')        throw "readNextPQPolynomStream: unexpected end of Data";
                else if (a=='=')        throw "readNextPQPolynomStream: unexpected assignment in Data";

                if (a=='-' &&  inp.peek()=='-')
                {
                        inp.putback('-');
                        //readCurrentComment(inp);
                        stripComments(inp);
                }
                else
                {
                        polynomData << a;
                }
                if      (braceLevel>4)  throw "readNextPQPolynomStream: too many opened braces! ";

                if      (braceLevel==2)
                {       
                        #ifdef DEBUG
                        std::cerr << "polynomData" << polynomData.str() << std::endl;
                        std::cerr << " readNextPQPolynomStream: finished!" << std::endl;
                        #endif
                        return;
                }
        }
        if (inp.fail())
                throw "readNextPQPolynomStream: unexpected error";
        std::cerr << " readNextPQPolynomStream: finished!" << std::endl;
}




void  extractStreamFromPQStream(stringstream &polynomData, P_or_QPolynom p_or_q, stringstream &PStream,stringstream &QStream )
{
        #ifdef DEBUG
                std::cerr << "extractStreamFromPQStream" << std::endl;
        #endif

        extractChar('{',polynomData);

        PStream <<'{';  QStream<< '{';
        
        polynomData>>ws;
        while (!polynomData.eof() && polynomData.peek()=='{')
        {
                PStream << extractNextBracedData(polynomData);
                extractChar(',',polynomData);
                QStream << extractNextBracedData(polynomData);
                polynomData>>ws;
                if ( polynomData.peek()!='}')
                {       
                        extractChar(',',polynomData);
                        PStream<< ',';
                        QStream<< ',';
                }
                polynomData>>ws;
        }
        
        extractChar('}',polynomData);

        PStream << '}'; QStream << '}';
        #ifdef DEBUG
                std::cerr << "P" << PStream.str() << std::endl;
                std::cerr << "Q" << QStream.str() << std::endl;
                std::cerr << "extractStreamFromPQStream : finished!" << std::endl;
        #endif
        return ;
}













//------------ ende spezieller Parser-Kram










template <class TPolynomXY, class TRing>
class  CenterfocusParams
{

public:
        typedef TPolynomXY      PolynomXY_Type;
        typedef TRing           RingType;

static const string     nonSmoothPointPassFilter_ConstString_m;
static const string     maxFocalValues_ConstString_m;
static const string     reqVanisnedValues_ConstString_m;
static const string     characteristic_ConstString_m;
static const string     polynomialDegree_ConstString_m;
static const string     randomTrialsNum_ConstString_m;
static const string     randomSeed_ConstString_m;
static const string     randomSeedFromSysTime_ConstString_m;
static const string     maxLift_ConstString_m;
static const string     liftTrials_ConstString_m;
static const string     exhaustiveMaxLift_ConstString_m;
static const string     exhaustiveLiftTrials_ConstString_m;
static const string     requestedLiftPointNum_ConstString_m;

static const string     epsPrecision_ConstString_m;
static const string     minJacobianRank_ConstString_m;
static const string     minJacobianSubMatrixRank_ConstString_m;
static const string     useFormula1_ConstString_m;
static const string     useFormula2_ConstString_m;
static const string     useFormula23_ConstString_m;
static const string     appendResults_ConstString_m;
 
static const string     experimentTag_ConstString_m;
static const string     experimentTagNoWhiteSpaces_ConstString_m;

static const string     showProgress_ConstString_m;

static const  string    true_ConstString_m;
static const  string    false_ConstString_m;

static const string     minComponentCodim_ConstString_m;

static const  string    randomCounterStartValue_ConstString_m;

static const  string  HamiltonianComponentSwitch_ConstString_m;

static const  string  logExtendedLiftStatistic_ConstString_m;

static const  string  pureSmothnessTest_ConstString_m;
        
 
static const  string  checkpointInterval_ConstString_m;

static const  string    pointFilter_ConstString_m;
static const  string    pointFilterStrategy_ConstString_m;


private:

        bool bWriteToCout_m;

        long64 randomCounterStartValue_m;

        bool bShowProgress_m;
        string inputFileString_m;
        bool   bLocking_m;
        bool    positionInLValue_m;

        bool bNonSmoothPointPassFilter_m;
        bool    firstPQ_m;
        
        int     braceLevel_m;

        int checkpointInterval_m;

        bool    parameterNameExpected_m;

        mutable ofstream os_m;  

        TRing * ringEps_m ;

        string outputFileName_m;

        long64 pointID_m;
        
        list<CoeffListEntry> coeffVariablesOrder_m;

                Parameterlist*  paramList_m;    
                
                
                int     epsPrecision_m;         
                int     fieldCharacteristic_m;          

                int     maxDegree;
                int     maxFocalValuesToCompute_m;
        
                int     gradderpolynome_m;      
        

        
                istream* inputFile_m;   
        
                bool    inputFromStd_m;
                int progressStepWidth_m;
                
                bool bMultipleExperimentsInAFile_m;

                string experimentTag_m;
                string experimentTagNoWS_m;

                bool bPureSmoothnessTest_m;

                
                int maxLift_m;
        
                int liftTrials_m;

                int exhaustiveMaxLift_m;
        
                int exhaustiveLiftTrials_m;


                int requestedLiftPointNum_m;

                long64          azZufallszahlen_m;      
                bool                    randomSeedFromSysTime_m ; 
                mutable long    randomSeed_m;           

                bool    benutzeFormel_1_m;      
                bool    benutzeFormel_2_m;              
                bool    benutzeFormel_23_m;
                int     HamiltonianComponentSwitch_m;

                int minComponentCodim_m;        

                int     reqFullJacobianMinRank_m;               
                int     reqSubJacobianMinRank_m;                
        
                int     bReqVanishedFocalValues_m;

                CFPointFilter*  pointFilter;
        
                bool    bLogExtendedLiftStatistic_m;

                string          lockFileName_m;
                bool            bHasVariableCoefficients_m;
                bool            bAllConstCoefficientsAreVariables_m;

                // Fuer folgende Variablen ist eigentlich eine Extra Polynompaar-Klasse faellig.
                bool    containsMonomsWithAllCoefficientsCheck_m;
                bool    containsMonomsWithRandomCoefficients_m;  // wird auch als Zahl eingesetzt, ind er Main, daher: initialisieren nur mit 1!
                
        

                TPolynomXY*     infEps_minusP_polynom_m;
                TPolynomXY*     infEps_Q_polynom_m;  


                CoeffList       monomsWithAllCoefficients_m; // list of monoms in P or Q for which we want to check all possible coefficiens 
                CoeffList       monomsWithRandomCoefficients_m; // list of monoms in P or Q which we want initialize with random coefficients


        
        
                //CoeffListEntry* currentMonomWithAllCoefficients;
public:

                int getCheckpointInterval()                             const{  return checkpointInterval_m;            }
                int             getMaxLift()                            const   {               return maxLift_m;                               }
        
                int             getLiftTrials()                                 const   {               return liftTrials_m;                    }
                int             getExhaustiveMaxLift()                  const   {               return exhaustiveMaxLift_m;     }
        
                int             getExhaustiveLiftTrials()               const   {               return exhaustiveLiftTrials_m; }                

        
                int             getRequestedLiftPointNum()      const   {               return requestedLiftPointNum_m; }

                inline long64   getRequestedTrialsNum()         const { return azZufallszahlen_m;       }

                inline long &   getRandomSeedRef()              const { return randomSeed_m;                    }
        
                inline long *   getRandomSeedPtr()              const { return & randomSeed_m;                  }
        
                inline bool     bInitRandomFromTime()           const { return randomSeedFromSysTime_m;                 }
 
                inline bool     useFormula1()                   const { return benutzeFormel_1_m;               }
        
                inline bool     useFormula2()                   const { return benutzeFormel_2_m;               }
                inline bool     useFormula23()                  const { return benutzeFormel_23_m;              }

                long64          getRandomCounterStartValue()            const   {               return  randomCounterStartValue_m;                      }

                inline int              getParametrizedFocalValuesNum()                 const
                {
                        if (useFormula23() && useFormula1() && !useFormula2() )
                                return 3;
                        else if (useFormula2() && useFormula1() && !useFormula23() )
                                return 2;
                        else if (useFormula1() && !useFormula23() && !useFormula2() )
                                return 1;
                        else if (!useFormula1() && !useFormula23() && !useFormula2() )
                                return 0;
                        else
                        {
                                std::cerr << "Error: formula combination { formula1=" << useFormula1()<< " and  formula2=" << useFormula2() <<  " and formula23=" << useFormula23() << "} not allowed!" << std::endl;
                                exit(0);
                        }
                }

                inline int      getHamiltonianComponentSwitch()                         const { return HamiltonianComponentSwitch_m;            }
        
                inline unsigned int     getRequiredFullJacobianMinRank()        const { return reqFullJacobianMinRank_m;        }

                inline unsigned int     getRequiredSubJacobianMinRank()         const { return reqSubJacobianMinRank_m;         }
        
                inline int      requiredVanishedFocalValuesNum()        const { return bReqVanishedFocalValues_m;       }

                unsigned int            getMinComponentCodim()  const   {       return minComponentCodim_m;             }




         
                bool            nonSmoothPointPassFilter()                      const  {        return bNonSmoothPointPassFilter_m;             }

                inline int              getEpsPrecision()                               const { return epsPrecision_m;  }       

                inline int              getFieldCharacteristic()                const { return fieldCharacteristic_m;   }

                inline int              getMaxFocalValuesToCompute()            const { return  maxFocalValuesToCompute_m;      }

                inline int              getPolynomialDegree()                   const { return gradderpolynome_m;               }

                inline string   getExperimentTag()                      const { return experimentTag_m;                 }
                inline string   getExperimentTagNoWS()                  const { return experimentTagNoWS_m;                     }

                inline bool     inputFromStd()                          const { return inputFromStd_m;                  }

                
        
                inline string   getOutputFileName()                     const { return outputFileName_m;        }

                inline bool     showProgress()                          const { return bShowProgress_m;                 }

                int                     getProgressStepWidth()                  const   {       return progressStepWidth_m      ;       };      
                
                long64          getPointID()                            const { return pointID_m;                               };


                bool                    pureSmoothnessTest()                    const { return bPureSmoothnessTest_m;           }

                bool writeResultToCout()        const   {return bWriteToCout_m; };

                int             getMaxComputableFocalValues()           const   
                {       
                        assert(fieldCharacteristic_m>2); 
                        return (fieldCharacteristic_m-3)/2;     
                }

                long64   getCoeffTryRandom()    const;
        
                long64   getCoeffTryAll()       const ;

                inline Parameterlist const *    getParameterList()      {       return paramList_m;     }

                bool            isCoefficientVariable   (int x_exp, int y_exp, P_or_QPolynom p_or_q )   const;
                bool            isCoefficientVariable   (const CoeffListEntry & coeffEntry)             const;
                bool            isRandomVariable                (const CoeffListEntry & coeffEntry)             const;

                bool            allConstCoefficientsAreVariables()      const   {       return bAllConstCoefficientsAreVariables_m;     }
                
                bool            hasVariableCoefficients()               const   {       return bHasVariableCoefficients_m;      }

                inline const CoeffList &        getMonomsWithRandomCoefficients()   const {     return monomsWithRandomCoefficients_m; }
        
                inline const CoeffList &        getMonomsWithAllCoefficients()  const { return monomsWithAllCoefficients_m; }
        
                inline bool                     polynomsHaveRandomCoeff()               const { return containsMonomsWithRandomCoefficients_m; }
        
                inline bool                     polynomsHaveCheckAllCoeff()             const { return containsMonomsWithAllCoefficientsCheck_m; }
        
                inline bool                             logExtendedLiftStatistic()              const   {       return bLogExtendedLiftStatistic_m;             }       

                inline bool     polynomsContainsVariableCoeff() const 
                {       
                        return containsMonomsWithRandomCoefficients_m || containsMonomsWithAllCoefficientsCheck_m ;
                };

                bool   pointPassedFilter(       uint16_t        exactVanishedFocalValues,
                                                        uint16_t        jacobianRank,
                                                        bool    smooth,
                                                        uint16_t        quadricsRank)   const
                {
                        
                        return pointFilter->pointPassedFilter(exactVanishedFocalValues,jacobianRank, smooth,quadricsRank);

                }

                inline int                              getPDFCoefficientNum()          const 
                {

                        // 6 Koeffizienten sind nicht variabel.->PDF vom Grad 3 hat 4*5-6 Koeffizienten, die festgelegt werden müssen.
                        return (getPolynomialDegree() + 1 )*( getPolynomialDegree() + 2 ) - 6 ;         
                        
                }

        const list<CoeffListEntry> getCoeffVariablesOrder() const
        {
                return coeffVariablesOrder_m;
        }


        void  printParameters(ostream &oFile) const;


        
        
        // todo: brauche evtl. eine Liste von Polynompaar-Objekten,
        // Problem: es gibt auch Zufallspolynome
                CenterfocusParams( const int argc, const char * const argv[] );
        
                ofstream&               getOsRef()              const           {       return os_m;    }
        

                const TRing *   getRing()                       const   {       return  ringEps_m       ; }

        const TRing &   getRingRef()                    const   {       return  *ringEps_m      ; }


        TPolynomXY const *      getMinusPPolynom()      const   {        return         infEps_minusP_polynom_m;        }
        TPolynomXY const *      getQPolynom()           const   {       return  infEps_Q_polynom_m;             }

        TPolynomXY const &      getMinusPPolynomRef()   const   {       return  *infEps_minusP_polynom_m;       }
        TPolynomXY const &      getQPolynomRef()                const { return  *infEps_Q_polynom_m;            }
        

        bool areWellDefined();

        
private:
                void    init();

                void  setupOutputFile(const int argc, const char * const argv[]);

                void    initExperimentTag() ;

                void    initPolynomialDegree();
                void    initFieldCharacteristic();


                void initHamiltonianComponentSwitch();
                void    initHasVariableCoefficients();
        
                void    initRandomSeed();       
                
                void initCoeffVariablesOrder();

                void  initPointFilter();
                
                //void initLocking();
        long64   getCoeffTry(const CoeffList & coefflist) const;

                void    checkParameters() const;
                void    loadParamList( istream &fileInStream);
                void    loadParamList( string inputFile_);
                void    loadParamListFromString(const char * inputParameters);

                bool   initBoolParameter(string name, bool & internParameter, int printOrder);

                template <class TInternParameter>
                bool   initNonNegativeIntParameter(string name, TInternParameter & internParameter, int printOrder);
                void convertStringParamsToOptions();
                // liest die naehsten p,q-Polynome aus der Eingabedatei ein.
                // liest die naehsten p,q-Polynome aus der Eingabedatei ein.
                // veraedert:
                // p,q,openBracesCount,
                //monomsWithRandomCoeffitents, monomsWithAllCoeffitents,
                // leider ist die Funktion noch nicht vollstaedig,
                // da sich der Grad der polynome aedern kann, wenn mehrere 
                // Polynome n der Eingabedatei angegeben werden.

        public: 
                bool readNextPolynoms();
                string readLParameter();

        private:
                
                void  readMonomGroup(   TRing *                 ring1, 
                                                TPolynomXY              &pol, 
                                                string          &monomGroup, 
                                                int                     momomGroupDegree,
                                                P_or_QPolynom   p_or_q          );
                

                void  updatePolynom(    TRing*          ring1,
                                                TPolynomXY              &pol,
                                                stringstream    &polynomStream,
                                                P_or_QPolynom   p_or_q          );
        
        
                void  updatePolynoms( stringstream & polynomData, TRing* ring1 );

                void    updatePolynomsFromDifferentialForm(string  differentialFormString);

public:
        
// must be public
        void initAllCoeffitientsAreVariables();

        ~CenterfocusParams()
        {       
                delete infEps_minusP_polynom_m; infEps_minusP_polynom_m=NULL;
                delete infEps_Q_polynom_m;              infEps_Q_polynom_m=NULL;
                //delete[] list;
                delete paramList_m;     paramList_m=NULL;
                delete inputFile_m;     inputFile_m=NULL;
                delete ringEps_m;               ringEps_m=NULL;
                
        }


        
        
};

#include "ReadCenterFocusParams.cpp"

} // end namespace nCenterFocus
        



#endif