Struct polynomial_ring::Polynomial

pub struct Polynomial<T> { /* private fields */ }

Polynomial ring $R[x]$

use num::Rational64;
use polynomial_ring::Polynomial;
let f = Polynomial::new(vec![3, 1, 4, 1, 5].into_iter().map(|x| Rational64::from_integer(x)).collect());
let g = Polynomial::new(vec![2, 7, 1].into_iter().map(|x| Rational64::from_integer(x)).collect());
let mut r = f.clone();
let q = r.division(&g);
assert_eq!(f, q * g + r);

Implementations

impl<T: Sized> Polynomial<T>

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

degree of polynomial

use polynomial_ring::Polynomial;
let p = Polynomial::new(vec![3, 2, 1]); // 3+2x+x^2
assert_eq!(p.deg(), Some(2));
let q = Polynomial::new(vec![0]); // 0
assert_eq!(q.deg(), None);

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

leading coefficent

use polynomial_ring::Polynomial;
let p = Polynomial::new(vec![3, 2, 1]); // 3+2x+x^2
assert_eq!(p.lc(), Some(&1));
let q = Polynomial::new(vec![0]); // 0
assert_eq!(q.lc(), None);

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

get coefficents

use polynomial_ring::Polynomial;
let p = Polynomial::new(vec![3, 2, 1]); // 3+2x+x^2
assert_eq!(p.coefs(), vec![3, 2, 1]);
let q = Polynomial::new(vec![0]); // 0
assert_eq!(q.coefs(), vec![]);

impl<M: Sized + Zero> Polynomial<M>

pub fn new(coef: Vec<M>) -> Self

construct polynomial

use polynomial_ring::Polynomial;
let p = Polynomial::new(vec![3, 2, 1]);
assert_eq!(p.to_string(), "x^2+2*x+3");

pub fn from_monomial(coefficent: M, degree: usize) -> Self

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

use polynomial_ring::Polynomial;
let p = Polynomial::from_monomial(3, 2);
let q = Polynomial::new(vec![0, 0, 3]);
assert_eq!(p, q);

impl<R: Sized> Polynomial<R>

pub fn eval<'a>(&self, x: &'a R) -> R where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R> + MulAssign<&'a R>, 

evaluate polynomial by Horner’s method

use polynomial_ring::Polynomial;
let p = Polynomial::new(vec![3, 2, 1]); // 3+2x+x^2
assert_eq!(p.eval(&1), 6);
assert_eq!(p.eval(&2), 11);

pub fn derivative(self) -> Self where
    R: Sized + Clone + Zero + One + for<'x> AddAssign<&'x R> + Mul<Output = R>,
    for<'x> &'x R: Mul<Output = R>, 

derivative

use polynomial_ring::{Polynomial, polynomial};
let p = polynomial![1, 2, 3, 2, 1]; // 1+2x+3x^2+2x^3+x^4
assert_eq!(p.derivative(), polynomial![2, 6, 6, 4]);

pub fn pseudo_division(&mut self, other: &Self) -> (R, Self) where
    R: Sized + Clone + Zero + One + for<'x> AddAssign<&'x R> + for<'x> MulAssign<&'x R>,
    for<'x> &'x R: Sub<Output = R> + Mul<Output = R>, 

pseudo division

Let $R$ be an integral domain. Let $f, g \in R[x]$, where $g \neq 0$. This function calculate $s \in R$, $q, r \in R[x]$ s.t. $sf=qg+r$, where $r=0$ or $\deg(r)<\deg(g)$.

