Struct BigNumBase

pub struct BigNumBase<T>
where
    T: Base,
{
    pub sig: u64,
    pub exp: u64,
    pub base: T,
}

This is the main struct for bignumbe-rs.

It takes a generic argument for the base, e.g. BigNumBase<Binary>. It is recommended to either create a custom type alias or use one of the predefined ones (BigNumBin, BigNumOct, BigNumDec, BigNumHex). You should be able to use them pretty much exactly like other numbers in most contexts. For convenience I define From and all math operations for u64, but keep in mind that the From implementation, like new, involves recalculating the base ranges.

use bignumbe_rs::{BigNumBase, Binary};

type BigNum = BigNumBase<Binary>;

let bn1 = BigNum::from(1);
let bn2 = BigNum::from(u64::MAX);

// Since this operation's result doesn't fit in `u64` it wraps over to the minimum
// significand and increments the `exp`
assert_eq!(bn1 + bn2, BigNum::new(1 << 63, 1));

assert_eq!(bn1 / bn2, BigNum::from(0));
assert_eq!(bn1 * bn2, bn2);
assert_eq!(bn2 * bn2, BigNum::new(u64::MAX - 1, 64));

Fields

sig: u64

exp: u64

base: T

Implementations

impl<T> BigNumBase<T>

where T: Base,

pub fn new(sig: u64, exp: u64) -> Self

Creates a new BigNumBase instance that represents the value sig * T::NUMBER^exp. E.g. BigNumBin::new(12341234, 12341) represents 12341234 * 2^12341. This method will perform normalization if necessary, to ensure the significand is in the valid range (if the number is non-compact). As such when creating a BigNum from scratch you should always use this unless you absolutely need a raw constructor

pub fn new_raw(sig: u64, exp: u64) -> Self

Creates a BigNumBase directly from values, panicking if not possible. This is mostly for testing but may be more performant on inputs that are guaranteed valid

pub fn fuzzy_eq(self, other: Self, margin: u64) -> bool

Allows fuzzy comparison between two values. Since operations can result in loss of precision this allows you to compare values that may have drifted. Since each operation can result in an error of 1, an upper bound is the sum of the number of operations performed on each operand. E.g. for n: BigNumDec, to ensure that (n * 1000) / 500 = (n / 500) * 1000, you might use a margin of 4

Trait Implementations

impl<T> Add<BigNumBase<T>> for u64

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<u64> for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign<u64> for BigNumBase<T>

where T: Base,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<T> AddAssign for BigNumBase<T>

where T: Base,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T> Clone for BigNumBase<T>

where T: Base + Clone,

fn clone(&self) -> BigNumBase<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for BigNumBase<T>

where T: Base + Debug,

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

Formats the value using the given formatter.

impl Display for BigNumBase<Decimal>

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

Formats the value using the given formatter.

impl<T> Div<BigNumBase<T>> for u64

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<u64> for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DivAssign<u64> for BigNumBase<T>

where T: Base,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<T> From<u64> for BigNumBase<T>

where T: Base,

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<T> Mul<BigNumBase<T>> for u64

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<f64> for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<u64> for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<f64> for BigNumBase<T>

where T: Base,

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<T> MulAssign<u64> for BigNumBase<T>

where T: Base,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<T> MulAssign for BigNumBase<T>

where T: Base,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T> Ord for BigNumBase<T>

where T: Base,

fn cmp(&self, other: &Self) -> 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<T> PartialEq for BigNumBase<T>

where T: Base,

fn eq(&self, other: &Self) -> 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<T> PartialOrd for BigNumBase<T>

where T: Base,

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

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.

impl<T> Pred for BigNumBase<T>

where T: Base,

fn pred(self) -> Self

impl<T> Product for BigNumBase<T>

where T: Base,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<T> Shl<u64> for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> Self::Output

Performs the << operation.

impl<T> Shr<u64> for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> Self::Output

Performs the >> operation.

impl<T> Sub<BigNumBase<T>> for u64

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<u64> for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub for BigNumBase<T>

where T: Base,

type Output = BigNumBase<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> SubAssign<u64> for BigNumBase<T>

where T: Base,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<T> SubAssign for BigNumBase<T>

where T: Base,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T> Succ for BigNumBase<T>

where T: Base,

fn succ(self) -> Self

impl<T> Sum for BigNumBase<T>

where T: Base,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> Copy for BigNumBase<T>

where T: Base + Copy,

impl<T> Eq for BigNumBase<T>

where T: Base,