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