Struct Int 

#[repr(transparent)]
pub struct Int<const LIMBS: usize>(Uint<LIMBS>);

Stack-allocated big signed integer. See Uint for unsigned integers.

Created as a Uint newtype.

Tuple Fields

0: Uint<LIMBS>

Implementations

impl<const LIMBS: usize> Int<LIMBS>

pub const fn checked_add(&self, rhs: &Self) -> CtOption<Self>

Perform checked addition. Returns none when the addition overflowed.

pub const fn overflowing_add(&self, rhs: &Self) -> (Self, Choice)

Perform addition, raising the overflow flag on overflow.

pub const fn wrapping_add(&self, rhs: &Self) -> Self

Perform wrapping addition, discarding overflow.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn bitand(&self, rhs: &Self) -> Self

Computes bitwise a & b.

pub const fn bitand_limb(&self, rhs: Limb) -> Self

Perform bitwise AND between self and the given Limb, performing the AND operation on every limb of self.

pub const fn wrapping_and(&self, rhs: &Self) -> Self

Perform wrapping bitwise AND.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub const fn checked_and(&self, rhs: &Self) -> CtOption<Self>

Perform checked bitwise AND, returning a CtOption which is_some always

impl<const LIMBS: usize> Int<LIMBS>

pub const fn not(&self) -> Self

Computes bitwise !a.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn bitor(&self, rhs: &Self) -> Self

Computes bitwise a | b.

pub const fn wrapping_or(&self, rhs: &Self) -> Self

Perform wrapping bitwise OR.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub const fn checked_or(&self, rhs: &Self) -> CtOption<Self>

Perform checked bitwise OR, returning a CtOption which is_some always

impl<const LIMBS: usize> Int<LIMBS>

pub const fn bitxor(&self, rhs: &Self) -> Self

Computes bitwise a ^ b.

pub const fn wrapping_xor(&self, rhs: &Self) -> Self

Perform wrapping bitwise XOR.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_xor(&self, rhs: &Self) -> CtOption<Self>

Perform checked bitwise XOR, returning a CtOption which is_some always

impl<const LIMBS: usize> Int<LIMBS>

pub(crate) const fn conditional_swap(a: &mut Self, b: &mut Self, c: Choice)

Swap a and b if c is truthy, otherwise, do nothing.

pub(crate) const fn is_nonzero(&self) -> Choice

Returns the truthy value if self!=0 or the falsy value otherwise.

pub(crate) const fn eq(lhs: &Self, rhs: &Self) -> Choice

Returns the truthy value if self == rhs or the falsy value otherwise.

pub(crate) const fn lt(lhs: &Self, rhs: &Self) -> Choice

Returns the truthy value if self < rhs and the falsy value otherwise.

pub(crate) const fn gt(lhs: &Self, rhs: &Self) -> Choice

Returns the truthy value if self > rhs and the falsy value otherwise.

pub(crate) const fn cmp(lhs: &Self, rhs: &Self) -> Ordering

Returns the ordering between self and rhs as an i8. Values correspond to the Ordering enum: -1 is Less 0 is Equal 1 is Greater

pub const fn cmp_vartime(&self, rhs: &Self) -> Ordering

Returns the Ordering between self and rhs in variable time.

impl<const LIMBS: usize> Int<LIMBS>

pub(crate) const fn select(a: &Self, b: &Self, c: Choice) -> Self

Return b if c is truthy, otherwise return a.

impl<const LIMBS: usize> Int<LIMBS>

Checked division operations.

const fn div_rem_base<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Int<RHS_LIMBS>>, ) -> (Uint<LIMBS>, Uint<RHS_LIMBS>, Choice, Choice)

Base div_rem operation on dividing Ints.

Computes the quotient and remainder of self / rhs. Furthermore, returns the signs of self and rhs.

pub const fn checked_div_rem<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Int<RHS_LIMBS>>, ) -> (CtOption<Self>, Int<RHS_LIMBS>)

Compute the quotient and remainder of self / rhs.

Returns none for the quotient when Int::MIN / Int::MINUS_ONE; that quotient cannot be captured in an Int.

Example:

use crypto_bigint::{I128, NonZero};
let (quotient, remainder) = I128::from(8).checked_div_rem(&I128::from(3).to_nz().unwrap());
assert_eq!(quotient.unwrap(), I128::from(2));
assert_eq!(remainder, I128::from(2));

let (quotient, remainder) = I128::from(-8).checked_div_rem(&I128::from(3).to_nz().unwrap());
assert_eq!(quotient.unwrap(), I128::from(-2));
assert_eq!(remainder, I128::from(-2));

let (quotient, remainder) = I128::from(8).checked_div_rem(&I128::from(-3).to_nz().unwrap());
assert_eq!(quotient.unwrap(), I128::from(-2));
assert_eq!(remainder, I128::from(2));

let (quotient, remainder) = I128::from(-8).checked_div_rem(&I128::from(-3).to_nz().unwrap());
assert_eq!(quotient.unwrap(), I128::from(2));
assert_eq!(remainder, I128::from(-2));

pub fn checked_div<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> CtOption<Self>

Perform checked division, returning a CtOption which is_some if

• the rhs != 0, and
• self != MIN or rhs != MINUS_ONE.

Note: this operation rounds towards zero, truncating any fractional part of the exact result.

pub const fn rem<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Int<RHS_LIMBS>>, ) -> Int<RHS_LIMBS>

Computes self % rhs, returns the remainder.

impl<const LIMBS: usize> Int<LIMBS>

Vartime checked division operations.

const fn div_rem_base_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Int<RHS_LIMBS>>, ) -> (Uint<LIMBS>, Uint<RHS_LIMBS>, Choice, Choice)

Variable time equivalent of Self::div_rem_base

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub const fn checked_div_rem_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Int<RHS_LIMBS>>, ) -> (CtOption<Self>, Int<RHS_LIMBS>)

Variable time equivalent of Self::checked_div_rem

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub fn checked_div_vartime<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> CtOption<Self>

Variable time equivalent of Self::checked_div

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub const fn rem_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Int<RHS_LIMBS>>, ) -> Int<RHS_LIMBS>

Variable time equivalent of Self::rem

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

impl<const LIMBS: usize> Int<LIMBS>

Vartime checked div-floor operations.

pub const fn checked_div_rem_floor_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Int<RHS_LIMBS>>, ) -> (CtOption<Self>, Int<RHS_LIMBS>)

Variable time equivalent of Self::checked_div_rem_floor

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub fn checked_div_floor_vartime<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> CtOption<Self>

