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 COPYING 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 <stdio.h>
  12 #include <string>
  13 #include <vector>
  14
  15 #if defined(_MSC_VER) || defined(__BORLANDC__)
  16 typedef __int64  int64;
  17 typedef unsigned __int64  uint64;
  18 #else
  19 typedef long long  int64;
  20 typedef unsigned long long  uint64;
  21 #endif
  22 #if defined(_MSC_VER) && _MSC_VER < 1300
  23 #define for  if (false) ; else for
  24 #endif
  25
  26
  27 inline int Testuint256AdHoc(std::vector<std::string> vArg);
  28
  29
  30
  31 // We have to keep a separate base class without constructors
  32 // so the compiler will let us use it in a union
  33 template<unsigned int BITS>
  34 class base_uint
  35 {
  36 protected:
  37     enum { WIDTH=BITS/32 };
  38     unsigned int pn[WIDTH];
  39 public:
  40
  41     bool operator!() const
  42     {
  43         for (int i = 0; i < WIDTH; i++)
  44             if (pn[i] != 0)
  45                 return false;
  46         return true;
  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         return ret;
  55     }
  56
  57     const base_uint operator-() const
  58     {
  59         base_uint ret;
  60         for (int i = 0; i < WIDTH; i++)
  61             ret.pn[i] = ~pn[i];
  62         ret++;
  63         return ret;
  64     }
  65
  66
  67     base_uint& operator=(uint64 b)
  68     {
  69         pn[0] = (unsigned int)b;
  70         pn[1] = (unsigned int)(b >> 32);
  71         for (int i = 2; i < WIDTH; i++)
  72             pn[i] = 0;
  73         return *this;
  74     }
  75
  76     base_uint& operator^=(const base_uint& b)
  77     {
  78         for (int i = 0; i < WIDTH; i++)
  79             pn[i] ^= b.pn[i];
  80         return *this;
  81     }
  82
  83     base_uint& operator&=(const base_uint& b)
  84     {
  85         for (int i = 0; i < WIDTH; i++)
  86             pn[i] &= b.pn[i];
  87         return *this;
  88     }
  89
  90     base_uint& operator|=(const base_uint& b)
  91     {
  92         for (int i = 0; i < WIDTH; i++)
  93             pn[i] |= b.pn[i];
  94         return *this;
  95     }
  96
  97     base_uint& operator^=(uint64 b)
  98     {
  99         pn[0] ^= (unsigned int)b;
 100         pn[1] ^= (unsigned int)(b >> 32);
 101         return *this;
 102     }
 103
 104     base_uint& operator|=(uint64 b)
 105     {
 106         pn[0] |= (unsigned int)b;
 107         pn[1] |= (unsigned int)(b >> 32);
 108         return *this;
 109     }
 110
 111     base_uint& operator<<=(unsigned int shift)
 112     {
 113         base_uint a(*this);
 114         for (int i = 0; i < WIDTH; i++)
 115             pn[i] = 0;
 116         int k = shift / 32;
 117         shift = shift % 32;
 118         for (int i = 0; i < WIDTH; i++)
 119         {
 120             if (i+k+1 < WIDTH && shift != 0)
 121                 pn[i+k+1] |= (a.pn[i] >> (32-shift));
 122             if (i+k < WIDTH)
 123                 pn[i+k] |= (a.pn[i] << shift);
 124         }
 125         return *this;
 126     }
 127
 128     base_uint& operator>>=(unsigned int shift)
 129     {
 130         base_uint a(*this);
 131         for (int i = 0; i < WIDTH; i++)
 132             pn[i] = 0;
 133         int k = shift / 32;
 134         shift = shift % 32;
 135         for (int i = 0; i < WIDTH; i++)
 136         {
 137             if (i-k-1 >= 0 && shift != 0)
 138                 pn[i-k-1] |= (a.pn[i] << (32-shift));
 139             if (i-k >= 0)
 140                 pn[i-k] |= (a.pn[i] >> shift);
 141         }
 142         return *this;
 143     }
 144
 145     base_uint& operator+=(const base_uint& b)
 146     {
 147         uint64 carry = 0;
 148         for (int i = 0; i < WIDTH; i++)
 149         {
 150             uint64 n = carry + pn[i] + b.pn[i];
 151             pn[i] = n & 0xffffffff;
 152             carry = n >> 32;
 153         }
 154         return *this;
 155     }
 156
 157     base_uint& operator-=(const base_uint& b)
 158     {
 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     base_uint& operator-=(uint64 b64)
 172     {
 173         base_uint b;
 174         b = b64;
 175         *this += -b;
 176         return *this;
 177     }
 178
 179
 180     base_uint& operator++()
 181     {
 182         // prefix operator
 183         int i = 0;
 184         while (++pn[i] == 0 && i < WIDTH-1)
 185             i++;
 186         return *this;
 187     }
 188
 189     const base_uint operator++(int)
 190     {
 191         // postfix operator
 192         const base_uint ret = *this;
 193         ++(*this);
 194         return ret;
 195     }
 196
 197     base_uint& operator--()
 198     {
 199         // prefix operator
 200         int i = 0;
 201         while (--pn[i] == -1 && i < WIDTH-1)
 202             i++;
 203         return *this;
 204     }
 205
 206     const base_uint operator--(int)
 207     {
 208         // postfix operator
 209         const base_uint ret = *this;
 210         --(*this);
 211         return ret;
 212     }
 213
 214
 215     friend inline bool operator<(const base_uint& a, const base_uint& b)
 216     {
 217         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 218         {
 219             if (a.pn[i] < b.pn[i])
 220                 return true;
 221             else if (a.pn[i] > b.pn[i])
 222                 return false;
 223         }
 224         return false;
 225     }
 226
 227     friend inline bool operator<=(const base_uint& a, const base_uint& b)
 228     {
 229         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 230         {
 231             if (a.pn[i] < b.pn[i])
 232                 return true;
 233             else if (a.pn[i] > b.pn[i])
 234                 return false;
 235         }
 236         return true;
 237     }
 238
 239     friend inline bool operator>(const base_uint& a, const base_uint& b)
 240     {
 241         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 242         {
 243             if (a.pn[i] > b.pn[i])
 244                 return true;
 245             else if (a.pn[i] < b.pn[i])
 246                 return false;
 247         }
 248         return false;
 249     }
 250
 251     friend inline bool operator>=(const base_uint& a, const base_uint& b)
 252     {
 253         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 254         {
 255             if (a.pn[i] > b.pn[i])
 256                 return true;
 257             else if (a.pn[i] < b.pn[i])
 258                 return false;
 259         }
 260         return true;
 261     }
 262
 263     friend inline bool operator==(const base_uint& a, const base_uint& b)
 264     {
 265         for (int i = 0; i < base_uint::WIDTH; i++)
 266             if (a.pn[i] != b.pn[i])
 267                 return false;
 268         return true;
 269     }
 270
 271     friend inline bool operator==(const base_uint& a, uint64 b)
 272     {
 273         if (a.pn[0] != (unsigned int)b)
 274             return false;
 275         if (a.pn[1] != (unsigned int)(b >> 32))
 276             return false;
 277         for (int i = 2; i < base_uint::WIDTH; i++)
 278             if (a.pn[i] != 0)
 279                 return false;
 280         return true;
 281     }
 282
 283     friend inline bool operator!=(const base_uint& a, const base_uint& b)
 284     {
 285         return (!(a == b));
 286     }
 287
 288     friend inline bool operator!=(const base_uint& a, uint64 b)
 289     {
 290         return (!(a == b));
 291     }
 292
 293
 294
 295     std::string GetHex() const
 296     {
 297         char psz[sizeof(pn)*2 + 1];
 298         for (unsigned int i = 0; i < sizeof(pn); i++)
 299             sprintf(psz + i*2, "%02x", ((unsigned char*)pn)[sizeof(pn) - i - 1]);
 300         return std::string(psz, psz + sizeof(pn)*2);
 301     }
 302
 303     void SetHex(const char* psz)
 304     {
 305         for (int i = 0; i < WIDTH; i++)
 306             pn[i] = 0;
 307
 308         // skip leading spaces
 309         while (isspace(*psz))
 310             psz++;
 311
 312         // skip 0x
 313         if (psz[0] == '0' && tolower(psz[1]) == 'x')
 314             psz += 2;
 315
 316         // hex string to uint
 317         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 };
 318         const char* pbegin = psz;
 319         while (phexdigit[(unsigned char)*psz] || *psz == '0')
 320             psz++;
 321         psz--;
 322         unsigned char* p1 = (unsigned char*)pn;
 323         unsigned char* pend = p1 + WIDTH * 4;
 324         while (psz >= pbegin && p1 < pend)
 325         {
 326             *p1 = phexdigit[(unsigned char)*psz--];
 327             if (psz >= pbegin)
 328             {
 329                 *p1 |= (phexdigit[(unsigned char)*psz--] << 4);
 330                 p1++;
 331             }
 332         }
 333     }
 334
 335     void SetHex(const std::string& str)
 336     {
 337         SetHex(str.c_str());
 338     }
 339
 340     std::string ToString() const
 341     {
 342         return (GetHex());
 343     }
 344
 345     unsigned char* begin()
 346     {
 347         return (unsigned char*)&pn[0];
 348     }
 349
 350     unsigned char* end()
 351     {
 352         return (unsigned char*)&pn[WIDTH];
 353     }
 354
 355     unsigned int size()
 356     {
 357         return sizeof(pn);
 358     }
 359
 360
 361     unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const
 362     {
 363         return sizeof(pn);
 364     }
 365
 366     template<typename Stream>
 367     void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const
 368     {
 369         s.write((char*)pn, sizeof(pn));
 370     }
 371
 372     template<typename Stream>
 373     void Unserialize(Stream& s, int nType=0, int nVersion=VERSION)
 374     {
 375         s.read((char*)pn, sizeof(pn));
 376     }
 377
 378
 379     friend class uint160;
 380     friend class uint256;
 381     friend inline int Testuint256AdHoc(std::vector<std::string> vArg);
 382 };
 383
 384 typedef base_uint<160> base_uint160;
 385 typedef base_uint<256> base_uint256;
 386
 387
 388
 389 //
 390 // uint160 and uint256 could be implemented as templates, but to keep
 391 // compile errors and debugging cleaner, they're copy and pasted.
 392 //
 393
 394
 395
 396 //////////////////////////////////////////////////////////////////////////////
 397 //
 398 // uint160
 399 //
 400
 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 class uint256 : public base_uint256
 516 {
 517 public:
 518     typedef base_uint256 basetype;
 519
 520     uint256()
 521     {
 522         for (int i = 0; i < WIDTH; i++)
 523             pn[i] = 0;
 524     }
 525
 526     uint256(const basetype& b)
 527     {
 528         for (int i = 0; i < WIDTH; i++)
 529             pn[i] = b.pn[i];
 530     }
 531
 532     uint256& operator=(const basetype& b)
 533     {
 534         for (int i = 0; i < WIDTH; i++)
 535             pn[i] = b.pn[i];
 536         return *this;
 537     }
 538
 539     uint256(uint64 b)
 540     {
 541         pn[0] = (unsigned int)b;
 542         pn[1] = (unsigned int)(b >> 32);
 543         for (int i = 2; i < WIDTH; i++)
 544             pn[i] = 0;
 545     }
 546
 547     uint256& operator=(uint64 b)
 548     {
 549         pn[0] = (unsigned int)b;
 550         pn[1] = (unsigned int)(b >> 32);
 551         for (int i = 2; i < WIDTH; i++)
 552             pn[i] = 0;
 553         return *this;
 554     }
 555
 556     explicit uint256(const std::string& str)
 557     {
 558         SetHex(str);
 559     }
 560
 561     explicit uint256(const std::vector<unsigned char>& vch)
 562     {
 563         if (vch.size() == sizeof(pn))
 564             memcpy(pn, &vch[0], sizeof(pn));
 565         else
 566             *this = 0;
 567     }
 568 };
 569
 570 inline bool operator==(const uint256& a, uint64 b)                           { return (base_uint256)a == b; }
 571 inline bool operator!=(const uint256& a, uint64 b)                           { return (base_uint256)a != b; }
 572 inline const uint256 operator<<(const base_uint256& a, unsigned int shift)   { return uint256(a) <<= shift; }
 573 inline const uint256 operator>>(const base_uint256& a, unsigned int shift)   { return uint256(a) >>= shift; }
 574 inline const uint256 operator<<(const 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
 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 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
 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 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 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 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
 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 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 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 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
 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 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 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 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
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630 inline int Testuint256AdHoc(std::vector<std::string> vArg)
 631 {
 632     uint256 g(0);
 633
 634
 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     g++;  printf("g++\n");
 647     printf("%s\n", g.ToString().c_str());
 648
 649
 650
 651     uint256 a(7);
 652     printf("a=7\n");
 653     printf("%s\n", a.ToString().c_str());
 654
 655     uint256 b;
 656     printf("b undefined\n");
 657     printf("%s\n", b.ToString().c_str());
 658     int c = 3;
 659
 660     a = c;
 661     a.pn[3] = 15;
 662     printf("%s\n", a.ToString().c_str());
 663     uint256 k(c);
 664
 665     a = 5;
 666     a.pn[3] = 15;
 667     printf("%s\n", a.ToString().c_str());
 668     b = 1;
 669     b <<= 52;
 670
 671     a |= b;
 672
 673     a ^= 0x500;
 674
 675     printf("a %s\n", a.ToString().c_str());
 676
 677     a = a | b | (uint256)0x1000;
 678
 679
 680     printf("a %s\n", a.ToString().c_str());
 681     printf("b %s\n", b.ToString().c_str());
 682
 683     a = 0xfffffffe;
 684     a.pn[4] = 9;
 685
 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     a++;
 694     printf("%s\n", a.ToString().c_str());
 695
 696     a--;
 697     printf("%s\n", a.ToString().c_str());
 698     a--;
 699     printf("%s\n", a.ToString().c_str());
 700     a--;
 701     printf("%s\n", a.ToString().c_str());
 702     uint256 d = a--;
 703     printf("%s\n", d.ToString().c_str());
 704     printf("%s\n", a.ToString().c_str());
 705     a--;
 706     printf("%s\n", a.ToString().c_str());
 707     a--;
 708     printf("%s\n", a.ToString().c_str());
 709
 710     d = a;
 711
 712     printf("%s\n", d.ToString().c_str());
 713     for (int i = uint256::WIDTH-1; i >= 0; i--) printf("%08x", d.pn[i]); printf("\n");
 714
 715     uint256 neg = d;
 716     neg = ~neg;
 717     printf("%s\n", neg.ToString().c_str());
 718
 719
 720     uint256 e = uint256("0xABCDEF123abcdef12345678909832180000011111111");
 721     printf("\n");
 722     printf("%s\n", e.ToString().c_str());
 723
 724
 725     printf("\n");
 726     uint256 x1 = uint256("0xABCDEF123abcdef12345678909832180000011111111");
 727     uint256 x2;
 728     printf("%s\n", x1.ToString().c_str());
 729     for (int i = 0; i < 270; i += 4)
 730     {
 731         x2 = x1 << i;
 732         printf("%s\n", x2.ToString().c_str());
 733     }
 734
 735     printf("\n");
 736     printf("%s\n", x1.ToString().c_str());
 737     for (int i = 0; i < 270; i += 4)
 738     {
 739         x2 = x1;
 740         x2 >>= i;
 741         printf("%s\n", x2.ToString().c_str());
 742     }
 743
 744
 745     for (int i = 0; i < 100; i++)
 746     {
 747         uint256 k = (~uint256(0) >> i);
 748         printf("%s\n", k.ToString().c_str());
 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     return (0);
 758 }
 759
 760 #endif