Struct Odd 

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

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<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>) -> Odd<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: &NonZero<Int<LIMBS>>, ) -> XgcdOutput<LIMBS, Odd<Uint<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<Odd<T>>

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.

pub fn into_nz(self) -> NonZero<T>

All odd integers are definitionally non-zero, so we can convert into the equivalent NonZero type.

impl<T> Odd<T>

where T: ?Sized,

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) -> Odd<Uint<LIMBS>>

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) -> Odd<Uint<LIMBS>>

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) -> &Odd<UintRef>

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) -> &Odd<UintRef>

Borrow this OddBoxedUint as a &OddUintRef.

pub fn random<R>(rng: &mut R, bit_length: u32) -> Odd<BoxedUint>

where R: TryRng + ?Sized,

Generate a random Odd<Uint<T>>.

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

Execute the Extended GCD algorithm.

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

impl Odd<UintRef>

pub const fn invert_mod_u64(&self) -> u64

Returns the multiplicative inverse of the argument modulo 2^64.

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> AsRef<NonZero<T>> for Odd<T>

where T: ?Sized,

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

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

impl AsRef<Odd<UintRef>> for Odd<BoxedUint>

Available on crate feature alloc only.

fn as_ref(&self) -> &Odd<UintRef>

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

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

fn as_ref(&self) -> &Odd<UintRef>

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

impl<T> AsRef<T> for Odd<T>

where T: ?Sized,

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<(), Error>

Formats the value using the given formatter.

impl<T> Clone for Odd<T>

where T: Clone + ?Sized,

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

where T: Copy, Odd<T>: CtSelect,

Available on crate feature subtle only.

fn conditional_select(a: &Odd<T>, b: &Odd<T>, choice: Choice) -> Odd<T>

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

where T: ConstOne + One,

const ONE: Odd<T>

The multiplicative identity element of Self, 1.

impl<T> ConstantTimeEq for Odd<T>

where Odd<T>: CtEq, T: ?Sized,

Available on crate feature subtle only.

fn ct_eq(&self, other: &Odd<T>) -> 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 Odd<T>

where T: CtAssign,

fn ct_assign(&mut self, other: &Odd<T>, 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: &Odd<T>) -> 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: &Odd<T>, choice: Choice) -> Odd<T>

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

where T: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<T> Default for Odd<T>

where T: One,

fn default() -> Odd<T>

Returns the “default value” for a type.

impl<T> Deref for Odd<T>

where T: ?Sized,

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<(), Error>

Formats the value using the given formatter.

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>) -> Odd<Uint<LIMBS>>

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) -> <Odd<BoxedUint> as Gcd<BoxedUint>>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime( &self, rhs: &BoxedUint, ) -> <Odd<BoxedUint> as Gcd<BoxedUint>>::Output

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

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

type Output = Odd<Uint<LIMBS>>

Output type.

fn gcd(&self, rhs: &Int<LIMBS>) -> <Odd<Int<LIMBS>> as Gcd<Int<LIMBS>>>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime( &self, rhs: &Int<LIMBS>, ) -> <Odd<Int<LIMBS>> as Gcd<Int<LIMBS>>>::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) -> <Odd<Limb> as Gcd<Limb>>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Limb) -> <Odd<Limb> as Gcd<Limb>>::Output

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

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

type Output = Odd<Uint<LIMBS>>

Output type.

fn gcd( &self, rhs: &NonZero<Uint<LIMBS>>, ) -> <Odd<Uint<LIMBS>> as Gcd<NonZero<Uint<LIMBS>>>>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime( &self, rhs: &NonZero<Uint<LIMBS>>, ) -> <Odd<Uint<LIMBS>> as Gcd<NonZero<Uint<LIMBS>>>>::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: &Odd<Int<LIMBS>>, ) -> <Uint<LIMBS> as Gcd<Odd<Int<LIMBS>>>>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime( &self, rhs: &Odd<Int<LIMBS>>, ) -> <Uint<LIMBS> as Gcd<Odd<Int<LIMBS>>>>::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: &Odd<Uint<LIMBS>>, ) -> <Uint<LIMBS> as Gcd<Odd<Uint<LIMBS>>>>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime( &self, rhs: &Odd<Uint<LIMBS>>, ) -> <Uint<LIMBS> as Gcd<Odd<Uint<LIMBS>>>>::Output

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

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