use polynomial_ring::{polynomial, Polynomial};
let f = polynomial![1, 3, 1]; // 1+3x+x^2 ∈ Z[x]
let g = polynomial![5, 2]; // 5+2x ∈ Z[x]
let mut r = f.clone();
let (s, q) = r.pseudo_division(&g);
assert_eq!(f * s, q * g + r);
let f = polynomial![1, -1, -1, 1]; // 1-x-x^2+x^3 ∈ Z[x]
let g = polynomial![1, 2]; // 1+2x ∈ Z[x]
let mut r = f.clone();
let (s, q) = r.pseudo_division(&g);
assert_eq!(polynomial![s] * f, q * g + r);
// 1-yx-x^2+yx^3 ∈ Z[y][x]
let f = polynomial![polynomial![1], polynomial![0, -1], polynomial![-1], polynomial![0, 1]];
// -1+y^2x ∈ Z[y][x]
let g = polynomial![polynomial![-1], polynomial![0, 0, 1]];
let mut r = f.clone();
let (s, q) = r.pseudo_division(&g);
assert_eq!(f * s, q * g + r);
// x^3 ∈ Z[y][x]
let f = polynomial![polynomial![], polynomial![], polynomial![], polynomial![1]];
// yx ∈ Z[y][x]
let g = polynomial![polynomial![], polynomial![0, 1]];
let mut r = f.clone();
let (s, q) = r.pseudo_division(&g);
assert_eq!(f * s, q * g + r);

pub fn resultant(self, other: Self) -> R where
    R: Sized + Clone + Zero + One + for<'x> AddAssign<&'x R> + for<'x> MulAssign<&'x R> + Neg<Output = R>,
    for<'x> &'x R: Sub<Output = R> + Mul<Output = R> + Div<Output = R>, 

calculate resultant

use polynomial_ring::{polynomial, Polynomial};
use num_traits::{One, Zero};
let f = polynomial![0, 2, 0, 1]; // 2x+x^3 ∈ Z[x]
let g = polynomial![2, 3, 5]; // 2+3x+5x^2 ∈ Z[x]
let r = f.resultant(g);
assert_eq!(r, 164);
let f = polynomial![-4, 0, 0, 0, 1]; // -4+x^4 ∈ Z[x]
let g = polynomial![0, 2, 0, 1]; // 2x+x^3 ∈ Z[x]
let r = f.resultant(g); // deg(gcd(f, g)) = deg(x^2-2) = 2 ≠ 0
assert_eq!(r, 0);
let f = polynomial![polynomial![1], polynomial![0], polynomial![1]]; // 1+x^2 ∈ Z[y][x]
let g = polynomial![polynomial![1], polynomial![1, 2]]; // 1+(1+2y)x ∈ Z[y][x]
let r = f.resultant(g);
assert_eq!(r, polynomial![2, 4, 4]); // 2+4y+4y^2
let y3 = Polynomial::from_monomial(polynomial![-1], 3); // -y^3 ∈ Z[x][y]
let y2xy = Polynomial::from_monomial(polynomial![0, -1], 2) + &y3; // -xy^2-y^3 ∈ Z[x][y]
let x = polynomial![polynomial![0, 1]]; // x ∈ Z[x][y]
let f = polynomial![y3, polynomial![], x.clone()]; // -y^3+xz^2 ∈ Z[x][y][z]
let g = polynomial![y2xy, polynomial![], x]; // -xy^2-y^3+xz^2 ∈ Z[x][y][z]
let r = f.resultant(g);
assert_eq!(r, Polynomial::from_monomial(Polynomial::from_monomial(1, 4), 4)); // x^4y^4

pub fn primitive_part_mut(&mut self) where
    R: Sized + Clone + Zero + for<'x> DivAssign<&'x R> + RingNormalize,
    for<'x> &'x R: Rem<Output = R>, 

calculate primitive part of input polynomial

divide polynomial by GCD of coefficents.

