src/arbint.h

   1 /**
   2  * @file arbint.h
   3  * @brief Arbitrary sized integer declarations
   4  * @see arbint.cpp
   5  */
   6
   7 #ifndef _ARBINT_H
   8 #define _ARBINT_H
   9
  10 #include "common.h"
  11
  12 namespace IPDF
  13 {
  14         class Arbint
  15         {
  16                 public:
  17                         typedef int64_t digit_t;
  18
  19                         Arbint(digit_t i);
  20                         Arbint(const std::vector<digit_t> & digits);
  21                         Arbint(unsigned n, digit_t d0, ...);
  22                         Arbint(const std::string & str, const std::string & base="0123456789");
  23                         ~Arbint() {}
  24                         Arbint(const Arbint & cpy);
  25
  26                         digit_t AsDigit() const
  27                         {
  28                                 digit_t digit = (m_digits.size() == 1) ? m_digits[0] : 0xFFFFFFFFFFFFFFFF;
  29                                 return (m_sign) ? -digit : digit;
  30                         }
  31
  32                         inline bool Sign() const {return m_sign;}
  33                         inline char SignChar() const {return (m_sign) ? '-' : '+';}
  34                         std::string DigitStr() const;
  35
  36                         std::string Str(const std::string & base="0123456789") const;
  37                         inline std::string Str(const char * base) const
  38                         {
  39                                 return Str(std::string(base));
  40                         }
  41
  42                         Arbint & operator=(const Arbint & equ);
  43                         Arbint & operator+=(const Arbint & add);
  44                         Arbint & operator-=(const Arbint & sub);
  45                         Arbint & operator*=(const Arbint & mul);
  46                         void Division(const Arbint & div, Arbint & result, Arbint & modulo) const;
  47
  48                         inline Arbint operator+(const Arbint & add) const
  49                         {
  50                                 Arbint a(*this);
  51                                 a += add;
  52                                 return a;
  53                         }
  54                         inline Arbint operator-(const Arbint & add) const
  55                         {
  56                                 Arbint a(*this);
  57                                 a -= add;
  58                                 return a;
  59                         }
  60
  61                         inline Arbint operator*(const Arbint & mul) const
  62                         {
  63                                 Arbint a(*this);
  64                                 a *= mul;
  65                                 return a;
  66                         }
  67
  68                         inline Arbint & operator/=(const Arbint & div)
  69                         {
  70                                 Arbint result(0L);
  71                                 Arbint remainder(0L);
  72                                 this->Division(div, result, remainder);
  73                                 this->operator=(result);
  74                                 return *this;
  75                         }
  76                         inline Arbint operator/(const Arbint & div)
  77                         {
  78                                 Arbint cpy(*this);
  79                                 cpy /= div;
  80                                 return cpy;
  81                         }
  82                         inline Arbint operator%(const Arbint & div)
  83                         {
  84                                 Arbint result(0L);
  85                                 Arbint remainder(0L);
  86                                 this->Division(div, result, remainder);
  87                                 return remainder;
  88                         }
  89
  90                         bool operator==(const Arbint & equ) const;
  91                         bool operator<(const Arbint & less) const;
  92
  93                         inline bool operator!=(const Arbint & equ) const
  94                         {
  95                                 return !(this->operator==(equ));
  96                         }
  97                         inline bool operator<=(const Arbint & leq) const
  98                         {
  99                                 return (this->operator==(leq) || this->operator<(leq));
 100                         }
 101
 102                         inline bool operator>=(const Arbint & leq) const
 103                         {
 104                                 return (this->operator==(leq) || this->operator>(leq));
 105                         }
 106                         inline bool operator>(const Arbint & grea) const
 107                         {
 108                                 return !(this->operator<=(grea));
 109                         }
 110
 111                         bool IsZero() const;
 112
 113                         //inline operator double() const {return double(AsDigit());}
 114                         inline operator digit_t() const {return AsDigit();}
 115                         //inline operator int() const {return int(AsDigit());}
 116
 117                         unsigned Shrink();
 118                 private:
 119
 120                         Arbint & AddBasic(const Arbint & add);
 121                         Arbint & SubBasic(const Arbint & sub);
 122
 123                         std::vector<digit_t> m_digits;
 124                         bool m_sign;
 125                         void Zero();
 126
 127         };
 128
 129 extern "C"
 130 {
 131         typedef int64_t digit_t;
 132         digit_t add_digits(digit_t * dst, digit_t * add, digit_t size);
 133         digit_t sub_digits(digit_t * dst, digit_t * add, digit_t size);
 134         digit_t mul_digits(digit_t * dst, digit_t mul, digit_t size);
 135 }
 136
 137 }
 138 #endif //_ARBINT_H