Struct Polynomial

pub struct Polynomial<Var, Coef, Exp>(/* private fields */);

A polynomial in several variables.

This data structure is for polynomials in normal form: a polynomial is a formal linear combination of monomials in which no monomial is repeated, and no variable is repeated within any monomial. The implementation is indeed a Combination of a Monomials. The use of a normal form means that polynomial arithmetic automatically performs certain simplifications.

In abstract terms, polynomials with coefficients valued in a commutative ring R are the free commutative algebra over R.

Implementations

impl<Var, Coef, Exp> Polynomial<Var, Coef, Exp>

where Var: Ord, Exp: Ord,

pub fn generator(var: Var) -> Self

where Coef: One, Exp: One,

Constructs the generating polynomial corresponding to a variable.

pub fn from_monomial(m: Monomial<Var, Exp>) -> Self

where Coef: One,

Constructs the polynomial corresponding to a monomial.

pub fn monomials(&self) -> impl ExactSizeIterator<Item = &Monomial<Var, Exp>>

Iterates over the monomials in the polynomial.

pub fn extend_scalars<NewCoef, F>(self, f: F) -> Polynomial<Var, NewCoef, Exp>

where F: FnMut(Coef) -> NewCoef,

Maps the coefficients of the polynomial.

In the usual situations when the coefficients from commutative rigs and the mapping is a rig homomorphism, this operation is extension of scalars applied to free commutative algebras.

pub fn eval<A, F>(&self, f: F) -> A

where A: Clone + Mul<Coef, Output = A> + Pow<Exp, Output = A> + Sum + Product, F: Clone + FnMut(&Var) -> A, Coef: Clone, Exp: Clone,

Evaluates the polynomial by substituting for the variables.

pub fn eval_pairs<A>(&self, pairs: impl IntoIterator<Item = (Var, A)>) -> A

where A: Clone + Mul<Coef, Output = A> + Pow<Exp, Output = A> + Sum + Product, Coef: Clone, Exp: Clone,

Evaluates the polynomial on a sequence of variable-value pairs.

This is a convenient way to evaluate the polynomial at a single point but it is not very efficient.

pub fn map_variables<NewVar, F>(&self, f: F) -> Polynomial<NewVar, Coef, Exp>

where Coef: Clone + Add<Output = Coef>, Exp: Clone + Add<Output = Exp>, NewVar: Clone + Ord, F: FnMut(&Var) -> NewVar,

Maps over the variables in the polynomial.

The mapping need not be injective. This is conceptually equivalent to evaluating the polynomial with a map that sends generators to generators but avoids assuming that an arbitrary polynomial can be exponentiated, which is only makes sense when the exponents are nonnegative integers.

Trait Implementations

impl<Var, Coef, Exp> Add for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Add<Output = Coef>, Exp: Ord,

type Output = Polynomial<Var, Coef, Exp>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Var, Coef, Exp> AddAssign<(Coef, Monomial<Var, Exp>)> for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Add<Output = Coef>, Exp: Ord,

fn add_assign(&mut self, rhs: (Coef, Monomial<Var, Exp>))

Performs the += operation.

impl<Var: Clone, Coef: Clone, Exp: Clone> Clone for Polynomial<Var, Coef, Exp>

fn clone(&self) -> Polynomial<Var, Coef, Exp>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Var, Coef, Exp> CommAlg for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + Default + CommRing, Exp: Clone + Ord + AdditiveMonoid,

type R = Coef

The base ring of the algebra.

fn from_scalar(r: Self::R) -> Self

Convert an element of the base ring into an element of the algebra.

impl<Var, Coef, Exp> Default for Polynomial<Var, Coef, Exp>

fn default() -> Self

Returns the “default value” for a type.

impl<Var, Coef, Exp> Display for Polynomial<Var, Coef, Exp>

where Var: Display, Coef: Display + PartialEq + One, Exp: Display + PartialEq + One,

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

Formats the value using the given formatter.

impl<Var, Coef, Exp> FromIterator<(Coef, Monomial<Var, Exp>)> for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Add<Output = Coef>, Exp: Ord,

fn from_iter<T: IntoIterator<Item = (Coef, Monomial<Var, Exp>)>>( iter: T, ) -> Self

Creates a value from an iterator.

impl<Var, Coef, Exp> Module for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Clone + Default + CommRing, Exp: Ord,

type Ring = Coef

Base ring for the module.

impl<Var, Coef, Exp> Mul<Coef> for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Clone + Default + Mul<Output = Coef>, Exp: Ord,

type Output = Polynomial<Var, Coef, Exp>

The resulting type after applying the * operator.

fn mul(self, a: Coef) -> Self::Output

Performs the * operation.

impl<Var, Coef, Exp> Mul for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + Add<Output = Coef> + Mul<Output = Coef>, Exp: Clone + Ord + Add<Output = Exp>,

Multiply polynomials using the distributive law.

type Output = Polynomial<Var, Coef, Exp>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Var, Coef, Exp> Neg for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Default + Neg<Output = Coef>, Exp: Ord,

type Output = Polynomial<Var, Coef, Exp>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Var, Coef, Exp> One for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + Add<Output = Coef> + One, Exp: Clone + Ord + Add<Output = Exp>,

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,

Returns true if self is equal to the multiplicative identity.

impl<Var: PartialEq, Coef: PartialEq, Exp: PartialEq> PartialEq for Polynomial<Var, Coef, Exp>

fn eq(&self, other: &Polynomial<Var, Coef, Exp>) -> 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<Var, Coef, Exp> RigModule for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Clone + Default + CommRig, Exp: Ord,

type Rig = Coef

Base rig for the module.

impl<Var, Coef, Exp> Zero for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Add<Output = Coef>, Exp: Ord,

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<Var, Coef, Exp> AbGroup for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: Default + AbGroup, Exp: Ord,

impl<Var, Coef, Exp> AdditiveMonoid for Polynomial<Var, Coef, Exp>

where Var: Ord, Coef: AdditiveMonoid, Exp: Ord,

impl<Var, Coef, Exp> CommMonoid for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + CommRig, Exp: Clone + Ord + AdditiveMonoid,

impl<Var, Coef, Exp> CommRig for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + CommRig, Exp: Clone + Ord + AdditiveMonoid,

impl<Var, Coef, Exp> CommRing for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + Default + CommRing, Exp: Clone + Ord + AdditiveMonoid,

impl<Var: Eq, Coef: Eq, Exp: Eq> Eq for Polynomial<Var, Coef, Exp>

impl<Var, Coef, Exp> Monoid for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + Rig, Exp: Clone + Ord + AdditiveMonoid,

impl<Var, Coef, Exp> Rig for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + Rig, Exp: Clone + Ord + AdditiveMonoid,

impl<Var, Coef, Exp> Ring for Polynomial<Var, Coef, Exp>

where Var: Clone + Ord, Coef: Clone + Default + Ring, Exp: Clone + Ord + AdditiveMonoid,

impl<Var, Coef, Exp> StructuralPartialEq for Polynomial<Var, Coef, Exp>