Struct algebraics::mod_int::ModularInteger

pub struct ModularInteger<V, M> { /* fields omitted */ }

Methods

impl<V, M> ModularInteger<V, M>

pub fn value(&self) -> &V

pub fn modulus(&self) -> &M

impl<V, M: PartialEq> ModularInteger<V, M>

pub fn has_matching_moduli(&self, rhs: &Self) -> bool

impl<V: ModularReduce + Eq, M: Modulus<V>> ModularInteger<V, M>

pub fn new(value: V, modulus: M) -> Self

pub fn neg_assign(&mut self)

*self = -*self

pub fn from_u8(value: u8, modulus: M) -> Self

pub fn from_i8(value: i8, modulus: M) -> Self

pub fn from_u16(value: u16, modulus: M) -> Self

pub fn from_i16(value: i16, modulus: M) -> Self

pub fn from_u32(value: u32, modulus: M) -> Self

pub fn from_i32(value: i32, modulus: M) -> Self

pub fn from_u64(value: u64, modulus: M) -> Self

pub fn from_i64(value: i64, modulus: M) -> Self

pub fn from_u128(value: u128, modulus: M) -> Self

pub fn from_i128(value: i128, modulus: M) -> Self

pub fn from_usize(value: usize, modulus: M) -> Self

pub fn from_isize(value: isize, modulus: M) -> Self

pub fn from_bigint(value: &BigInt, modulus: M) -> Self

pub fn from_biguint(value: &BigUint, modulus: M) -> Self

impl<V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD, M: Modulus<V>> ModularInteger<V, M>

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

pub fn inverse(&self) -> Self

Trait Implementations

impl<V, M> PolynomialCoefficient for ModularInteger<V, M> where
    V: ModularReducePow<usize> + Eq + One + Zero + Debug + Hash,
    M: Modulus<V> + Debug + Hash, 

type Element = Self

type Divisor = DivisorIsOne

const NESTING_DEPTH: usize

fn is_element_zero(element: &Self::Element) -> bool

fn is_element_one(element: &Self::Element) -> bool

fn is_coefficient_zero(coefficient: &Self) -> bool

fn is_coefficient_one(coefficient: &Self) -> bool

fn set_element_zero(element: &mut Self::Element)

fn set_element_one(element: &mut Self::Element)

fn set_coefficient_zero(coefficient: &mut Self)

fn set_coefficient_one(coefficient: &mut Self)

fn make_zero_element(element: Cow<Self::Element>) -> Self::Element

fn make_one_element(element: Cow<Self::Element>) -> Self::Element

fn make_zero_coefficient_from_element(element: Cow<Self::Element>) -> Self

fn make_one_coefficient_from_element(element: Cow<Self::Element>) -> Self

fn make_zero_coefficient_from_coefficient(coefficient: Cow<Self>) -> Self

fn make_one_coefficient_from_coefficient(coefficient: Cow<Self>) -> Self

fn negate_element(element: &mut Self::Element)

fn mul_element_by_usize(
    element: Cow<Self::Element>,
    multiplier: usize
) -> Self::Element

fn mul_assign_element_by_usize(element: &mut Self::Element, multiplier: usize)

fn divisor_to_element(
    _v: Cow<Self::Divisor>,
    other_element: Cow<Self::Element>
) -> Self::Element

fn coefficients_to_elements(
    coefficients: Cow<[Self]>
) -> (Vec<Self::Element>, Self::Divisor)

fn make_coefficient(
    element: Cow<Self::Element>,
    _divisor: Cow<Self::Divisor>
) -> Self

fn reduce_divisor(_elements: &mut [Self::Element], _divisor: &mut Self::Divisor)

fn get_reduced_divisor(
    elements: &[Self::Element],
    _divisor: &Self::Divisor
) -> (Vec<Self::Element>, Self::Divisor)

fn coefficient_to_element(
    coefficient: Cow<Self>
) -> (Self::Element, Self::Divisor)

