Struct Odd 

#[repr(transparent)]
pub struct Odd<T: ?Sized>(pub(crate) T);

Wrapper type for odd integers.

These are frequently used in cryptography, e.g. as a modulus.

Tuple Fields

0: T

Implementations

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

const fn half_mod(q: &Self) -> Self

Compute 1/2 mod q.

const fn mul_add_div2k( &self, b: Limb, addend: &Uint<LIMBS>, k: u32, ) -> Uint<LIMBS>

Compute ((self * b) + addend) / 2^k

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

pub(crate) const MINIMAL_BINGCD_ITERATIONS: u32

The minimal number of binary GCD iterations required to guarantee successful completion.

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

Computes gcd(self, rhs), leveraging (a constant time implementation of) the classic Binary GCD algorithm.

Note: this algorithm is efficient for Uints with relatively few LIMBS.

Ref: Pornin, Optimized Binary GCD for Modular Inversion, Algorithm 1. https://eprint.iacr.org/2020/972.pdf

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

Computes gcd(self, rhs), leveraging (a constant time implementation of) the classic Binary GCD algorithm.

Note: this algorithm is efficient for Uints with relatively few LIMBS.

Ref: Pornin, Optimized Binary GCD for Modular Inversion, Algorithm 1. https://eprint.iacr.org/2020/972.pdf

This method returns a pair consisting of the GCD and the sign of the Jacobi symbol, 0 for positive and 1 for negative.

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

Variable time equivalent of Self::classic_bingcd.

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

Variable time equivalent of Self::classic_bingcd_.

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

Computes gcd(self, rhs), leveraging the optimized Binary GCD algorithm.

Note: this algorithm becomes more efficient than the classical algorithm for Uints with relatively many LIMBS. A best-effort threshold is presented in Self::bingcd.

Note: the full algorithm has an additional parameter; this function selects the best-effort value for this parameter. You might be able to further tune your performance by calling the Self::optimized_bingcd_ function directly.

Ref: Pornin, Optimized Binary GCD for Modular Inversion, Algorithm 2. https://eprint.iacr.org/2020/972.pdf

pub(crate) const fn optimized_bingcd_<const K: u32, const LIMBS_K: usize, const LIMBS_2K: usize>( &self, rhs: &Uint<LIMBS>, batch_max: u32, ) -> (Self, Word)

Computes gcd(self, rhs), leveraging the optimized Binary GCD algorithm.

Ref: Pornin, Optimized Binary GCD for Modular Inversion, Algorithm 2. https://eprint.iacr.org/2020/972.pdf

In summary, the optimized algorithm does not operate on self and rhs directly, but instead of condensed summaries that fit in few registers. Based on these summaries, an update matrix is constructed by which self and rhs are updated in larger steps.

This function is generic over the following three values:

• K: the number of bits used when summarizing self and rhs for the inner loop. The K top bits and K least significant bits are selected. It is recommended to keep K close to a (multiple of) the number of bits that fit in a single register.
• LIMBS_K: should be chosen as the minimum number s.t. Uint::<LIMBS>::BITS ≥ K,
• LIMBS_2K: should be chosen as the minimum number s.t. Uint::<LIMBS>::BITS ≥ 2K.

This method returns a pair consisting of the GCD and the sign of the Jacobi symbol, 0 for positive and 1 for negative.

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

Variable time equivalent of Self::optimized_bingcd.

pub(crate) const fn optimized_bingcd_vartime_<const K: u32, const LIMBS_K: usize, const LIMBS_2K: usize>( &self, rhs: &Uint<LIMBS>, batch_max: u32, ) -> (Self, Word)

Variable time equivalent of Self::optimized_bingcd_.

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

const MIN_BINXGCD_ITERATIONS: u32

The minimal number of binary GCD iterations required to guarantee successful completion.

pub(crate) const fn binxgcd_nz( &self, rhs: &NonZeroUint<LIMBS>, ) -> RawXgcdOutput<LIMBS, PatternMatrix<LIMBS>>

Given (self, rhs), computes (g, x, y) s.t. self * x + rhs * y = g = gcd(self, rhs), leveraging the Binary Extended GCD algorithm.

pub(crate) const fn binxgcd_odd( &self, rhs: &Self, ) -> RawXgcdOutput<LIMBS, PatternMatrix<LIMBS>>

Execute the classic Extended GCD algorithm.

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

pub(crate) const fn classic_binxgcd( &self, rhs: &Self, ) -> RawXgcdOutput<LIMBS, DividedPatternMatrix<LIMBS>>

Execute the classic Binary Extended GCD algorithm.

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

Ref: Pornin, Optimized Binary GCD for Modular Inversion, Algorithm 1. https://eprint.iacr.org/2020/972.pdf.

pub(crate) const fn optimized_binxgcd( &self, rhs: &Self, ) -> RawXgcdOutput<LIMBS, DividedPatternMatrix<LIMBS>>