Variable time equivalent of Self::checked_div_floor

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

impl<const LIMBS: usize> Int<LIMBS>

Checked div-floor operations.

pub fn checked_div_floor<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> CtOption<Self>

Perform checked floored division, returning a CtOption which is_some only if

• the rhs != 0, and
• self != MIN or rhs != MINUS_ONE.

Note: this operation rounds down.

Example:

use crypto_bigint::I128;
assert_eq!(
    I128::from(8).checked_div_floor(&I128::from(3)).unwrap(),
    I128::from(2)
);
assert_eq!(
    I128::from(-8).checked_div_floor(&I128::from(3)).unwrap(),
    I128::from(-3)
);
assert_eq!(
    I128::from(8).checked_div_floor(&I128::from(-3)).unwrap(),
    I128::from(-3)
);
assert_eq!(
    I128::from(-8).checked_div_floor(&I128::from(-3)).unwrap(),
    I128::from(2)
)

pub const fn checked_div_rem_floor<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Int<RHS_LIMBS>>, ) -> (CtOption<Self>, Int<RHS_LIMBS>)

Perform checked division and mod, returning the quotient and remainder.

The quotient is a CtOption which is_some only if

• the rhs != 0, and
• self != MIN or rhs != MINUS_ONE.

Note: this operation rounds down.

Example:

use crypto_bigint::I128;

let three = I128::from(3).to_nz().unwrap();
let (quotient, remainder) = I128::from(8).checked_div_rem_floor(&three);
assert_eq!(quotient.unwrap(), I128::from(2));
assert_eq!(remainder, I128::from(2));

let (quotient, remainder) = I128::from(-8).checked_div_rem_floor(&three);
assert_eq!(quotient.unwrap(), I128::from(-3));
assert_eq!(remainder, I128::from(-1));

let minus_three = I128::from(-3).to_nz().unwrap();
let (quotient, remainder) = I128::from(8).checked_div_rem_floor(&minus_three);
assert_eq!(quotient.unwrap(), I128::from(-3));
assert_eq!(remainder, I128::from(-1));

let (quotient, remainder) = I128::from(-8).checked_div_rem_floor(&minus_three);
assert_eq!(quotient.unwrap(), I128::from(2));
assert_eq!(remainder, I128::from(2));

impl<const LIMBS: usize> Int<LIMBS>

Checked division operations.

const fn div_rem_base_unsigned<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> (Uint<LIMBS>, Uint<RHS_LIMBS>, Choice)

Base div_rem operation on dividing an Int by a Uint. Computes the quotient and remainder of self / rhs. Furthermore, returns the sign of self.

pub const fn div_rem_unsigned<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> (Self, Int<RHS_LIMBS>)

Compute the quotient and remainder of self / rhs.

Example:

use crypto_bigint::{I128, NonZero, U128};

let (quotient, remainder) = I128::from(8).div_rem_unsigned(&U128::from(3u32).to_nz().unwrap());
assert_eq!(quotient, I128::from(2));
assert_eq!(remainder, I128::from(2));

let (quotient, remainder) = I128::from(-8).div_rem_unsigned(&U128::from(3u32).to_nz().unwrap());
assert_eq!(quotient, I128::from(-2));
assert_eq!(remainder, I128::from(-2));

pub const fn div_unsigned<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> Self

Perform division. Note: this operation rounds towards zero, truncating any fractional part of the exact result.

pub const fn rem_unsigned<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> Int<RHS_LIMBS>

Compute the remainder. The remainder will have the same sign as self (or be zero).

impl<const LIMBS: usize> Int<LIMBS>

Vartime checked division operations.

const fn div_rem_base_unsigned_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> (Uint<LIMBS>, Uint<RHS_LIMBS>, Choice)

Variable time equivalent of Self::div_rem_base_unsigned.

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub const fn div_rem_unsigned_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> (Self, Int<RHS_LIMBS>)

Variable time equivalent of Self::div_rem_unsigned.

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub const fn div_unsigned_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> Self

Variable time equivalent of Self::div_unsigned.

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub const fn rem_unsigned_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> Int<RHS_LIMBS>

Variable time equivalent of Self::rem_unsigned.

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

impl<const LIMBS: usize> Int<LIMBS>

Checked div-floor operations

pub fn div_rem_floor_unsigned<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> (Self, Uint<RHS_LIMBS>)

Perform floored division and mod: given n and d, computes q and r s.t. n = qd + r and q = ⌊n/d⌋. Note: this operation rounds down, not towards zero.

Example:

use crypto_bigint::{I128, U128};

let three = U128::from(3u32).to_nz().unwrap();
assert_eq!(
    I128::from(8).div_rem_floor_unsigned(&three),
    (I128::from(2), U128::from(2u32))
);
assert_eq!(
    I128::from(-8).div_rem_floor_unsigned(&three),
    (I128::from(-3), U128::ONE)
);

pub fn div_floor_unsigned<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> Self

Perform checked division. Note: this operation rounds down.

Example:

use crypto_bigint::{I128, U128};
assert_eq!(
    I128::from(8).div_floor_unsigned(&U128::from(3u32).to_nz().unwrap()),
    I128::from(2)
);
assert_eq!(
    I128::from(-8).div_floor_unsigned(&U128::from(3u32).to_nz().unwrap()),
    I128::from(-3)
);

pub fn normalized_rem<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> Uint<RHS_LIMBS>

Compute self % rhs and return the result contained in the interval [0, rhs).

Example:

use crypto_bigint::{I128, U128};
assert_eq!(
    I128::from(8).normalized_rem(&U128::from(3u32).to_nz().unwrap()),
    U128::from(2u32)
);
assert_eq!(
    I128::from(-8).normalized_rem(&U128::from(3u32).to_nz().unwrap()),
    U128::ONE
);

impl<const LIMBS: usize> Int<LIMBS>

Vartime checked div-floor operations

pub fn div_rem_floor_unsigned_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> (Self, Uint<RHS_LIMBS>)

Variable time equivalent of Self::div_rem_floor_unsigned.

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub fn div_floor_unsigned_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> Self

Variable time equivalent of Self::div_floor_unsigned.

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub fn normalized_rem_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> Uint<RHS_LIMBS>

Variable time equivalent of Self::normalized_rem.

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn from_be_hex(hex: &str) -> Self

Create a new Int from the provided big endian hex string.

See Uint::from_be_hex for more details.

Panics

• if the hex is malformed or not zero-padded accordingly for the size.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn from_i8(n: i8) -> Self

Create a Int from an i8 (const-friendly)

pub const fn from_i16(n: i16) -> Self

