Struct polynomial_ring::Polynomial

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

Polynomial ring $R[x]$

use num::Rational64;
use polynomial_ring::Polynomial;
let p = Polynomial::new(vec![3, 1, 4, 1, 5].into_iter().map(|x| Rational64::from_integer(x)).collect());
let q = Polynomial::new(vec![2, 7, 1].into_iter().map(|x| Rational64::from_integer(x)).collect());
let mut r = p.clone();
let d = r.division(&q);
assert_eq!(p, d * q + 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]);

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 p = Polynomial::new(vec![3, 1, 4, 1, 5].into_iter().map(|x| Rational64::from_integer(x)).collect());
let q = Polynomial::new(vec![2, 7, 1].into_iter().map(|x| Rational64::from_integer(x)).collect());
let mut r = p.clone();
let d = r.division(&q);
assert_eq!(p, d * q + 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>, 

square free

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>