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