Create a Int from an i16 (const-friendly)

pub const fn from_i32(n: i32) -> Self

Create a Int from an i32 (const-friendly)

pub const fn from_i64(n: i64) -> Self

Create a Int from an i64 (const-friendly)

pub const fn from_i128(n: i128) -> Self

Create a Int from an i128 (const-friendly)

pub(super) const fn from_uint_opt(opt: CtOption<Uint<LIMBS>>) -> CtOption<Self>

Convert a CtOption<Uint<LIMBS>> to a CtOption<Int<LIMBS>>

impl<const LIMBS: usize> Int<LIMBS>

pub const fn gcd_unsigned(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Compute the greatest common divisor of self and rhs.

pub const fn gcd_unsigned_vartime(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Compute the greatest common divisor of self and rhs.

Executes in variable time w.r.t. all input parameters.

pub const fn xgcd(&self, rhs: &Self) -> XgcdOutput<LIMBS, Uint<LIMBS>>

Executes the Extended GCD algorithm.

Given (self, rhs), computes (g, x, y), s.t. self * x + rhs * y = g = gcd(self, rhs).

impl<const LIMBS: usize> Int<LIMBS>

pub fn invert_odd_mod( &self, modulus: &Odd<Uint<LIMBS>>, ) -> CtOption<Uint<LIMBS>>

Computes the multiplicative inverse of self mod modulus, where modulus is odd.

pub const fn invert_mod( &self, modulus: &NonZero<Uint<LIMBS>>, ) -> CtOption<Uint<LIMBS>>

Computes the multiplicative inverse of self mod modulus.

Returns some if an inverse exists, otherwise none.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn jacobi_symbol<const RHS_LIMBS: usize>( &self, rhs: &Odd<Uint<RHS_LIMBS>>, ) -> JacobiSymbol

Compute the Jacobi symbol (self|rhs).

For prime rhs, this corresponds to the Legendre symbol and indicates whether self is quadratic residue modulo rhs.

pub const fn jacobi_symbol_vartime<const RHS_LIMBS: usize>( &self, rhs: &Odd<Uint<RHS_LIMBS>>, ) -> JacobiSymbol

Compute the Jacobi symbol (self|rhs).

For prime rhs, this corresponds to the Legendre symbol and indicates whether self is quadratic residue modulo rhs.

This method executes in variable-time for the value of self.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn split_mul<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> (Uint<LIMBS>, Uint<RHS_LIMBS>, Choice)

👎Deprecated since 0.7.0: please use widening_mul instead

Compute “wide” multiplication as a 3-tuple (lo, hi, negate). The (lo, hi) components contain the magnitude of the product, with sizes corresponding to the sizes of the operands; negate indicates whether the result should be negated when converted from Uint to Int.

Note: even if negate is truthy, the magnitude might be zero!

pub const fn widening_mul<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> (Uint<LIMBS>, Uint<RHS_LIMBS>, Choice)

Compute “wide” multiplication as a 3-tuple (lo, hi, negate). The (lo, hi) components contain the magnitude of the product, with sizes corresponding to the sizes of the operands; negate indicates whether the result should be negated when converted from Uint to Int.

Note: even if negate is truthy, the magnitude might be zero!

pub const fn concatenating_mul<const RHS_LIMBS: usize, const WIDE_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> Int<WIDE_LIMBS>

where Uint<LIMBS>: Concat<RHS_LIMBS, Output = Uint<WIDE_LIMBS>>,

Multiply self by rhs, returning a concatenated “wide” result.

pub const fn checked_mul<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> CtOption<Self>

Multiply self by rhs, returning a CtOption which is is_some only if overflow did not occur.

pub const fn saturating_mul<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> Self

Multiply self by rhs, saturating at the numeric bounds instead of overflowing.

pub const fn wrapping_mul<const RHS_LIMBS: usize>( &self, rhs: &Int<RHS_LIMBS>, ) -> Self

Multiply self by rhs, wrapping the result in case of overflow. This is equivalent to (self * rhs) % (Uint::<LIMBS>::MAX + 1).

impl<const LIMBS: usize> Int<LIMBS>

Squaring operations.

pub fn concatenating_square<const WIDE_LIMBS: usize>(&self) -> Uint<WIDE_LIMBS>

where Uint<LIMBS>: Concat<LIMBS, Output = Uint<WIDE_LIMBS>>,

Square self, returning a concatenated “wide” result.

pub fn checked_square(&self) -> CtOption<Uint<LIMBS>>

Square self, checking that the result fits in the original Uint size.

pub const fn wrapping_square(&self) -> Uint<LIMBS>

Perform wrapping square, discarding overflow.

pub const fn saturating_square(&self) -> Uint<LIMBS>

Perform saturating squaring, returning MAX on overflow.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn split_mul_unsigned<const RHS_LIMBS: usize>( &self, rhs: &Uint<RHS_LIMBS>, ) -> (Uint<LIMBS>, Uint<RHS_LIMBS>, Choice)

👎Deprecated since 0.7.0: please use widening_mul_unsigned instead

Compute “wide” multiplication between an Int and Uint as 3-tuple (lo, hi, negate). The (lo, hi) components contain the magnitude of the product, with sizes corresponding to the sizes of the operands; negate indicates whether the result should be negated when converted from Uint to Int.

Note: even if negate is truthy, the magnitude might be zero!

pub const fn widening_mul_unsigned<const RHS_LIMBS: usize>( &self, rhs: &Uint<RHS_LIMBS>, ) -> (Uint<LIMBS>, Uint<RHS_LIMBS>, Choice)

Compute “wide” multiplication between an Int and Uint as 3-tuple (lo, hi, negate). The (lo, hi) components contain the magnitude of the product, with sizes corresponding to the sizes of the operands; negate indicates whether the result should be negated when converted from Uint to Int.

Note: even if negate is truthy, the magnitude might be zero!

pub const fn split_mul_unsigned_right<const RHS_LIMBS: usize>( &self, rhs: &Uint<RHS_LIMBS>, ) -> (Uint<RHS_LIMBS>, Uint<LIMBS>, Choice)

👎Deprecated since 0.7.0: please use Uint::widening_mul_signed instead

Compute “wide” multiplication between an Int and Uint as 3-tuple (lo, hi, negate). The (lo, hi) components contain the magnitude of the product, with sizes corresponding to the sizes of the operands, in reversed order; negate indicates whether the result should be negated when converted from Uint to Int.

Note: even if negate is truthy, the magnitude might be zero!

pub const fn widening_mul_unsigned_right<const RHS_LIMBS: usize>( &self, rhs: &Uint<RHS_LIMBS>, ) -> (Uint<RHS_LIMBS>, Uint<LIMBS>, Choice)

👎Deprecated since 0.7.0: please use Uint::widening_mul_signed instead

Compute “wide” multiplication between an Int and Uint as 3-tuple (lo, hi, negate). The (lo, hi) components contain the magnitude of the product, with sizes corresponding to the sizes of the operands, in reversed order; negate indicates whether the result should be negated when converted from Uint to Int.

Note: even if negate is truthy, the magnitude might be zero!

pub const fn concatenating_mul_unsigned<const RHS_LIMBS: usize, const WIDE_LIMBS: usize>( &self, rhs: &Uint<RHS_LIMBS>, ) -> Int<WIDE_LIMBS>

where Uint<LIMBS>: Concat<RHS_LIMBS, Output = Uint<WIDE_LIMBS>>,

Multiply self by Uint rhs, returning a concatenated “wide” result.

pub fn checked_mul_unsigned_right<const RHS_LIMBS: usize>( &self, rhs: &Uint<RHS_LIMBS>, ) -> CtOption<Int<RHS_LIMBS>>

👎Deprecated since 0.7.0: please use Uint::checked_mul(_int) instead

Checked multiplication of self with an Uint<RHS_LIMBS>, where the result is to be stored in an Int<RHS_LIMBS>.

pub fn checked_mul_unsigned<const RHS_LIMBS: usize>( &self, rhs: &Uint<RHS_LIMBS>, ) -> CtOption<Int<LIMBS>>

Checked multiplication with a Uint.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn overflowing_neg(&self) -> (Self, Choice)

Map this Int to its two’s-complement negation: map self to (self ^ 1111...1111) + 0000...0001.

Returns the negation, as well as whether the operation overflowed. The operation overflows when attempting to negate Int::MIN; the positive counterpart of this value cannot be represented.

pub const fn wrapping_neg(&self) -> Self

Wrapping negate this Int.

Warning: this operation maps Int::MIN to itself, since the positive counterpart of this value cannot be represented.

pub const fn wrapping_neg_if(&self, negate: Choice) -> Int<LIMBS>

Wrapping negate this Int if negate is truthy; otherwise do nothing.

Warning: this operation maps Int::MIN to itself, since the positive counterpart of this value cannot be represented.

pub const fn checked_neg(&self) -> CtOption<Self>

Negate this Int.

Yields None when self == Self::MIN, since the positive counterpart of this value cannot be represented.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn resize<const T: usize>(&self) -> Int<T>

Resize the representation of self to an Int<T>. Warning: this operation may lead to loss of information.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn shl(&self, shift: u32) -> Self

Computes self << shift.

Panics

• if shift >= Self::BITS.

pub const fn shl_vartime(&self, shift: u32) -> Self

Computes self << shift in variable time.

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

Panics

• if shift >= Self::BITS.

pub const fn overflowing_shl(&self, shift: u32) -> CtOption<Self>

Computes self << shift.

Returns None if shift >= Self::BITS.

pub const fn overflowing_shl_vartime(&self, shift: u32) -> Option<Self>

Computes self << shift.

Returns None if shift >= Self::BITS.

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

pub const fn unbounded_shl(&self, shift: u32) -> Self

Computes self << shift in a panic-free manner, returning zero if the shift exceeds the precision.

pub const fn unbounded_shl_vartime(&self, shift: u32) -> Self

Computes self << shift in variable-time in a panic-free manner, returning zero if the shift exceeds the precision.

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

pub const fn wrapping_shl(&self, shift: u32) -> Self

Computes self << shift in a panic-free manner, reducing shift modulo the type’s width.

pub const fn wrapping_shl_vartime(&self, shift: u32) -> Self

Computes self << shift in variable-time in a panic-free manner, reducing shift modulo the type’s width.

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn shr(&self, shift: u32) -> Self

Computes self >> shift.

Note, this is signed shift right, i.e., the value shifted in on the left is equal to the most significant bit.

Panics

• if shift >= Self::BITS.

pub const fn shr_vartime(&self, shift: u32) -> Self

Computes self >> shift in variable time.

Note, this is signed shift right, i.e., the value shifted in on the left is equal to the most significant bit.

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

Panics

• if shift >= Self::BITS.

pub const fn overflowing_shr(&self, shift: u32) -> CtOption<Self>

Computes self >> shift.

Note, this is signed shift right, i.e., the value shifted in on the left is equal to the most significant bit.

Returns None if shift >= Self::BITS.

pub const fn overflowing_shr_vartime(&self, shift: u32) -> Option<Self>

Computes self >> shift.

NOTE: this is signed shift right, i.e., the value shifted in on the left is equal to the most significant bit.

Returns None if shift >= Self::BITS.

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

pub const fn unbounded_shr(&self, shift: u32) -> Self

Computes self >> shift in a panic-free manner.

If the shift exceeds the precision, returns

• 0 when self is non-negative, and
• -1 when self is negative.

pub const fn unbounded_shr_vartime(&self, shift: u32) -> Self

Computes self >> shift in variable-time in a panic-free manner.

If the shift exceeds the precision, returns

• 0 when self is non-negative, and
• -1 when self is negative.

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

pub const fn wrapping_shr(&self, shift: u32) -> Self

Computes self >> shift in a panic-free manner.

If the shift exceeds the precision, returns

• 0 when self is non-negative, and
• -1 when self is negative.

pub const fn wrapping_shr_vartime(&self, shift: u32) -> Self

Computes self >> shift in variable-time in a panic-free manner.

If the shift exceeds the precision, returns

• 0 when self is non-negative, and
• -1 when self is negative.

NOTE: this operation is variable time with respect to shift ONLY.

When used with a fixed shift, this function is constant-time with respect to self.

impl<const LIMBS: usize> Int<LIMBS>

const fn most_significant_word(&self) -> Word

Returns the word of most significant [Limb].

For the degenerate case where the number of limbs is zero, zeroed word is returned (which is semantically correct). This method leaks the limb length of the value, which is also OK.

pub const fn new_from_abs_sign( abs: Uint<LIMBS>, is_negative: Choice, ) -> CtOption<Self>

Construct new Int from an absolute value and sign.

Returns None when the result exceeds the bounds of an Int<LIMBS>.

pub(crate) const fn new_from_abs_opt_sign( maybe_abs: CtOption<Uint<LIMBS>>, is_negative: Choice, ) -> CtOption<Self>

Construct a new Int from an CtOption of an absolute value and sign.

pub const fn is_negative(&self) -> Choice

Whether this Int is negative, as a Choice.

pub const fn is_positive(&self) -> Choice

Whether this Int is positive, as a Choice.

pub const fn abs_sign(&self) -> (Uint<LIMBS>, Choice)

The sign and magnitude of this Int.

pub const fn abs(&self) -> Uint<LIMBS>

The magnitude of this Int.

impl<const LIMBS: usize> Int<LIMBS>

pub fn checked_sqrt(&self) -> CtOption<Self>

Perform checked sqrt, returning a CtOption which is_some only if the integer is non-negative and the square root is exact.

pub fn checked_sqrt_vartime(&self) -> Option<Self>

Perform checked sqrt, returning a CtOption which is_some only if the integer is non-negative and the square root is exact.

Variable time with respect to self.

impl<const LIMBS: usize> Int<LIMBS>

pub const fn underflowing_sub(&self, rhs: &Self) -> (Self, Choice)

Perform subtraction, returning the result along with a Choice which is_true only if the operation underflowed.

pub const fn wrapping_sub(&self, rhs: &Self) -> Self

Perform wrapping subtraction, discarding underflow and wrapping around the boundary of the type.

impl<const LIMBS: usize> Int<LIMBS>

pub const ZERO: Self

The value 0.

pub const ONE: Self

The value 1.

pub const MINUS_ONE: Self

The value -1

pub const MIN: Self

Smallest value this Int can express.

pub const MAX: Self

Maximum value this Int can express.

pub const SIGN_MASK: Self = Self::MIN

Bit mask for the sign bit of this Int.

pub const BITS: u32 = Uint<LIMBS>::BITS

Total size of the represented integer in bits.

pub const BYTES: usize = Uint<LIMBS>::BYTES

Total size of the represented integer in bytes.

pub const LIMBS: usize = LIMBS

The number of limbs used on this platform.

pub const fn new(limbs: [Limb; LIMBS]) -> Self

Const-friendly Int constructor.

pub(crate) const fn from_bits(value: Uint<LIMBS>) -> Self

Const-friendly Int constructor.

Reinterprets the bits of a value of type Uint as an Int. For a proper conversion, see Int::new_from_abs_sign; the public interface of this function is available at Uint::as_int.

pub const fn from_words(arr: [Word; LIMBS]) -> Self

Create an Int from an array of Words (i.e. word-sized unsigned integers).

pub const fn to_words(self) -> [Word; LIMBS]

Create an array of Words (i.e. word-sized unsigned integers) from an Int.

pub const fn as_words(&self) -> &[Word; LIMBS]

Borrow the inner limbs as an array of Words.

pub const fn as_mut_words(&mut self) -> &mut [Word; LIMBS]

Borrow the inner limbs as a mutable array of Words.

pub fn as_words_mut(&mut self) -> &mut [Word]

👎Deprecated since 0.7.0: please use as_mut_words instead

Borrow the inner limbs as a mutable slice of Words.

pub const fn as_limbs(&self) -> &[Limb; LIMBS]

Borrow the limbs of this Int.

pub const fn as_mut_limbs(&mut self) -> &mut [Limb; LIMBS]

Borrow the limbs of this Int mutably.

pub const fn as_limbs_mut(&mut self) -> &mut [Limb]

👎Deprecated since 0.7.0: please use as_mut_limbs instead

Borrow the limbs of this Int mutably.

pub const fn to_limbs(self) -> [Limb; LIMBS]

Convert this Int into its inner limbs.

pub const fn to_nz(self) -> CtOption<NonZero<Self>>

Convert to a NonZero<Int<LIMBS>>.

Returns some if the original value is non-zero, and false otherwise.

pub const fn to_odd(self) -> CtOption<Odd<Self>>

Convert to a Odd<Int<LIMBS>>.

Returns some if the original value is odd, and false otherwise.

pub const fn as_uint(&self) -> &Uint<LIMBS>

Interpret the data in this object as a Uint instead.

Note: this is a casting operation. See

• Self::try_into_uint for the checked equivalent, and
• Self::abs to obtain the absolute value of self.

pub const fn try_into_uint(self) -> CtOption<Uint<LIMBS>>

Get a Uint equivalent of this value; returns None if self is negative.

Note: this is a checked conversion operation. See

• Self::as_uint for the unchecked equivalent, and
• Self::abs to obtain the absolute value of self.

pub const fn is_min(&self) -> Choice

Whether this Int is equal to Self::MIN.

pub const fn is_max(&self) -> Choice

Whether this Int is equal to Self::MAX.

pub const fn is_zero(&self) -> Choice

Is this Int equal to zero?

const fn invert_msb(&self) -> Self

Invert the most significant bit (msb) of this Int

Trait Implementations

impl<const LIMBS: usize> Add<&Int<LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const LIMBS: usize> Add for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const LIMBS: usize> AddAssign<&Int<LIMBS>> for Int<LIMBS>

fn add_assign(&mut self, other: &Self)

Performs the += operation.

impl<const LIMBS: usize> AddAssign for Int<LIMBS>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<const LIMBS: usize> AsMut<[Limb]> for Int<LIMBS>

fn as_mut(&mut self) -> &mut [Limb]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<const LIMBS: usize> AsMut<[u64; LIMBS]> for Int<LIMBS>

fn as_mut(&mut self) -> &mut [Word; LIMBS]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<const LIMBS: usize> AsRef<[Limb]> for Int<LIMBS>

fn as_ref(&self) -> &[Limb]

Converts this type into a shared reference of the (usually inferred) input type.

impl<const LIMBS: usize> AsRef<[u64; LIMBS]> for Int<LIMBS>

fn as_ref(&self) -> &[Word; LIMBS]

Converts this type into a shared reference of the (usually inferred) input type.

impl<const LIMBS: usize> Binary for Int<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> BitAnd<&Int<LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Int<LIMBS>) -> Int<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAnd<&Int<LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Int<LIMBS>) -> Int<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAnd<Int<LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: Int<LIMBS>) -> Int<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAnd for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Int<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAndAssign<&Int<LIMBS>> for Int<LIMBS>