use polynomial_ring::{polynomial, Polynomial};
use num_traits::{One, Zero};
let mut f = polynomial![2, 4, -2, 6]; // 2+4x+2x^2+6x^3 ∈ Z[x]
f.primitive_part_mut();
assert_eq!(f, polynomial![1, 2, -1, 3]);// 1+2x+x^2+3x^3 ∈ Z[x]
let mut g = polynomial![polynomial![1, 1], polynomial![1, 2, 1], polynomial![3, 4, 1], polynomial![-1, -1]]; // (1+x)+(1+2x+x^2)y+(3+4x+x^2)y^2+(-1-x)y^3 ∈ Z[x][y]
g.primitive_part_mut();
assert_eq!(g, polynomial![polynomial![1], polynomial![1, 1], polynomial![3, 1], polynomial![-1]]); // 1+(1+x)y+(3+x)y^2-y^3 ∈ Z[x][y]

impl<K: Sized> Polynomial<K>

pub fn monic(&mut self) where
    K: Clone + for<'x> DivAssign<&'x K>, 

make polynomial monic

use num::Rational64;
use polynomial_ring::Polynomial;
let mut p = Polynomial::new(vec![1, 2, 3].into_iter().map(|x| Rational64::from_integer(x)).collect());
p.monic();
let q = Polynomial::new(vec![(1, 3), (2, 3), (1, 1)].into_iter().map(|(n, d)| Rational64::new(n, d)).collect());
assert_eq!(p, q);

pub fn division(&mut self, other: &Self) -> Self where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

polynomial division

use num::Rational64;
use polynomial_ring::Polynomial;
let f = Polynomial::new(vec![3, 1, 4, 1, 5].into_iter().map(|x| Rational64::from_integer(x)).collect());
let g = Polynomial::new(vec![2, 7, 1].into_iter().map(|x| Rational64::from_integer(x)).collect());
let mut r = f.clone();
let q = r.division(&g);
assert_eq!(f, q * g + r);

pub fn square_free(&self) -> Self where
    K: Sized + Clone + Zero + One + Mul<Output = K> + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K> + for<'x> DivAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

calculate square-free polynomial

use polynomial_ring::{Polynomial, polynomial};
use num::Rational64;
let f = polynomial![Rational64::from(1), Rational64::from(1)];
let g = polynomial![Rational64::from(1), Rational64::from(1), Rational64::from(1)];
let p = &f * &f * &f * &g * &g; // (x+1)^3(x^2+x+1)^2
assert_eq!(p.square_free(), &f * &g); // (x+1)(x^2+x+1)

Trait Implementations

impl<'a, M> Add<&'a Polynomial<M>> for &'a Polynomial<M> where
    M: Sized + Clone + Zero + for<'x> AddAssign<&'x M>, 

type Output = Polynomial<M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, M> Add<&'a Polynomial<M>> for Polynomial<M> where
    M: Sized + Clone + Zero + for<'x> AddAssign<&'x M>, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: &Self) -> Self::Output

Performs the + operation.

impl<'a, M> Add<Polynomial<M>> for &'a Polynomial<M> where
    M: Sized + Clone + Zero + for<'x> AddAssign<&'x M>, 

type Output = Polynomial<M>

The resulting type after applying the + operator.

fn add(self, other: Polynomial<M>) -> Self::Output

Performs the + operation.

impl<M> Add<Polynomial<M>> for Polynomial<M> where
    M: Sized + Clone + Zero + for<'x> AddAssign<&'x M>, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: Polynomial<M>) -> Self::Output

Performs the + operation.

impl<'a, M> AddAssign<&'a Polynomial<M>> for Polynomial<M> where
    M: Sized + Clone + Zero + for<'x> AddAssign<&'x M>, 

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

Performs the += operation.

impl<M> AddAssign<Polynomial<M>> for Polynomial<M> where
    M: Sized + Clone + Zero + for<'x> AddAssign<&'x M>, 

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Clone> Clone for Polynomial<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Polynomial<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Polynomial<T>

fn default() -> Polynomial<T>

Returns the “default value” for a type.

impl<R> Display for Polynomial<R> where
    R: Eq + Display + Zero + One, 

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

Formats the value using the given formatter.

impl<'a, K> Div<&'a Polynomial<K>> for &'a Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

type Output = Polynomial<K>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self::Output

