Struct algebraic_equation_over_finite_prime_field::PolynomialOverP

pub struct PolynomialOverP<T> { /* fields omitted */ }

Implementations

impl<T> PolynomialOverP<T>

PolynomialOverP ring over finite prime field $F_p[x]$

use num_traits::Zero;
use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::new(vec![3, 1, 4, 1, 5], 17);
let q = PolynomialOverP::<i32>::new(vec![2, 7, 1], 17);
let mut r = p.clone();
let d = r.division(&q);
assert!((d * q + r - p).is_zero());

pub fn deg(&self) -> Option<usize>

degree of polynomial

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::new(vec![3, 2, 1], 5); // 3+2x+x^2
assert_eq!(p.deg(), Some(2));
let q = PolynomialOverP::<i32>::new(vec![0], 5); // 0
assert_eq!(q.deg(), None);

pub fn lc(&self) -> Option<&T>

leading coefficent

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::new(vec![3, 2, 1], 5); // 3+2x+x^2
assert_eq!(p.lc(), Some(&1));
let q = PolynomialOverP::<i32>::new(vec![0], 5); // 0
assert_eq!(q.lc(), None);

pub fn coefs(self) -> Vec<T, Global>

get coefficents

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::new(vec![3, 2, 1], 5); // 3+2x+x^2
assert_eq!(p.coefs(), vec![3, 2, 1]);
let q = PolynomialOverP::<i32>::new(vec![0], 5); // 0
assert_eq!(q.coefs(), vec![]);

pub fn prime_ref(&self) -> &T

get prime

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::new(vec![3, 2, 1], 97); // 3+2x+x^2
assert_eq!(p.prime_ref(), &97);
let q = PolynomialOverP::<i32>::new(vec![0], 5); // 0
assert_eq!(q.prime_ref(), &5);

pub fn new(coef: Vec<T, Global>, prime: T) -> PolynomialOverP<T> where
    T: Zero,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Rem<&'x T>>::Output == T, 

construct polynomial

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::new(vec![3, 2, 1], 5);
assert_eq!(p.to_string(), "x^2+2*x+3");

pub fn from_monomial(
    coefficent: T,
    degree: usize,
    prime: T
) -> PolynomialOverP<T> where
    T: Zero, 

construct polynomial from monomial $cx^d$ ($c$=coefficent, $d$=degree)

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::from_monomial(3, 2, 5);
let q = PolynomialOverP::<i32>::new(vec![0, 0, 3], 5);
assert_eq!(p, q);

pub fn one(prime: T) -> PolynomialOverP<T> where
    T: One, 

Make one polynomial

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::one(5);
assert_eq!(p, PolynomialOverP::<i32>::new(vec![1], 5));

pub fn eval(&self, x: &'a T) -> T where
    T: Clone + Zero,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Mul<&'x T>,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Mul<&'x T>>::Output == T,
    <&'x T as Rem<&'x T>>::Output == T, 

evaluate polynomial by Horner’s method

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::new(vec![3, 2, 1], 7); // 3+2x+x^2
assert_eq!(p.eval(&1), 6);
assert_eq!(p.eval(&2), 4);
assert_eq!(p.eval(&3), 4);

pub fn derivative(self) -> PolynomialOverP<T> where
    T: Clone + Zero + for<'x> AddAssign<&'x T> + From<usize>,
    &'x T: for<'x> Mul<&'x T>,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Mul<&'x T>>::Output == T,
    <&'x T as Rem<&'x T>>::Output == T, 

derivative

use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<usize>::new(vec![1, 2, 3, 2, 1], 7); // 1+2x+3x^2+2x^3+x^4
assert_eq!(p.derivative(), PolynomialOverP::<usize>::new(vec![2, 6, 6, 4], 7));
let q = PolynomialOverP::<usize>::new(vec![1, 2, 3, 4, 3, 2, 1], 5); // 1+2x+3x^2+4x^3+3x^4+2x^5+x^6
assert_eq!(q.derivative(), PolynomialOverP::<usize>::new(vec![2, 1, 2, 2, 0, 1], 5));

pub fn monic(&mut self) where
    T: Clone + Eq + Zero + One + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>, 

make polynomial monic

use polynomial_over_finite_prime_field::PolynomialOverP;
let mut p = PolynomialOverP::<i32>::new(vec![1, 2, 3], 5);
p.monic();
let q = PolynomialOverP::<i32>::new(vec![2, 4, 1], 5);
assert_eq!(p, q);

pub fn division(&mut self, other: &PolynomialOverP<T>) -> PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

polynomial division

use num_traits::Zero;
use polynomial_over_finite_prime_field::PolynomialOverP;
let p = PolynomialOverP::<i32>::new(vec![3, 1, 4, 1, 5], 17);
let q = PolynomialOverP::<i32>::new(vec![2, 7, 1], 17);
let mut r = p.clone();
let d = r.division(&q);
assert!((d * q + r - p).is_zero());

Trait Implementations

impl<'a, T> Add<&'a PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Clone + Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T>,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    other: &'a PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Add<&'a PolynomialOverP<T>>>::Output

Performs the + operation.

impl<'a, T> Add<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T>,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    other: &PolynomialOverP<T>
) -> <PolynomialOverP<T> as Add<&'a PolynomialOverP<T>>>::Output