fn bitand_assign(&mut self, other: &Self)

Performs the &= operation.

impl<const LIMBS: usize> BitAndAssign for Int<LIMBS>

fn bitand_assign(&mut self, other: Self)

Performs the &= operation.

impl<const LIMBS: usize> BitOr<&Int<LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Int<LIMBS>) -> Int<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOr<&Int<LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Int<LIMBS>) -> Int<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOr<Int<LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: Int<LIMBS>) -> Int<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOr for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Int<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOrAssign<&Int<LIMBS>> for Int<LIMBS>

fn bitor_assign(&mut self, other: &Self)

Performs the |= operation.

impl<const LIMBS: usize> BitOrAssign for Int<LIMBS>

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl<const LIMBS: usize> BitXor<&Int<LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Int<LIMBS>) -> Int<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXor<&Int<LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Int<LIMBS>) -> Int<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXor<Int<LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Int<LIMBS>) -> Int<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXor for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Int<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXorAssign<&Int<LIMBS>> for Int<LIMBS>

fn bitxor_assign(&mut self, other: &Self)

Performs the ^= operation.

impl<const LIMBS: usize> BitXorAssign for Int<LIMBS>

fn bitxor_assign(&mut self, other: Self)

Performs the ^= operation.

impl<const LIMBS: usize> Bounded for Int<LIMBS>