Performs the / operation.

impl<'a, K> Div<&'a Polynomial<K>> for Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: &Self) -> Self::Output

Performs the / operation.

impl<'a, R> Div<&'a R> for &'a Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> DivAssign<&'x R>, 

type Output = Polynomial<R>

The resulting type after applying the / operator.

fn div(self, other: &R) -> Self::Output

Performs the / operation.

impl<'a, R> Div<&'a R> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> DivAssign<&'x R>, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: &R) -> Self::Output

Performs the / operation.

impl<'a, K> Div<Polynomial<K>> for &'a Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

type Output = Polynomial<K>

The resulting type after applying the / operator.

fn div(self, other: Polynomial<K>) -> Self::Output

Performs the / operation.

impl<K> Div<Polynomial<K>> for Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self::Output

Performs the / operation.

impl<'a, R> Div<R> for &'a Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> DivAssign<&'x R>, 

type Output = Polynomial<R>

The resulting type after applying the / operator.

fn div(self, other: R) -> Self::Output

Performs the / operation.

impl<R> Div<R> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> DivAssign<&'x R>, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: R) -> Self::Output

Performs the / operation.

impl<'a, K> DivAssign<&'a Polynomial<K>> for Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

fn div_assign(&mut self, other: &Self)

Performs the /= operation.

impl<'a, R> DivAssign<&'a R> for Polynomial<R> where
    R: Sized + Zero + for<'x> DivAssign<&'x R>, 

fn div_assign(&mut self, other: &R)

Performs the /= operation.

impl<K> DivAssign<Polynomial<K>> for Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<'a, R> DivAssign<R> for Polynomial<R> where
    R: Sized + Zero + for<'x> DivAssign<&'x R>, 

fn div_assign(&mut self, other: R)

Performs the /= operation.

impl<'a, R> Mul<&'a Polynomial<R>> for &'a Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R>,
    for<'x> &'x R: Mul<Output = R>, 

type Output = Polynomial<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, R> Mul<&'a Polynomial<R>> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R>,
    for<'x> &'x R: Mul<Output = R>, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: &Self) -> Self::Output

Performs the * operation.

impl<'a, R> Mul<&'a R> for &'a Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> MulAssign<&'x R>, 

type Output = Polynomial<R>

The resulting type after applying the * operator.

fn mul(self, other: &R) -> Self::Output

Performs the * operation.

impl<'a, R> Mul<&'a R> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> MulAssign<&'x R>, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: &R) -> Self::Output

Performs the * operation.

impl<'a, R> Mul<Polynomial<R>> for &'a Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R>,
    for<'x> &'x R: Mul<Output = R>, 

type Output = Polynomial<R>

The resulting type after applying the * operator.

fn mul(self, other: Polynomial<R>) -> Self::Output

Performs the * operation.

impl<R> Mul<Polynomial<R>> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R>,
    for<'x> &'x R: Mul<Output = R>, 

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, R> Mul<R> for &'a Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> MulAssign<&'x R>, 

type Output = Polynomial<R>

The resulting type after applying the * operator.

fn mul(self, other: R) -> Self::Output

Performs the * operation.

impl<R> Mul<R> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> MulAssign<&'x R>, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: R) -> Self::Output

Performs the * operation.

impl<'a, R> MulAssign<&'a Polynomial<R>> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R>,
    for<'x> &'x R: Mul<Output = R>, 

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

Performs the *= operation.

impl<'a, R> MulAssign<&'a R> for Polynomial<R> where
    R: Sized + Zero + for<'x> MulAssign<&'x R>, 

fn mul_assign(&mut self, other: &R)

Performs the *= operation.

impl<R> MulAssign<Polynomial<R>> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R>,
    for<'x> &'x R: Mul<Output = R>, 

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<'a, R> MulAssign<R> for Polynomial<R> where
    R: Sized + Zero + for<'x> MulAssign<&'x R>, 

fn mul_assign(&mut self, other: R)

