BigInteger big;

big._data = cs_vbyte(0); // empty array is error

return big;

// according to C# spec, only non-negative int32 values accepted here

if (exponent < 0) return BigInteger::Error();

mpz_class big1 = csBigIntegerMPZparse(value.ToByteArray());

mpz_class r;

uint64_t _exp = exponent;

mpz_pow_ui(r.get_mpz_t(), big1.get_mpz_t(), _exp);

cs_vbyte vr = csBigIntegerGetBytesFromMPZ(r);

reverse(vr.begin(), vr.end()); // to little-endian

return BigInteger(vr);

mpz_class a = val;

_data = csBigIntegerGetBytesFromMPZ(a);

cs_vbyte vb = this->ToByteArray(); // little-endian

mpz_class a = csBigIntegerMPZparse(vb);

cs_int32 i = a.get_ui(); // unsigned int

if (a < 0) i *= -1;

return i;

cs_vbyte vb = this->ToByteArray(); // little-endian

mpz_class a = csBigIntegerMPZparse(vb);

cs_int64 i = a.get_si(); // signed long int

return i;

mpz_class bThis =

csBigIntegerMPZparse(this->ToByteArray()); // parse from little-endian

return bThis.get_str(10);

std::string sbin;

while (big > 0) {

mpz_class rest = (big % 2);

sbin.insert(0, (rest.get_ui() == 0 ? std::string("0") : std::string("1")));

big = big / 2;

}

return sbin;

// check if positive or negative

if (big >= 0) {

// -------------------

// positive conversion

// -------------------

cs_vbyte v;

while (big > 0) {

mpz_class rest = (big % 256);

v.push_back((cs_byte)rest.get_ui());

big = big / 256;

}

// added in little-endian format (backwards)

std::string leHex = Helper::toHexString(v);

if (leHex.length() == 0) leHex = "00";

// check if became negative

if (Helper::checkNegativeBit(leHex)) {

v.push_back(0); // guarantee non-negative

}

// v is added backwards (little-endian), must reverse (to big-endian)

reverse(v.begin(), v.end());

if (v.size() == 0) v.push_back(0x00);

// finished

return v;

} else {

// -------------------

// negative conversion

// -------------------

// turn into positive

mpz_class x = big * (-1);

// cout << "x positive " << x << endl;

// ========================

// perform two's complement

// ========================

// convert to binary

cs_vbyte vx =

csBigIntegerGetBytesFromMPZ(x); // positive is easy to convert

// cout << Helper::toHexString(vx) << endl;

mpz_class bx(Helper::toHexString(vx), 16);

// get binary representation

std::string y = bx.get_str(2);

// cout << "numbits: " << y.length() << endl;

// cout << "ybits: " << y << endl;

// cout << "dbits: " << csBigIntegerGetBitsFromNonNegativeMPZ(x) << endl;

// extra padding for limit cases (avoid overflow)

y.insert(0, "0"); // prepend

// guarantee length must be at least 8, or add padding!

while ((y.length() < 8) || (y.length() % 8 != 0)) {

y.insert(0, "0"); // prepend

}

// invert bits

std::string y2 = "";

for (int i = 0; i < (int)y.length(); i++) y2 += (y[i] == '0' ? '1' : '0');

// cout << "rbits: " << y2 << endl;

// go back to bigint

// BigInteger by3(y2, 2); // recursive behavior

mpz_class by3(y2, 2);

// sum 1

mpz_class bby3 = by3 + 1;

// cout << "(~y)+1: " << bby3 << endl;

// convert to binary again

std::string y4 = csBigIntegerGetBitsFromNonNegativeMPZ(bby3);

// cout << "y4bits: " << y4 << endl;

// padding

while ((y4.length() < 8) || (y4.length() % 8 != 0)) {

y4.insert(0, "0"); // prepend

}

// cout << "y4bits: " << y4 << endl;

// get in bytes

cs_vbyte v = Helper::BinToBytes(y4);

// cout << "v: " << Helper::toHexString(v) << endl;

// convert to little-endian

reverse(v.begin(), v.end()); // to little-endian

// will add extra ff to guarantee its negative, and simplify later (remove

// extra ff)

v.push_back(0xff);

cs_vbyte vsimple = v;

while ((vsimple.size() > 1) &&

(vsimple.at(((int)vsimple.size()) - 1) == 0xff)) {

vsimple.pop_back();

std::string lehex = Helper::toHexString(vsimple);

if (Helper::checkNegativeBit(lehex)) {

// still negative! can keep removal

v = vsimple;

} else

break;

}

// convert to big-endian

reverse(v.begin(), v.end()); // to big-endian

// finished

return v;

}

// if (n.size() == 0)

// return mpz_class(0); // never invoked

std::string s = Helper::toHexString(n);

// verify if number is negative (most significant bit)

if (Helper::checkNegativeBit(s)) {

// is negative, must handle twos-complement

mpz_class vint(Helper::revertHexString(s), 16); // as big-endian again

// get bitstring

std::string rbitnum = csBigIntegerGetBitsFromNonNegativeMPZ(vint);

// negate bits

std::stringstream y2;

for (int i = 0; i < (int)rbitnum.length(); i++)

y2 << (rbitnum[i] == '0' ? '1' : '0');

// to bigint again

mpz_class by2(y2.str(), 2);

// add one

mpz_class by2add = by2 + 1;

// get negative

mpz_class finalnum = by2add * (-1);

// ensure it's negative (TODO(igormcoelho): remove)

assert(finalnum < 0); // must be negative

// finished

return finalnum;

} else {

// positive is easy (in little-endian format)

std::string sbig = Helper::revertHexString(s);

// build bignum in big-endian

return mpz_class(sbig, 16); // big-endian again

}

if (base == 10) {

// if (n.length() == 0)

// n = "0"; // not necessary

return mpz_class(n, base);

}

// never used! internal function only

// if (base == 2) {

// if (n.length() == 0)

// n = "0";

// return mpz_class(n, base);

//}

// never used! internal function only

// if (base != 16) {

// cout << "UNSUPPORTED BASE! " << base << endl;

// exit(1);

//}

// zero padding

while (n.length() < 2) n.insert(0, "0");

// return bytearray initialized

cs_vbyte vb;

// prefix '0x' optional. input always big-endian

if ((n[0] == '0') && (n[1] == 'x')) {

// removing '0x'

n = n.substr(2, n.length() - 2);

vb = Helper::HexToBytes(n);

} else {

vb = Helper::HexToBytes(n); // directly reading big-endian byte array

}

reverse(vb.begin(), vb.end()); // to little-endian

// base 16

return csBigIntegerMPZparse(vb); // vb is little-endian byte array