Performs the + operation.

impl<T> Add<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T>,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    other: PolynomialOverP<T>
) -> <PolynomialOverP<T> as Add<PolynomialOverP<T>>>::Output

Performs the + operation.

impl<'a, T> Add<PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Clone + Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T>,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    other: PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Add<PolynomialOverP<T>>>::Output

Performs the + operation.

impl<'a, T> AddAssign<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T>,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

pub fn add_assign(&mut self, other: &PolynomialOverP<T>)

Performs the += operation.

impl<T> AddAssign<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T>,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

pub fn add_assign(&mut self, other: PolynomialOverP<T>)

Performs the += operation.

impl<T> Clone for PolynomialOverP<T> where
    T: Clone, 

pub fn clone(&self) -> PolynomialOverP<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for PolynomialOverP<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Display for PolynomialOverP<T> where
    T: Eq + Display + Zero + One, 

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

Formats the value using the given formatter.

impl<'a, T> Div<&'a PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    other: &'a PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Div<&'a PolynomialOverP<T>>>::Output

Performs the / operation.

impl<'a, T> Div<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    other: &PolynomialOverP<T>
) -> <PolynomialOverP<T> as Div<&'a PolynomialOverP<T>>>::Output

Performs the / operation.

impl<'a, T> Div<PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    other: PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Div<PolynomialOverP<T>>>::Output

Performs the / operation.

impl<T> Div<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    other: PolynomialOverP<T>
) -> <PolynomialOverP<T> as Div<PolynomialOverP<T>>>::Output

Performs the / operation.

impl<'a, T> DivAssign<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

pub fn div_assign(&mut self, other: &PolynomialOverP<T>)

Performs the /= operation.

impl<T> DivAssign<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

pub fn div_assign(&mut self, other: PolynomialOverP<T>)

Performs the /= operation.

impl<'a, T> Mul<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone + Ord,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    &'x T: for<'x> Mul<&'x T>,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T,
    <&'x T as Mul<&'x T>>::Output == T,
    <&'x T as Rem<&'x T>>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    other: &PolynomialOverP<T>
) -> <PolynomialOverP<T> as Mul<&'a PolynomialOverP<T>>>::Output

Performs the * operation.

impl<'a, T> Mul<&'a PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone + Ord,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    &'x T: for<'x> Mul<&'x T>,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T,
    <&'x T as Mul<&'x T>>::Output == T,
    <&'x T as Rem<&'x T>>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    other: &'a PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Mul<&'a PolynomialOverP<T>>>::Output

Performs the * operation.

impl<'a, T> Mul<PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone + Ord,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    &'x T: for<'x> Mul<&'x T>,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T,
    <&'x T as Mul<&'x T>>::Output == T,
    <&'x T as Rem<&'x T>>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    other: PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Mul<PolynomialOverP<T>>>::Output

Performs the * operation.

impl<T> Mul<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone + Ord,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    &'x T: for<'x> Mul<&'x T>,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T,
    <&'x T as Mul<&'x T>>::Output == T,
    <&'x T as Rem<&'x T>>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    other: PolynomialOverP<T>
) -> <PolynomialOverP<T> as Mul<PolynomialOverP<T>>>::Output

Performs the * operation.

impl<'a, T> MulAssign<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone + Ord,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    &'x T: for<'x> Mul<&'x T>,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T,
    <&'x T as Mul<&'x T>>::Output == T,
    <&'x T as Rem<&'x T>>::Output == T, 

pub fn mul_assign(&mut self, other: &PolynomialOverP<T>)

Performs the *= operation.

impl<T> MulAssign<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone + Ord,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    &'x T: for<'x> Mul<&'x T>,
    &'x T: for<'x> Rem<&'x T>,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T,
    <&'x T as Mul<&'x T>>::Output == T,
    <&'x T as Rem<&'x T>>::Output == T, 

