Struct NonZero 

pub struct NonZero<T: ?Sized>(/* private fields */);

Wrapper type for non-zero integers.

Implementations

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

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

Compute the greatest common divisor of self and rhs.

pub const fn gcd_unsigned_vartime( &self, rhs: &Uint<LIMBS>, ) -> NonZeroUint<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, NonZeroUint<LIMBS>>

Execute the Extended GCD algorithm.

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

impl<T> NonZero<T>

pub fn new(n: T) -> CtOption<Self>

where T: Zero + One + CtAssign,

Create a new non-zero integer.

pub fn get(self) -> T

Returns the inner value.

pub const fn get_copy(self) -> T

where T: Copy,

Returns a copy of the inner value for Copy types.

This allows the function to be const fn, since Copy is implicitly !Drop, which avoids problems around const fn destructors.

impl<T: ?Sized> NonZero<T>

pub const fn as_ref(&self) -> &T

Provides access to the contents of NonZero in a const context.

impl<T> NonZero<T>

where T: Bounded + ?Sized,

pub const BITS: u32 = T::BITS

Total size of the represented integer in bits.

pub const BYTES: usize = T::BYTES

Total size of the represented integer in bytes.

impl<T> NonZero<T>

where T: Constants,

pub const ONE: Self

The value 1.

pub const MAX: Self

Maximum value this integer can express.

impl<T> NonZero<T>

where T: Zero + One + CtAssign + Encoding,

pub fn from_be_bytes(bytes: T::Repr) -> CtOption<Self>

Decode from big endian bytes.

pub fn from_le_bytes(bytes: T::Repr) -> CtOption<Self>

Decode from little endian bytes.

impl NonZero<Limb>

pub const fn new_unwrap(n: Limb) -> Self

Creates a new non-zero limb in a const context.

Panics

• if the value is zero.

Note

In future versions of Rust it should be possible to replace this with NonZero::new(…).unwrap()

pub const fn from_u8(n: NonZeroU8) -> Self

Create a NonZero<Limb> from a NonZeroU8 (const-friendly)

pub const fn from_u16(n: NonZeroU16) -> Self

Create a NonZero<Limb> from a NonZeroU16 (const-friendly)

pub const fn from_u32(n: NonZeroU32) -> Self

Create a NonZero<Limb> from a NonZeroU32 (const-friendly)

pub const fn from_u64(n: NonZeroU64) -> Self

Create a NonZero<Limb> from a NonZeroU64 (const-friendly)

impl<const LIMBS: usize> NonZero<Uint<LIMBS>>

pub const fn new_unwrap(n: Uint<LIMBS>) -> Self

Creates a new non-zero integer in a const context.

In future versions of Rust it should be possible to replace this with NonZero::new(…).unwrap()

Panics

• if the value is zero.

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

Create a new NonZero<Uint> from the provided big endian hex string.

Panics

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

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

Create a new NonZero<Uint> from the provided little endian hex string.

Panics

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

pub const fn from_u8(n: NonZeroU8) -> Self

Create a NonZeroUint from a NonZeroU8 (const-friendly)

pub const fn from_u16(n: NonZeroU16) -> Self

Create a NonZeroUint from a NonZeroU16 (const-friendly)

pub const fn from_u32(n: NonZeroU32) -> Self

Create a NonZeroUint from a NonZeroU32 (const-friendly)

pub const fn from_u64(n: NonZeroU64) -> Self

Create a NonZeroUint from a NonZeroU64 (const-friendly)

pub const fn from_u128(n: NonZeroU128) -> Self

Create a NonZeroUint from a NonZeroU128 (const-friendly)

pub const fn as_uint_ref(&self) -> &NonZeroUintRef

Borrow this NonZero<Uint> as a &NonZeroUintRef.

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

pub const fn new_unwrap(n: Int<LIMBS>) -> Self

Creates a new non-zero integer in a const context.

Panics

• if the value is zero.

Note

In future versions of Rust it should be possible to replace this with NonZero::new(…).unwrap()

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

The sign and magnitude of this NonZeroInt.

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

The magnitude of this NonZeroInt.

impl NonZero<BoxedUint>

pub fn as_uint_ref(&self) -> &NonZeroUintRef

Available on crate feature alloc only.

Borrow this NonZeroBoxedUint as a &NonZeroUintRef.

impl<T: ToUnsigned + ?Sized> NonZero<T>

pub fn to_unsigned(&self) -> NonZero<T::Unsigned>

Convert from a reference into an owned NonZero<T: Unsigned>.

impl<T> NonZero<T>

where T: ArrayEncoding + Zero + One + CtAssign,

