src/uint256.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2011 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|=(uint64 b)
 103     {
 104         pn[0] |= (unsigned int)b;
 105         pn[1] |= (unsigned int)(b >> 32);
 106         return *this;
 107     }
 108
 109     base_uint& operator<<=(unsigned int shift)
 110     {
 111         base_uint a(*this);
 112         for (int i = 0; i < WIDTH; i++)
 113             pn[i] = 0;
 114         int k = shift / 32;
 115         shift = shift % 32;
 116         for (int i = 0; i < WIDTH; i++)
 117         {
 118             if (i+k+1 < WIDTH && shift != 0)
 119                 pn[i+k+1] |= (a.pn[i] >> (32-shift));
 120             if (i+k < WIDTH)
 121                 pn[i+k] |= (a.pn[i] << shift);
 122         }
 123         return *this;
 124     }
 125
 126     base_uint& operator>>=(unsigned int shift)
 127     {
 128         base_uint a(*this);
 129         for (int i = 0; i < WIDTH; i++)
 130             pn[i] = 0;
 131         int k = shift / 32;
 132         shift = shift % 32;
 133         for (int i = 0; i < WIDTH; i++)
 134         {
 135             if (i-k-1 >= 0 && shift != 0)
 136                 pn[i-k-1] |= (a.pn[i] << (32-shift));
 137             if (i-k >= 0)
 138                 pn[i-k] |= (a.pn[i] >> shift);
 139         }
 140         return *this;
 141     }
 142
 143     base_uint& operator+=(const base_uint& b)
 144     {
 145         uint64 carry = 0;
 146         for (int i = 0; i < WIDTH; i++)
 147         {
 148             uint64 n = carry + pn[i] + b.pn[i];
 149             pn[i] = n & 0xffffffff;
 150             carry = n >> 32;
 151         }
 152         return *this;
 153     }
 154
 155     base_uint& operator-=(const base_uint& b)
 156     {
 157         *this += -b;
 158         return *this;
 159     }
 160
 161     base_uint& operator+=(uint64 b64)
 162     {
 163         base_uint b;
 164         b = b64;
 165         *this += b;
 166         return *this;
 167     }
 168
 169     base_uint& operator-=(uint64 b64)
 170     {
 171         base_uint b;
 172         b = b64;
 173         *this += -b;
 174         return *this;
 175     }
 176
 177
 178     base_uint& operator++()
 179     {
 180         // prefix operator
 181         int i = 0;
 182         while (++pn[i] == 0 && i < WIDTH-1)
 183             i++;
 184         return *this;
 185     }
 186
 187     const base_uint operator++(int)
 188     {
 189         // postfix operator
 190         const base_uint ret = *this;
 191         ++(*this);
 192         return ret;
 193     }
 194
 195     base_uint& operator--()
 196     {
 197         // prefix operator
 198         int i = 0;
 199         while (--pn[i] == -1 && i < WIDTH-1)
 200             i++;
 201         return *this;
 202     }
 203
 204     const base_uint operator--(int)
 205     {
 206         // postfix operator
 207         const base_uint ret = *this;
 208         --(*this);
 209         return ret;
 210     }
 211
 212
 213     friend inline bool operator<(const base_uint& a, const base_uint& b)
 214     {
 215         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 216         {
 217             if (a.pn[i] < b.pn[i])
 218                 return true;
 219             else if (a.pn[i] > b.pn[i])
 220                 return false;
 221         }
 222         return false;
 223     }
 224
 225     friend inline bool operator<=(const base_uint& a, const base_uint& b)
 226     {
 227         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 228         {
 229             if (a.pn[i] < b.pn[i])
 230                 return true;
 231             else if (a.pn[i] > b.pn[i])
 232                 return false;
 233         }
 234         return true;
 235     }
 236
 237     friend inline bool operator>(const base_uint& a, const base_uint& b)
 238     {
 239         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 240         {
 241             if (a.pn[i] > b.pn[i])
 242                 return true;
 243             else if (a.pn[i] < b.pn[i])
 244                 return false;
 245         }
 246         return false;
 247     }
 248
 249     friend inline bool operator>=(const base_uint& a, const base_uint& b)
 250     {
 251         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 252         {
 253             if (a.pn[i] > b.pn[i])
 254                 return true;
 255             else if (a.pn[i] < b.pn[i])
 256                 return false;
 257         }
 258         return true;
 259     }
 260
 261     friend inline bool operator==(const base_uint& a, const base_uint& b)
 262     {
 263         for (int i = 0; i < base_uint::WIDTH; i++)
 264             if (a.pn[i] != b.pn[i])
 265                 return false;
 266         return true;
 267     }
 268
 269     friend inline bool operator==(const base_uint& a, uint64 b)
 270     {
 271         if (a.pn[0] != (unsigned int)b)
 272             return false;
 273         if (a.pn[1] != (unsigned int)(b >> 32))
 274             return false;
 275         for (int i = 2; i < base_uint::WIDTH; i++)
 276             if (a.pn[i] != 0)
 277                 return false;
 278         return true;
 279     }
 280
 281     friend inline bool operator!=(const base_uint& a, const base_uint& b)
 282     {
 283         return (!(a == b));
 284     }
 285
 286     friend inline bool operator!=(const base_uint& a, uint64 b)
 287     {
 288         return (!(a == b));
 289     }
 290
 291
 292
 293     std::string GetHex() const
 294     {
 295         char psz[sizeof(pn)*2 + 1];
 296         for (int i = 0; i < sizeof(pn); i++)
 297             sprintf(psz + i*2, "%02x", ((unsigned char*)pn)[sizeof(pn) - i - 1]);
 298         return std::string(psz, psz + sizeof(pn)*2);
 299     }
 300
 301     void SetHex(const char* psz)
 302     {
 303         for (int i = 0; i < WIDTH; i++)
 304             pn[i] = 0;
 305
 306         // skip leading spaces
 307         while (isspace(*psz))
 308             psz++;
 309
 310         // skip 0x
 311         if (psz[0] == '0' && tolower(psz[1]) == 'x')
 312             psz += 2;
 313
 314         // hex string to uint
 315         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 };
 316         const char* pbegin = psz;
 317         while (phexdigit[*psz] || *psz == '0')
 318             psz++;
 319         psz--;
 320         unsigned char* p1 = (unsigned char*)pn;
 321         unsigned char* pend = p1 + WIDTH * 4;
 322         while (psz >= pbegin && p1 < pend)
 323         {
 324             *p1 = phexdigit[(unsigned char)*psz--];
 325             if (psz >= pbegin)
 326             {
 327                 *p1 |= (phexdigit[(unsigned char)*psz--] << 4);
 328                 p1++;
 329             }
 330         }
 331     }
 332
 333     void SetHex(const std::string& str)
 334     {
 335         SetHex(str.c_str());
 336     }
 337
 338     std::string ToString() const
 339     {
 340         return (GetHex());
 341     }
 342
 343     unsigned char* begin()
 344     {
 345         return (unsigned char*)&pn[0];
 346     }
 347
 348     unsigned char* end()
 349     {
 350         return (unsigned char*)&pn[WIDTH];
 351     }
 352
 353     unsigned int size()
 354     {
 355         return sizeof(pn);
 356     }
 357
 358
 359     unsigned int GetSerializeSize(int nType=0, int nVersion=PROTOCOL_VERSION) const
 360     {
 361         return sizeof(pn);
 362     }
 363
 364     template<typename Stream>
 365     void Serialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) 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     {
 373         s.read((char*)pn, sizeof(pn));
 374     }
 375
 376
 377     friend class uint160;
 378     friend class uint256;
 379     friend inline int Testuint256AdHoc(std::vector<std::string> vArg);
 380 };
 381
 382 typedef base_uint<160> base_uint160;
 383 typedef base_uint<256> base_uint256;
 384
 385
 386
 387 //
 388 // uint160 and uint256 could be implemented as templates, but to keep
 389 // compile errors and debugging cleaner, they're copy and pasted.
 390 //
 391
 392
 393
 394 //////////////////////////////////////////////////////////////////////////////
 395 //
 396 // uint160
 397 //
 398
 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 class uint256 : public base_uint256
 514 {
 515 public:
 516     typedef base_uint256 basetype;
 517
 518     uint256()
 519     {
 520         for (int i = 0; i < WIDTH; i++)
 521             pn[i] = 0;
 522     }
 523
 524     uint256(const basetype& b)
 525     {
 526         for (int i = 0; i < WIDTH; i++)
 527             pn[i] = b.pn[i];
 528     }
 529
 530     uint256& operator=(const basetype& b)
 531     {
 532         for (int i = 0; i < WIDTH; i++)
 533             pn[i] = b.pn[i];
 534         return *this;
 535     }
 536
 537     uint256(uint64 b)
 538     {
 539         pn[0] = (unsigned int)b;
 540         pn[1] = (unsigned int)(b >> 32);
 541         for (int i = 2; i < WIDTH; i++)
 542             pn[i] = 0;
 543     }
 544
 545     uint256& operator=(uint64 b)
 546     {
 547         pn[0] = (unsigned int)b;
 548         pn[1] = (unsigned int)(b >> 32);
 549         for (int i = 2; i < WIDTH; i++)
 550             pn[i] = 0;
 551         return *this;
 552     }
 553
 554     explicit uint256(const std::string& str)
 555     {
 556         SetHex(str);
 557     }
 558
 559     explicit uint256(const std::vector<unsigned char>& vch)
 560     {
 561         if (vch.size() == sizeof(pn))
 562             memcpy(pn, &vch[0], sizeof(pn));
 563         else
 564             *this = 0;
 565     }
 566 };
 567
 568 inline bool operator==(const uint256& a, uint64 b)                           { return (base_uint256)a == b; }
 569 inline bool operator!=(const uint256& a, uint64 b)                           { return (base_uint256)a != b; }
 570 inline const uint256 operator<<(const base_uint256& a, unsigned int shift)   { return uint256(a) <<= shift; }
 571 inline const uint256 operator>>(const base_uint256& a, unsigned int shift)   { return uint256(a) >>= shift; }
 572 inline const uint256 operator<<(const 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
 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 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
 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 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 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 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
 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 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 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 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
 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 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 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 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
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628 inline int Testuint256AdHoc(std::vector<std::string> vArg)
 629 {
 630     uint256 g(0);
 631
 632
 633     printf("%s\n", g.ToString().c_str());
 634     g--;  printf("g--\n");
 635     printf("%s\n", g.ToString().c_str());
 636     g--;  printf("g--\n");
 637     printf("%s\n", g.ToString().c_str());
 638     g++;  printf("g++\n");
 639     printf("%s\n", g.ToString().c_str());
 640     g++;  printf("g++\n");
 641     printf("%s\n", g.ToString().c_str());
 642     g++;  printf("g++\n");
 643     printf("%s\n", g.ToString().c_str());
 644     g++;  printf("g++\n");
 645     printf("%s\n", g.ToString().c_str());
 646
 647
 648
 649     uint256 a(7);
 650     printf("a=7\n");
 651     printf("%s\n", a.ToString().c_str());
 652
 653     uint256 b;
 654     printf("b undefined\n");
 655     printf("%s\n", b.ToString().c_str());
 656     int c = 3;
 657
 658     a = c;
 659     a.pn[3] = 15;
 660     printf("%s\n", a.ToString().c_str());
 661     uint256 k(c);
 662
 663     a = 5;
 664     a.pn[3] = 15;
 665     printf("%s\n", a.ToString().c_str());
 666     b = 1;
 667     b <<= 52;
 668
 669     a |= b;
 670
 671     a ^= 0x500;
 672
 673     printf("a %s\n", a.ToString().c_str());
 674
 675     a = a | b | (uint256)0x1000;
 676
 677
 678     printf("a %s\n", a.ToString().c_str());
 679     printf("b %s\n", b.ToString().c_str());
 680
 681     a = 0xfffffffe;
 682     a.pn[4] = 9;
 683
 684     printf("%s\n", a.ToString().c_str());
 685     a++;
 686     printf("%s\n", a.ToString().c_str());
 687     a++;
 688     printf("%s\n", a.ToString().c_str());
 689     a++;
 690     printf("%s\n", a.ToString().c_str());
 691     a++;
 692     printf("%s\n", a.ToString().c_str());
 693
 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     uint256 d = a--;
 701     printf("%s\n", d.ToString().c_str());
 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
 708     d = a;
 709
 710     printf("%s\n", d.ToString().c_str());
 711     for (int i = uint256::WIDTH-1; i >= 0; i--) printf("%08x", d.pn[i]); printf("\n");
 712
 713     uint256 neg = d;
 714     neg = ~neg;
 715     printf("%s\n", neg.ToString().c_str());
 716
 717
 718     uint256 e = uint256("0xABCDEF123abcdef12345678909832180000011111111");
 719     printf("\n");
 720     printf("%s\n", e.ToString().c_str());
 721
 722
 723     printf("\n");
 724     uint256 x1 = uint256("0xABCDEF123abcdef12345678909832180000011111111");
 725     uint256 x2;
 726     printf("%s\n", x1.ToString().c_str());
 727     for (int i = 0; i < 270; i += 4)
 728     {
 729         x2 = x1 << i;
 730         printf("%s\n", x2.ToString().c_str());
 731     }
 732
 733     printf("\n");
 734     printf("%s\n", x1.ToString().c_str());
 735     for (int i = 0; i < 270; i += 4)
 736     {
 737         x2 = x1;
 738         x2 >>= i;
 739         printf("%s\n", x2.ToString().c_str());
 740     }
 741
 742
 743     for (int i = 0; i < 100; i++)
 744     {
 745         uint256 k = (~uint256(0) >> i);
 746         printf("%s\n", k.ToString().c_str());
 747     }
 748
 749     for (int i = 0; i < 100; i++)
 750     {
 751         uint256 k = (~uint256(0) << i);
 752         printf("%s\n", k.ToString().c_str());
 753     }
 754
 755     return (0);
 756 }
 757
 758 #endif