Struct Big8x3

pub struct Big8x3 {
    size: usize,
    base: [u8; 3],
}

🔬This is a nightly-only experimental API. (core_private_bignum)

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

🔬This is a nightly-only experimental API. (core_private_bignum)

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: [u8; 3]

🔬This is a nightly-only experimental API. (core_private_bignum)

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 Big8x3

pub fn from_small(v: u8) -> Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

Makes a bignum from one digit.

pub fn from_u64(v: u64) -> Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

Makes a bignum from u64 value.

pub fn digits(&self) -> &[u8]

🔬This is a nightly-only experimental API. (core_private_bignum)

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.

pub fn get_bit(&self, i: usize) -> u8

🔬This is a nightly-only experimental API. (core_private_bignum)

Returns the i-th bit where bit 0 is the least significant one. In other words, the bit with weight 2^i.

pub fn is_zero(&self) -> bool

🔬This is a nightly-only experimental API. (core_private_bignum)

Returns true if the bignum is zero.

pub fn bit_length(&self) -> usize

🔬This is a nightly-only experimental API. (core_private_bignum)

Returns the number of bits necessary to represent this value. Note that zero is considered to need 0 bits.

pub fn add<'a>(&'a mut self, other: &Big8x3) -> &'a mut Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

Adds other to itself and returns its own mutable reference.

pub fn add_small(&mut self, other: u8) -> &mut Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

pub fn sub<'a>(&'a mut self, other: &Big8x3) -> &'a mut Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

Subtracts other from itself and returns its own mutable reference.

pub fn mul_small(&mut self, other: u8) -> &mut Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

Multiplies itself by a digit-sized other and returns its own mutable reference.

pub fn mul_pow2(&mut self, bits: usize) -> &mut Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

Multiplies itself by 2^bits and returns its own mutable reference.

pub fn mul_pow5(&mut self, e: usize) -> &mut Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

Multiplies itself by 5^e and returns its own mutable reference.

pub fn mul_digits<'a>(&'a mut self, other: &[u8]) -> &'a mut Big8x3

🔬This is a nightly-only experimental API. (core_private_bignum)

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.

pub fn div_rem_small(&mut self, other: u8) -> (&mut Big8x3, u8)

🔬This is a nightly-only experimental API. (core_private_bignum)

Divides itself by a digit-sized other and returns its own mutable reference and the remainder.

pub fn div_rem(&self, d: &Big8x3, q: &mut Big8x3, r: &mut Big8x3)

🔬This is a nightly-only experimental API. (core_private_bignum)

Divide self by another bignum, overwriting q with the quotient and r with the remainder.

Trait Implementations

impl Clone for Big8x3

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Big8x3

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Big8x3

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl Ord for Big8x3

fn cmp(&self, other: &Big8x3) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Big8x3

fn eq(&self, other: &Big8x3) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Big8x3

fn partial_cmp(&self, other: &Big8x3) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

#[doc(hidden)] fn __chaining_lt(&self, other: &Rhs) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

#[doc(hidden)] fn __chaining_le(&self, other: &Rhs) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

#[doc(hidden)] fn __chaining_gt(&self, other: &Rhs) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

#[doc(hidden)] fn __chaining_ge(&self, other: &Rhs) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl UseCloned for Big8x3