pub fn from_be_byte_array(bytes: ByteArray<T>) -> CtOption<Self>

Available on crate feature hybrid-array only.

Decode a non-zero integer from big endian bytes.

pub fn from_le_byte_array(bytes: ByteArray<T>) -> CtOption<Self>

Available on crate feature hybrid-array only.

Decode a non-zero integer from little endian bytes.

impl<const LIMBS: usize> NonZero<Uint<LIMBS>>

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

Compute the greatest common divisor of self and rhs.

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

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, NonZeroUint<LIMBS>>

Execute 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> NonZero<Uint<LIMBS>>

pub const fn floor_root_vartime(&self, exp: NonZeroU32) -> Self

Computes floor(self^(1/exp)).

Callers can check if self is an exact power of exp by exponentiating the result.

This method is variable time in self and in the exponent.

pub fn checked_root_vartime(&self, exp: NonZeroU32) -> Option<Self>

Compute the root self^(1/exp) returning an Option which is_some only if the root is exact.

This method is variable time in self and in the exponent.

impl<const LIMBS: usize> NonZero<Uint<LIMBS>>

pub const fn floor_sqrt(&self) -> Self

Computes floor(√(self)) in constant time.

Callers can check if self is a square by squaring the result.

pub const fn floor_sqrt_vartime(&self) -> Self

Computes floor(√(self)).

Callers can check if self is a square by squaring the result.

Variable time with respect to self.

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

Perform checked sqrt, returning a CtOption which is_some only if the square root is exact.

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

Perform checked sqrt, returning an Option which is_some only if the square root is exact.

Trait Implementations

impl<T: ?Sized> AsRef<NonZero<T>> for Odd<T>

fn as_ref(&self) -> &NonZero<T>

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

impl AsRef<NonZero<UintRef>> for NonZeroBoxedUint

Available on crate feature alloc only.

fn as_ref(&self) -> &NonZeroUintRef

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

impl<const LIMBS: usize> AsRef<NonZero<UintRef>> for NonZeroUint<LIMBS>

fn as_ref(&self) -> &NonZeroUintRef

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

impl<T: ?Sized> AsRef<T> for NonZero<T>

fn as_ref(&self) -> &T

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

impl<T> Binary for NonZero<T>

where T: Binary + ?Sized,

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

Formats the value using the given formatter.

impl<const LIMBS: usize> CheckedSquareRoot for NonZero<Uint<LIMBS>>

type Output = NonZero<Uint<LIMBS>>

Output of the square root operation.

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

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

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

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

impl<T: Clone + ?Sized> Clone for NonZero<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> ConditionallySelectable for NonZero<T>

where T: Copy, Self: CtSelect,

Available on crate feature subtle only.

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

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

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl<T> ConstOne for NonZero<T>

where T: ConstOne + One,

const ONE: Self

The multiplicative identity element of Self, 1.

impl<T> ConstantTimeEq for NonZero<T>

where T: ?Sized, Self: CtEq,

Available on crate feature subtle only.

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

Determine if two items are equal.

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

Determine if two items are NOT equal.

impl<T> CtAssign for NonZero<T>

where T: CtAssign,

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

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

impl<T> CtAssignSlice for NonZero<T>

where T: CtAssign,

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<T> CtEq for NonZero<T>

where T: CtEq + ?Sized,

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<T> CtEqSlice for NonZero<T>

where T: CtEq,

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<T> CtSelect for NonZero<T>

where T: CtSelect,

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<T: Debug + ?Sized> Debug for NonZero<T>

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

Formats the value using the given formatter.

impl<T> Default for NonZero<T>

where T: One,

fn default() -> Self

Returns the “default value” for a type.

impl<T: ?Sized> Deref for NonZero<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'de, T: Deserialize<'de> + Zero> Deserialize<'de> for NonZero<T>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for NonZero<T>

where T: Display + ?Sized,

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 &Wrapping<Int<LIMBS>>

type Output = Wrapping<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<Int<RHS_LIMBS>>> for Wrapping<Int<LIMBS>>

type Output = Wrapping<Int<LIMBS>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&NonZero<Limb>> for &Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Limb>) -> Limb

Performs the / operation.

impl<const LIMBS: usize> Div<&NonZero<Limb>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const LIMBS: usize> Div<&NonZero<Limb>> for &Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<LIMBS>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&NonZero<Limb>> for Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Limb>) -> Self

Performs the / operation.

