src/uint256.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
   5 #ifndef BITCOIN_UINT256_H
   6 #define BITCOIN_UINT256_H
   7
   8 #include <limits.h>
   9 #include <string.h>
  10 #include <string>
  11 #include <vector>
  12
  13 typedef long long  int64;
  14 typedef unsigned long long  uint64;
  15
  16
  17 inline int Testuint256AdHoc(std::vector<std::string> vArg);
  18
  19
  20
  21 /** Base class without constructors for uint256 and uint160.
  22  * This makes the compiler let u use it in a union.
  23  */
  24 template<unsigned int BITS>
  25 class base_uint
  26 {
  27 protected:
  28     enum { WIDTH=BITS/32 };
  29     unsigned int pn[WIDTH];
  30 public:
  31
  32     bool operator!() const
  33     {
  34         for (int i = 0; i < WIDTH; i++)
  35             if (pn[i] != 0)
  36                 return false;
  37         return true;
  38     }
  39
  40     const base_uint operator~() const
  41     {
  42         base_uint ret;
  43         for (int i = 0; i < WIDTH; i++)
  44             ret.pn[i] = ~pn[i];
  45         return ret;
  46     }
  47
  48     const base_uint operator-() const
  49     {
  50         base_uint ret;
  51         for (int i = 0; i < WIDTH; i++)
  52             ret.pn[i] = ~pn[i];
  53         ret++;
  54         return ret;
  55     }
  56
  57
  58     base_uint& operator=(uint64 b)
  59     {
  60         pn[0] = (unsigned int)b;
  61         pn[1] = (unsigned int)(b >> 32);
  62         for (int i = 2; i < WIDTH; i++)
  63             pn[i] = 0;
  64         return *this;
  65     }
  66
  67     base_uint& operator^=(const base_uint& b)
  68     {
  69         for (int i = 0; i < WIDTH; i++)
  70             pn[i] ^= b.pn[i];
  71         return *this;
  72     }
  73
  74     base_uint& operator&=(const base_uint& b)
  75     {
  76         for (int i = 0; i < WIDTH; i++)
  77             pn[i] &= b.pn[i];
  78         return *this;
  79     }
  80
  81     base_uint& operator|=(const base_uint& b)
  82     {
  83         for (int i = 0; i < WIDTH; i++)
  84             pn[i] |= b.pn[i];
  85         return *this;
  86     }
  87
  88     base_uint& operator^=(uint64 b)
  89     {
  90         pn[0] ^= (unsigned int)b;
  91         pn[1] ^= (unsigned int)(b >> 32);
  92         return *this;
  93     }
  94
  95     base_uint& operator|=(uint64 b)
  96     {
  97         pn[0] |= (unsigned int)b;
  98         pn[1] |= (unsigned int)(b >> 32);
  99         return *this;
 100     }
 101
 102     base_uint& operator<<=(unsigned int shift)
 103     {
 104         base_uint a(*this);
 105         for (int i = 0; i < WIDTH; i++)
 106             pn[i] = 0;
 107         int k = shift / 32;
 108         shift = shift % 32;
 109         for (int i = 0; i < WIDTH; i++)
 110         {
 111             if (i+k+1 < WIDTH && shift != 0)
 112                 pn[i+k+1] |= (a.pn[i] >> (32-shift));
 113             if (i+k < WIDTH)
 114                 pn[i+k] |= (a.pn[i] << shift);
 115         }
 116         return *this;
 117     }
 118
 119     base_uint& operator>>=(unsigned int shift)
 120     {
 121         base_uint a(*this);
 122         for (int i = 0; i < WIDTH; i++)
 123             pn[i] = 0;
 124         int k = shift / 32;
 125         shift = shift % 32;
 126         for (int i = 0; i < WIDTH; i++)
 127         {
 128             if (i-k-1 >= 0 && shift != 0)
 129                 pn[i-k-1] |= (a.pn[i] << (32-shift));
 130             if (i-k >= 0)
 131                 pn[i-k] |= (a.pn[i] >> shift);
 132         }
 133         return *this;
 134     }
 135
 136     base_uint& operator+=(const base_uint& b)
 137     {
 138         uint64 carry = 0;
 139         for (int i = 0; i < WIDTH; i++)
 140         {
 141             uint64 n = carry + pn[i] + b.pn[i];
 142             pn[i] = n & 0xffffffff;
 143             carry = n >> 32;
 144         }
 145         return *this;
 146     }
 147
 148     base_uint& operator-=(const base_uint& b)
 149     {
 150         *this += -b;
 151         return *this;
 152     }
 153
 154     base_uint& operator+=(uint64 b64)
 155     {
 156         base_uint b;
 157         b = b64;
 158         *this += b;
 159         return *this;
 160     }
 161
 162     base_uint& operator-=(uint64 b64)
 163     {
 164         base_uint b;
 165         b = b64;
 166         *this += -b;
 167         return *this;
 168     }
 169
 170
 171     base_uint& operator++()
 172     {
 173         // prefix operator
 174         int i = 0;
 175         while (++pn[i] == 0 && i < WIDTH-1)
 176             i++;
 177         return *this;
 178     }
 179
 180     const base_uint operator++(int)
 181     {
 182         // postfix operator
 183         const base_uint ret = *this;
 184         ++(*this);
 185         return ret;
 186     }
 187
 188     base_uint& operator--()
 189     {
 190         // prefix operator
 191         int i = 0;
 192         while (--pn[i] == -1 && i < WIDTH-1)
 193             i++;
 194         return *this;
 195     }
 196
 197     const base_uint operator--(int)
 198     {
 199         // postfix operator
 200         const base_uint ret = *this;
 201         --(*this);
 202         return ret;
 203     }
 204
 205
 206     friend inline bool operator<(const base_uint& a, const base_uint& b)
 207     {
 208         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 209         {
 210             if (a.pn[i] < b.pn[i])
 211                 return true;
 212             else if (a.pn[i] > b.pn[i])
 213                 return false;
 214         }
 215         return false;
 216     }
 217
 218     friend inline bool operator<=(const base_uint& a, const base_uint& b)
 219     {
 220         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 221         {
 222             if (a.pn[i] < b.pn[i])
 223                 return true;
 224             else if (a.pn[i] > b.pn[i])
 225                 return false;
 226         }
 227         return true;
 228     }
 229
 230     friend inline bool operator>(const base_uint& a, const base_uint& b)
 231     {
 232         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 233         {
 234             if (a.pn[i] > b.pn[i])
 235                 return true;
 236             else if (a.pn[i] < b.pn[i])
 237                 return false;
 238         }
 239         return false;
 240     }
 241
 242     friend inline bool operator>=(const base_uint& a, const base_uint& b)
 243     {
 244         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 245         {
 246             if (a.pn[i] > b.pn[i])
 247                 return true;
 248             else if (a.pn[i] < b.pn[i])
 249                 return false;
 250         }
 251         return true;
 252     }
 253
 254     friend inline bool operator==(const base_uint& a, const base_uint& b)
 255     {
 256         for (int i = 0; i < base_uint::WIDTH; i++)
 257             if (a.pn[i] != b.pn[i])
 258                 return false;
 259         return true;
 260     }
 261
 262     friend inline bool operator==(const base_uint& a, uint64 b)
 263     {
 264         if (a.pn[0] != (unsigned int)b)
 265             return false;
 266         if (a.pn[1] != (unsigned int)(b >> 32))
 267             return false;
 268         for (int i = 2; i < base_uint::WIDTH; i++)
 269             if (a.pn[i] != 0)
 270                 return false;
 271         return true;
 272     }
 273
 274     friend inline bool operator!=(const base_uint& a, const base_uint& b)
 275     {
 276         return (!(a == b));
 277     }
 278
 279     friend inline bool operator!=(const base_uint& a, uint64 b)
 280     {
 281         return (!(a == b));
 282     }
 283
 284
 285
 286     std::string GetHex() const
 287     {
 288         char psz[sizeof(pn)*2 + 1];
 289         for (unsigned int i = 0; i < sizeof(pn); i++)
 290             sprintf(psz + i*2, "%02x", ((unsigned char*)pn)[sizeof(pn) - i - 1]);
 291         return std::string(psz, psz + sizeof(pn)*2);
 292     }
 293
 294     void SetHex(const char* psz)
 295     {
 296         for (int i = 0; i < WIDTH; i++)
 297             pn[i] = 0;
 298
 299         // skip leading spaces
 300         while (isspace(*psz))
 301             psz++;
 302
 303         // skip 0x
 304         if (psz[0] == '0' && tolower(psz[1]) == 'x')
 305             psz += 2;
 306
 307         // hex string to uint
 308         static unsigned char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
 309         const char* pbegin = psz;
 310         while (phexdigit[(unsigned char)*psz] || *psz == '0')
 311             psz++;
 312         psz--;
 313         unsigned char* p1 = (unsigned char*)pn;
 314         unsigned char* pend = p1 + WIDTH * 4;
 315         while (psz >= pbegin && p1 < pend)
 316         {
 317             *p1 = phexdigit[(unsigned char)*psz--];
 318             if (psz >= pbegin)
 319             {
 320                 *p1 |= (phexdigit[(unsigned char)*psz--] << 4);
 321                 p1++;
 322             }
 323         }
 324     }
 325
 326     void SetHex(const std::string& str)
 327     {
 328         SetHex(str.c_str());
 329     }
 330
 331     std::string ToString() const
 332     {
 333         return (GetHex());
 334     }
 335
 336     unsigned char* begin()
 337     {
 338         return (unsigned char*)&pn[0];
 339     }
 340
 341     unsigned char* end()
 342     {
 343         return (unsigned char*)&pn[WIDTH];
 344     }
 345
 346     unsigned int size()
 347     {
 348         return sizeof(pn);
 349     }
 350
 351     uint64 Get64(int n=0) const
 352     {
 353         return pn[2*n] | (uint64)pn[2*n+1] << 32;
 354     }
 355
 356 //    unsigned int GetSerializeSize(int nType=0, int nVersion=PROTOCOL_VERSION) const
 357     unsigned int GetSerializeSize(int nType, int nVersion) const
 358     {
 359         return sizeof(pn);
 360     }
 361
 362     template<typename Stream>
 363 //    void Serialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) const
 364     void Serialize(Stream& s, int nType, int nVersion) const
 365     {
 366         s.write((char*)pn, sizeof(pn));
 367     }
 368
 369     template<typename Stream>
 370 //    void Unserialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION)
 371     void Unserialize(Stream& s, int nType, int nVersion)
 372     {
 373         s.read((char*)pn, sizeof(pn));
 374     }
 375
 376
 377     friend class uint160;
 378     friend class uint256;
 379     friend inline int Testuint256AdHoc(std::vector<std::string> vArg);
 380 };
 381
 382 typedef base_uint<160> base_uint160;
 383 typedef base_uint<256> base_uint256;
 384
 385
 386
 387 //
 388 // uint160 and uint256 could be implemented as templates, but to keep
 389 // compile errors and debugging cleaner, they're copy and pasted.
 390 //
 391
 392
 393
 394 //////////////////////////////////////////////////////////////////////////////
 395 //
 396 // uint160
 397 //
 398
 399 /** 160-bit unsigned integer */
 400 class uint160 : public base_uint160
 401 {
 402 public:
 403     typedef base_uint160 basetype;
 404
 405     uint160()
 406     {
 407         for (int i = 0; i < WIDTH; i++)
 408             pn[i] = 0;
 409     }
 410
 411     uint160(const basetype& b)
 412     {
 413         for (int i = 0; i < WIDTH; i++)
 414             pn[i] = b.pn[i];
 415     }
 416
 417     uint160& operator=(const basetype& b)
 418     {
 419         for (int i = 0; i < WIDTH; i++)
 420             pn[i] = b.pn[i];
 421         return *this;
 422     }
 423
 424     uint160(uint64 b)
 425     {
 426         pn[0] = (unsigned int)b;
 427         pn[1] = (unsigned int)(b >> 32);
 428         for (int i = 2; i < WIDTH; i++)
 429             pn[i] = 0;
 430     }
 431
 432     uint160& operator=(uint64 b)
 433     {
 434         pn[0] = (unsigned int)b;
 435         pn[1] = (unsigned int)(b >> 32);
 436         for (int i = 2; i < WIDTH; i++)
 437             pn[i] = 0;
 438         return *this;
 439     }
 440
 441     explicit uint160(const std::string& str)
 442     {
 443         SetHex(str);
 444     }
 445
 446     explicit uint160(const std::vector<unsigned char>& vch)
 447     {
 448         if (vch.size() == sizeof(pn))
 449             memcpy(pn, &vch[0], sizeof(pn));
 450         else
 451             *this = 0;
 452     }
 453 };
 454
 455 inline bool operator==(const uint160& a, uint64 b)                           { return (base_uint160)a == b; }
 456 inline bool operator!=(const uint160& a, uint64 b)                           { return (base_uint160)a != b; }
 457 inline const uint160 operator<<(const base_uint160& a, unsigned int shift)   { return uint160(a) <<= shift; }
 458 inline const uint160 operator>>(const base_uint160& a, unsigned int shift)   { return uint160(a) >>= shift; }
 459 inline const uint160 operator<<(const uint160& a, unsigned int shift)        { return uint160(a) <<= shift; }
 460 inline const uint160 operator>>(const uint160& a, unsigned int shift)        { return uint160(a) >>= shift; }
 461
 462 inline const uint160 operator^(const base_uint160& a, const base_uint160& b) { return uint160(a) ^= b; }
 463 inline const uint160 operator&(const base_uint160& a, const base_uint160& b) { return uint160(a) &= b; }
 464 inline const uint160 operator|(const base_uint160& a, const base_uint160& b) { return uint160(a) |= b; }
 465 inline const uint160 operator+(const base_uint160& a, const base_uint160& b) { return uint160(a) += b; }
 466 inline const uint160 operator-(const base_uint160& a, const base_uint160& b) { return uint160(a) -= b; }
 467
 468 inline bool operator<(const base_uint160& a, const uint160& b)          { return (base_uint160)a <  (base_uint160)b; }
 469 inline bool operator<=(const base_uint160& a, const uint160& b)         { return (base_uint160)a <= (base_uint160)b; }
 470 inline bool operator>(const base_uint160& a, const uint160& b)          { return (base_uint160)a >  (base_uint160)b; }
 471 inline bool operator>=(const base_uint160& a, const uint160& b)         { return (base_uint160)a >= (base_uint160)b; }
 472 inline bool operator==(const base_uint160& a, const uint160& b)         { return (base_uint160)a == (base_uint160)b; }
 473 inline bool operator!=(const base_uint160& a, const uint160& b)         { return (base_uint160)a != (base_uint160)b; }
 474 inline const uint160 operator^(const base_uint160& a, const uint160& b) { return (base_uint160)a ^  (base_uint160)b; }
 475 inline const uint160 operator&(const base_uint160& a, const uint160& b) { return (base_uint160)a &  (base_uint160)b; }
 476 inline const uint160 operator|(const base_uint160& a, const uint160& b) { return (base_uint160)a |  (base_uint160)b; }
 477 inline const uint160 operator+(const base_uint160& a, const uint160& b) { return (base_uint160)a +  (base_uint160)b; }
 478 inline const uint160 operator-(const base_uint160& a, const uint160& b) { return (base_uint160)a -  (base_uint160)b; }
 479
 480 inline bool operator<(const uint160& a, const base_uint160& b)          { return (base_uint160)a <  (base_uint160)b; }
 481 inline bool operator<=(const uint160& a, const base_uint160& b)         { return (base_uint160)a <= (base_uint160)b; }
 482 inline bool operator>(const uint160& a, const base_uint160& b)          { return (base_uint160)a >  (base_uint160)b; }
 483 inline bool operator>=(const uint160& a, const base_uint160& b)         { return (base_uint160)a >= (base_uint160)b; }
 484 inline bool operator==(const uint160& a, const base_uint160& b)         { return (base_uint160)a == (base_uint160)b; }
 485 inline bool operator!=(const uint160& a, const base_uint160& b)         { return (base_uint160)a != (base_uint160)b; }
 486 inline const uint160 operator^(const uint160& a, const base_uint160& b) { return (base_uint160)a ^  (base_uint160)b; }
 487 inline const uint160 operator&(const uint160& a, const base_uint160& b) { return (base_uint160)a &  (base_uint160)b; }
 488 inline const uint160 operator|(const uint160& a, const base_uint160& b) { return (base_uint160)a |  (base_uint160)b; }
 489 inline const uint160 operator+(const uint160& a, const base_uint160& b) { return (base_uint160)a +  (base_uint160)b; }
 490 inline const uint160 operator-(const uint160& a, const base_uint160& b) { return (base_uint160)a -  (base_uint160)b; }
 491
 492 inline bool operator<(const uint160& a, const uint160& b)               { return (base_uint160)a <  (base_uint160)b; }
 493 inline bool operator<=(const uint160& a, const uint160& b)              { return (base_uint160)a <= (base_uint160)b; }
 494 inline bool operator>(const uint160& a, const uint160& b)               { return (base_uint160)a >  (base_uint160)b; }
 495 inline bool operator>=(const uint160& a, const uint160& b)              { return (base_uint160)a >= (base_uint160)b; }
 496 inline bool operator==(const uint160& a, const uint160& b)              { return (base_uint160)a == (base_uint160)b; }
 497 inline bool operator!=(const uint160& a, const uint160& b)              { return (base_uint160)a != (base_uint160)b; }
 498 inline const uint160 operator^(const uint160& a, const uint160& b)      { return (base_uint160)a ^  (base_uint160)b; }
 499 inline const uint160 operator&(const uint160& a, const uint160& b)      { return (base_uint160)a &  (base_uint160)b; }
 500 inline const uint160 operator|(const uint160& a, const uint160& b)      { return (base_uint160)a |  (base_uint160)b; }
 501 inline const uint160 operator+(const uint160& a, const uint160& b)      { return (base_uint160)a +  (base_uint160)b; }
 502 inline const uint160 operator-(const uint160& a, const uint160& b)      { return (base_uint160)a -  (base_uint160)b; }
 503
 504
 505
 506
 507
 508
 509 //////////////////////////////////////////////////////////////////////////////
 510 //
 511 // uint256
 512 //
 513
 514 /** 256-bit unsigned integer */
 515 class uint256 : public base_uint256
 516 {
 517 public:
 518     typedef base_uint256 basetype;
 519
 520     uint256()
 521     {
 522         for (int i = 0; i < WIDTH; i++)
 523             pn[i] = 0;
 524     }
 525
 526     uint256(const basetype& b)
 527     {
 528         for (int i = 0; i < WIDTH; i++)
 529             pn[i] = b.pn[i];
 530     }
 531
 532     uint256& operator=(const basetype& b)
 533     {
 534         for (int i = 0; i < WIDTH; i++)
 535             pn[i] = b.pn[i];
 536         return *this;
 537     }
 538
 539     uint256(uint64 b)
 540     {
 541         pn[0] = (unsigned int)b;
 542         pn[1] = (unsigned int)(b >> 32);
 543         for (int i = 2; i < WIDTH; i++)
 544             pn[i] = 0;
 545     }
 546
 547     uint256& operator=(uint64 b)
 548     {
 549         pn[0] = (unsigned int)b;
 550         pn[1] = (unsigned int)(b >> 32);
 551         for (int i = 2; i < WIDTH; i++)
 552             pn[i] = 0;
 553         return *this;
 554     }
 555
 556     explicit uint256(const std::string& str)
 557     {
 558         SetHex(str);
 559     }
 560
 561     explicit uint256(const std::vector<unsigned char>& vch)
 562     {
 563         if (vch.size() == sizeof(pn))
 564             memcpy(pn, &vch[0], sizeof(pn));
 565         else
 566             *this = 0;
 567     }
 568 };
 569
 570 inline bool operator==(const uint256& a, uint64 b)                           { return (base_uint256)a == b; }
 571 inline bool operator!=(const uint256& a, uint64 b)                           { return (base_uint256)a != b; }
 572 inline const uint256 operator<<(const base_uint256& a, unsigned int shift)   { return uint256(a) <<= shift; }
 573 inline const uint256 operator>>(const base_uint256& a, unsigned int shift)   { return uint256(a) >>= shift; }
 574 inline const uint256 operator<<(const uint256& a, unsigned int shift)        { return uint256(a) <<= shift; }
 575 inline const uint256 operator>>(const uint256& a, unsigned int shift)        { return uint256(a) >>= shift; }
 576
 577 inline const uint256 operator^(const base_uint256& a, const base_uint256& b) { return uint256(a) ^= b; }
 578 inline const uint256 operator&(const base_uint256& a, const base_uint256& b) { return uint256(a) &= b; }
 579 inline const uint256 operator|(const base_uint256& a, const base_uint256& b) { return uint256(a) |= b; }
 580 inline const uint256 operator+(const base_uint256& a, const base_uint256& b) { return uint256(a) += b; }
 581 inline const uint256 operator-(const base_uint256& a, const base_uint256& b) { return uint256(a) -= b; }
 582
 583 inline bool operator<(const base_uint256& a, const uint256& b)          { return (base_uint256)a <  (base_uint256)b; }
 584 inline bool operator<=(const base_uint256& a, const uint256& b)         { return (base_uint256)a <= (base_uint256)b; }
 585 inline bool operator>(const base_uint256& a, const uint256& b)          { return (base_uint256)a >  (base_uint256)b; }
 586 inline bool operator>=(const base_uint256& a, const uint256& b)         { return (base_uint256)a >= (base_uint256)b; }
 587 inline bool operator==(const base_uint256& a, const uint256& b)         { return (base_uint256)a == (base_uint256)b; }
 588 inline bool operator!=(const base_uint256& a, const uint256& b)         { return (base_uint256)a != (base_uint256)b; }
 589 inline const uint256 operator^(const base_uint256& a, const uint256& b) { return (base_uint256)a ^  (base_uint256)b; }
 590 inline const uint256 operator&(const base_uint256& a, const uint256& b) { return (base_uint256)a &  (base_uint256)b; }
 591 inline const uint256 operator|(const base_uint256& a, const uint256& b) { return (base_uint256)a |  (base_uint256)b; }
 592 inline const uint256 operator+(const base_uint256& a, const uint256& b) { return (base_uint256)a +  (base_uint256)b; }
 593 inline const uint256 operator-(const base_uint256& a, const uint256& b) { return (base_uint256)a -  (base_uint256)b; }
 594
 595 inline bool operator<(const uint256& a, const base_uint256& b)          { return (base_uint256)a <  (base_uint256)b; }
 596 inline bool operator<=(const uint256& a, const base_uint256& b)         { return (base_uint256)a <= (base_uint256)b; }
 597 inline bool operator>(const uint256& a, const base_uint256& b)          { return (base_uint256)a >  (base_uint256)b; }
 598 inline bool operator>=(const uint256& a, const base_uint256& b)         { return (base_uint256)a >= (base_uint256)b; }
 599 inline bool operator==(const uint256& a, const base_uint256& b)         { return (base_uint256)a == (base_uint256)b; }
 600 inline bool operator!=(const uint256& a, const base_uint256& b)         { return (base_uint256)a != (base_uint256)b; }
 601 inline const uint256 operator^(const uint256& a, const base_uint256& b) { return (base_uint256)a ^  (base_uint256)b; }
 602 inline const uint256 operator&(const uint256& a, const base_uint256& b) { return (base_uint256)a &  (base_uint256)b; }
 603 inline const uint256 operator|(const uint256& a, const base_uint256& b) { return (base_uint256)a |  (base_uint256)b; }
 604 inline const uint256 operator+(const uint256& a, const base_uint256& b) { return (base_uint256)a +  (base_uint256)b; }
 605 inline const uint256 operator-(const uint256& a, const base_uint256& b) { return (base_uint256)a -  (base_uint256)b; }
 606
 607 inline bool operator<(const uint256& a, const uint256& b)               { return (base_uint256)a <  (base_uint256)b; }
 608 inline bool operator<=(const uint256& a, const uint256& b)              { return (base_uint256)a <= (base_uint256)b; }
 609 inline bool operator>(const uint256& a, const uint256& b)               { return (base_uint256)a >  (base_uint256)b; }
 610 inline bool operator>=(const uint256& a, const uint256& b)              { return (base_uint256)a >= (base_uint256)b; }
 611 inline bool operator==(const uint256& a, const uint256& b)              { return (base_uint256)a == (base_uint256)b; }
 612 inline bool operator!=(const uint256& a, const uint256& b)              { return (base_uint256)a != (base_uint256)b; }
 613 inline const uint256 operator^(const uint256& a, const uint256& b)      { return (base_uint256)a ^  (base_uint256)b; }
 614 inline const uint256 operator&(const uint256& a, const uint256& b)      { return (base_uint256)a &  (base_uint256)b; }
 615 inline const uint256 operator|(const uint256& a, const uint256& b)      { return (base_uint256)a |  (base_uint256)b; }
 616 inline const uint256 operator+(const uint256& a, const uint256& b)      { return (base_uint256)a +  (base_uint256)b; }
 617 inline const uint256 operator-(const uint256& a, const uint256& b)      { return (base_uint256)a -  (base_uint256)b; }
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628 #ifdef TEST_UINT256
 629
 630 inline int Testuint256AdHoc(std::vector<std::string> vArg)
 631 {
 632     uint256 g(0);
 633
 634
 635     printf("%s\n", g.ToString().c_str());
 636     g--;  printf("g--\n");
 637     printf("%s\n", g.ToString().c_str());
 638     g--;  printf("g--\n");
 639     printf("%s\n", g.ToString().c_str());
 640     g++;  printf("g++\n");
 641     printf("%s\n", g.ToString().c_str());
 642     g++;  printf("g++\n");
 643     printf("%s\n", g.ToString().c_str());
 644     g++;  printf("g++\n");
 645     printf("%s\n", g.ToString().c_str());
 646     g++;  printf("g++\n");
 647     printf("%s\n", g.ToString().c_str());
 648
 649
 650
 651     uint256 a(7);
 652     printf("a=7\n");
 653     printf("%s\n", a.ToString().c_str());
 654
 655     uint256 b;
 656     printf("b undefined\n");
 657     printf("%s\n", b.ToString().c_str());
 658     int c = 3;
 659
 660     a = c;
 661     a.pn[3] = 15;
 662     printf("%s\n", a.ToString().c_str());
 663     uint256 k(c);
 664
 665     a = 5;
 666     a.pn[3] = 15;
 667     printf("%s\n", a.ToString().c_str());
 668     b = 1;
 669     b <<= 52;
 670
 671     a |= b;
 672
 673     a ^= 0x500;
 674
 675     printf("a %s\n", a.ToString().c_str());
 676
 677     a = a | b | (uint256)0x1000;
 678
 679
 680     printf("a %s\n", a.ToString().c_str());
 681     printf("b %s\n", b.ToString().c_str());
 682
 683     a = 0xfffffffe;
 684     a.pn[4] = 9;
 685
 686     printf("%s\n", a.ToString().c_str());
 687     a++;
 688     printf("%s\n", a.ToString().c_str());
 689     a++;
 690     printf("%s\n", a.ToString().c_str());
 691     a++;
 692     printf("%s\n", a.ToString().c_str());
 693     a++;
 694     printf("%s\n", a.ToString().c_str());
 695
 696     a--;
 697     printf("%s\n", a.ToString().c_str());
 698     a--;
 699     printf("%s\n", a.ToString().c_str());
 700     a--;
 701     printf("%s\n", a.ToString().c_str());
 702     uint256 d = a--;
 703     printf("%s\n", d.ToString().c_str());
 704     printf("%s\n", a.ToString().c_str());
 705     a--;
 706     printf("%s\n", a.ToString().c_str());
 707     a--;
 708     printf("%s\n", a.ToString().c_str());
 709
 710     d = a;
 711
 712     printf("%s\n", d.ToString().c_str());
 713     for (int i = uint256::WIDTH-1; i >= 0; i--) printf("%08x", d.pn[i]); printf("\n");
 714
 715     uint256 neg = d;
 716     neg = ~neg;
 717     printf("%s\n", neg.ToString().c_str());
 718
 719
 720     uint256 e = uint256("0xABCDEF123abcdef12345678909832180000011111111");
 721     printf("\n");
 722     printf("%s\n", e.ToString().c_str());
 723
 724
 725     printf("\n");
 726     uint256 x1 = uint256("0xABCDEF123abcdef12345678909832180000011111111");
 727     uint256 x2;
 728     printf("%s\n", x1.ToString().c_str());
 729     for (int i = 0; i < 270; i += 4)
 730     {
 731         x2 = x1 << i;
 732         printf("%s\n", x2.ToString().c_str());
 733     }
 734
 735     printf("\n");
 736     printf("%s\n", x1.ToString().c_str());
 737     for (int i = 0; i < 270; i += 4)
 738     {
 739         x2 = x1;
 740         x2 >>= i;
 741         printf("%s\n", x2.ToString().c_str());
 742     }
 743
 744
 745     for (int i = 0; i < 100; i++)
 746     {
 747         uint256 k = (~uint256(0) >> i);
 748         printf("%s\n", k.ToString().c_str());
 749     }
 750
 751     for (int i = 0; i < 100; i++)
 752     {
 753         uint256 k = (~uint256(0) << i);
 754         printf("%s\n", k.ToString().c_str());
 755     }
 756
 757     return (0);
 758 }
 759
 760 #endif
 761
 762 #endif