type Output = Odd<Uint<LIMBS>>

Output type.

fn gcd( &self, rhs: &Uint<LIMBS>, ) -> <Odd<Int<LIMBS>> as Gcd<Uint<LIMBS>>>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime( &self, rhs: &Uint<LIMBS>, ) -> <Odd<Int<LIMBS>> as Gcd<Uint<LIMBS>>>::Output

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

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

type Output = Odd<Uint<LIMBS>>

Output type.

fn gcd( &self, rhs: &Uint<LIMBS>, ) -> <Odd<Uint<LIMBS>> as Gcd<Uint<LIMBS>>>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime( &self, rhs: &Uint<LIMBS>, ) -> <Odd<Uint<LIMBS>> as Gcd<Uint<LIMBS>>>::Output

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

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

type Output = Odd<Uint<LIMBS>>

Output type.

fn gcd(&self, rhs: &Odd<Int<LIMBS>>) -> <Odd<Int<LIMBS>> as Gcd>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Odd<Int<LIMBS>>) -> <Odd<Int<LIMBS>> as Gcd>::Output

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

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

type Output = Odd<Uint<LIMBS>>

Output type.

fn gcd(&self, rhs: &Odd<Uint<LIMBS>>) -> <Odd<Uint<LIMBS>> as Gcd>::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime( &self, rhs: &Odd<Uint<LIMBS>>, ) -> <Odd<Uint<LIMBS>> as Gcd>::Output

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

impl<T> Hash for Odd<T>

where T: Hash + ?Sized,

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

where __H: Hasher,

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<(), Error>

Formats the value using the given formatter.

impl<T> Mul for Odd<T>

where T: Mul<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: Odd<T>) -> Odd<T>

Performs the * operation.

impl<T> Octal for Odd<T>

where T: Octal + ?Sized,

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

Formats the value using the given formatter.

impl<T> One for Odd<T>

where T: One,

fn one() -> Odd<T>

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<Output = T>,

fn one() -> Odd<T>

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

where T: Ord + ?Sized,

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

where T: PartialEq + ?Sized,

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

where T: PartialOrd + ?Sized,

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>( rng: &mut R, ) -> Result<Odd<Uint<LIMBS>>, <R as TryRng>::Error>

where R: TryRng + ?Sized,

Generate a random Odd<Uint<T>>.

fn random_from_rng<R>(rng: &mut R) -> Self

where R: Rng + ?Sized,

Generate a random value.

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

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

fn random() -> Self

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

impl Resize for &Odd<BoxedUint>

Available on crate feature alloc only.

type Output = Odd<BoxedUint>

The result of the resizing.

fn resize_unchecked( self, at_least_bits_precision: u32, ) -> <&Odd<BoxedUint> as Resize>::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<<&Odd<BoxedUint> as Resize>::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 Odd<BoxedUint>

Available on crate feature alloc only.

type Output = Odd<BoxedUint>

The result of the resizing.

fn resize_unchecked( self, at_least_bits_precision: u32, ) -> <Odd<BoxedUint> as Resize>::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<<Odd<BoxedUint> as Resize>::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> UpperHex for Odd<T>

where T: UpperHex + ?Sized,

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

Formats the value using the given formatter.

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

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

Output type.

fn xgcd(&self, rhs: &Odd<Int<LIMBS>>) -> <Odd<Int<LIMBS>> as Xgcd>::Output

Compute the extended greatest common divisor of self and rhs.

fn xgcd_vartime( &self, rhs: &Odd<Int<LIMBS>>, ) -> <Odd<Int<LIMBS>> as Xgcd>::Output

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

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

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

Output type.

fn xgcd(&self, rhs: &Odd<Uint<LIMBS>>) -> <Odd<Uint<LIMBS>> as Xgcd>::Output

Compute the extended greatest common divisor of self and rhs.

fn xgcd_vartime( &self, rhs: &Odd<Uint<LIMBS>>, ) -> <Odd<Uint<LIMBS>> as Xgcd>::Output

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

impl<T> Zeroize for Odd<T>

where T: Zeroize + One,

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

where T: Copy + ?Sized,

impl<T> Eq for Odd<T>

where T: Eq + ?Sized,

impl<T> StructuralPartialEq for Odd<T>

where T: ?Sized,