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