const BITS: u32 = Self::BITS

Size of this integer in bits.

const BYTES: usize = Self::BYTES

Size of this integer in bytes.

impl<const LIMBS: usize> CheckedAdd for Int<LIMBS>

fn checked_add(&self, rhs: &Self) -> CtOption<Self>

Perform checked addition, returning a CtOption which is_some only if the operation did not overflow.

impl<const LIMBS: usize, const RHS_LIMBS: usize> CheckedDiv<Int<RHS_LIMBS>> for Int<LIMBS>

fn checked_div(&self, rhs: &Int<RHS_LIMBS>) -> CtOption<Self>

Perform checked division, returning a CtOption which is_some only if the divisor is non-zero.

impl<const LIMBS: usize, const RHS_LIMBS: usize> CheckedMul<Int<RHS_LIMBS>> for Int<LIMBS>

fn checked_mul(&self, rhs: &Int<RHS_LIMBS>) -> CtOption<Self>

Perform checked multiplication, returning a CtOption which is_some only if the operation did not overflow.

impl<const LIMBS: usize, const RHS_LIMBS: usize> CheckedMul<Uint<RHS_LIMBS>> for Int<LIMBS>

fn checked_mul(&self, rhs: &Uint<RHS_LIMBS>) -> CtOption<Self>