impl<const LIMBS: usize> Div<&NonZero<Limb>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const LIMBS: usize> Div<&NonZero<Limb>> for Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<LIMBS>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs: ToUnsigned + ?Sized> Div<&NonZero<Rhs>> for &BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs: ToUnsigned + ?Sized> Div<&NonZero<Rhs>> for &Wrapping<BoxedUint>

Available on crate feature alloc only.

type Output = Wrapping<BoxedUint>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs: ToUnsigned + ?Sized> Div<&NonZero<Rhs>> for BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs: ToUnsigned + ?Sized> Div<&NonZero<Rhs>> for Wrapping<BoxedUint>

Available on crate feature alloc only.

type Output = Wrapping<BoxedUint>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Rhs>) -> 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 &Uint<LIMBS>

type Output = Uint<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 &Wrapping<Int<LIMBS>>

type Output = Wrapping<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 &Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<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<Uint<RHS_LIMBS>>> for Uint<LIMBS>

type Output = Uint<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 Wrapping<Int<LIMBS>>

type Output = Wrapping<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 Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<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 &Wrapping<Int<LIMBS>>

type Output = Wrapping<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<Int<RHS_LIMBS>>> for Wrapping<Int<LIMBS>>

type Output = Wrapping<Int<LIMBS>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZero<Limb>> for &Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Limb>) -> Limb

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<Limb>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<Limb>> for &Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<LIMBS>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZero<Limb>> for Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Limb>) -> Self

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<Limb>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<Limb>> for Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<LIMBS>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs: AsMut<UintRef>> Div<NonZero<Rhs>> for &BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs: AsMut<UintRef>> Div<NonZero<Rhs>> for &Wrapping<BoxedUint>

Available on crate feature alloc only.

type Output = Wrapping<BoxedUint>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs: AsMut<UintRef>> Div<NonZero<Rhs>> for BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs: AsMut<UintRef>> Div<NonZero<Rhs>> for Wrapping<BoxedUint>

Available on crate feature alloc only.

type Output = Wrapping<BoxedUint>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Rhs>) -> 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 &Uint<LIMBS>

type Output = Uint<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 &Wrapping<Int<LIMBS>>

type Output = Wrapping<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 &Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<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<Uint<RHS_LIMBS>>> for Uint<LIMBS>

type Output = Uint<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 Wrapping<Int<LIMBS>>

type Output = Wrapping<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 Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<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<Int<LIMBS>>> for Wrapping<Int<LIMBS>>

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

Performs the /= operation.

impl DivAssign<&NonZero<Limb>> for Limb

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

impl<Rhs: ToUnsigned + ?Sized> DivAssign<&NonZero<Rhs>> for BoxedUint

Available on crate feature alloc only.

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

Performs the /= operation.

impl<Rhs: ToUnsigned + ?Sized> DivAssign<&NonZero<Rhs>> for Wrapping<BoxedUint>

Available on crate feature alloc only.

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

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<Uint<LIMBS>>> for Uint<LIMBS>

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

Performs the /= operation.

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

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

Performs the /= operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> DivAssign<&NonZero<Uint<RHS_LIMBS>>> for Wrapping<Uint<LIMBS>>

fn div_assign(&mut self, rhs: &NonZero<Uint<RHS_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<Int<LIMBS>>> for Wrapping<Int<LIMBS>>

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

Performs the /= operation.

impl DivAssign<NonZero<Limb>> for Limb

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

Performs the /= operation.

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

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

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<NonZero<Limb>> for Wrapping<Uint<LIMBS>>

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

Performs the /= operation.

impl<Rhs: AsMut<UintRef>> DivAssign<NonZero<Rhs>> for BoxedUint

Available on crate feature alloc only.

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

Performs the /= operation.

impl<Rhs: AsMut<UintRef>> DivAssign<NonZero<Rhs>> for Wrapping<BoxedUint>

Available on crate feature alloc only.

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

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<Uint<LIMBS>>> for Uint<LIMBS>

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

Performs the /= operation.

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

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

Performs the /= operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> DivAssign<NonZero<Uint<RHS_LIMBS>>> for Wrapping<Uint<LIMBS>>

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

Performs the /= operation.

impl<const LIMBS: usize> FloorSquareRoot for NonZero<Uint<LIMBS>>

fn floor_sqrt(&self) -> Self

Computes floor(sqrt(self)).

fn floor_sqrt_vartime(&self) -> Self

Computes floor(sqrt(self)).

impl<const LIMBS: usize> From<NonZero<u128>> for NonZero<Uint<LIMBS>>

fn from(integer: NonZeroU128) -> Self

Converts to this type from the input type.

impl From<NonZero<u16>> for NonZero<Limb>

fn from(integer: NonZeroU16) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<NonZero<u16>> for NonZero<Uint<LIMBS>>

fn from(integer: NonZeroU16) -> Self

Converts to this type from the input type.

impl From<NonZero<u32>> for NonZero<Limb>

fn from(integer: NonZeroU32) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<NonZero<u32>> for NonZero<Uint<LIMBS>>

fn from(integer: NonZeroU32) -> Self

Converts to this type from the input type.

impl From<NonZero<u64>> for NonZero<Limb>

fn from(integer: NonZeroU64) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<NonZero<u64>> for NonZero<Uint<LIMBS>>

fn from(integer: NonZeroU64) -> Self

Converts to this type from the input type.

impl From<NonZero<u8>> for NonZero<Limb>

fn from(integer: NonZeroU8) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<NonZero<u8>> for NonZero<Uint<LIMBS>>

fn from(integer: NonZeroU8) -> Self

Converts to this type from the input type.

impl<T> From<Odd<T>> for NonZero<T>

fn from(odd: Odd<T>) -> NonZero<T>

Converts to this type from the input type.

impl Gcd<BoxedUint> for NonZero<BoxedUint>

Available on crate feature alloc only.

type Output = NonZero<BoxedUint>

Output type.

fn gcd(&self, rhs: &BoxedUint) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &BoxedUint) -> Self::Output

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

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

