Struct `Big64x20`

pub struct Big64x20 { pub(in ::num::imp::bignum) size: usize, pub(in ::num::imp::bignum) base: [Digit64; 20] }

Stack-allocated arbitrary-precision (up to certain limit) integer.

This is backed by a fixed-size array of given type ("digit"). While the array is not very large (normally some hundred bytes), copying it recklessly may result in the performance hit. Thus this is intentionally not Copy.

All operations available to bignums panic in the case of overflows. The caller is responsible to use large enough bignum types.

Fields

size: usize: One plus the offset to the maximum "digit" in use. This does not decrease, so be aware of the computation order. base[size..] should be zero.
base: [Digit64; 20]: Digits. [a, b, c, ...] represents a + b*2^W + c*2^(2W) + ... where W is the number of bits in the digit type.

Implementations

`impl Big64x20`

fn from_small(v: Digit64) -> Big64x20: Makes a bignum from one digit.
fn from_u64(v: u64) -> Big64x20: Makes a bignum from u64 value.
fn digits(&self) -> &[Digit64]: Returns the internal digits as a slice [a, b, c, ...] such that the numeric value is a + b * 2^W + c * 2^(2W) + ... where W is the number of bits in the digit type.
fn get_bit(&self, i: usize) -> u8: Returns the i-th bit where bit 0 is the least significant one. In other words, the bit with weight 2^i.
fn is_zero(&self) -> bool: Returns true if the bignum is zero.
fn bit_length(&self) -> usize: Returns the number of bits necessary to represent this value. Note that zero is considered to need 0 bits.
fn add<'a>(&'a mut self, other: &Big64x20) -> &'a mut Big64x20: Adds other to itself and returns its own mutable reference.
fn add_small(&mut self, other: Digit64) -> &mut Big64x20
fn sub<'a>(&'a mut self, other: &Big64x20) -> &'a mut Big64x20: Subtracts other from itself and returns its own mutable reference.
fn mul_small(&mut self, other: Digit64) -> &mut Big64x20: Multiplies itself by a digit-sized other and returns its own mutable reference.
fn mul_pow2(&mut self, bits: usize) -> &mut Big64x20: Multiplies itself by 2^bits and returns its own mutable reference.
fn mul_pow5(&mut self, e: usize) -> &mut Big64x20: Multiplies itself by 5^e and returns its own mutable reference.
fn mul_digits<'a>(&'a mut self, other: &[Digit64]) -> &'a mut Big64x20: Multiplies itself by a number described by other[0] + other[1] * 2^W + other[2] * 2^(2W) + ... (where W is the number of bits in the digit type) and returns its own mutable reference.
fn div_rem_small(&mut self, other: Digit64) -> (&mut Big64x20, Digit64): Divides itself by a digit-sized other and returns its own mutable reference and the remainder.