Perform checked multiplication, returning a CtOption which is_some only if the operation did not overflow.

impl<const LIMBS: usize> CheckedSquareRoot for Int<LIMBS>

type Output = Int<LIMBS>

Output of the square root operation.

fn checked_sqrt(&self) -> CtOption<Self::Output>

Computes sqrt(self), returning none if no root exists.

fn checked_sqrt_vartime(&self) -> Option<Self::Output>

Computes sqrt(self), returning none if no root exists.

impl<const LIMBS: usize> CheckedSub for Int<LIMBS>

fn checked_sub(&self, rhs: &Self) -> CtOption<Self>

Perform checked subtraction, returning a CtOption which is_some only if the operation did not underflow.

impl<const LIMBS: usize> Clone for Int<LIMBS>

fn clone(&self) -> Int<LIMBS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const LIMBS: usize> ConstOne for Int<LIMBS>

const ONE: Self = Self::ONE

The multiplicative identity element of Self, 1.

impl<const LIMBS: usize> ConstZero for Int<LIMBS>

const ZERO: Self = Self::ZERO

The additive identity element of Self, 0.

impl<const LIMBS: usize> Constants for Int<LIMBS>

const MAX: Self = Self::MAX

Maximum value this integer can express.

impl<const LIMBS: usize> CtAssign for Int<LIMBS>

fn ct_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign src to self if choice is Choice::TRUE.

impl<const LIMBS: usize> CtAssignSlice for Int<LIMBS>

fn ct_assign_slice(dst: &mut [Self], src: &[Self], choice: Choice)

Conditionally assign src to dst if choice is Choice::TRUE, or leave it unchanged for Choice::FALSE.

impl<const LIMBS: usize> CtEq for Int<LIMBS>

fn ct_eq(&self, other: &Self) -> Choice

Determine if self is equal to other in constant-time.

fn ct_ne(&self, other: &Rhs) -> Choice

Determine if self is NOT equal to other in constant-time.

impl<const LIMBS: usize> CtEqSlice for Int<LIMBS>

fn ct_eq_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is equal to b in constant-time.

fn ct_ne_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is NOT equal to b in constant-time.

impl<const LIMBS: usize> CtGt for Int<LIMBS>

fn ct_gt(&self, other: &Self) -> Choice

Compute whether self > other in constant time.

impl<const LIMBS: usize> CtLt for Int<LIMBS>

fn ct_lt(&self, other: &Self) -> Choice

Compute whether self < other in constant time.

impl<const LIMBS: usize> CtSelect for Int<LIMBS>

fn ct_select(&self, other: &Self, choice: Choice) -> Self

Select between self and other based on choice, returning a copy of the value.

fn ct_swap(&mut self, other: &mut Self, choice: Choice)

Conditionally swap self and other if choice is Choice::TRUE.

impl<const LIMBS: usize> Debug for Int<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> Default for Int<LIMBS>

fn default() -> Self

Returns the “default value” for a type.

impl<const LIMBS: usize> Display for Int<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Div<&NonZero<Int<RHS_LIMBS>>> for &Int<LIMBS>

type Output = CtOption<Int<LIMBS>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Int<RHS_LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Div<&NonZero<Int<RHS_LIMBS>>> for Int<LIMBS>

type Output = CtOption<Int<LIMBS>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Int<RHS_LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Div<&NonZero<Uint<RHS_LIMBS>>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Uint<RHS_LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Div<&NonZero<Uint<RHS_LIMBS>>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Uint<RHS_LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Div<NonZero<Int<RHS_LIMBS>>> for &Int<LIMBS>

type Output = CtOption<Int<LIMBS>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Int<RHS_LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Div<NonZero<Int<RHS_LIMBS>>> for Int<LIMBS>

type Output = CtOption<Int<LIMBS>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Int<RHS_LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Div<NonZero<Uint<RHS_LIMBS>>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Uint<RHS_LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Div<NonZero<Uint<RHS_LIMBS>>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Uint<RHS_LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize> DivAssign<&NonZero<Int<LIMBS>>> for Int<LIMBS>

fn div_assign(&mut self, rhs: &NonZero<Int<LIMBS>>)

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<&NonZero<Uint<LIMBS>>> for Int<LIMBS>

fn div_assign(&mut self, rhs: &NonZero<Uint<LIMBS>>)

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<NonZero<Int<LIMBS>>> for Int<LIMBS>

fn div_assign(&mut self, rhs: NonZero<Int<LIMBS>>)

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<NonZero<Uint<LIMBS>>> for Int<LIMBS>