type Output = NonZero<Uint<LIMBS>>

Output type.

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

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &NonZeroInt<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<NonZero<Uint<LIMBS>>> for OddUint<LIMBS>

type Output = Odd<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<NonZero<Uint<LIMBS>>> for Uint<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<T: Hash + ?Sized> Hash for NonZero<T>

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> 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<T> LowerHex for NonZero<T>

where T: LowerHex + ?Sized,

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

Formats the value using the given formatter.

impl<T> Mul for NonZero<T>

where T: Mul<T, Output = T>,

Any non-zero integer multiplied by another non-zero integer is definitionally non-zero.

type Output = NonZero<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Octal for NonZero<T>

where T: Octal + ?Sized,

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

Formats the value using the given formatter.

impl<T> One for NonZero<T>

where T: One, Self: CtEq,

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<T> One for NonZero<T>

where T: One + Mul<T, Output = T>,

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<T: Ord + ?Sized> Ord for NonZero<T>

fn cmp(&self, other: &NonZero<T>) -> 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 + ?Sized> PartialEq for NonZero<T>

fn eq(&self, other: &NonZero<T>) -> 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 + ?Sized> PartialOrd for NonZero<T>

fn partial_cmp(&self, other: &NonZero<T>) -> 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> Random for NonZero<T>

where T: Random + Zero + One + CtAssign,

Available on crate feature rand_core only.

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

This uses rejection sampling to avoid zero.

As a result, it runs in variable time. If the generator rng is cryptographically secure (for example, it implements CryptoRng), then this is guaranteed not to leak anything about the output value.

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

Generate a random value.

fn try_random() -> Result<Self, Error>

Available on crate feature getrandom only.

Randomly generate a value of this type using the system’s ambient cryptographically secure random number generator.

fn random() -> Self

Available on crate feature getrandom only.

Randomly generate a value of this type using the system’s ambient cryptographically secure random number generator.

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 &Wrapping<Int<LIMBS>>

type Output = Wrapping<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<Int<RHS_LIMBS>>> for Wrapping<Int<LIMBS>>

type Output = Wrapping<Int<RHS_LIMBS>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<&NonZero<Limb>> for &Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Limb>) -> Limb

Performs the % operation.

impl<const LIMBS: usize> Rem<&NonZero<Limb>> for &Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const LIMBS: usize> Rem<&NonZero<Limb>> for &Wrapping<Uint<LIMBS>>

type Output = Wrapping<Limb>

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<&NonZero<Limb>> for Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Limb>) -> Self

Performs the % operation.

impl<const LIMBS: usize> Rem<&NonZero<Limb>> for Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const LIMBS: usize> Rem<&NonZero<Limb>> for Wrapping<Uint<LIMBS>>

type Output = Wrapping<Limb>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Rhs: ToUnsigned + ?Sized> Rem<&NonZero<Rhs>> for &BoxedUint

Available on crate feature alloc only.

type Output = <Rhs as ToUnsigned>::Unsigned

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Rhs: ToUnsigned + ?Sized> Rem<&NonZero<Rhs>> for BoxedUint

Available on crate feature alloc only.

type Output = <Rhs as ToUnsigned>::Unsigned

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Rhs>) -> 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 &Uint<LIMBS>

type Output = Uint<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 &Wrapping<Int<LIMBS>>

