fast_Ring.h

Go to the documentation of this file.

#ifndef FAST_RING_H
#define FAST_RING_H


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


#include "fastNumber.h"




using namespace std;

// zum Design:
// bei Koerper fehlt istElement(zahl)
// generic_Ring sollte sowas bieten, wie getZahl


template <class TNum, class kdefs>
class fast_Ring 
{
public:
        typedef         struct sqrtInf 
                        {
                                short solutions;
                                TNum    sqrt;
                                sqrtInf(short _sol,TNum _sqrt): solutions(_sol), sqrt(_sqrt)
                                { }
                        sqrtInf(): solutions(0), sqrt(TNum::Zero)
                                { }
        } sqrtInf_t;


        

        typedef         TNum                                    ElementType;

        typedef         fast_Ring< TNum,kdefs  >                FieldType;

        typedef         typename FieldType::ElementType         ScalarType;



private:

        const unsigned short characteristic;

        long    moduloTableSize_m;

        const unsigned short epsilon;
        

        const TNum      generator;
        const TNum*     elementsToExponentsTab;
        const TNum*     exponentsToElementTab;

        const TNum*     additiveInverseTable;
        const TNum*     multiplicationTable;
        const TNum*     additionTable;
        const TNum*     multiplicativeInverseTable;
        const TNum*     fastAdditionTable;

        const ScalarType * moduloTable;
        const sqrtInf_t* sqrtTable;


protected:
        inline void     init() ;

 public:
        



        bool            wellDefined();

        inline const FieldType * getField() const
        {
                return this;
        }

        inline const FieldType & getFieldRef() const
        {
                return *this;
        }

                fast_Ring(unsigned short _characteristic, unsigned short epsPrec); 
                
                ~fast_Ring();
                inline unsigned short  getCharacteristic() const        {       return characteristic;  }
                inline const  unsigned short & getCharacteristicRef() const     {       return characteristic;  }
        
                inline unsigned short  getEpsPrecision() const          {       return epsilon;         }

                inline void  setEpsPrecision(int epsPrecision) const            
                {
                        assert(epsPrecision<=epsilon);
                        //if (epsPrecision<2)
                        //return epsilon;               
                        return;
                }

                inline bool      isValid(TNum a ) const         { assert(a ==Convert(a) );      return true;    }
        
        //-----------Additionsfunktionen
        

                inline          TNum    add             ( const TNum a, const  TNum b)  const;  
                inline          TNum    addRef  ( const TNum &a,const  TNum& b) const;
                inline void     addInPlace              (TNum& a, const TNum  b)        const;
                inline void     addInPlaceRef           (TNum& a, const TNum & b)       const;
        //-----------Multiplikationsfunktionen

                inline  TNum            addInv   ( const TNum   a ) const;
                inline  TNum            addInvRef( const TNum & a ) const;

                inline  void            addInvInPlace(  TNum & a ) const;
                inline void     accMult( TNum& a ,const TNum b , const TNum c)  const;
                inline void     accMultRef( TNum& a ,const TNum& b , const TNum& c)  const;

                inline void     accMult( TNum* a ,const TNum b , const TNum c)  const;
                inline void     accMultAddr( TNum* a ,const TNum* b , const TNum* c) const;

                inline void     accMultSpec( TNum* const a ,const TNum b , const TNum * const c) const;
        
                inline TNum             multiply(const TNum a, const TNum b) const;
                inline TNum             multiplyRef(const TNum& a, const TNum& b) const;

                inline void     multiplyInPlace( TNum& a, const TNum b) const;
                inline void     multiplyInPlaceRef( TNum& a, const TNum& b) const;
                inline TNum             scalarMultiply   (const FieldType::ElementType a, const TNum b) const;
                inline TNum             scalarMultiplyRef(const FieldType::ElementType& a, const TNum& b) const;

                inline void     scalarMultiplyInPlace   (const FieldType::ElementType a,  TNum & b) const;
                inline void     scalarMultiplyInPlaceRef(const FieldType::ElementType& a,  TNum& b) const;
                inline TNum const       multByExp   (const TNum a, const TNum b) const;
                inline TNum const       multByExpRef(const TNum & a, const TNum & b) const;
                inline void             multByExpInPlace( TNum & a, const TNum  b) const;
                inline void             multByExpInPlaceRef( TNum & a, const TNum & b) const;
                inline  TNum            multInv   (const TNum a) const;
                inline  TNum            multInvRef(const TNum &a) const;
                inline void             multInvInPlace( TNum &a) const;
                inline TNum     pow       ( TNum const a ,unsigned int exp) const;
                inline void     powInPlace( TNum &     a ,unsigned int exp) const;
                inline          sqrtInf         sqrt    ( const TNum a)  const; 
                inline          sqrtInf         sqrtRef ( const TNum &a) const;
                inline  typename FieldType::ElementType  lookupModuloTable(int convertee) const;

                inline int getLookupModuloTableSize() const;

                template <class TConvNum >
                inline TNum     Convert(const TConvNum a) const;

                //template <class TConvNum =double >
                inline TNum     Convert(const double a) const;
                inline TNum     Convert(const int a) const;

                template <class TConvNum >
                inline void     ConvertInPlace( TConvNum & a) const;
                
                inline int      ConvertScalar(const int a) const;

                inline int      ConvertScalarSpec(const int  a) const;
                
                inline int      FastConvertScalar(const int  a) const;
                inline  size_t  getMaxSingleIndex() const;
                inline  size_t  getMaxPairIndex() const;
                inline  size_t  getSingleIndex(const TNum z1) const;
                inline  size_t  getSingleIndexByRef(const TNum &z1) const;

                inline  size_t  getPairIndexByRef(const TNum &z1, const TNum& z2) const;
                inline  size_t  getPairIndex(const TNum z1, const TNum z2) const;

        //inline static void  clear() { }; /* gibt den Index in der Multiplikations- bzw. Additionstabelle zurck */


 protected:
        
        TNum*   createAdditionTable(); /* initialisiert Additionstafel */
        TNum*   createMultiplicationTable(); /* initialisiert Multiplikationstafel */   

        TNum*   createSubtractionTable(); /* initialisiert SubtraAdditionstafel */
        TNum*   createAdditiveInverseTable();
        
        TNum*   createMultiplicativeInverseTable(); /* initialisiert Tabelle fr multiplikative Inverse */

        TNum    getGenerator();

        TNum*   initElementsToExponentsTab(TNum erzeuger);
        TNum*   initExponentsToElementTab(TNum erzeuger);

        TNum*   createFastAdditionTable();

        typename FieldType::ElementType*        createModuloTable(); /* initialisiert Additionstafel */

        sqrtInf_t* createSqrtTable();

};





/*
template <class TNum>
inline int generic_Ring<TNum >::ConvertScalar(const int a) const
{
        int res = a;
        while (res<0)
        {
                res += kdefs::charakteristik;
        }
        if ( res >= kdefs::charakteristik ) 
        {       
                res %= kdefs::charakteristik;
        }
        return res;
}*/




        #include "fast_Ring.cpp"

#endif