fn div_assign(&mut self, rhs: NonZero<Uint<LIMBS>>)

Performs the /= operation.

impl<const LIMBS: usize> DivVartime for Int<LIMBS>

fn div_vartime(&self, rhs: &NonZero<Int<LIMBS>>) -> Self

Computes self / rhs in variable time.

impl<const LIMBS: usize> FixedInteger for Int<LIMBS>

const LIMBS: usize = LIMBS

The number of limbs used on this platform.

impl<const LIMBS: usize, const LIMBS2: usize> From<&Int<LIMBS>> for Int<LIMBS2>

fn from(num: &Int<LIMBS>) -> Int<LIMBS2>

Converts to this type from the input type.

impl From<Int<1>> for i64

fn from(n: I64) -> i64

Converts to this type from the input type.

impl From<Int<2>> for i128

fn from(n: I128) -> i128

Converts to this type from the input type.

impl<const LIMBS: usize> From<i128> for Int<LIMBS>

fn from(n: i128) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<i16> for Int<LIMBS>

fn from(n: i16) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<i32> for Int<LIMBS>

fn from(n: i32) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<i64> for Int<LIMBS>

fn from(n: i64) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<i8> for Int<LIMBS>

fn from(n: i8) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> Gcd<Int<LIMBS>> for NonZeroInt<LIMBS>

type Output = NonZero<Uint<LIMBS>>

Output type.

fn gcd(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const LIMBS: usize> Gcd<Int<LIMBS>> for OddInt<LIMBS>

type Output = Odd<Uint<LIMBS>>

Output type.

fn gcd(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const LIMBS: usize> Gcd<Int<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn gcd(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const LIMBS: usize> Gcd<NonZero<Uint<LIMBS>>> for Int<LIMBS>

type Output = NonZero<Uint<LIMBS>>

Output type.

fn gcd(&self, rhs: &NonZeroUint<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &NonZeroUint<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const LIMBS: usize> Gcd<Odd<Uint<LIMBS>>> for Int<LIMBS>

type Output = Odd<Uint<LIMBS>>

Output type.

fn gcd(&self, rhs: &OddUint<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &OddUint<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const LIMBS: usize> Gcd<Uint<LIMBS>> for Int<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn gcd(&self, rhs: &Uint<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Uint<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const LIMBS: usize> Gcd for Int<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn gcd(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const LIMBS: usize> Hash for Int<LIMBS>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const LIMBS: usize> Integer for Int<LIMBS>

fn as_limbs(&self) -> &[Limb]

Borrow the raw limbs used to represent this integer.

fn as_mut_limbs(&mut self) -> &mut [Limb]

Mutably borrow the raw limbs used to represent this integer.

fn nlimbs(&self) -> usize

Number of limbs in this integer.

fn is_odd(&self) -> Choice

Is this integer value an odd number?

fn is_even(&self) -> Choice

Is this integer value an even number?

impl<const LIMBS: usize> InvertMod<NonZero<Uint<LIMBS>>> for Int<LIMBS>

where Uint<LIMBS>: InvertMod<Output = Uint<LIMBS>>,

type Output = Uint<LIMBS>

Output type.

fn invert_mod(&self, modulus: &NonZero<Uint<LIMBS>>) -> CtOption<Self::Output>

Compute 1 / self mod p.

impl<const LIMBS: usize> LowerHex for Int<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<&Int<RHS_LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Int<RHS_LIMBS>) -> Self::Output

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<&Int<RHS_LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Int<RHS_LIMBS>) -> Self

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<&Uint<RHS_LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Uint<RHS_LIMBS>) -> Self::Output

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<&Uint<RHS_LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Uint<RHS_LIMBS>) -> Self

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<Int<RHS_LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<Int<RHS_LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Int<RHS_LIMBS>) -> Self

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<Uint<RHS_LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<Uint<RHS_LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Uint<RHS_LIMBS>) -> Self

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> MulAssign<&Int<RHS_LIMBS>> for Int<LIMBS>

fn mul_assign(&mut self, rhs: &Int<RHS_LIMBS>)

Performs the *= operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> MulAssign<Int<RHS_LIMBS>> for Int<LIMBS>

fn mul_assign(&mut self, rhs: Int<RHS_LIMBS>)

Performs the *= operation.

impl<const LIMBS: usize> Not for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl<const LIMBS: usize> One for Int<LIMBS>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> Choice

Determine if this value is equal to 1.

fn set_one(&mut self)

Set self to its multiplicative identity, i.e. Self::one.

fn one_like(_other: &Self) -> Self

Return the value 0 with the same precision as other.

impl<const LIMBS: usize> One for Int<LIMBS>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<const LIMBS: usize> Ord for Int<LIMBS>

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<const LIMBS: usize> PartialEq for Int<LIMBS>

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<const LIMBS: usize> PartialOrd for Int<LIMBS>

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<const LIMBS: usize> Random for Int<LIMBS>

fn try_random_from_rng<R: TryRng + ?Sized>( rng: &mut R, ) -> Result<Self, R::Error>

Generate a cryptographically secure random Int.

fn random_from_rng<R: Rng + ?Sized>(rng: &mut R) -> Self

Generate a random value.

impl<const LIMBS: usize> RandomBits for Int<LIMBS>

fn try_random_bits<R: TryRng + ?Sized>( rng: &mut R, bit_length: u32, ) -> Result<Self, RandomBitsError<R::Error>>

Generate a random value in range [0, 2^bit_length).

fn try_random_bits_with_precision<R: TryRng + ?Sized>( rng: &mut R, bit_length: u32, bits_precision: u32, ) -> Result<Self, RandomBitsError<R::Error>>

Generate a random value in range [0, 2^bit_length), returning an integer with the closest available size to bits_precision (if the implementing type supports runtime sizing).

fn random_bits<R: TryRng + ?Sized>(rng: &mut R, bit_length: u32) -> Self

Generate a random value in range [0, 2^bit_length).

fn random_bits_with_precision<R: TryRng + ?Sized>( rng: &mut R, bit_length: u32, bits_precision: u32, ) -> Self

Generate a random value in range [0, 2^bit_length), returning an integer with the closest available size to bits_precision (if the implementing type supports runtime sizing).

impl<const LIMBS: usize, const RHS_LIMBS: usize> Rem<&NonZero<Int<RHS_LIMBS>>> for &Int<LIMBS>

type Output = Int<RHS_LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Int<RHS_LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Rem<&NonZero<Int<RHS_LIMBS>>> for Int<LIMBS>

type Output = Int<RHS_LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Int<RHS_LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Rem<&NonZero<Uint<RHS_LIMBS>>> for &Int<LIMBS>

type Output = Int<RHS_LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Uint<RHS_LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Rem<&NonZero<Uint<RHS_LIMBS>>> for Int<LIMBS>

type Output = Int<RHS_LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Uint<RHS_LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Rem<NonZero<Int<RHS_LIMBS>>> for &Int<LIMBS>

type Output = Int<RHS_LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Int<RHS_LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Rem<NonZero<Int<RHS_LIMBS>>> for Int<LIMBS>

type Output = Int<RHS_LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Int<RHS_LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Rem<NonZero<Uint<RHS_LIMBS>>> for &Int<LIMBS>

type Output = Int<RHS_LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Uint<RHS_LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Rem<NonZero<Uint<RHS_LIMBS>>> for Int<LIMBS>

type Output = Int<RHS_LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Uint<RHS_LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize> RemAssign<&NonZero<Int<LIMBS>>> for Int<LIMBS>

fn rem_assign(&mut self, rhs: &NonZero<Int<LIMBS>>)

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<&NonZero<Uint<LIMBS>>> for Int<LIMBS>

fn rem_assign(&mut self, rhs: &NonZero<Uint<LIMBS>>)

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<NonZero<Int<LIMBS>>> for Int<LIMBS>

fn rem_assign(&mut self, rhs: NonZero<Int<LIMBS>>)

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<NonZero<Uint<LIMBS>>> for Int<LIMBS>

fn rem_assign(&mut self, rhs: NonZero<Uint<LIMBS>>)

Performs the %= operation.

impl<const LIMBS: usize> Shl<i32> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: i32) -> Int<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<i32> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: i32) -> Int<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<u32> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: u32) -> Int<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<u32> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: u32) -> Int<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<usize> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> Int<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<usize> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> Int<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> ShlAssign<i32> for Int<LIMBS>

