bignum.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Copyright (c) 2017-2021 The PIVX Core developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_LIBZEROCOIN_BIGNUM_H
#define PIVX_LIBZEROCOIN_BIGNUM_H
 
#if defined HAVE_CONFIG_H
#include "config/pivx-config.h"
#endif
 
#include <gmp.h>
 
#include <stdexcept>
#include <vector>
#include <limits.h>
 
#include "arith_uint256.h"
#include "serialize.h"
#include "uint256.h"
#include "version.h"
#include "random.h"
 
class bignum_error : public std::runtime_error
{
public:
    explicit bignum_error(const std::string& str) : std::runtime_error(str) {}
};
 
class CBigNum
{
    mpz_t bn;
public:
    CBigNum();
    CBigNum(const CBigNum& b);
    CBigNum& operator=(const CBigNum& b);
    ~CBigNum();
 
    //CBigNum(char n) is not portable.  Use 'signed char' or 'unsigned char'.
    CBigNum(signed char n);
    CBigNum(short n);
    CBigNum(int n);
    CBigNum(long n);
    CBigNum(long long n);
    CBigNum(unsigned char n);
    CBigNum(unsigned short n);
    CBigNum(unsigned int n);
    CBigNum(unsigned long n);
    CBigNum(unsigned long long n);
    explicit CBigNum(uint256 n);
    explicit CBigNum(const std::vector<unsigned char>& vch);
 
    static CBigNum randBignum(const CBigNum& range);
 
    int bitSize() const;
    void setulong(unsigned long n);
    unsigned long getulong() const;
    unsigned int getuint() const;
    int getint() const;
    void setint64(int64_t sn);
    void setuint64(uint64_t n);
    void setuint256(uint256 n);
    arith_uint256 getuint256() const;
    void setvch(const std::vector<unsigned char>& vch);
    std::vector<unsigned char> getvch() const;
    void SetDec(const std::string& str);
    void SetHex(const std::string& str);
    bool SetHexBool(const std::string& str);
    std::string ToString(int nBase=10) const;
    std::string GetHex() const;
    std::string GetDec() const;
 
    template<typename Stream>
    void Serialize(Stream& s) const
    {
        ::Serialize(s, getvch());
    }
 
    template<typename Stream>
    void Unserialize(Stream& s)
    {
        std::vector<unsigned char> vch;
        ::Unserialize(s, vch);
        setvch(vch);
    }
 
    CBigNum pow(const int e) const;
 
    CBigNum pow(const CBigNum& e) const;
 
    CBigNum mul_mod(const CBigNum& b, const CBigNum& m) const;
 
    CBigNum pow_mod(const CBigNum& e, const CBigNum& m) const;
 
    CBigNum inverse(const CBigNum& m) const;
 
    CBigNum gcd( const CBigNum& b) const;
 
    bool isPrime(const int checks=15) const;
 
    bool isOne() const;
    bool operator!() const;
    CBigNum& operator+=(const CBigNum& b);
    CBigNum& operator-=(const CBigNum& b);
    CBigNum& operator*=(const CBigNum& b);
    CBigNum& operator/=(const CBigNum& b);
    CBigNum& operator%=(const CBigNum& b);
    CBigNum& operator<<=(unsigned int shift);
    CBigNum& operator>>=(unsigned int shift);
    CBigNum& operator++();
    const CBigNum operator++(int);
    CBigNum& operator--();
    const CBigNum operator--(int);
 
    friend inline const CBigNum operator+(const CBigNum& a, const CBigNum& b);
    friend inline const CBigNum operator-(const CBigNum& a, const CBigNum& b);
    friend inline const CBigNum operator/(const CBigNum& a, const CBigNum& b);
    friend inline const CBigNum operator%(const CBigNum& a, const CBigNum& b);
    friend inline const CBigNum operator*(const CBigNum& a, const CBigNum& b);
    friend inline const CBigNum operator<<(const CBigNum& a, unsigned int shift);
    friend inline const CBigNum operator-(const CBigNum& a);
    friend inline bool operator==(const CBigNum& a, const CBigNum& b);
    friend inline bool operator!=(const CBigNum& a, const CBigNum& b);
    friend inline bool operator<=(const CBigNum& a, const CBigNum& b);
    friend inline bool operator>=(const CBigNum& a, const CBigNum& b);
    friend inline bool operator<(const CBigNum& a, const CBigNum& b);
    friend inline bool operator>(const CBigNum& a, const CBigNum& b);
};
 
inline const CBigNum operator+(const CBigNum& a, const CBigNum& b) {
    CBigNum r;
    mpz_add(r.bn, a.bn, b.bn);
    return r;
}
inline const CBigNum operator-(const CBigNum& a, const CBigNum& b) {
    CBigNum r;
    mpz_sub(r.bn, a.bn, b.bn);
    return r;
}
inline const CBigNum operator-(const CBigNum& a) {
    CBigNum r;
    mpz_neg(r.bn, a.bn);
    return r;
}
inline const CBigNum operator*(const CBigNum& a, const CBigNum& b) {
    CBigNum r;
    mpz_mul(r.bn, a.bn, b.bn);
    return r;
}
inline const CBigNum operator/(const CBigNum& a, const CBigNum& b) {
    CBigNum r;
    mpz_tdiv_q(r.bn, a.bn, b.bn);
    return r;
}
inline const CBigNum operator%(const CBigNum& a, const CBigNum& b) {
    CBigNum r;
    mpz_mmod(r.bn, a.bn, b.bn);
    return r;
}
inline const CBigNum operator<<(const CBigNum& a, unsigned int shift) {
    CBigNum r;
    mpz_mul_2exp(r.bn, a.bn, shift);
    return r;
}
inline const CBigNum operator>>(const CBigNum& a, unsigned int shift) {
    CBigNum r = a;
    r >>= shift;
    return r;
}
inline bool operator==(const CBigNum& a, const CBigNum& b) { return (mpz_cmp(a.bn, b.bn) == 0); }
inline bool operator!=(const CBigNum& a, const CBigNum& b) { return (mpz_cmp(a.bn, b.bn) != 0); }
inline bool operator<=(const CBigNum& a, const CBigNum& b) { return (mpz_cmp(a.bn, b.bn) <= 0); }
inline bool operator>=(const CBigNum& a, const CBigNum& b) { return (mpz_cmp(a.bn, b.bn) >= 0); }
inline bool operator<(const CBigNum& a, const CBigNum& b)  { return (mpz_cmp(a.bn, b.bn) < 0); }
inline bool operator>(const CBigNum& a, const CBigNum& b)  { return (mpz_cmp(a.bn, b.bn) > 0); }
 
inline std::ostream& operator<<(std::ostream &strm, const CBigNum &b) { return strm << b.ToString(10); }
 
typedef CBigNum Bignum;
 
const CBigNum BN_ZERO = CBigNum(0);
const CBigNum BN_ONE = CBigNum(1);
const CBigNum BN_TWO = CBigNum(2);
const CBigNum BN_THREE = CBigNum(3);
 
#endif // PIVX_LIBZEROCOIN_BIGNUM_H