Performs the *= operation.

impl<G> Neg for Polynomial<G> where
    G: Sized + Neg<Output = G>, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, G> Neg for &'a Polynomial<G> where
    G: Sized,
    for<'x> &'x G: Neg<Output = G>, 

type Output = Polynomial<G>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R> One for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R> + One,
    for<'x> &'x R: Mul<Output = R>, 

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool where
    Self: PartialEq<Self>, 

Returns true if self is equal to the multiplicative identity.

impl<T: PartialEq> PartialEq<Polynomial<T>> for Polynomial<T>

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

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

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

This method tests for !=.

impl<R> Product<Polynomial<R>> for Polynomial<R> where
    R: Sized + Clone + Zero + for<'x> AddAssign<&'x R> + One,
    for<'x> &'x R: Mul<Output = R>, 

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

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, K> Rem<&'a Polynomial<K>> for &'a Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

type Output = Polynomial<K>

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self::Output

Performs the % operation.

impl<'a, K> Rem<&'a Polynomial<K>> for Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, other: &Self) -> Self::Output

Performs the % operation.

impl<'a, K> Rem<Polynomial<K>> for &'a Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

type Output = Polynomial<K>

The resulting type after applying the % operator.

fn rem(self, other: Polynomial<K>) -> Self::Output

Performs the % operation.

impl<K> Rem<Polynomial<K>> for Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self::Output

Performs the % operation.

impl<'a, K> RemAssign<&'a Polynomial<K>> for Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

fn rem_assign(&mut self, other: &Self)

Performs the %= operation.

impl<'a, K> RemAssign<Polynomial<K>> for Polynomial<K> where
    K: Sized + Clone + Zero + for<'x> AddAssign<&'x K> + for<'x> SubAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K> + Div<Output = K>, 

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<K> RingNormalize for Polynomial<K> where
    K: Sized + Clone + Zero + One + for<'x> AddAssign<&'x K> + for<'x> DivAssign<&'x K>,
    for<'x> &'x K: Mul<Output = K>, 

fn leading_unit(&self) -> Self

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, G> Sub<&'a Polynomial<G>> for &'a Polynomial<G> where
    G: Sized + Clone + Zero + for<'x> SubAssign<&'x G>, 

type Output = Polynomial<G>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<'a, G> Sub<&'a Polynomial<G>> for Polynomial<G> where
    G: Sized + Clone + Zero + for<'x> SubAssign<&'x G>, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: &Self) -> Self::Output

Performs the - operation.

impl<'a, G> Sub<Polynomial<G>> for &'a Polynomial<G> where
    G: Sized + Clone + Zero + for<'x> SubAssign<&'x G>, 

type Output = Polynomial<G>

The resulting type after applying the - operator.

fn sub(self, other: Polynomial<G>) -> Self::Output

Performs the - operation.

impl<G> Sub<Polynomial<G>> for Polynomial<G> where
    G: Sized + Clone + Zero + for<'x> SubAssign<&'x G>, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: Polynomial<G>) -> Self::Output

Performs the - operation.

impl<'a, G> SubAssign<&'a Polynomial<G>> for Polynomial<G> where
    G: Sized + Clone + Zero + for<'x> SubAssign<&'x G>, 

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

Performs the -= operation.

impl<G> SubAssign<Polynomial<G>> for Polynomial<G> where
    G: Sized + Clone + Zero + for<'x> SubAssign<&'x G>, 

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<M> Sum<Polynomial<M>> for Polynomial<M> where
    M: Sized + Clone + Zero + for<'x> AddAssign<&'x M>, 

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

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<M> Zero for Polynomial<M> where
    M: Sized + Clone + Zero + for<'x> AddAssign<&'x M>, 

fn zero() -> Self

Returns the additive identity element of Self, 0.

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> Eq for Polynomial<T>

impl<T> StructuralEq for Polynomial<T>

impl<T> StructuralPartialEq for Polynomial<T>