basicNumber.h

Go to the documentation of this file.

#ifndef basicNumber_h
#define basicNumber_h



#include <vector>
#include <iostream>
#include <assert.h>


#include "typedefs.h"
#include <math.h>

#define STR(X) #X
#define SW_STATUS(v1)  STR(v1)





template <typename TScalar>
class basicNumber
{

protected:

          TScalar x;    
          TScalar eps;  

 public:

                typedef TScalar scalarType; // ja? dann sollte man auch fieldScalar als TScalar uebergeben!
        
                static  const   basicNumber Zero;//=basicNumber(0);
                
                static  const   basicNumber One;//=basicNumber(1);

                static inline bool memsetClearAllowed() {       return true; }
                static inline bool wellDefined(unsigned int characteristic);

                inline   basicNumber();
        
                inline basicNumber (TScalar s);
        
                inline basicNumber (TScalar epsPrecision, std::string s );
        
                inline basicNumber (TScalar s, TScalar t);
                
                inline basicNumber (const  basicNumber & z);
        
                inline  unsigned short  getEpsPrecision() const;
                inline  void    setEpsPrecision(int epsPrecision) const {       assert(false);  };
                inline  short   getEpsDegree() const;
                inline  TScalar         getX()          const;  
                inline  TScalar         getEps()        const;  

                inline  void            setX  (TScalar xxx);    
                inline  void            setEps(TScalar _eps) ;

                inline  TScalar         getValue(TScalar epsPrecision) const ;

                inline  void            setValue(TScalar epsPrecision, TScalar coeff) ;
                inline TScalar&         operator[](int i);

                // inline void          operator+=(const basicNumber &z);


                inline  int             nearlyEqual(const basicNumber z) const;
        
                inline  bool            isZero()        const;
                inline  bool            isNotZero()     const;

                inline  bool            operator==( const basicNumber z) const;
                inline  bool            operator!=( const basicNumber z) const;
                
                static size_t   getPairIndex     (const basicNumber a,
                                                                const basicNumber b,
                                                                const TScalar   characteristic);
        
                static size_t   getPairIndexByRef(const basicNumber & a, 
                                                                const basicNumber & b,
                                                                const TScalar   & characteristic);
        
                static size_t   getSingleIndex  (const basicNumber b,
                                                                 const TScalar           characteristic);

                static size_t   getSingleIndexByRef(const basicNumber &         b,
                                                                  const TScalar           & characteristic);

                static size_t           getMaxSingleIndex(  const TScalar       characteristic);
                static size_t           getMaxPairIndex  (  const TScalar       characteristic);
                void printMultSecure(std::ostream &os)  const;

};







template <typename TScalar>
class fieldScalar
{

protected:

          TScalar x;            

 public:
        inline operator int() {return x;}
        //inline operator uint16_t() {return x;}
        //inline operator const uint16_t() const {return x;}
        
        //operator uint16_t() {return x;}
        //operator uint32_t() {return x;}

                typedef TScalar scalarType;
        
                static  const   fieldScalar Zero;//=fieldScalar(0);
                
                static  const   fieldScalar One;//=fieldScalar(1);

                static inline bool memsetClearAllowed() {       return true; }

                static inline bool wellDefined(unsigned int characteristic);
        

                inline   fieldScalar(std::stringstream  & sstream);
                inline   fieldScalar();
                //inline   fieldScalar(int bla):x((TScalar)bla) {};
        
                inline fieldScalar (TScalar s);
                inline fieldScalar (TScalar s,TScalar eps) ; //{ s + 0*EPS }
        
                inline fieldScalar (TScalar epsPrecision, std::string s );
                
                inline fieldScalar (const  fieldScalar & z);
        
                inline  unsigned short  getEpsPrecision() const;

                inline  short   getEpsDegree() const;
                inline  TScalar         getX()   const;
                inline  TScalar         getEps()  const;

                inline  void            setX  (TScalar xxx);    
                inline  void            setEps(TScalar _eps) ;


                inline  TScalar         getValue(TScalar epsPrecision) const;

                inline  void            setValue(TScalar _epsExponent, TScalar coeff) ;
                inline TScalar&         operator[](int i);
                //inline void           operator+=(const fieldScalar &z);

                inline  int             nearlyEqual(const fieldScalar z) const;
        
                inline  bool            isZero()         const;
                inline  bool            isNotZero()     const;

                inline  bool            operator==( const fieldScalar z) const;
                inline  bool            operator!=( const fieldScalar z) const;

                inline static size_t    getSingleIndex          (const fieldScalar b,    
                                                                                 const TScalar  characteristic          );

                inline static size_t    getSingleIndexByRef     (const fieldScalar & b,  
                                                                                const TScalar   & characteristic        );

                inline static size_t    getSingleIndex          (const fieldScalar b  );

                inline static size_t    getSingleIndexByRef     (const fieldScalar & b);

                inline static size_t    getPairIndex     ( const fieldScalar a,  
                                                                         const fieldScalar b, 
                                                                         const TScalar  characteristic  );

                inline static size_t    getPairIndexByRef(const fieldScalar & a,
                                                                        const fieldScalar & b,
                                                                        const TScalar   &characteristic );

                static size_t   getMaxSingleIndex(const TScalar characteristic  );

                static size_t   getMaxPairIndex  (const TScalar characteristic  );
        void printMultSecure(std::ostream &os)  const;
};


        #include "basicNumber.cpp"

#endif // #ifndef basicNumber_h