type Output = Wrapping<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 &Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<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<Uint<RHS_LIMBS>>> for Uint<LIMBS>

type Output = Uint<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 Wrapping<Int<LIMBS>>

type Output = Wrapping<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 Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<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 &Wrapping<Int<LIMBS>>

type Output = Wrapping<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<Int<RHS_LIMBS>>> for Wrapping<Int<LIMBS>>

type Output = Wrapping<Int<RHS_LIMBS>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<NonZero<Limb>> for &Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Limb>) -> Limb

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<Limb>> for &Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<Limb>> for &Wrapping<Uint<LIMBS>>

type Output = Wrapping<Limb>

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<NonZero<Limb>> for Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Limb>) -> Self

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<Limb>> for Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<Limb>> for Wrapping<Uint<LIMBS>>

type Output = Wrapping<Limb>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Rhs: AsMut<UintRef>> Rem<NonZero<Rhs>> for &BoxedUint

Available on crate feature alloc only.

type Output = Rhs

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Rhs: AsMut<UintRef>> Rem<NonZero<Rhs>> for BoxedUint

Available on crate feature alloc only.

type Output = Rhs

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Rhs>) -> 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 &Uint<LIMBS>

type Output = Uint<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 &Wrapping<Int<LIMBS>>

type Output = Wrapping<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 &Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<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<Uint<RHS_LIMBS>>> for Uint<LIMBS>

type Output = Uint<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 Wrapping<Int<LIMBS>>

type Output = Wrapping<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 Wrapping<Uint<LIMBS>>

type Output = Wrapping<Uint<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<Int<LIMBS>>> for Wrapping<Int<LIMBS>>

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

Performs the %= operation.

impl RemAssign<&NonZero<Limb>> for Limb

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

impl<Rhs: AsRef<UintRef> + ?Sized> RemAssign<&NonZero<Rhs>> for BoxedUint

Available on crate feature alloc only.

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

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<Uint<LIMBS>>> for Uint<LIMBS>

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

Performs the %= operation.

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

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

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<&NonZero<Uint<LIMBS>>> for Wrapping<Uint<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<Int<LIMBS>>> for Wrapping<Int<LIMBS>>

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

Performs the %= operation.

impl RemAssign<NonZero<Limb>> for Limb

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

Performs the %= operation.

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

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

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<NonZero<Limb>> for Wrapping<Uint<LIMBS>>

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

Performs the %= operation.

impl<Rhs: AsRef<UintRef>> RemAssign<NonZero<Rhs>> for BoxedUint

Available on crate feature alloc only.

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

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<Uint<LIMBS>>> for Uint<LIMBS>

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

impl Resize for &NonZero<BoxedUint>

Available on crate feature alloc only.

type Output = NonZero<BoxedUint>

The result of the resizing.

fn resize_unchecked(self, at_least_bits_precision: u32) -> Self::Output

Resizes to the minimum storage that fits at_least_bits_precision without checking if the bit size of self is larger than at_least_bits_precision.

fn try_resize(self, at_least_bits_precision: u32) -> Option<Self::Output>

Resizes to the minimum storage that fits at_least_bits_precision returning None if the bit size of self is larger than at_least_bits_precision.

fn resize(self, at_least_bits_precision: u32) -> Self::Output

Resizes to the minimum storage that fits at_least_bits_precision panicking if the bit size of self is larger than at_least_bits_precision.

impl Resize for NonZero<BoxedUint>

Available on crate feature alloc only.

type Output = NonZero<BoxedUint>

The result of the resizing.

fn resize_unchecked(self, at_least_bits_precision: u32) -> Self::Output

Resizes to the minimum storage that fits at_least_bits_precision without checking if the bit size of self is larger than at_least_bits_precision.

fn try_resize(self, at_least_bits_precision: u32) -> Option<Self::Output>

Resizes to the minimum storage that fits at_least_bits_precision returning None if the bit size of self is larger than at_least_bits_precision.

fn resize(self, at_least_bits_precision: u32) -> Self::Output

Resizes to the minimum storage that fits at_least_bits_precision panicking if the bit size of self is larger than at_least_bits_precision.

impl<T: Serialize + Zero> Serialize for NonZero<T>

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> UpperHex for NonZero<T>

where T: UpperHex + ?Sized,

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

Formats the value using the given formatter.

impl<T: Zeroize + Zero> Zeroize for NonZero<T>

Available on crate feature zeroize only.

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<T: Copy + ?Sized> Copy for NonZero<T>

impl<T: Eq + ?Sized> Eq for NonZero<T>

impl<T: ?Sized> StructuralPartialEq for NonZero<T>