src/uint256.h

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