fn divisor_pow_usize(_base: Self::Divisor, _exponent: usize) -> Self::Divisor

fn element_pow_usize(base: Self::Element, exponent: usize) -> Self::Element

fn coefficient_pow_usize(base: Self, exponent: usize) -> Self

fn from_iterator<I: Iterator<Item = Self>>(iter: I) -> Polynomial<Self>

impl<V, M> PolynomialReducingFactorSupported for ModularInteger<V, M> where
    V: ModularReducePow<usize> + Integer + Debug + Hash,
    M: PrimeModulus<V> + Debug + Hash, 

fn get_nonzero_reducing_factor(
    elements: &[Self::Element],
    _divisor: &Self::Divisor
) -> Option<Self>

returns the factor f of the passed in polynomial p where p / f is content-free (for integer polynomials) or monic (for polynomials over fields).

impl<V, M> ExactDiv<ModularInteger<V, M>> for ModularInteger<V, M> where
    V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD,
    M: Modulus<V>, 

type Output = ModularInteger<V, M>

fn exact_div(self, rhs: ModularInteger<V, M>) -> Self::Output

fn checked_exact_div(self, rhs: ModularInteger<V, M>) -> Option<Self::Output>

impl<'r, V, M> ExactDiv<&'r ModularInteger<V, M>> for ModularInteger<V, M> where
    V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD,
    M: Modulus<V>, 

type Output = ModularInteger<V, M>

