Struct arpfloat::BigInt

pub struct BigInt<const PARTS: usize> { /* private fields */ }

This is a fixed-size big int implementation that’s used to represent the significand part of the floating point number.

Implementations

impl<const PARTS: usize> BigInt<PARTS>

pub fn zero() -> Self

Create a new zero big int number.

pub fn one() -> Self

Create a new number with the value 1.

pub fn one_hot(bit: usize) -> Self

Create a new number with a single ‘1’ set at bit bit.

pub fn all1s(bits: usize) -> Self

Create a new number, where the first bits bits are set to 1.

pub fn from_u64(val: u64) -> Self

Create a number and set the lowest 64 bits to val.

pub fn from_u128(val: u128) -> Self

Create a number and set the lowest 128 bits to val.

pub fn as_u64(&self) -> u64

Returns the lowest 64 bits.

pub fn as_u128(&self) -> u128

Returns the lowest 64 bits.

pub fn cast<const P: usize>(&self) -> BigInt<P>

Convert this instance to a smaller number. Notice that this may truncate the number.

pub fn is_zero(&self) -> bool

\return true if the number is equal to zero.

pub fn is_even(&self) -> bool

Returns true if this number is even.

pub fn is_odd(&self) -> bool

Returns true if this number is odd.

pub fn flip_bit(&mut self, bit_num: usize)

Flip the bit_num bit.

pub fn mask(&mut self, bits: usize)

Zero out all of the bits above bits.

pub fn get_loss_kind_for_bit(&self, bit: usize) -> LossFraction

Returns the fractional part that’s lost during truncation at bit.

pub fn msb_index(&self) -> usize

Returns the index of the most significant bit (the highest ‘1’), using 1-based counting (the first bit is 1, and zero means no bits are set).

pub fn trailing_zeros(&self) -> usize

Returns the index of the first ‘1’ in the number. The number must not be a zero.

pub fn from_parts(parts: &[u64; PARTS]) -> Self

pub fn inplace_add(&mut self, rhs: &Self) -> bool

Add rhs to self, and return true if the operation overflowed.

pub fn inplace_sub(&mut self, rhs: &Self) -> bool

Add rhs to self, and return true if the operation overflowed (borrow).

pub fn inplace_mul<const P2: usize>(&mut self, rhs: Self) -> bool

Multiply rhs to self, and return true if the operation overflowed. The generic parameter P2 is here to work around a limitation in the rust generic system. P2 needs to be greater or equal to PARTS*2.

pub fn inplace_div(&mut self, divisor: Self) -> Self

Divide self by divisor, and return the reminder.

pub fn shift_left(&mut self, bits: usize)

Shift the bits in the numbers bits to the left.

pub fn shift_right(&mut self, bits: usize)

Shift the bits in the numbers bits to the right.

pub fn powi(&self, exp: u64) -> Self

\return raise this number to the power of exp.

pub fn get_part(&self, idx: usize) -> u64

\return the word at idx idx.

pub fn dump(&self)

Trait Implementations

impl<const PARTS: usize> Add<BigInt<PARTS>> for BigInt<PARTS>

type Output = BigInt<PARTS>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const PARTS: usize> Clone for BigInt<PARTS>

fn clone(&self) -> BigInt<PARTS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const PARTS: usize> Debug for BigInt<PARTS>

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

Formats the value using the given formatter.

impl<const PARTS: usize> Default for BigInt<PARTS>

fn default() -> Self

Returns the “default value” for a type.

impl<const PARTS: usize> Div<BigInt<PARTS>> for BigInt<PARTS>

type Output = BigInt<PARTS>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const PARTS: usize> Mul<BigInt<PARTS>> for BigInt<PARTS>

type Output = BigInt<PARTS>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const PARTS: usize> Ord for BigInt<PARTS>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<const PARTS: usize> PartialEq<BigInt<PARTS>> for BigInt<PARTS>

fn eq(&self, other: &BigInt<PARTS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<const PARTS: usize> PartialOrd<BigInt<PARTS>> for BigInt<PARTS>

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<const PARTS: usize> Sub<BigInt<PARTS>> for BigInt<PARTS>

type Output = BigInt<PARTS>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const PARTS: usize> Copy for BigInt<PARTS>

impl<const PARTS: usize> Eq for BigInt<PARTS>

impl<const PARTS: usize> StructuralEq for BigInt<PARTS>

impl<const PARTS: usize> StructuralPartialEq for BigInt<PARTS>