Given (self, rhs), computes (g, x, y) s.t. self * x + rhs * y = g = gcd(self, rhs), leveraging the Binary Extended GCD algorithm.

Warning: self and rhs must be contained in an U128 or larger.

Note: this algorithm becomes more efficient than the classical algorithm for Uints with relatively many LIMBS. A best-effort threshold is presented in [Self::binxgcd_].

Note: the full algorithm has an additional parameter; this function selects the best-effort value for this parameter. You might be able to further tune your performance by calling the Self::optimized_bingcd_ function directly.

Ref: Pornin, Optimized Binary GCD for Modular Inversion, Algorithm 2. https://eprint.iacr.org/2020/972.pdf.

pub(crate) const fn optimized_binxgcd_<const K: u32, const LIMBS_K: usize, const LIMBS_2K: usize>( &self, rhs: &Self, ) -> RawXgcdOutput<LIMBS, DividedPatternMatrix<LIMBS>>

Given (self, rhs), computes (g, x, y), s.t. self * x + rhs * y = g = gcd(self, rhs), leveraging the optimized Binary Extended GCD algorithm.

Ref: Pornin, Optimized Binary GCD for Modular Inversion, Algorithm 2. https://eprint.iacr.org/2020/972.pdf

In summary, the optimized algorithm does not operate on self and rhs directly, but instead of condensed summaries that fit in few registers. Based on these summaries, an update matrix is constructed by which self and rhs are updated in larger steps.

This function is generic over the following three values:

• K: the number of bits used when summarizing self and rhs for the inner loop. The K+1 top bits and K-1 least significant bits are selected. It is recommended to keep K close to a (multiple of) the number of bits that fit in a single register.
• LIMBS_K: should be chosen as the minimum number s.t. Uint::<LIMBS>::BITS ≥ K,
• LIMBS_2K: should be chosen as the minimum number s.t. Uint::<LIMBS>::BITS ≥ 2K.

pub(super) const fn partial_binxgcd<const UPDATE_LIMBS: usize>( &self, rhs: &Uint<LIMBS>, iterations: u32, halt_at_zero: Choice, ) -> (Self, Uint<LIMBS>, DividedPatternMatrix<UPDATE_LIMBS>, Word)

Executes the optimized Binary GCD inner loop.

Ref: Pornin, Optimized Binary GCD for Modular Inversion, Algorithm 2. https://eprint.iacr.org/2020/972.pdf.

The function outputs the reduced values (a, b) for the input values (self, rhs) as well as the matrix that yields the former two when multiplied with the latter two.

Note: this implementation deviates slightly from the paper, in that it can be instructed to “run in place” (i.e., execute iterations that do nothing) once a becomes zero. This is done by passing a truthy halt_at_zero.

The function executes in time variable in iterations.

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

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

Compute the greatest common divisor of self and rhs.

pub const fn gcd_unsigned_vartime(&self, rhs: &Uint<LIMBS>) -> OddUint<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: &NonZero<Int<LIMBS>>, ) -> XgcdOutput<LIMBS, OddUint<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> Odd<T>

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

where T: Integer,

Create a new odd 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> Odd<T>

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

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

pub const fn as_nz_ref(&self) -> &NonZero<T>

All odd integers are definitionally non-zero, so we can also obtain a reference to the equivalent NonZero type.

impl<T> Odd<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<const LIMBS: usize> Odd<Uint<LIMBS>>

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

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

Panics

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

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

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

Panics

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

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

Borrow this OddUint as a &OddUintRef.

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

Construct an Odd<Uint<T>> from the unsigned integer value, truncating the upper bits if the value is too large to be represented.

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

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

The sign and magnitude of this Odd<Int<{LIMBS}>>.

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

The magnitude of this Odd<Int<{LIMBS}>>.

impl Odd<UintRef>

pub const fn to_uint_resize<const T: usize>(&self) -> Odd<Uint<T>>

Construct an Odd<Uint<T>> from the unsigned integer value, truncating the upper bits if the value is too large to be represented.

impl Odd<BoxedUint>

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

Borrow this OddBoxedUint as a &OddUintRef.

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

Generate a random Odd<Uint<T>>.

impl<const LIMBS: usize> Odd<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, OddUint<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> Odd<Uint<LIMBS>>

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

Compute a full-width quadratic inversion, self^-1 mod 2^Self::BITS.

pub(crate) const fn invert_mod2k_vartime(&self, k: u32) -> Uint<LIMBS>

Compute a quadratic inversion, self^-1 mod 2^k where k <= Self::BITS.

This method is variable-time in k only.

impl Odd<UintRef>

pub const fn invert_mod_u64(&self) -> u64

Returns the multiplicative inverse of the argument modulo 2^64. The implementation is based on the Hurchalla’s method for computing the multiplicative inverse modulo a power of two.

For better understanding the implementation, the following paper is recommended: J. Hurchalla, “An Improved Integer Multiplicative Inverse (modulo 2^w)”, https://arxiv.org/pdf/2204.limbs4342.pdf