fn exact_div(self, rhs: &'r ModularInteger<V, M>) -> Self::Output

fn checked_exact_div(
    self,
    rhs: &'r ModularInteger<V, M>
) -> Option<Self::Output>

impl<'l, V, M> ExactDiv<ModularInteger<V, M>> for &'l ModularInteger<V, M> where
    V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD,
    M: Modulus<V>, 

type Output = ModularInteger<V, M>

fn exact_div(self, rhs: ModularInteger<V, M>) -> Self::Output

fn checked_exact_div(self, rhs: ModularInteger<V, M>) -> Option<Self::Output>

impl<'l, 'r, V, M> ExactDiv<&'r ModularInteger<V, M>> for &'l ModularInteger<V, M> where
    V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD,
    M: Modulus<V>, 

type Output = ModularInteger<V, M>

fn exact_div(self, rhs: &'r ModularInteger<V, M>) -> Self::Output

fn checked_exact_div(
    self,
    rhs: &'r ModularInteger<V, M>
) -> Option<Self::Output>

impl<V, M> ExactDivAssign<ModularInteger<V, M>> for ModularInteger<V, M> where
    V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD,
    M: Modulus<V>, 

fn exact_div_assign(&mut self, rhs: ModularInteger<V, M>)

fn checked_exact_div_assign(
    &mut self,
    rhs: ModularInteger<V, M>
) -> Result<(), ()>

impl<'r, V, M> ExactDivAssign<&'r ModularInteger<V, M>> for ModularInteger<V, M> where
    V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD,
    M: Modulus<V>, 

fn exact_div_assign(&mut self, rhs: &'r ModularInteger<V, M>)

fn checked_exact_div_assign(
    &mut self,
    rhs: &'r ModularInteger<V, M>
) -> Result<(), ()>

impl<V, M> AlwaysExactDiv<ModularInteger<V, M>> for ModularInteger<V, M> where
    V: ModularReduce + Integer + GCD<Output = V> + ExtendedGCD,
    M: PrimeModulus<V>, 

impl<'r, V, M> AlwaysExactDiv<&'r ModularInteger<V, M>> for ModularInteger<V, M> where
    V: ModularReduce + Integer + GCD<Output = V> + ExtendedGCD,
    M: PrimeModulus<V>, 

impl<'l, V, M> AlwaysExactDiv<ModularInteger<V, M>> for &'l ModularInteger<V, M> where
    V: ModularReduce + Integer + GCD<Output = V> + ExtendedGCD,
    M: PrimeModulus<V>, 

impl<'l, 'r, V, M> AlwaysExactDiv<&'r ModularInteger<V, M>> for &'l ModularInteger<V, M> where
    V: ModularReduce + Integer + GCD<Output = V> + ExtendedGCD,
    M: PrimeModulus<V>, 

impl<V, M> AlwaysExactDivAssign<ModularInteger<V, M>> for ModularInteger<V, M> where
    V: ModularReduce + Integer + GCD<Output = V> + ExtendedGCD,
    M: PrimeModulus<V>, 

impl<'r, V, M> AlwaysExactDivAssign<&'r ModularInteger<V, M>> for ModularInteger<V, M> where
    V: ModularReduce + Integer + GCD<Output = V> + ExtendedGCD,
    M: PrimeModulus<V>, 

impl<V, M> Into<(V, M)> for ModularInteger<V, M>

fn into(self) -> (V, M)

Performs the conversion.

impl<V: ModularReduce + Eq, M: Modulus<V>> From<(V, M)> for ModularInteger<V, M>

fn from((value, modulus): (V, M)) -> Self

Performs the conversion.

impl<V: Clone, M: Clone> Clone for ModularInteger<V, M>

fn clone(&self) -> ModularInteger<V, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Copy, M: Copy> Copy for ModularInteger<V, M>

impl<V: Eq, M: Eq> Eq for ModularInteger<V, M>

impl<V: PartialEq, M: PartialEq> PartialEq<ModularInteger<V, M>> for ModularInteger<V, M>

fn eq(&self, other: &ModularInteger<V, M>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ModularInteger<V, M>) -> bool

This method tests for !=.

impl<V: Display, M: Display> Display for ModularInteger<V, M>

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

Formats the value using the given formatter.

impl<V: Debug, M: Debug> Debug for ModularInteger<V, M>

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

Formats the value using the given formatter.

impl<V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD, M: Modulus<V>> Div<ModularInteger<V, M>> for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the / operator.

fn div(self, rhs: ModularInteger<V, M>) -> ModularInteger<V, M>

Performs the / operation.

impl<'_, V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD, M: Modulus<V>> Div<ModularInteger<V, M>> for &'_ ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the / operator.

fn div(self, rhs: ModularInteger<V, M>) -> ModularInteger<V, M>

Performs the / operation.

impl<'_, V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD, M: Modulus<V>> Div<&'_ ModularInteger<V, M>> for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the / operator.

fn div(self, rhs: &ModularInteger<V, M>) -> ModularInteger<V, M>

Performs the / operation.

impl<'a, 'b, V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD, M: Modulus<V>> Div<&'a ModularInteger<V, M>> for &'b ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the / operator.

fn div(self, rhs: &ModularInteger<V, M>) -> ModularInteger<V, M>

Performs the / operation.

impl<V: ModularReduce + Eq, M: Modulus<V>> Sub<ModularInteger<V, M>> for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the - operator.

fn sub(self, rhs: ModularInteger<V, M>) -> Self::Output

Performs the - operation.

impl<'r, V: ModularReduce + Eq, M: Modulus<V>> Sub<&'r ModularInteger<V, M>> for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &ModularInteger<V, M>) -> Self::Output

Performs the - operation.

impl<'l, V: ModularReduce + Eq, M: Modulus<V>> Sub<ModularInteger<V, M>> for &'l ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the - operator.

fn sub(self, rhs: ModularInteger<V, M>) -> Self::Output

Performs the - operation.

impl<'l, 'r, V: ModularReduce + Eq, M: Modulus<V>> Sub<&'r ModularInteger<V, M>> for &'l ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &ModularInteger<V, M>) -> Self::Output

Performs the - operation.

impl<V: ModularReduce + Eq, M: Modulus<V>> Add<ModularInteger<V, M>> for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, V: ModularReduce + Eq, M: Modulus<V>> Add<&'r ModularInteger<V, M>> for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the + operator.

fn add(self, rhs: &ModularInteger<V, M>) -> Self::Output

Performs the + operation.

impl<'l, V: ModularReduce + Eq, M: Modulus<V>> Add<ModularInteger<V, M>> for &'l ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the + operator.

fn add(self, rhs: ModularInteger<V, M>) -> Self::Output

Performs the + operation.

impl<'l, 'r, V: ModularReduce + Eq, M: Modulus<V>> Add<&'r ModularInteger<V, M>> for &'l ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the + operator.

fn add(self, rhs: &ModularInteger<V, M>) -> Self::Output

Performs the + operation.

impl<V: ModularReduce + Eq, M: Modulus<V>> Mul<ModularInteger<V, M>> for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, V: ModularReduce + Eq, M: Modulus<V>> Mul<&'r ModularInteger<V, M>> for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &ModularInteger<V, M>) -> Self::Output

Performs the * operation.

impl<'l, V: ModularReduce + Eq, M: Modulus<V>> Mul<ModularInteger<V, M>> for &'l ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the * operator.

fn mul(self, rhs: ModularInteger<V, M>) -> Self::Output

Performs the * operation.

impl<'l, 'r, V: ModularReduce + Eq, M: Modulus<V>> Mul<&'r ModularInteger<V, M>> for &'l ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the * operator.

fn mul(self, rhs: &ModularInteger<V, M>) -> Self::Output

Performs the * operation.

impl<V: ModularReduce + Eq, M: Modulus<V>> Neg for ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, V: ModularReduce + Eq, M: Modulus<V>> Neg for &'a ModularInteger<V, M>

type Output = ModularInteger<V, M>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<V: ModularReduce + Eq, M: Modulus<V>> AddAssign<ModularInteger<V, M>> for ModularInteger<V, M>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<'r, V: ModularReduce + Eq, M: Modulus<V>> AddAssign<&'r ModularInteger<V, M>> for ModularInteger<V, M>

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

Performs the += operation.

impl<V: ModularReduce + Eq, M: Modulus<V>> SubAssign<ModularInteger<V, M>> for ModularInteger<V, M>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'r, V: ModularReduce + Eq, M: Modulus<V>> SubAssign<&'r ModularInteger<V, M>> for ModularInteger<V, M>

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<V: ModularReduce + Eq, M: Modulus<V>> MulAssign<ModularInteger<V, M>> for ModularInteger<V, M>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<'r, V: ModularReduce + Eq, M: Modulus<V>> MulAssign<&'r ModularInteger<V, M>> for ModularInteger<V, M>

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD, M: Modulus<V>> DivAssign<ModularInteger<V, M>> for ModularInteger<V, M>

fn div_assign(&mut self, rhs: ModularInteger<V, M>)

Performs the /= operation.

impl<'_, V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD, M: Modulus<V>> DivAssign<&'_ ModularInteger<V, M>> for ModularInteger<V, M>

fn div_assign(&mut self, rhs: &ModularInteger<V, M>)

Performs the /= operation.

impl<V: Hash, M: Hash> Hash for ModularInteger<V, M>

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, 

Feeds a slice of this type into the given [Hasher].

impl<V, M> StructuralPartialEq for ModularInteger<V, M>

impl<V, M> StructuralEq for ModularInteger<V, M>

impl<V: ModularReduce + Eq, M: Modulus<V>> CheckedAdd for ModularInteger<V, M>

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

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<V: ModularReduce + Eq + One + Zero + GCD<Output = V> + ExtendedGCD, M: Modulus<V>> CheckedDiv for ModularInteger<V, M>

fn checked_div(&self, rhs: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<V: ModularReduce + Eq, M: Modulus<V>> CheckedMul for ModularInteger<V, M>

fn checked_mul(&self, rhs: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<V: ModularReduce + Eq, M: Modulus<V>> CheckedSub for ModularInteger<V, M>

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

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.