Changeset View
Changeset View
Standalone View
Standalone View
src/seeder/uint256.h
- This file was added.
// Copyright (c) 2009-2010 Satoshi Nakamoto | |||||
// Copyright (c) 2011 The Bitcoin developers | |||||
// Distributed under the MIT/X11 software license, see the accompanying | |||||
// file license.txt or http://www.opensource.org/licenses/mit-license.php. | |||||
#ifndef BITCOIN_UINT256_H | |||||
#define BITCOIN_UINT256_H | |||||
#include "serialize.h" | |||||
#include <limits.h> | |||||
#include <string> | |||||
#include <vector> | |||||
#if defined(_MSC_VER) || defined(__BORLANDC__) | |||||
typedef __int64 int64; | |||||
typedef unsigned __int64 uint64; | |||||
#else | |||||
typedef long long int64; | |||||
typedef unsigned long long uint64; | |||||
#endif | |||||
#if defined(_MSC_VER) && _MSC_VER < 1300 | |||||
#define for if (false); else for | |||||
#endif | |||||
inline int Testuint256AdHoc(std::vector<std::string> vArg); | |||||
// We have to keep a separate base class without constructors | |||||
// so the compiler will let us use it in a union | |||||
template <unsigned int BITS> class base_uint { | |||||
protected: | |||||
enum { WIDTH = BITS / 32 }; | |||||
unsigned int pn[WIDTH]; | |||||
public: | |||||
bool operator!() const { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
if (pn[i] != 0) return false; | |||||
return true; | |||||
} | |||||
const base_uint operator~() const { | |||||
base_uint ret; | |||||
for (int i = 0; i < WIDTH; i++) | |||||
ret.pn[i] = ~pn[i]; | |||||
return ret; | |||||
} | |||||
const base_uint operator-() const { | |||||
base_uint ret; | |||||
for (int i = 0; i < WIDTH; i++) | |||||
ret.pn[i] = ~pn[i]; | |||||
ret++; | |||||
return ret; | |||||
} | |||||
base_uint &operator=(uint64 b) { | |||||
pn[0] = (unsigned int)b; | |||||
pn[1] = (unsigned int)(b >> 32); | |||||
for (int i = 2; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
return *this; | |||||
} | |||||
base_uint &operator^=(const base_uint &b) { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] ^= b.pn[i]; | |||||
return *this; | |||||
} | |||||
base_uint &operator&=(const base_uint &b) { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] &= b.pn[i]; | |||||
return *this; | |||||
} | |||||
base_uint &operator|=(const base_uint &b) { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] |= b.pn[i]; | |||||
return *this; | |||||
} | |||||
base_uint &operator^=(uint64 b) { | |||||
pn[0] ^= (unsigned int)b; | |||||
pn[1] ^= (unsigned int)(b >> 32); | |||||
return *this; | |||||
} | |||||
base_uint &operator&=(uint64 b) { | |||||
pn[0] &= (unsigned int)b; | |||||
pn[1] &= (unsigned int)(b >> 32); | |||||
return *this; | |||||
} | |||||
base_uint &operator|=(uint64 b) { | |||||
pn[0] |= (unsigned int)b; | |||||
pn[1] |= (unsigned int)(b >> 32); | |||||
return *this; | |||||
} | |||||
base_uint &operator<<=(unsigned int shift) { | |||||
base_uint a(*this); | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
int k = shift / 32; | |||||
shift = shift % 32; | |||||
for (int i = 0; i < WIDTH; i++) { | |||||
if (i + k + 1 < WIDTH && shift != 0) | |||||
pn[i + k + 1] |= (a.pn[i] >> (32 - shift)); | |||||
if (i + k < WIDTH) pn[i + k] |= (a.pn[i] << shift); | |||||
} | |||||
return *this; | |||||
} | |||||
base_uint &operator>>=(unsigned int shift) { | |||||
base_uint a(*this); | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
int k = shift / 32; | |||||
shift = shift % 32; | |||||
for (int i = 0; i < WIDTH; i++) { | |||||
if (i - k - 1 >= 0 && shift != 0) | |||||
pn[i - k - 1] |= (a.pn[i] << (32 - shift)); | |||||
if (i - k >= 0) pn[i - k] |= (a.pn[i] >> shift); | |||||
} | |||||
return *this; | |||||
} | |||||
base_uint &operator+=(const base_uint &b) { | |||||
uint64 carry = 0; | |||||
for (int i = 0; i < WIDTH; i++) { | |||||
uint64 n = carry + pn[i] + b.pn[i]; | |||||
pn[i] = n & 0xffffffff; | |||||
carry = n >> 32; | |||||
} | |||||
return *this; | |||||
} | |||||
base_uint &operator-=(const base_uint &b) { | |||||
*this += -b; | |||||
return *this; | |||||
} | |||||
base_uint &operator+=(uint64 b64) { | |||||
base_uint b; | |||||
b = b64; | |||||
*this += b; | |||||
return *this; | |||||
} | |||||
base_uint &operator-=(uint64 b64) { | |||||
base_uint b; | |||||
b = b64; | |||||
*this += -b; | |||||
return *this; | |||||
} | |||||
base_uint &operator++() { | |||||
// prefix operator | |||||
int i = 0; | |||||
while (++pn[i] == 0 && i < WIDTH - 1) | |||||
i++; | |||||
return *this; | |||||
} | |||||
const base_uint operator++(int) { | |||||
// postfix operator | |||||
const base_uint ret = *this; | |||||
++(*this); | |||||
return ret; | |||||
} | |||||
base_uint &operator--() { | |||||
// prefix operator | |||||
int i = 0; | |||||
while (--pn[i] == -1 && i < WIDTH - 1) | |||||
i++; | |||||
return *this; | |||||
} | |||||
const base_uint operator--(int) { | |||||
// postfix operator | |||||
const base_uint ret = *this; | |||||
--(*this); | |||||
return ret; | |||||
} | |||||
friend inline bool operator<(const base_uint &a, const base_uint &b) { | |||||
for (int i = base_uint::WIDTH - 1; i >= 0; i--) { | |||||
if (a.pn[i] < b.pn[i]) | |||||
return true; | |||||
else if (a.pn[i] > b.pn[i]) | |||||
return false; | |||||
} | |||||
return false; | |||||
} | |||||
friend inline bool operator<=(const base_uint &a, const base_uint &b) { | |||||
for (int i = base_uint::WIDTH - 1; i >= 0; i--) { | |||||
if (a.pn[i] < b.pn[i]) | |||||
return true; | |||||
else if (a.pn[i] > b.pn[i]) | |||||
return false; | |||||
} | |||||
return true; | |||||
} | |||||
friend inline bool operator>(const base_uint &a, const base_uint &b) { | |||||
for (int i = base_uint::WIDTH - 1; i >= 0; i--) { | |||||
if (a.pn[i] > b.pn[i]) | |||||
return true; | |||||
else if (a.pn[i] < b.pn[i]) | |||||
return false; | |||||
} | |||||
return false; | |||||
} | |||||
friend inline bool operator>=(const base_uint &a, const base_uint &b) { | |||||
for (int i = base_uint::WIDTH - 1; i >= 0; i--) { | |||||
if (a.pn[i] > b.pn[i]) | |||||
return true; | |||||
else if (a.pn[i] < b.pn[i]) | |||||
return false; | |||||
} | |||||
return true; | |||||
} | |||||
friend inline bool operator==(const base_uint &a, const base_uint &b) { | |||||
for (int i = 0; i < base_uint::WIDTH; i++) | |||||
if (a.pn[i] != b.pn[i]) return false; | |||||
return true; | |||||
} | |||||
friend inline bool operator==(const base_uint &a, uint64 b) { | |||||
if (a.pn[0] != (unsigned int)b) return false; | |||||
if (a.pn[1] != (unsigned int)(b >> 32)) return false; | |||||
for (int i = 2; i < base_uint::WIDTH; i++) | |||||
if (a.pn[i] != 0) return false; | |||||
return true; | |||||
} | |||||
friend inline bool operator!=(const base_uint &a, const base_uint &b) { | |||||
return (!(a == b)); | |||||
} | |||||
friend inline bool operator!=(const base_uint &a, uint64 b) { | |||||
return (!(a == b)); | |||||
} | |||||
std::string GetHex() const { | |||||
char psz[sizeof(pn) * 2 + 1]; | |||||
for (int i = 0; i < sizeof(pn); i++) | |||||
sprintf(psz + i * 2, "%02x", | |||||
((unsigned char *)pn)[sizeof(pn) - i - 1]); | |||||
return std::string(psz, psz + sizeof(pn) * 2); | |||||
} | |||||
void SetHex(const char *psz) { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
// skip leading spaces | |||||
while (isspace(*psz)) | |||||
psz++; | |||||
// skip 0x | |||||
if (psz[0] == '0' && tolower(psz[1]) == 'x') psz += 2; | |||||
// hex string to uint | |||||
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}; | |||||
const char *pbegin = psz; | |||||
while (phexdigit[(unsigned char)*psz] || *psz == '0') | |||||
psz++; | |||||
psz--; | |||||
unsigned char *p1 = (unsigned char *)pn; | |||||
unsigned char *pend = p1 + WIDTH * 4; | |||||
while (psz >= pbegin && p1 < pend) { | |||||
*p1 = phexdigit[(unsigned char)*psz--]; | |||||
if (psz >= pbegin) { | |||||
*p1 |= (phexdigit[(unsigned char)*psz--] << 4); | |||||
p1++; | |||||
} | |||||
} | |||||
} | |||||
void SetHex(const std::string &str) { SetHex(str.c_str()); } | |||||
std::string ToString() const { return (GetHex()); } | |||||
unsigned char *begin() { return (unsigned char *)&pn[0]; } | |||||
unsigned char *end() { return (unsigned char *)&pn[WIDTH]; } | |||||
unsigned int size() { return sizeof(pn); } | |||||
unsigned int GetSerializeSize(int nType = 0, | |||||
int nVersion = PROTOCOL_VERSION) const { | |||||
return sizeof(pn); | |||||
} | |||||
template <typename Stream> | |||||
void Serialize(Stream &s, int nType = 0, | |||||
int nVersion = PROTOCOL_VERSION) const { | |||||
s.write((char *)pn, sizeof(pn)); | |||||
} | |||||
template <typename Stream> | |||||
void Unserialize(Stream &s, int nType = 0, | |||||
int nVersion = PROTOCOL_VERSION) { | |||||
s.read((char *)pn, sizeof(pn)); | |||||
} | |||||
friend class uint160; | |||||
friend class uint256; | |||||
friend inline int Testuint256AdHoc(std::vector<std::string> vArg); | |||||
}; | |||||
typedef base_uint<160> base_uint160; | |||||
typedef base_uint<256> base_uint256; | |||||
// | |||||
// uint160 and uint256 could be implemented as templates, but to keep | |||||
// compile errors and debugging cleaner, they're copy and pasted. | |||||
// | |||||
////////////////////////////////////////////////////////////////////////////// | |||||
// | |||||
// uint160 | |||||
// | |||||
class uint160 : public base_uint160 { | |||||
public: | |||||
typedef base_uint160 basetype; | |||||
uint160() { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
} | |||||
uint160(const basetype &b) { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = b.pn[i]; | |||||
} | |||||
uint160 &operator=(const basetype &b) { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = b.pn[i]; | |||||
return *this; | |||||
} | |||||
uint160(uint64 b) { | |||||
pn[0] = (unsigned int)b; | |||||
pn[1] = (unsigned int)(b >> 32); | |||||
for (int i = 2; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
} | |||||
uint160 &operator=(uint64 b) { | |||||
pn[0] = (unsigned int)b; | |||||
pn[1] = (unsigned int)(b >> 32); | |||||
for (int i = 2; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
return *this; | |||||
} | |||||
explicit uint160(const std::string &str) { SetHex(str); } | |||||
explicit uint160(const std::vector<unsigned char> &vch) { | |||||
if (vch.size() == sizeof(pn)) | |||||
memcpy(pn, &vch[0], sizeof(pn)); | |||||
else | |||||
*this = 0; | |||||
} | |||||
}; | |||||
inline bool operator==(const uint160 &a, uint64 b) { | |||||
return (base_uint160)a == b; | |||||
} | |||||
inline bool operator!=(const uint160 &a, uint64 b) { | |||||
return (base_uint160)a != b; | |||||
} | |||||
inline const uint160 operator<<(const base_uint160 &a, unsigned int shift) { | |||||
return uint160(a) <<= shift; | |||||
} | |||||
inline const uint160 operator>>(const base_uint160 &a, unsigned int shift) { | |||||
return uint160(a) >>= shift; | |||||
} | |||||
inline const uint160 operator<<(const uint160 &a, unsigned int shift) { | |||||
return uint160(a) <<= shift; | |||||
} | |||||
inline const uint160 operator>>(const uint160 &a, unsigned int shift) { | |||||
return uint160(a) >>= shift; | |||||
} | |||||
inline const uint160 operator^(const base_uint160 &a, const base_uint160 &b) { | |||||
return uint160(a) ^= b; | |||||
} | |||||
inline const uint160 operator&(const base_uint160 &a, const base_uint160 &b) { | |||||
return uint160(a) &= b; | |||||
} | |||||
inline const uint160 operator|(const base_uint160 &a, const base_uint160 &b) { | |||||
return uint160(a) |= b; | |||||
} | |||||
inline const uint160 operator+(const base_uint160 &a, const base_uint160 &b) { | |||||
return uint160(a) += b; | |||||
} | |||||
inline const uint160 operator-(const base_uint160 &a, const base_uint160 &b) { | |||||
return uint160(a) -= b; | |||||
} | |||||
inline bool operator<(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a < (base_uint160)b; | |||||
} | |||||
inline bool operator<=(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a <= (base_uint160)b; | |||||
} | |||||
inline bool operator>(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a > (base_uint160)b; | |||||
} | |||||
inline bool operator>=(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a >= (base_uint160)b; | |||||
} | |||||
inline bool operator==(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a == (base_uint160)b; | |||||
} | |||||
inline bool operator!=(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a != (base_uint160)b; | |||||
} | |||||
inline const uint160 operator^(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a ^ (base_uint160)b; | |||||
} | |||||
inline const uint160 operator&(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a & (base_uint160)b; | |||||
} | |||||
inline const uint160 operator|(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a | (base_uint160)b; | |||||
} | |||||
inline const uint160 operator+(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a + (base_uint160)b; | |||||
} | |||||
inline const uint160 operator-(const base_uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a - (base_uint160)b; | |||||
} | |||||
inline bool operator<(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a < (base_uint160)b; | |||||
} | |||||
inline bool operator<=(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a <= (base_uint160)b; | |||||
} | |||||
inline bool operator>(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a > (base_uint160)b; | |||||
} | |||||
inline bool operator>=(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a >= (base_uint160)b; | |||||
} | |||||
inline bool operator==(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a == (base_uint160)b; | |||||
} | |||||
inline bool operator!=(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a != (base_uint160)b; | |||||
} | |||||
inline const uint160 operator^(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a ^ (base_uint160)b; | |||||
} | |||||
inline const uint160 operator&(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a & (base_uint160)b; | |||||
} | |||||
inline const uint160 operator|(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a | (base_uint160)b; | |||||
} | |||||
inline const uint160 operator+(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a + (base_uint160)b; | |||||
} | |||||
inline const uint160 operator-(const uint160 &a, const base_uint160 &b) { | |||||
return (base_uint160)a - (base_uint160)b; | |||||
} | |||||
inline bool operator<(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a < (base_uint160)b; | |||||
} | |||||
inline bool operator<=(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a <= (base_uint160)b; | |||||
} | |||||
inline bool operator>(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a > (base_uint160)b; | |||||
} | |||||
inline bool operator>=(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a >= (base_uint160)b; | |||||
} | |||||
inline bool operator==(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a == (base_uint160)b; | |||||
} | |||||
inline bool operator!=(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a != (base_uint160)b; | |||||
} | |||||
inline const uint160 operator^(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a ^ (base_uint160)b; | |||||
} | |||||
inline const uint160 operator&(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a & (base_uint160)b; | |||||
} | |||||
inline const uint160 operator|(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a | (base_uint160)b; | |||||
} | |||||
inline const uint160 operator+(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a + (base_uint160)b; | |||||
} | |||||
inline const uint160 operator-(const uint160 &a, const uint160 &b) { | |||||
return (base_uint160)a - (base_uint160)b; | |||||
} | |||||
////////////////////////////////////////////////////////////////////////////// | |||||
// | |||||
// uint256 | |||||
// | |||||
class uint256 : public base_uint256 { | |||||
public: | |||||
typedef base_uint256 basetype; | |||||
uint256() { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
} | |||||
uint256(const basetype &b) { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = b.pn[i]; | |||||
} | |||||
uint256 &operator=(const basetype &b) { | |||||
for (int i = 0; i < WIDTH; i++) | |||||
pn[i] = b.pn[i]; | |||||
return *this; | |||||
} | |||||
uint256(uint64 b) { | |||||
pn[0] = (unsigned int)b; | |||||
pn[1] = (unsigned int)(b >> 32); | |||||
for (int i = 2; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
} | |||||
uint256 &operator=(uint64 b) { | |||||
pn[0] = (unsigned int)b; | |||||
pn[1] = (unsigned int)(b >> 32); | |||||
for (int i = 2; i < WIDTH; i++) | |||||
pn[i] = 0; | |||||
return *this; | |||||
} | |||||
explicit uint256(const std::string &str) { SetHex(str); } | |||||
explicit uint256(const std::vector<unsigned char> &vch) { | |||||
if (vch.size() == sizeof(pn)) | |||||
memcpy(pn, &vch[0], sizeof(pn)); | |||||
else | |||||
*this = 0; | |||||
} | |||||
}; | |||||
inline bool operator==(const uint256 &a, uint64 b) { | |||||
return (base_uint256)a == b; | |||||
} | |||||
inline bool operator!=(const uint256 &a, uint64 b) { | |||||
return (base_uint256)a != b; | |||||
} | |||||
inline const uint256 operator<<(const base_uint256 &a, unsigned int shift) { | |||||
return uint256(a) <<= shift; | |||||
} | |||||
inline const uint256 operator>>(const base_uint256 &a, unsigned int shift) { | |||||
return uint256(a) >>= shift; | |||||
} | |||||
inline const uint256 operator<<(const uint256 &a, unsigned int shift) { | |||||
return uint256(a) <<= shift; | |||||
} | |||||
inline const uint256 operator>>(const uint256 &a, unsigned int shift) { | |||||
return uint256(a) >>= shift; | |||||
} | |||||
inline const uint256 operator^(const base_uint256 &a, const base_uint256 &b) { | |||||
return uint256(a) ^= b; | |||||
} | |||||
inline const uint256 operator&(const base_uint256 &a, const base_uint256 &b) { | |||||
return uint256(a) &= b; | |||||
} | |||||
inline const uint256 operator|(const base_uint256 &a, const base_uint256 &b) { | |||||
return uint256(a) |= b; | |||||
} | |||||
inline const uint256 operator+(const base_uint256 &a, const base_uint256 &b) { | |||||
return uint256(a) += b; | |||||
} | |||||
inline const uint256 operator-(const base_uint256 &a, const base_uint256 &b) { | |||||
return uint256(a) -= b; | |||||
} | |||||
inline bool operator<(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a < (base_uint256)b; | |||||
} | |||||
inline bool operator<=(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a <= (base_uint256)b; | |||||
} | |||||
inline bool operator>(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a > (base_uint256)b; | |||||
} | |||||
inline bool operator>=(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a >= (base_uint256)b; | |||||
} | |||||
inline bool operator==(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a == (base_uint256)b; | |||||
} | |||||
inline bool operator!=(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a != (base_uint256)b; | |||||
} | |||||
inline const uint256 operator^(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a ^ (base_uint256)b; | |||||
} | |||||
inline const uint256 operator&(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a & (base_uint256)b; | |||||
} | |||||
inline const uint256 operator|(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a | (base_uint256)b; | |||||
} | |||||
inline const uint256 operator+(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a + (base_uint256)b; | |||||
} | |||||
inline const uint256 operator-(const base_uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a - (base_uint256)b; | |||||
} | |||||
inline bool operator<(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a < (base_uint256)b; | |||||
} | |||||
inline bool operator<=(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a <= (base_uint256)b; | |||||
} | |||||
inline bool operator>(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a > (base_uint256)b; | |||||
} | |||||
inline bool operator>=(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a >= (base_uint256)b; | |||||
} | |||||
inline bool operator==(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a == (base_uint256)b; | |||||
} | |||||
inline bool operator!=(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a != (base_uint256)b; | |||||
} | |||||
inline const uint256 operator^(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a ^ (base_uint256)b; | |||||
} | |||||
inline const uint256 operator&(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a & (base_uint256)b; | |||||
} | |||||
inline const uint256 operator|(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a | (base_uint256)b; | |||||
} | |||||
inline const uint256 operator+(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a + (base_uint256)b; | |||||
} | |||||
inline const uint256 operator-(const uint256 &a, const base_uint256 &b) { | |||||
return (base_uint256)a - (base_uint256)b; | |||||
} | |||||
inline bool operator<(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a < (base_uint256)b; | |||||
} | |||||
inline bool operator<=(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a <= (base_uint256)b; | |||||
} | |||||
inline bool operator>(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a > (base_uint256)b; | |||||
} | |||||
inline bool operator>=(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a >= (base_uint256)b; | |||||
} | |||||
inline bool operator==(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a == (base_uint256)b; | |||||
} | |||||
inline bool operator!=(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a != (base_uint256)b; | |||||
} | |||||
inline const uint256 operator^(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a ^ (base_uint256)b; | |||||
} | |||||
inline const uint256 operator&(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a & (base_uint256)b; | |||||
} | |||||
inline const uint256 operator|(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a | (base_uint256)b; | |||||
} | |||||
inline const uint256 operator+(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a + (base_uint256)b; | |||||
} | |||||
inline const uint256 operator-(const uint256 &a, const uint256 &b) { | |||||
return (base_uint256)a - (base_uint256)b; | |||||
} | |||||
inline int Testuint256AdHoc(std::vector<std::string> vArg) { | |||||
uint256 g(0); | |||||
printf("%s\n", g.ToString().c_str()); | |||||
g--; | |||||
printf("g--\n"); | |||||
printf("%s\n", g.ToString().c_str()); | |||||
g--; | |||||
printf("g--\n"); | |||||
printf("%s\n", g.ToString().c_str()); | |||||
g++; | |||||
printf("g++\n"); | |||||
printf("%s\n", g.ToString().c_str()); | |||||
g++; | |||||
printf("g++\n"); | |||||
printf("%s\n", g.ToString().c_str()); | |||||
g++; | |||||
printf("g++\n"); | |||||
printf("%s\n", g.ToString().c_str()); | |||||
g++; | |||||
printf("g++\n"); | |||||
printf("%s\n", g.ToString().c_str()); | |||||
uint256 a(7); | |||||
printf("a=7\n"); | |||||
printf("%s\n", a.ToString().c_str()); | |||||
uint256 b; | |||||
printf("b undefined\n"); | |||||
printf("%s\n", b.ToString().c_str()); | |||||
int c = 3; | |||||
a = c; | |||||
a.pn[3] = 15; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
uint256 k(c); | |||||
a = 5; | |||||
a.pn[3] = 15; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
b = 1; | |||||
b <<= 52; | |||||
a |= b; | |||||
a ^= 0x500; | |||||
printf("a %s\n", a.ToString().c_str()); | |||||
a = a | b | (uint256)0x1000; | |||||
printf("a %s\n", a.ToString().c_str()); | |||||
printf("b %s\n", b.ToString().c_str()); | |||||
a = 0xfffffffe; | |||||
a.pn[4] = 9; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a++; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a++; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a++; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a++; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a--; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a--; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a--; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
uint256 d = a--; | |||||
printf("%s\n", d.ToString().c_str()); | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a--; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
a--; | |||||
printf("%s\n", a.ToString().c_str()); | |||||
d = a; | |||||
printf("%s\n", d.ToString().c_str()); | |||||
for (int i = uint256::WIDTH - 1; i >= 0; i--) | |||||
printf("%08x", d.pn[i]); | |||||
printf("\n"); | |||||
uint256 neg = d; | |||||
neg = ~neg; | |||||
printf("%s\n", neg.ToString().c_str()); | |||||
uint256 e = uint256("0xABCDEF123abcdef12345678909832180000011111111"); | |||||
printf("\n"); | |||||
printf("%s\n", e.ToString().c_str()); | |||||
printf("\n"); | |||||
uint256 x1 = uint256("0xABCDEF123abcdef12345678909832180000011111111"); | |||||
uint256 x2; | |||||
printf("%s\n", x1.ToString().c_str()); | |||||
for (int i = 0; i < 270; i += 4) { | |||||
x2 = x1 << i; | |||||
printf("%s\n", x2.ToString().c_str()); | |||||
} | |||||
printf("\n"); | |||||
printf("%s\n", x1.ToString().c_str()); | |||||
for (int i = 0; i < 270; i += 4) { | |||||
x2 = x1; | |||||
x2 >>= i; | |||||
printf("%s\n", x2.ToString().c_str()); | |||||
} | |||||
for (int i = 0; i < 100; i++) { | |||||
uint256 k = (~uint256(0) >> i); | |||||
printf("%s\n", k.ToString().c_str()); | |||||
} | |||||
for (int i = 0; i < 100; i++) { | |||||
uint256 k = (~uint256(0) << i); | |||||
printf("%s\n", k.ToString().c_str()); | |||||
} | |||||
return (0); | |||||
} | |||||
#endif |