src/uint256.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Distributed under the MIT/X11 software license, see the accompanying
   3 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
   4 #ifndef BITCOIN_UINT256_H
   5 #define BITCOIN_UINT256_H
   6
   7 #include "serialize.h"
   8
   9 #include <limits.h>
  10 #include <string>
  11 #include <vector>
  12
  13 #if defined(_MSC_VER) || defined(__BORLANDC__)
  14 typedef __int64  int64;
  15 typedef unsigned __int64  uint64;
  16 #else
  17 typedef long long  int64;
  18 typedef unsigned long long  uint64;
  19 #endif
  20 #if defined(_MSC_VER) && _MSC_VER < 1300
  21 #define for  if (false) ; else for
  22 #endif
  23
  24
  25 inline int Testuint256AdHoc(std::vector<std::string> vArg);
  26
  27
  28
  29 // We have to keep a separate base class without constructors
  30 // so the compiler will let us use it in a union
  31 template<unsigned int BITS>
  32 class base_uint
  33 {
  34 protected:
  35     enum { WIDTH=BITS/32 };
  36     unsigned int pn[WIDTH];
  37 public:
  38
  39     bool operator!() const
  40     {
  41         for (int i = 0; i < WIDTH; i++)
  42             if (pn[i] != 0)
  43                 return false;
  44         return true;
  45     }
  46
  47     const base_uint operator~() const
  48     {
  49         base_uint ret;
  50         for (int i = 0; i < WIDTH; i++)
  51             ret.pn[i] = ~pn[i];
  52         return ret;
  53     }
  54
  55     const base_uint operator-() const
  56     {
  57         base_uint ret;
  58         for (int i = 0; i < WIDTH; i++)
  59             ret.pn[i] = ~pn[i];
  60         ret++;
  61         return ret;
  62     }
  63
  64
  65     base_uint& operator=(uint64 b)
  66     {
  67         pn[0] = (unsigned int)b;
  68         pn[1] = (unsigned int)(b >> 32);
  69         for (int i = 2; i < WIDTH; i++)
  70             pn[i] = 0;
  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|=(const base_uint& b)
  89     {
  90         for (int i = 0; i < WIDTH; i++)
  91             pn[i] |= b.pn[i];
  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|=(uint64 b)
 110     {
 111         pn[0] |= (unsigned int)b;
 112         pn[1] |= (unsigned int)(b >> 32);
 113         return *this;
 114     }
 115
 116     base_uint& operator<<=(unsigned int shift)
 117     {
 118         base_uint a(*this);
 119         for (int i = 0; i < WIDTH; i++)
 120             pn[i] = 0;
 121         int k = shift / 32;
 122         shift = shift % 32;
 123         for (int i = 0; i < WIDTH; i++)
 124         {
 125             if (i+k+1 < WIDTH && shift != 0)
 126                 pn[i+k+1] |= (a.pn[i] >> (32-shift));
 127             if (i+k < WIDTH)
 128                 pn[i+k] |= (a.pn[i] << shift);
 129         }
 130         return *this;
 131     }
 132
 133     base_uint& operator>>=(unsigned int shift)
 134     {
 135         base_uint a(*this);
 136         for (int i = 0; i < WIDTH; i++)
 137             pn[i] = 0;
 138         int k = shift / 32;
 139         shift = shift % 32;
 140         for (int i = 0; i < WIDTH; i++)
 141         {
 142             if (i-k-1 >= 0 && shift != 0)
 143                 pn[i-k-1] |= (a.pn[i] << (32-shift));
 144             if (i-k >= 0)
 145                 pn[i-k] |= (a.pn[i] >> shift);
 146         }
 147         return *this;
 148     }
 149
 150     base_uint& operator+=(const base_uint& b)
 151     {
 152         uint64 carry = 0;
 153         for (int i = 0; i < WIDTH; i++)
 154         {
 155             uint64 n = carry + pn[i] + b.pn[i];
 156             pn[i] = n & 0xffffffff;
 157             carry = n >> 32;
 158         }
 159         return *this;
 160     }
 161
 162     base_uint& operator-=(const base_uint& b)
 163     {
 164         *this += -b;
 165         return *this;
 166     }
 167
 168     base_uint& operator+=(uint64 b64)
 169     {
 170         base_uint b;
 171         b = b64;
 172         *this += b;
 173         return *this;
 174     }
 175
 176     base_uint& operator-=(uint64 b64)
 177     {
 178         base_uint b;
 179         b = b64;
 180         *this += -b;
 181         return *this;
 182     }
 183
 184
 185     base_uint& operator++()
 186     {
 187         // prefix operator
 188         int i = 0;
 189         while (++pn[i] == 0 && i < WIDTH-1)
 190             i++;
 191         return *this;
 192     }
 193
 194     const base_uint operator++(int)
 195     {
 196         // postfix operator
 197         const base_uint ret = *this;
 198         ++(*this);
 199         return ret;
 200     }
 201
 202     base_uint& operator--()
 203     {
 204         // prefix operator
 205         int i = 0;
 206         while (--pn[i] == -1 && i < WIDTH-1)
 207             i++;
 208         return *this;
 209     }
 210
 211     const base_uint operator--(int)
 212     {
 213         // postfix operator
 214         const base_uint ret = *this;
 215         --(*this);
 216         return ret;
 217     }
 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 false;
 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 true;
 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 false;
 254     }
 255
 256     friend inline bool operator>=(const base_uint& a, const base_uint& b)
 257     {
 258         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 259         {
 260             if (a.pn[i] > b.pn[i])
 261                 return true;
 262             else if (a.pn[i] < b.pn[i])
 263                 return false;
 264         }
 265         return true;
 266     }
 267
 268     friend inline bool operator==(const base_uint& a, const base_uint& b)
 269     {
 270         for (int i = 0; i < base_uint::WIDTH; i++)
 271             if (a.pn[i] != b.pn[i])
 272                 return false;
 273         return true;
 274     }
 275
 276     friend inline bool operator==(const base_uint& a, uint64 b)
 277     {
 278         if (a.pn[0] != (unsigned int)b)
 279             return false;
 280         if (a.pn[1] != (unsigned int)(b >> 32))
 281             return false;
 282         for (int i = 2; i < base_uint::WIDTH; i++)
 283             if (a.pn[i] != 0)
 284                 return false;
 285         return true;
 286     }
 287
 288     friend inline bool operator!=(const base_uint& a, const base_uint& b)
 289     {
 290         return (!(a == b));
 291     }
 292
 293     friend inline bool operator!=(const base_uint& a, uint64 b)
 294     {
 295         return (!(a == b));
 296     }
 297
 298
 299
 300     std::string GetHex() const
 301     {
 302         char psz[sizeof(pn)*2 + 1];
 303         for (int i = 0; i < sizeof(pn); i++)
 304             sprintf(psz + i*2, "%02x", ((unsigned char*)pn)[sizeof(pn) - i - 1]);
 305         return std::string(psz, psz + sizeof(pn)*2);
 306     }
 307
 308     void SetHex(const char* psz)
 309     {
 310         for (int i = 0; i < WIDTH; i++)
 311             pn[i] = 0;
 312
 313         // skip leading spaces
 314         while (isspace(*psz))
 315             psz++;
 316
 317         // skip 0x
 318         if (psz[0] == '0' && tolower(psz[1]) == 'x')
 319             psz += 2;
 320
 321         // hex string to uint
 322         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 };
 323         const char* pbegin = psz;
 324         while (phexdigit[*psz] || *psz == '0')
 325             psz++;
 326         psz--;
 327         unsigned char* p1 = (unsigned char*)pn;
 328         unsigned char* pend = p1 + WIDTH * 4;
 329         while (psz >= pbegin && p1 < pend)
 330         {
 331             *p1 = phexdigit[(unsigned char)*psz--];
 332             if (psz >= pbegin)
 333             {
 334                 *p1 |= (phexdigit[(unsigned char)*psz--] << 4);
 335                 p1++;
 336             }
 337         }
 338     }
 339
 340     void SetHex(const std::string& str)
 341     {
 342         SetHex(str.c_str());
 343     }
 344
 345     std::string ToString() const
 346     {
 347         return (GetHex());
 348     }
 349
 350     unsigned char* begin()
 351     {
 352         return (unsigned char*)&pn[0];
 353     }
 354
 355     unsigned char* end()
 356     {
 357         return (unsigned char*)&pn[WIDTH];
 358     }
 359
 360     unsigned int size()
 361     {
 362         return sizeof(pn);
 363     }
 364
 365
 366     unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const
 367     {
 368         return sizeof(pn);
 369     }
 370
 371     template<typename Stream>
 372     void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const
 373     {
 374         s.write((char*)pn, sizeof(pn));
 375     }
 376
 377     template<typename Stream>
 378     void Unserialize(Stream& s, int nType=0, int nVersion=VERSION)
 379     {
 380         s.read((char*)pn, sizeof(pn));
 381     }
 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
 394 //
 395 // uint160 and uint256 could be implemented as templates, but to keep
 396 // compile errors and debugging cleaner, they're copy and pasted.
 397 //
 398
 399
 400
 401 //////////////////////////////////////////////////////////////////////////////
 402 //
 403 // uint160
 404 //
 405
 406 class uint160 : public base_uint160
 407 {
 408 public:
 409     typedef base_uint160 basetype;
 410
 411     uint160()
 412     {
 413         for (int i = 0; i < WIDTH; i++)
 414             pn[i] = 0;
 415     }
 416
 417     uint160(const basetype& b)
 418     {
 419         for (int i = 0; i < WIDTH; i++)
 420             pn[i] = b.pn[i];
 421     }
 422
 423     uint160& operator=(const basetype& b)
 424     {
 425         for (int i = 0; i < WIDTH; i++)
 426             pn[i] = b.pn[i];
 427         return *this;
 428     }
 429
 430     uint160(uint64 b)
 431     {
 432         pn[0] = (unsigned int)b;
 433         pn[1] = (unsigned int)(b >> 32);
 434         for (int i = 2; i < WIDTH; i++)
 435             pn[i] = 0;
 436     }
 437
 438     uint160& operator=(uint64 b)
 439     {
 440         pn[0] = (unsigned int)b;
 441         pn[1] = (unsigned int)(b >> 32);
 442         for (int i = 2; i < WIDTH; i++)
 443             pn[i] = 0;
 444         return *this;
 445     }
 446
 447     explicit uint160(const std::string& str)
 448     {
 449         SetHex(str);
 450     }
 451
 452     explicit uint160(const std::vector<unsigned char>& vch)
 453     {
 454         if (vch.size() == sizeof(pn))
 455             memcpy(pn, &vch[0], sizeof(pn));
 456         else
 457             *this = 0;
 458     }
 459 };
 460
 461 inline bool operator==(const uint160& a, uint64 b)                           { return (base_uint160)a == b; }
 462 inline bool operator!=(const uint160& a, uint64 b)                           { return (base_uint160)a != b; }
 463 inline const uint160 operator<<(const base_uint160& a, unsigned int shift)   { return uint160(a) <<= shift; }
 464 inline const uint160 operator>>(const base_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 inline const uint160 operator>>(const uint160& a, unsigned int shift)        { return uint160(a) >>= shift; }
 467
 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 inline const uint160 operator-(const base_uint160& a, const base_uint160& b) { return uint160(a) -= b; }
 473
 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 bool 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 inline const uint160 operator-(const base_uint160& a, const uint160& b) { return (base_uint160)a -  (base_uint160)b; }
 485
 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 bool 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 inline const uint160 operator-(const uint160& a, const base_uint160& b) { return (base_uint160)a -  (base_uint160)b; }
 497
 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 bool 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 inline const uint160 operator-(const uint160& a, const uint160& b)      { return (base_uint160)a -  (base_uint160)b; }
 509
 510
 511
 512
 513
 514
 515 //////////////////////////////////////////////////////////////////////////////
 516 //
 517 // uint256
 518 //
 519
 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
 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