Struct BigInt 

pub struct BigInt<A: IVm>(/* private fields */);

use nanvm_lib::{vm::{BigInt, IVm}, naive::Naive};
fn bigint_test<A: IVm>() {
    let a: BigInt<A> = 12345678901234567890u64.into();
    let b: BigInt<A> = (-1234567890123456789i64).into();
}

bigint_test::<Naive>();

Implementations

impl<A: IVm> BigInt<A>

pub fn pow(self, rhs: Self) -> Result<Self, Any<A>>

**. Not a core::ops trait — Rust has no operator for exponentiation, so this is a plain method, the same as Any::pow one level up.

Exponentiation by squaring, walking the exponent’s own bits rather than converting it to a Rust integer, so an exponent wider than u64 still works. A negative exponent throws instead of coercing to a fraction, unlike Number ** Number, since BigInt has none. A power longer than MAX_WORDS words throws the RangeError that * throws for the multiplication that crosses it.

impl<A: IVm> BigInt<A>

pub fn to_number(&self) -> Number

Number(bigint): the nearest Number, a tie going to the even significand, and Infinity or -Infinity past the range. https://tc39.es/ecma262/#sec-numberbigint

The top two words are the significand Number::compose rounds, and any word below them set is its sticky bit: with the top word not zero, the two hold at least 65 significant bits, more than the 54 the sticky bit needs.

impl<A: IVm> BigInt<A>

pub fn normalize_new(sign: Sign, items: impl IntoIterator<Item = u64>) -> Self

Note: this function accepts an iterator in least-significant-word-first order, i.e. the first item is the least significant word!

pub fn div_mod(self, rhs: Self) -> Result<(Self, Self), Any<A>>

Truncating division: (self / rhs, self % rhs).

The single owner of the protocol Div and Rem project from: the zero-divisor guard, the magnitude division, and both sign rules. The quotient truncates toward zero, so it is negative iff exactly one operand is; the remainder’s sign follows the dividend. Both match Rust’s own integer / and %. Only the zero divisor is special: JS throws instead of the NaN a Number operation would give.

Trait Implementations

impl<A: IVm> Add for BigInt<A>

+, or the RangeError of a sum longer than MAX_WORDS words, as * and << throw for a result that long.

type Output = Result<BigInt<A>, Any<A>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<A: IVm> BitAnd for BigInt<A>

type Output = BigInt<A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<A: IVm> BitOr for BigInt<A>

type Output = BigInt<A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<A: IVm> BitXor for BigInt<A>

type Output = BigInt<A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<A: Clone + IVm> Clone for BigInt<A>

where A::InternalBigInt: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: IVm> Debug for BigInt<A>

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

Formats the value using the given formatter.

impl<A: IVm> Default for BigInt<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: IVm> Display for BigInt<A>

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

Formats the value using the given formatter.

impl<A: IVm> Div for BigInt<A>

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

The quotient of BigInt::div_mod.

type Output = Result<BigInt<A>, Any<A>>

The resulting type after applying the / operator.

impl<A: IVm> Eq for BigInt<A>

impl<A: IVm> From<BigInt<A>> for Unpacked<A>

fn from(value: BigInt<A>) -> Self

Converts to this type from the input type.

impl<A: IVm> From<i64> for BigInt<A>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl<A: IVm> From<u64> for BigInt<A>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<A: IVm> Index<u32> for BigInt<A>

type Output = u64

The returned type after indexing.

fn index(&self, index: u32) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: IVm> Mul for BigInt<A>

*, or the RangeError of a product longer than MAX_WORDS words, as << throws for a shift that long.

type Output = Result<BigInt<A>, Any<A>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<A: IVm> Neg for BigInt<A>

type Output = BigInt<A>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A: IVm> Ord for BigInt<A>

The single owner of how two BigInts relate: PartialEq (in partial_eq.rs) and PartialOrd both delegate here.

Invariant: both operands are normalized — no leading (most-significant) zero words, and zero is always Sign::Positive with no words (no negative zero). That is what makes the sign order sound (a negative value is always below a positive one) and what abs_cmp_vec asserts; a non-normalized operand panics.

fn cmp(&self, rhs: &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<A: IVm> PartialEq for BigInt<A>

Equality is defined by Ord (in cmp.rs), the single owner of how two BigInts relate, so a == b holds exactly when a.cmp(&b) == Equal by construction rather than by two code paths happening to agree.

Invariant: both operands are normalized — no leading (most-significant) zero words, and zero is always Sign::Positive with no words (no negative zero). Ord relies on it and panics on a non-normalized operand, which only unchecked_new can build.

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

Equality operator ==.

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

Inequality operator !=.

impl<A: IVm> PartialOrd for BigInt<A>

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<A: IVm> Rem for BigInt<A>

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

The remainder of BigInt::div_mod.

type Output = Result<BigInt<A>, Any<A>>

The resulting type after applying the % operator.

impl<A: IVm> Shl for BigInt<A>

<<. https://tc39.es/ecma262/#sec-numeric-types-bigint-leftShift

type Output = Result<BigInt<A>, Any<A>>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<A: IVm> Shr for BigInt<A>

>>. https://tc39.es/ecma262/#sec-numeric-types-bigint-signedRightShift

Conceptually a shift over self’s infinite-precision two’s-complement bit string — equivalently, floor division by 2^rhs — not a shift of self’s magnitude with the sign carried along unchanged: those agree for a non-negative self (floor division truncates toward zero there anyway) but not for a negative one, where flooring rounds away from zero whenever a nonzero bit is shifted out. -1n >> 1n is -1n (all bits are 1, so shifting right forever still reads all 1s), not 0n the way carrying the sign over a plain magnitude shift would give.

type Output = Result<BigInt<A>, Any<A>>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<A: IVm> Sub for BigInt<A>

-, or the RangeError of a difference longer than MAX_WORDS words, as +, * and << throw for a result that long.

type Output = Result<BigInt<A>, Any<A>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<A: IVm> TryFrom<Any<A>> for BigInt<A>

type Error = Any<A>

The type returned in the event of a conversion error.

fn try_from(value: Any<A>) -> Result<Self, Self::Error>

Performs the conversion.