pub fn mul_assign(&mut self, other: PolynomialOverP<T>)

Performs the *= operation.

impl<'a, T> Neg for &'a PolynomialOverP<T> where
    T: Clone,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the - operator.

pub fn neg(self) -> <&'a PolynomialOverP<T> as Neg>::Output

Performs the unary - operation.

impl<T> Neg for PolynomialOverP<T> where
    T: Clone + Neg<Output = T>, 

type Output = PolynomialOverP<T>

The resulting type after applying the - operator.

pub fn neg(self) -> <PolynomialOverP<T> as Neg>::Output

Performs the unary - operation.

impl<T> PartialEq<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &PolynomialOverP<T>) -> bool

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

pub fn ne(&self, other: &PolynomialOverP<T>) -> bool

This method tests for !=.

impl<'a, T> Rem<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    other: &PolynomialOverP<T>
) -> <PolynomialOverP<T> as Rem<&'a PolynomialOverP<T>>>::Output

Performs the % operation.

impl<'a, T> Rem<&'a PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    other: &'a PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Rem<&'a PolynomialOverP<T>>>::Output

Performs the % operation.

impl<T> Rem<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    other: PolynomialOverP<T>
) -> <PolynomialOverP<T> as Rem<PolynomialOverP<T>>>::Output

Performs the % operation.

impl<'a, T> Rem<PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    other: PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Rem<PolynomialOverP<T>>>::Output

Performs the % operation.

impl<'a, T> RemAssign<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

pub fn rem_assign(&mut self, other: &PolynomialOverP<T>)

Performs the %= operation.

impl<'a, T> RemAssign<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Clone + Ord + Eq + Zero + One + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>,
    &'x T: for<'x> Neg,
    <&'x T as Neg>::Output == T, 

pub fn rem_assign(&mut self, other: PolynomialOverP<T>)

Performs the %= operation.

impl<T> RingNormalize for PolynomialOverP<T> where
    T: Clone + Eq + Zero + One + RingNormalize,
    &'x T: for<'x> EuclideanRingOperation<T>, 

pub fn leading_unit(&self) -> PolynomialOverP<T>

pub fn normalize_mut(&mut self)

fn into_normalize(self) -> Self

fn normalize(&self) -> Self where
    Self: Clone, 

fn is_similar(&self, other: &Self) -> bool where
    Self: Clone + Eq, 

impl<'a, T> Sub<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Sub<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Sub<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    other: &PolynomialOverP<T>
) -> <PolynomialOverP<T> as Sub<&'a PolynomialOverP<T>>>::Output

Performs the - operation.

impl<'a, T> Sub<&'a PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Sub<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Sub<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    other: &'a PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Sub<&'a PolynomialOverP<T>>>::Output

Performs the - operation.

impl<'a, T> Sub<PolynomialOverP<T>> for &'a PolynomialOverP<T> where
    T: Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Sub<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Sub<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    other: PolynomialOverP<T>
) -> <&'a PolynomialOverP<T> as Sub<PolynomialOverP<T>>>::Output

Performs the - operation.

impl<T> Sub<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Sub<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Sub<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

type Output = PolynomialOverP<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    other: PolynomialOverP<T>
) -> <PolynomialOverP<T> as Sub<PolynomialOverP<T>>>::Output

Performs the - operation.

impl<'a, T> SubAssign<&'a PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Sub<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Sub<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

pub fn sub_assign(&mut self, other: &PolynomialOverP<T>)

Performs the -= operation.

impl<T> SubAssign<PolynomialOverP<T>> for PolynomialOverP<T> where
    T: Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T> + Clone,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Sub<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Sub<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

pub fn sub_assign(&mut self, other: PolynomialOverP<T>)

Performs the -= operation.

impl<T> Zero for PolynomialOverP<T> where
    T: Clone + Ord + Zero + for<'x> AddAssign<&'x T> + for<'x> SubAssign<&'x T>,
    &'x T: for<'x> Add<&'x T>,
    &'x T: for<'x> Neg,
    <&'x T as Add<&'x T>>::Output == T,
    <&'x T as Neg>::Output == T, 

pub fn zero() -> PolynomialOverP<T>

Returns the additive identity element of Self, 0.

pub fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

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

impl<T> Eq for PolynomialOverP<T> where
    T: Eq, 

impl<T> StructuralEq for PolynomialOverP<T>

impl<T> StructuralPartialEq for PolynomialOverP<T>