fn shl_assign(&mut self, shift: i32)

Performs the <<= operation.

impl<const LIMBS: usize> ShlAssign<u32> for Int<LIMBS>

fn shl_assign(&mut self, shift: u32)

Performs the <<= operation.

impl<const LIMBS: usize> ShlAssign<usize> for Int<LIMBS>

fn shl_assign(&mut self, shift: usize)

Performs the <<= operation.

impl<const LIMBS: usize> ShlVartime for Int<LIMBS>

fn overflowing_shl_vartime(&self, shift: u32) -> Option<Self>

Computes self << shift.

fn unbounded_shl_vartime(&self, shift: u32) -> Self

Computes self << shift.

fn wrapping_shl_vartime(&self, shift: u32) -> Self

Computes self << shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl<const LIMBS: usize> Shr<i32> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: i32) -> Int<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<i32> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: i32) -> Int<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<u32> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: u32) -> Int<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<u32> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: u32) -> Int<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<usize> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> Int<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<usize> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> Int<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> ShrAssign<i32> for Int<LIMBS>

fn shr_assign(&mut self, shift: i32)

Performs the >>= operation.

impl<const LIMBS: usize> ShrAssign<u32> for Int<LIMBS>

fn shr_assign(&mut self, shift: u32)

Performs the >>= operation.

impl<const LIMBS: usize> ShrAssign<usize> for Int<LIMBS>

fn shr_assign(&mut self, shift: usize)

Performs the >>= operation.

impl<const LIMBS: usize> ShrVartime for Int<LIMBS>

fn overflowing_shr_vartime(&self, shift: u32) -> Option<Self>

Computes self >> shift.

fn unbounded_shr_vartime(&self, shift: u32) -> Self

Computes self >> shift.

fn wrapping_shr_vartime(&self, shift: u32) -> Self

Computes self >> shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl<const LIMBS: usize> Signed for Int<LIMBS>

type Unsigned = Uint<LIMBS>

Corresponding unsigned integer type.

fn abs_sign(&self) -> (Uint<LIMBS>, Choice)

The sign and magnitude of this Signed.

fn is_negative(&self) -> Choice

Whether this Signed is negative (and non-zero), as a Choice.

fn is_positive(&self) -> Choice

Whether this Signed is positive (and non-zero), as a Choice.

fn abs(&self) -> Self::Unsigned

The magnitude of this Signed.

impl<const LIMBS: usize> Sub<&Int<LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const LIMBS: usize> Sub for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const LIMBS: usize> SubAssign<&Int<LIMBS>> for Int<LIMBS>

fn sub_assign(&mut self, rhs: &Int<LIMBS>)

Performs the -= operation.

impl<const LIMBS: usize> SubAssign for Int<LIMBS>

fn sub_assign(&mut self, rhs: Int<LIMBS>)

Performs the -= operation.

impl<const LIMBS: usize> UpperHex for Int<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> WrappingAdd for Int<LIMBS>

fn wrapping_add(&self, v: &Self) -> Self

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl<const LIMBS: usize> WrappingMul for Int<LIMBS>

fn wrapping_mul(&self, v: &Self) -> Self

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl<const LIMBS: usize> WrappingNeg for Int<LIMBS>

fn wrapping_neg(&self) -> Self

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

impl<const LIMBS: usize> WrappingShl for Int<LIMBS>

fn wrapping_shl(&self, shift: u32) -> Int<LIMBS>

Panic-free bitwise shift-left; yields self << mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<const LIMBS: usize> WrappingShr for Int<LIMBS>

fn wrapping_shr(&self, shift: u32) -> Int<LIMBS>

Panic-free bitwise shift-right; yields self >> mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<const LIMBS: usize> WrappingSub for Int<LIMBS>

fn wrapping_sub(&self, v: &Self) -> Self

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl<const LIMBS: usize> Xgcd for Int<LIMBS>

type Output = XgcdOutput<LIMBS, Uint<LIMBS>>

Output type.

fn xgcd(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the extended greatest common divisor of self and rhs.

fn xgcd_vartime(&self, rhs: &Int<LIMBS>) -> Self::Output

Compute the extended greatest common divisor of self and rhs in variable time.

impl<const LIMBS: usize> Zero for Int<LIMBS>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> Choice

Determine if this value is equal to 0.

fn set_zero(&mut self)

Set self to its additive identity, i.e. Self::zero.

fn zero_like(other: &Self) -> Self

where Self: Clone,

Return the value 0 with the same precision as other.

impl<const LIMBS: usize> Zero for Int<LIMBS>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<const LIMBS: usize> Copy for Int<LIMBS>

impl<const LIMBS: usize> Eq for Int<LIMBS>

impl<const LIMBS: usize> Sealed for Int<LIMBS>