polynomdefs.h

Go to the documentation of this file.

#pragma once

#include "CompileFunctions.h"

#include <assert.h>

enum P_or_QPolynom
    {
      PCoefficient,
      QCoefficient,
};


// siehe zum besseren Verstaendnis "Aspektorientierte Programmierung in C++: Teil 2, Multiple Aussichten"
// http://www.heise.de/ix/artikel/2001/09/142/09.shtml
// Traits heisst uebrigens Charakterzuege
// see also http://www.oonumerics.org/tmpw00/
// http://www.it.neclab.eu/~berti/generic/




//polynomdefs und MAtrixDefs sind genau gleich -> Eine der Definitionen koennte wegfallen!
template <int DEGREE>
class polynomdefs
{
private:
        enum { 
                pshift_m = needbits<DEGREE>::value
        };
public:
        enum {  
                maxdegree_m     = nextpow2num<DEGREE>::value - 1
        };
        int getSize()  const { return size_m; }
        enum {

                size_m          = (nextpow2num<DEGREE>::value)*(nextpow2num<DEGREE>::value)
        };
        inline  static bool wellDefined()
        {
                return (DEGREE<128);
        };
        inline  static short getPairIndex(const short a, const short b) 
        {
                #ifdef COUNT
                        bitwiseShift    += 1;
                        bitwiseOR       += 1;
                #endif  
                
                //return (((int)a<<pshift)|(int)b);
                return ( ((int)a<<needbits<DEGREE>::value) | (int)b );
        }
};

template <int DEGREE>
class polynomdefsNoShift
{
private:
         
public:
        enum {  
                maxdegree_m     = DEGREE
        };

        enum {
                size_m  =  (DEGREE+1)*(DEGREE+1)
        };
        int getSize()  const { return size_m; }
        inline  static short getPairIndex(const short a, const short b) 
        {
                return ( ( (int)(a+b)*(DEGREE+1)) + (int)b );
        }
};

class dynamicQuadraticMatrixDefsNoShift
{
private:
        int     size_m; 

        dynamicQuadraticMatrixDefsNoShift();
 
public:
        const int       dim_m;
        

        inline int getSize()  const { return size_m; }

        dynamicQuadraticMatrixDefsNoShift(int dimension):       size_m((dimension+1)*(dimension+1) ) ,
                                                                                dim_m(dimension+1)      
                                                                                
        {
        }

        inline  short getPairIndex(const short a, const short b) const
        {
                return (  (int)(a*dim_m) + (int)b );
        }
};


class dynamicPolynomdefsNoShift
{

private:
          int   size_m;
        dynamicPolynomdefsNoShift();
public:
         int    maxdegree_m;
         int    maxdegreePlusOne_m;
        

        inline int getSize()  const { return size_m; }

        dynamicPolynomdefsNoShift(int degree):  size_m((degree+1)*(degree+1) ),
                                                                maxdegree_m(degree),
                                                                maxdegreePlusOne_m(degree+1)
        {
        }

        inline  short getPairIndex(const short a, const short b) const
        {
                return ( ( (int)(a+b)*maxdegreePlusOne_m) + (int)b );
        }
};


class dynamicPolynomdefsNoShiftNoMemoryHoles
{
private:
        int*    offsets_m;
        int     size_m;
        dynamicPolynomdefsNoShiftNoMemoryHoles();
        
        

public:
         int    maxdegree_m;
         int    maxdegreePlusOne_m;
        
        // wegen short getIndex()
        bool wellDefined()
        {
                assert(size_m<32000);
        }

        inline int getSize()  const { return size_m; }

        int computeSize(int degree)
        {
                int size=0;
                for (int currDegree=0;currDegree<=degree; currDegree++)
                {
                        offsets_m[currDegree] = size;
                        for (int yExp=0;yExp<=currDegree; yExp++)
                                size++;
                }
                return size;
        }

        dynamicPolynomdefsNoShiftNoMemoryHoles(int degree):     
                                                        offsets_m(new int[degree+1]),
                                                        size_m(computeSize(degree)),            
                                                        maxdegree_m(degree),
                                                        maxdegreePlusOne_m(degree+1)
        {
        }

