math.big #

fn b_and(a &Number, b &Number) Number

//////////////////////////////////////////////////////////

fn b_or(a &Number, b &Number) Number

fn b_xor(a &Number, b &Number) Number

fn cmp(a &Number, b &Number) int

//////////////////////////////////////////////////////////

fn divmod(a &Number, b &Number, c &Number) Number

fn fact(n int) Number

fn factorial(nn &Number) Number

//////////////////////////////////////////////////////////

fn from_hex_string(input string) Number

from_hex_string converts a hex string to big.Number

fn from_int(i int) Number

conversion actions to/from big numbers: from_int converts an ordinary int number i to big.Number

fn from_string(input string) Number

from_string converts a decimal string to big.Number

fn from_u64(u u64) Number

from_u64 converts an ordinary u64 number u to big.Number

fn new() Number

fn pow(a &Number, b &Number) Number

fn (n &Number) int() int

.int() converts (a small) big.Number n to an ordinary integer.

fn (n &Number) str() string

.str returns a decimal representation of the big unsigned integer number n.

fn (n &Number) hexstr() string

.hexstr returns a hexadecimal representation of the bignum n

fn (a &Number) + (b &Number) Number

////////////////////////////////////////////////////////// overloaded ops for the numbers:

fn (a &Number) - (b &Number) Number

fn (a &Number) * (b &Number) Number

fn (a &Number) / (b &Number) Number

fn (a &Number) % (b &Number) Number

fn (a &Number) is_zero() bool

fn (mut a Number) inc()

fn (mut a Number) dec()

fn (a &Number) isqrt() Number

fn (a &Number) lshift(nbits int) Number

fn (a &Number) rshift(nbits int) Number

fn (a &Number) clone() Number

fn (n &Number) bytes() []byte

bytes returns an array of the bytes for the number n, in little endian format, where .bytes()[0] is the least significant byte. The result is NOT trimmed, and will contain 0s, even after the significant bytes. This method is faster than .bytes_trimmed(), but may be less convenient.

assert big.from_int(1).bytes()[0] == byte(0x01)

assert big.from_int(1024).bytes()[1] == byte(0x04)

assert big.from_int(1048576).bytes()[2] == byte(0x10)

fn (n &Number) bytes_trimmed() []byte

bytes_trimmed returns an array of the bytes for the number n, in little endian format, where .bytes_trimmed()[0] is the least significant byte. The result is trimmed, so that the last byte of the result is also the the last meaningfull byte, != 0 .

assert big.from_int(1).bytes_trimmed() == [byte(0x01)]

assert big.from_int(1024).bytes_trimmed() == [byte(0x00), 0x04]

assert big.from_int(1048576).bytes_trimmed() == [byte(0x00), 0x00, 0x10]