Variable time with respect to the number of words in value, however that number will be fixed for a given integer size.

impl Odd<BoxedUint>

pub(crate) fn invert_mod_precision(&self) -> BoxedUint

Compute a full-width quadratic inversion, self^-1 mod 2^bits_precision().

pub(crate) fn invert_mod2k_vartime(&self, k: u32) -> BoxedUint

Compute a quadratic inversion, self^-1 mod 2^k where k <= bits_precision().

This method is variable-time in k only.

Trait Implementations

impl<T> AsRef<[Limb]> for Odd<T>

where T: AsRef<[Limb]>,

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

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

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<Odd<UintRef>> for OddBoxedUint

Available on crate feature alloc only.

fn as_ref(&self) -> &OddUintRef

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

impl<const LIMBS: usize> AsRef<Odd<UintRef>> for OddUint<LIMBS>

fn as_ref(&self) -> &OddUintRef

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

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

fn as_ref(&self) -> &T

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

impl<T> Binary for Odd<T>

where T: Binary + ?Sized,

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

Formats the value using the given formatter.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> ConstOne for Odd<T>

where T: ConstOne + One,

const ONE: Self

The multiplicative identity element of Self, 1.

impl<T> CtAssign for Odd<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 Odd<T>

where T: CtAssignSlice,

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 Odd<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 Odd<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 Odd<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 Odd<T>

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

Formats the value using the given formatter.

impl<T> Default for Odd<T>

where T: One,

fn default() -> Self

Returns the “default value” for a type.

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

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> Display for Odd<T>

where T: Display + ?Sized,

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

Formats the value using the given formatter.

impl<const LIMBS: usize> From<&Odd<Uint<LIMBS>>> for BoxedUint

fn from(uint: &Odd<Uint<LIMBS>>) -> BoxedUint

Converts to this type from the input type.

impl<const LIMBS: usize> From<&Odd<Uint<LIMBS>>> for Odd<BoxedUint>

fn from(uint: &Odd<Uint<LIMBS>>) -> Odd<BoxedUint>

Converts to this type from the input type.

impl<const LIMBS: usize> From<Odd<Limb>> for Odd<Uint<LIMBS>>

fn from(limb: Odd<Limb>) -> 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<const LIMBS: usize> From<Odd<Uint<LIMBS>>> for BoxedUint

fn from(uint: Odd<Uint<LIMBS>>) -> BoxedUint

Converts to this type from the input type.

impl<const LIMBS: usize> From<Odd<Uint<LIMBS>>> for Odd<BoxedUint>

fn from(uint: Odd<Uint<LIMBS>>) -> Odd<BoxedUint>

Converts to this type from the input type.

impl Gcd<BoxedUint> for Odd<BoxedUint>

type Output = Odd<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 Gcd<Limb> for Odd<Limb>

type Output = Limb

Output type.

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

Compute the greatest common divisor of self and rhs.

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

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

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

type Output = Odd<Uint<LIMBS>>

Output type.

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

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &OddInt<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<Odd<Uint<LIMBS>>> for NonZeroUint<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<Odd<Uint<LIMBS>>> for Uint<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<T: Hash + ?Sized> Hash for Odd<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<T> LowerHex for Odd<T>

where T: LowerHex + ?Sized,

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

Formats the value using the given formatter.

impl<T> Mul for Odd<T>

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

Any odd integer multiplied by another odd integer is definitionally odd.

type Output = Odd<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Octal for Odd<T>

where T: Octal + ?Sized,

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

Formats the value using the given formatter.

impl<T> One for Odd<T>

where T: One,

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 Odd<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 Odd<T>

fn cmp(&self, other: &Odd<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 PartialEq<Odd<BoxedUint>> for BoxedUint

Available on crate feature alloc only.

fn eq(&self, other: &OddBoxedUint) -> 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> PartialEq<Odd<Uint<LIMBS>>> for Uint<LIMBS>

fn eq(&self, other: &Odd<Uint<LIMBS>>) -> 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: PartialEq + ?Sized> PartialEq for Odd<T>

fn eq(&self, other: &Odd<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 PartialOrd<Odd<BoxedUint>> for BoxedUint

Available on crate feature alloc only.

fn partial_cmp(&self, other: &OddBoxedUint) -> 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> PartialOrd<Odd<Uint<LIMBS>>> for Uint<LIMBS>

fn partial_cmp(&self, other: &Odd<Uint<LIMBS>>) -> 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: PartialOrd + ?Sized> PartialOrd for Odd<T>

fn partial_cmp(&self, other: &Odd<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<const LIMBS: usize> Random for Odd<Uint<LIMBS>>

Available on crate feature rand_core only.

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

Generate a random Odd<Uint<T>>.

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

Generate a random value.

impl<T> UpperHex for Odd<T>

where T: UpperHex + ?Sized,

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

Formats the value using the given formatter.

impl<T: Zeroize> Zeroize for Odd<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 Odd<T>

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

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