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 uint64_t digit_t;
  18
  19                         Arbint(int64_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                         virtual ~Arbint() {}
  24                         Arbint(const Arbint & cpy);
  25
  26                         int64_t AsDigit() const
  27                         {
  28                                 int64_t digit = (m_digits.size() == 1) ? m_digits[0] : 0x7FFFFFFFFFFFFFFF;
  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                         Arbint & operator<<=(unsigned amount);
  49                         Arbint & operator>>=(unsigned amount);
  50
  51                         inline Arbint operator+(const Arbint & add) const
  52                         {
  53                                 Arbint a(*this);
  54                                 a += add;
  55                                 return a;
  56                         }
  57                         inline Arbint operator-(const Arbint & add) const
  58                         {
  59                                 Arbint a(*this);
  60                                 a -= add;
  61                                 return a;
  62                         }
  63
  64                         inline Arbint operator*(const Arbint & mul) const
  65                         {
  66                                 Arbint a(*this);
  67                                 a *= mul;
  68                                 return a;
  69                         }
  70
  71                         inline Arbint & operator/=(const Arbint & div)
  72                         {
  73                                 Arbint result(0L);
  74                                 Arbint remainder(0L);
  75                                 this->Division(div, result, remainder);
  76                                 this->operator=(result);
  77                                 return *this;
  78                         }
  79                         inline Arbint operator/(const Arbint & div)
  80                         {
  81                                 Arbint cpy(*this);
  82                                 cpy /= div;
  83                                 return cpy;
  84                         }
  85                         inline Arbint operator%(const Arbint & div)
  86                         {
  87                                 Arbint result(0L);
  88                                 Arbint remainder(0L);
  89                                 this->Division(div, result, remainder);
  90                                 return remainder;
  91                         }
  92
  93                         bool operator==(const Arbint & equ) const;
  94                         bool operator<(const Arbint & less) const;
  95
  96                         inline bool operator!=(const Arbint & equ) const
  97                         {
  98                                 return !(this->operator==(equ));
  99                         }
 100                         inline bool operator<=(const Arbint & leq) const
 101                         {
 102                                 return (this->operator==(leq) || this->operator<(leq));
 103                         }
 104
 105                         inline bool operator>=(const Arbint & leq) const
 106                         {
 107                                 return (this->operator==(leq) || this->operator>(leq));
 108                         }
 109                         inline bool operator>(const Arbint & grea) const
 110                         {
 111                                 return !(this->operator<=(grea));
 112                         }
 113                         inline Arbint operator>>(unsigned amount) const
 114                         {
 115                                 Arbint result(*this);
 116                                 result >>= amount;
 117                                 return result;
 118                         }
 119                         inline Arbint operator<<(unsigned amount) const
 120                         {
 121                                 Arbint result(*this);
 122                                 result <<= amount;
 123                                 return result;
 124                         }
 125                         bool IsZero() const;
 126
 127                         //inline operator double() const {return double(AsDigit());}
 128                         inline operator int64_t() const {return AsDigit();}
 129                         //inline operator int() const {return int(AsDigit());}
 130
 131                         unsigned Shrink();
 132
 133                         inline Arbint Abs() const {Arbint a(*this); a.m_sign = false; return a;}
 134                 private:
 135
 136                         Arbint & AddBasic(const Arbint & add);
 137                         Arbint & SubBasic(const Arbint & sub);
 138
 139                         bool GetBit(unsigned i) const;
 140                         void BitClear(unsigned i);
 141                         void BitSet(unsigned i);
 142
 143
 144                         std::vector<digit_t> m_digits;
 145                         bool m_sign;
 146                         void Zero();
 147
 148         };
 149
 150
 151
 152 extern "C"
 153 {
 154         typedef uint64_t digit_t;
 155         digit_t add_digits(digit_t * dst, digit_t * add, digit_t size);
 156         digit_t sub_digits(digit_t * dst, digit_t * add, digit_t size);
 157         digit_t mul_digits(digit_t * dst, digit_t mul, digit_t size);
 158         digit_t div_digits(digit_t * dst, digit_t div, digit_t size, digit_t * rem);
 159 }
 160
 161
 162
 163 }
 164 #endif //_ARBINT_H