frommer.h

Go to the documentation of this file.

#ifndef FROMMER_H
#define FROMMER_H

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

 
#include "FrommerTimer.h"
#include "timer.h"

namespace nCenterFocus
{




template < class TFrommerDefs, int variant>
class Frommer //has to implement the  IFrommer Interface
{

        private:
                std::string name_m;

        #ifdef FROMMERSTAGE_TIMER
                Timer tim_m;
                Timer tim2_m;
                FrommerTimer frommerTimer_m;
                MtcpManager_g.connectTimer(tim_m);
                MtcpManager_g.connectTimer(tim2_m);
        #endif

        public:

                typedef  typename TFrommerDefs::RingType        TRing;

                typedef  typename TFrommerDefs::RingType        RingType;

                typedef typename TFrommerDefs::PolynomXYType    TPolynomXY;
                typedef typename TFrommerDefs::TMatrixXYType TMatrixXYType;

        private:
        #ifdef SAFE
                bool initialized;
        #endif

        short int lastDegree;

        const TRing * const ring;               //u.u liesse sich hier bei den Aufrufen auch was optimieren

        const typename RingType::FieldType & field_ref_m;


        short maxFocalValuesToCompute;

        short maxDegree; 

        TPolynomXY const * q; 

        TPolynomXY const *minusp; 

        TMatrixXYType  * const A;
        TMatrixXYType  * const B; 

        TMatrixXYType  * const dxA;
        TMatrixXYType  * const dyA;

        const typename TRing::ScalarType*  a_table; 
        
        short        currentDegree;

        short currFocalValuePos;

        

protected:
        
                inline void init();
                typename TRing::ScalarType* createLowATable();
        
                void printLowATable(typename TRing::ScalarType* aTable);

        template <class TemplateMatrix>
        inline void outputMatrix(TemplateMatrix *mat) const ;

        inline void outputMatrices() const;

                inline void     compute_dyA_and_dxA();
        
                inline void     perform_C_Step();
                
        

                
                        
                inline void     perform_inner_C_Step(const short j,const short, register short n) ;

                template <int depth, int stage>
                inline void     perform_C_Step_differ_stages();

                template <int depth>
                inline void     perform_C_Step_wrapper(const int stage);

                template <int depth, int stage>
                 void perform_inner_C_Step_differ_stages(const short j,const short, register short n) ;
        
                inline void     perform_the_A_Step();
                inline void     perform_the_even_A_Step();
                inline void     perform_the_odd_A_Step();

public:

        

        Frommer(short m, const TRing *rr);
        virtual ~Frommer();

                inline void     setPolynoms(const TPolynomXY * const minusP_polynom, const TPolynomXY *const Q_polynom);

                inline void     doit(int bComputeAllFocalValues, int jacobi=false);

                 template <int hm>
                  void  doitx(short howMany);

                inline const TRing *    getRing() const;

                inline const TRing &    getRingRef() const;

                typename TRing::ElementType     getFocalValue( int pos) const;

                void    getComputedFocalValues(vector<typename TRing::ElementType> &computedFV ) const;

                short   getSuccessiveVanishedFocalValuesCount() const;
                short   getMaxFocalValuesToCompute() const {return  maxFocalValuesToCompute ; }
                short   getComputedFocalValuesNum() const {return  currFocalValuePos-1 ; }
        void perform_generic_C_Step();

        void printStageTimings(std::ostream & os) const;


        void setName(std::string name) {name_m=name;    }
        private:


        

                

                 typename TRing::ElementType*   computedFocalValues;
};



        #include "frommer.cpp"




} // end Namespace FrommerAlgorithm

#endif // !defined(FROMMER_H)