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