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 "serialize.h"
   9
  10 #include <limits.h>
  11 #include <string>
  12 #include <vector>
  13
  14 typedef long long  int64;
  15 typedef unsigned long long  uint64;
  16
  17
  18 inline int Testuint256AdHoc(std::vector<std::string> vArg);
  19
  20
  21
  22 // We have to keep a separate base class without constructors
  23 // so the compiler will let us use it in a union
  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 (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 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[*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
 352     unsigned int GetSerializeSize(int nType=0, int nVersion=PROTOCOL_VERSION) const
 353     {
 354         return sizeof(pn);
 355     }
 356
 357     template<typename Stream>
 358     void Serialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) const
 359     {
 360         s.write((char*)pn, sizeof(pn));
 361     }
 362
 363     template<typename Stream>
 364     void Unserialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION)
 365     {
 366         s.read((char*)pn, sizeof(pn));
 367     }
 368
 369
 370     friend class uint160;
 371     friend class uint256;
 372     friend inline int Testuint256AdHoc(std::vector<std::string> vArg);
 373 };
 374
 375 typedef base_uint<160> base_uint160;
 376 typedef base_uint<256> base_uint256;
 377
 378
 379
 380 //
 381 // uint160 and uint256 could be implemented as templates, but to keep
 382 // compile errors and debugging cleaner, they're copy and pasted.
 383 //
 384
 385
 386
 387 //////////////////////////////////////////////////////////////////////////////
 388 //
 389 // uint160
 390 //
 391
 392 class uint160 : public base_uint160
 393 {
 394 public:
 395     typedef base_uint160 basetype;
 396
 397     uint160()
 398     {
 399         for (int i = 0; i < WIDTH; i++)
 400             pn[i] = 0;
 401     }
 402
 403     uint160(const basetype& b)
 404     {
 405         for (int i = 0; i < WIDTH; i++)
 406             pn[i] = b.pn[i];
 407     }
 408
 409     uint160& operator=(const basetype& b)
 410     {
 411         for (int i = 0; i < WIDTH; i++)
 412             pn[i] = b.pn[i];
 413         return *this;
 414     }
 415
 416     uint160(uint64 b)
 417     {
 418         pn[0] = (unsigned int)b;
 419         pn[1] = (unsigned int)(b >> 32);
 420         for (int i = 2; i < WIDTH; i++)
 421             pn[i] = 0;
 422     }
 423
 424     uint160& operator=(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         return *this;
 431     }
 432
 433     explicit uint160(const std::string& str)
 434     {
 435         SetHex(str);
 436     }
 437
 438     explicit uint160(const std::vector<unsigned char>& vch)
 439     {
 440         if (vch.size() == sizeof(pn))
 441             memcpy(pn, &vch[0], sizeof(pn));
 442         else
 443             *this = 0;
 444     }
 445 };
 446
 447 inline bool operator==(const uint160& a, uint64 b)                           { return (base_uint160)a == b; }
 448 inline bool operator!=(const uint160& a, uint64 b)                           { return (base_uint160)a != b; }
 449 inline const uint160 operator<<(const base_uint160& a, unsigned int shift)   { return uint160(a) <<= shift; }
 450 inline const uint160 operator>>(const base_uint160& a, unsigned int shift)   { return uint160(a) >>= shift; }
 451 inline const uint160 operator<<(const uint160& a, unsigned int shift)        { return uint160(a) <<= shift; }
 452 inline const uint160 operator>>(const uint160& a, unsigned int shift)        { return uint160(a) >>= shift; }
 453
 454 inline const uint160 operator^(const base_uint160& a, const base_uint160& b) { return uint160(a) ^= b; }
 455 inline const uint160 operator&(const base_uint160& a, const base_uint160& b) { return uint160(a) &= b; }
 456 inline const uint160 operator|(const base_uint160& a, const base_uint160& b) { return uint160(a) |= b; }
 457 inline const uint160 operator+(const base_uint160& a, const base_uint160& b) { return uint160(a) += b; }
 458 inline const uint160 operator-(const base_uint160& a, const base_uint160& b) { return uint160(a) -= b; }
 459
 460 inline bool operator<(const base_uint160& a, const uint160& b)          { return (base_uint160)a <  (base_uint160)b; }
 461 inline bool operator<=(const base_uint160& a, const uint160& b)         { return (base_uint160)a <= (base_uint160)b; }
 462 inline bool operator>(const base_uint160& a, const uint160& b)          { return (base_uint160)a >  (base_uint160)b; }
 463 inline bool operator>=(const base_uint160& a, const uint160& b)         { return (base_uint160)a >= (base_uint160)b; }
 464 inline bool operator==(const base_uint160& a, const uint160& b)         { return (base_uint160)a == (base_uint160)b; }
 465 inline bool operator!=(const base_uint160& a, const uint160& b)         { return (base_uint160)a != (base_uint160)b; }
 466 inline const uint160 operator^(const base_uint160& a, const uint160& b) { return (base_uint160)a ^  (base_uint160)b; }
 467 inline const uint160 operator&(const base_uint160& a, const uint160& b) { return (base_uint160)a &  (base_uint160)b; }
 468 inline const uint160 operator|(const base_uint160& a, const uint160& b) { return (base_uint160)a |  (base_uint160)b; }
 469 inline const uint160 operator+(const base_uint160& a, const uint160& b) { return (base_uint160)a +  (base_uint160)b; }
 470 inline const uint160 operator-(const base_uint160& a, const uint160& b) { return (base_uint160)a -  (base_uint160)b; }
 471
 472 inline bool operator<(const uint160& a, const base_uint160& b)          { return (base_uint160)a <  (base_uint160)b; }
 473 inline bool operator<=(const uint160& a, const base_uint160& b)         { return (base_uint160)a <= (base_uint160)b; }
 474 inline bool operator>(const uint160& a, const base_uint160& b)          { return (base_uint160)a >  (base_uint160)b; }
 475 inline bool operator>=(const uint160& a, const base_uint160& b)         { return (base_uint160)a >= (base_uint160)b; }
 476 inline bool operator==(const uint160& a, const base_uint160& b)         { return (base_uint160)a == (base_uint160)b; }
 477 inline bool operator!=(const uint160& a, const base_uint160& b)         { return (base_uint160)a != (base_uint160)b; }
 478 inline const uint160 operator^(const uint160& a, const base_uint160& b) { return (base_uint160)a ^  (base_uint160)b; }
 479 inline const uint160 operator&(const uint160& a, const base_uint160& b) { return (base_uint160)a &  (base_uint160)b; }
 480 inline const uint160 operator|(const uint160& a, const base_uint160& b) { return (base_uint160)a |  (base_uint160)b; }
 481 inline const uint160 operator+(const uint160& a, const base_uint160& b) { return (base_uint160)a +  (base_uint160)b; }
 482 inline const uint160 operator-(const uint160& a, const base_uint160& b) { return (base_uint160)a -  (base_uint160)b; }
 483
 484 inline bool operator<(const uint160& a, const uint160& b)               { return (base_uint160)a <  (base_uint160)b; }
 485 inline bool operator<=(const uint160& a, const uint160& b)              { return (base_uint160)a <= (base_uint160)b; }
 486 inline bool operator>(const uint160& a, const uint160& b)               { return (base_uint160)a >  (base_uint160)b; }
 487 inline bool operator>=(const uint160& a, const uint160& b)              { return (base_uint160)a >= (base_uint160)b; }
 488 inline bool operator==(const uint160& a, const uint160& b)              { return (base_uint160)a == (base_uint160)b; }
 489 inline bool operator!=(const uint160& a, const uint160& b)              { return (base_uint160)a != (base_uint160)b; }
 490 inline const uint160 operator^(const uint160& a, const uint160& b)      { return (base_uint160)a ^  (base_uint160)b; }
 491 inline const uint160 operator&(const uint160& a, const uint160& b)      { return (base_uint160)a &  (base_uint160)b; }
 492 inline const uint160 operator|(const uint160& a, const uint160& b)      { return (base_uint160)a |  (base_uint160)b; }
 493 inline const uint160 operator+(const uint160& a, const uint160& b)      { return (base_uint160)a +  (base_uint160)b; }
 494 inline const uint160 operator-(const uint160& a, const uint160& b)      { return (base_uint160)a -  (base_uint160)b; }
 495
 496
 497
 498
 499
 500
 501 //////////////////////////////////////////////////////////////////////////////
 502 //
 503 // uint256
 504 //
 505
 506 class uint256 : public base_uint256
 507 {
 508 public:
 509     typedef base_uint256 basetype;
 510
 511     uint256()
 512     {
 513         for (int i = 0; i < WIDTH; i++)
 514             pn[i] = 0;
 515     }
 516
 517     uint256(const basetype& b)
 518     {
 519         for (int i = 0; i < WIDTH; i++)
 520             pn[i] = b.pn[i];
 521     }
 522
 523     uint256& operator=(const basetype& b)
 524     {
 525         for (int i = 0; i < WIDTH; i++)
 526             pn[i] = b.pn[i];
 527         return *this;
 528     }
 529
 530     uint256(uint64 b)
 531     {
 532         pn[0] = (unsigned int)b;
 533         pn[1] = (unsigned int)(b >> 32);
 534         for (int i = 2; i < WIDTH; i++)
 535             pn[i] = 0;
 536     }
 537
 538     uint256& operator=(uint64 b)
 539     {
 540         pn[0] = (unsigned int)b;
 541         pn[1] = (unsigned int)(b >> 32);
 542         for (int i = 2; i < WIDTH; i++)
 543             pn[i] = 0;
 544         return *this;
 545     }
 546
 547     explicit uint256(const std::string& str)
 548     {
 549         SetHex(str);
 550     }
 551
 552     explicit uint256(const std::vector<unsigned char>& vch)
 553     {
 554         if (vch.size() == sizeof(pn))
 555             memcpy(pn, &vch[0], sizeof(pn));
 556         else
 557             *this = 0;
 558     }
 559 };
 560
 561 inline bool operator==(const uint256& a, uint64 b)                           { return (base_uint256)a == b; }
 562 inline bool operator!=(const uint256& a, uint64 b)                           { return (base_uint256)a != b; }
 563 inline const uint256 operator<<(const base_uint256& a, unsigned int shift)   { return uint256(a) <<= shift; }
 564 inline const uint256 operator>>(const base_uint256& a, unsigned int shift)   { return uint256(a) >>= shift; }
 565 inline const uint256 operator<<(const uint256& a, unsigned int shift)        { return uint256(a) <<= shift; }
 566 inline const uint256 operator>>(const uint256& a, unsigned int shift)        { return uint256(a) >>= shift; }
 567
 568 inline const uint256 operator^(const base_uint256& a, const base_uint256& b) { return uint256(a) ^= b; }
 569 inline const uint256 operator&(const base_uint256& a, const base_uint256& b) { return uint256(a) &= b; }
 570 inline const uint256 operator|(const base_uint256& a, const base_uint256& b) { return uint256(a) |= b; }
 571 inline const uint256 operator+(const base_uint256& a, const base_uint256& b) { return uint256(a) += b; }
 572 inline const uint256 operator-(const base_uint256& a, const base_uint256& b) { return uint256(a) -= b; }
 573
 574 inline bool operator<(const base_uint256& a, const uint256& b)          { return (base_uint256)a <  (base_uint256)b; }
 575 inline bool operator<=(const base_uint256& a, const uint256& b)         { return (base_uint256)a <= (base_uint256)b; }
 576 inline bool operator>(const base_uint256& a, const uint256& b)          { return (base_uint256)a >  (base_uint256)b; }
 577 inline bool operator>=(const base_uint256& a, const uint256& b)         { return (base_uint256)a >= (base_uint256)b; }
 578 inline bool operator==(const base_uint256& a, const uint256& b)         { return (base_uint256)a == (base_uint256)b; }
 579 inline bool operator!=(const base_uint256& a, const uint256& b)         { return (base_uint256)a != (base_uint256)b; }
 580 inline const uint256 operator^(const base_uint256& a, const uint256& b) { return (base_uint256)a ^  (base_uint256)b; }
 581 inline const uint256 operator&(const base_uint256& a, const uint256& b) { return (base_uint256)a &  (base_uint256)b; }
 582 inline const uint256 operator|(const base_uint256& a, const uint256& b) { return (base_uint256)a |  (base_uint256)b; }
 583 inline const uint256 operator+(const base_uint256& a, const uint256& b) { return (base_uint256)a +  (base_uint256)b; }
 584 inline const uint256 operator-(const base_uint256& a, const uint256& b) { return (base_uint256)a -  (base_uint256)b; }
 585
 586 inline bool operator<(const uint256& a, const base_uint256& b)          { return (base_uint256)a <  (base_uint256)b; }
 587 inline bool operator<=(const uint256& a, const base_uint256& b)         { return (base_uint256)a <= (base_uint256)b; }
 588 inline bool operator>(const uint256& a, const base_uint256& b)          { return (base_uint256)a >  (base_uint256)b; }
 589 inline bool operator>=(const uint256& a, const base_uint256& b)         { return (base_uint256)a >= (base_uint256)b; }
 590 inline bool operator==(const uint256& a, const base_uint256& b)         { return (base_uint256)a == (base_uint256)b; }
 591 inline bool operator!=(const uint256& a, const base_uint256& b)         { return (base_uint256)a != (base_uint256)b; }
 592 inline const uint256 operator^(const uint256& a, const base_uint256& b) { return (base_uint256)a ^  (base_uint256)b; }
 593 inline const uint256 operator&(const uint256& a, const base_uint256& b) { return (base_uint256)a &  (base_uint256)b; }
 594 inline const uint256 operator|(const uint256& a, const base_uint256& b) { return (base_uint256)a |  (base_uint256)b; }
 595 inline const uint256 operator+(const uint256& a, const base_uint256& b) { return (base_uint256)a +  (base_uint256)b; }
 596 inline const uint256 operator-(const uint256& a, const base_uint256& b) { return (base_uint256)a -  (base_uint256)b; }
 597
 598 inline bool operator<(const uint256& a, const uint256& b)               { return (base_uint256)a <  (base_uint256)b; }
 599 inline bool operator<=(const uint256& a, const uint256& b)              { return (base_uint256)a <= (base_uint256)b; }
 600 inline bool operator>(const uint256& a, const uint256& b)               { return (base_uint256)a >  (base_uint256)b; }
 601 inline bool operator>=(const uint256& a, const uint256& b)              { return (base_uint256)a >= (base_uint256)b; }
 602 inline bool operator==(const uint256& a, const uint256& b)              { return (base_uint256)a == (base_uint256)b; }
 603 inline bool operator!=(const uint256& a, const uint256& b)              { return (base_uint256)a != (base_uint256)b; }
 604 inline const uint256 operator^(const uint256& a, const uint256& b)      { return (base_uint256)a ^  (base_uint256)b; }
 605 inline const uint256 operator&(const uint256& a, const uint256& b)      { return (base_uint256)a &  (base_uint256)b; }
 606 inline const uint256 operator|(const uint256& a, const uint256& b)      { return (base_uint256)a |  (base_uint256)b; }
 607 inline const uint256 operator+(const uint256& a, const uint256& b)      { return (base_uint256)a +  (base_uint256)b; }
 608 inline const uint256 operator-(const uint256& a, const uint256& b)      { return (base_uint256)a -  (base_uint256)b; }
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619 #ifdef TEST_UINT256
 620
 621 inline int Testuint256AdHoc(std::vector<std::string> vArg)
 622 {
 623     uint256 g(0);
 624
 625
 626     printf("%s\n", g.ToString().c_str());
 627     g--;  printf("g--\n");
 628     printf("%s\n", g.ToString().c_str());
 629     g--;  printf("g--\n");
 630     printf("%s\n", g.ToString().c_str());
 631     g++;  printf("g++\n");
 632     printf("%s\n", g.ToString().c_str());
 633     g++;  printf("g++\n");
 634     printf("%s\n", g.ToString().c_str());
 635     g++;  printf("g++\n");
 636     printf("%s\n", g.ToString().c_str());
 637     g++;  printf("g++\n");
 638     printf("%s\n", g.ToString().c_str());
 639
 640
 641
 642     uint256 a(7);
 643     printf("a=7\n");
 644     printf("%s\n", a.ToString().c_str());
 645
 646     uint256 b;
 647     printf("b undefined\n");
 648     printf("%s\n", b.ToString().c_str());
 649     int c = 3;
 650
 651     a = c;
 652     a.pn[3] = 15;
 653     printf("%s\n", a.ToString().c_str());
 654     uint256 k(c);
 655
 656     a = 5;
 657     a.pn[3] = 15;
 658     printf("%s\n", a.ToString().c_str());
 659     b = 1;
 660     b <<= 52;
 661
 662     a |= b;
 663
 664     a ^= 0x500;
 665
 666     printf("a %s\n", a.ToString().c_str());
 667
 668     a = a | b | (uint256)0x1000;
 669
 670
 671     printf("a %s\n", a.ToString().c_str());
 672     printf("b %s\n", b.ToString().c_str());
 673
 674     a = 0xfffffffe;
 675     a.pn[4] = 9;
 676
 677     printf("%s\n", a.ToString().c_str());
 678     a++;
 679     printf("%s\n", a.ToString().c_str());
 680     a++;
 681     printf("%s\n", a.ToString().c_str());
 682     a++;
 683     printf("%s\n", a.ToString().c_str());
 684     a++;
 685     printf("%s\n", a.ToString().c_str());
 686
 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     uint256 d = a--;
 694     printf("%s\n", d.ToString().c_str());
 695     printf("%s\n", a.ToString().c_str());
 696     a--;
 697     printf("%s\n", a.ToString().c_str());
 698     a--;
 699     printf("%s\n", a.ToString().c_str());
 700
 701     d = a;
 702
 703     printf("%s\n", d.ToString().c_str());
 704     for (int i = uint256::WIDTH-1; i >= 0; i--) printf("%08x", d.pn[i]); printf("\n");
 705
 706     uint256 neg = d;
 707     neg = ~neg;
 708     printf("%s\n", neg.ToString().c_str());
 709
 710
 711     uint256 e = uint256("0xABCDEF123abcdef12345678909832180000011111111");
 712     printf("\n");
 713     printf("%s\n", e.ToString().c_str());
 714
 715
 716     printf("\n");
 717     uint256 x1 = uint256("0xABCDEF123abcdef12345678909832180000011111111");
 718     uint256 x2;
 719     printf("%s\n", x1.ToString().c_str());
 720     for (int i = 0; i < 270; i += 4)
 721     {
 722         x2 = x1 << i;
 723         printf("%s\n", x2.ToString().c_str());
 724     }
 725
 726     printf("\n");
 727     printf("%s\n", x1.ToString().c_str());
 728     for (int i = 0; i < 270; i += 4)
 729     {
 730         x2 = x1;
 731         x2 >>= i;
 732         printf("%s\n", x2.ToString().c_str());
 733     }
 734
 735
 736     for (int i = 0; i < 100; i++)
 737     {
 738         uint256 k = (~uint256(0) >> i);
 739         printf("%s\n", k.ToString().c_str());
 740     }
 741
 742     for (int i = 0; i < 100; i++)
 743     {
 744         uint256 k = (~uint256(0) << i);
 745         printf("%s\n", k.ToString().c_str());
 746     }
 747
 748     return (0);
 749 }
 750
 751 #endif
 752
 753 #endif