        inline  short getPairIndex(const short a, const short b) const
        {

                int offset=0;
                int monomDegree = a+b;
                for (int currDegree=0; currDegree< monomDegree; currDegree++)
                {
                        for (int yExp=0;yExp<=currDegree; yExp++)
                                offset++;
                }
                assert( offsets_m[ monomDegree ] == offset );
                offset = offset + b;
                return offset;
        }
};




template <int DEGREE>
class polynomdefsNew
{
private:
        enum { 
                pshift_m = needbits<DEGREE>::value
        };
public:
        enum {  
                maxdegree_m     = DEGREE
        };

        enum {
                size_m          = (nextpow2num<DEGREE>::value)*(nextpow2num<DEGREE>::value)
        };

        inline static unsigned short getSize()
        {
                return (nextpow2num<DEGREE>::value)*(nextpow2num<DEGREE>::value);
        }
        inline  static size_t getPairIndex(const unsigned short a, const unsigned short b) 
        {
                #ifdef COUNT
                        bitwiseShift    += 1;
                        bitwiseOR       += 1;
                #endif  
                // Vorsicht bein shiften! muss ich pshift sicherheitshalber in ein int konvertieren ja/nein?
                //return (((int)a<<pshift)|(int)b);
                return ( ((int)(a+b)<<needbits<DEGREE>::value) | (int)b );
        }
};



template <int DEGREE>
class polynompairdefs
{
private:
        enum { 
                pshift_m = needbits<DEGREE>::valueplusone
        };
public:
        enum {  
                maxdegree_m     = DEGREE
        };

        enum {
                size_m          = 2*(nextpow2num<DEGREE>::value) * (nextpow2num<DEGREE>::value) 
        };

        int getSize()  const { return size_m; }
        inline  static short    getPairIndex(const short a, const short b) 
        {
                #ifdef COUNT
                        bitwiseShift    += 1;
                        bitwiseOR       += 1;
                #endif  
                // Vorsicht bein shiften! muss ich pshift sicherheitshalber in ein int konvertieren ja/nein?
                //return (((int)a<<pshift)|(int)b);
                return ( ((int)(a+b) << (needbits<DEGREE>::valueplusone)) | (int)(b<<1) );
        }


        inline  static short    getGroupIndex(const short a) 
        {
                #ifdef COUNT
                        bitwiseShift    += 1;
                        bitwiseOR       += 1;
                #endif  
                // Vorsicht bein shiften! muss ich pshift sicherheitshalber in ein int konvertieren ja/nein?
                //return (((int)a<<pshift)|(int)b);
                return ( (int) a << (needbits<DEGREE>::valueplusone) );
        }
};



//maxdegree mei Matrixdef
// haengt nicht vom unteren Datenyp der MAtrix ab, aber legt wohl die 
// maximale groesse fest
template <short CHAR>
class matrixdefs
{
private:
        enum {
                pshift_m = needbits<CHAR>::value
        };
public:
        enum {
                maxdegree_m = nextpow2num<CHAR>::value - 1
        };
        enum {
                size_m  = (nextpow2num<CHAR>::value)*(nextpow2num<CHAR>::value)
        };
        int getSize()  const { return size_m; }
                inline static  short getPairIndex(short a, short b) 
                {
                        #ifdef COUNT
                                bitwiseShift+=1;
                                bitwiseOR+=1;
                        #endif
                        // Vorsicht bein shiften! muss ich pshift sicherheitshalber in ein int konvertieren ja/nein?
                        return ( ((int)a<<needbits<CHAR>::value) | (int)b );

                }
};


template <unsigned int CHAR, unsigned short EPSPREC>
class kdefs_zahl_x
{
        public:
        /*      static  const  short charakteristik;
                static  const  short epsPrecision; // umbenennen in base_num_epsPrecision???
        */
                        
        enum {          
                charakteristik_m = CHAR 
        };
        enum {          
                charakteristik_minus_one_m = CHAR-1
        };
        enum {
                epsPrecision_m   = EPSPREC
        };
};

/* // this implementation does not compile with some compilers, therefore the 'enum' approach is used - leave it as syntax example!
template <int CHAR>
const  short kdefs_zahl_x<CHAR>::charakteristik(CHAR);

template <int CHAR>
const  short kdefs_zahl_x<CHAR>::epsPrecision(EPSPRECISION);
*/