Struct Monomial

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

A monomial in several variables.

This data structure is for monomials in several indeterminates/variables (Var), having exponents (Exp) valued in an additive monoid. Most standardly, the exponents will be natural numbers (say u32 or u64), in which case the monomials in a set of variables, under their usual multiplication, are the free commutative monoid on that set. Other types of coefficents are also allowed, such as negative integers as in Laurent polynomials, or real numbers as in S-systems.

The underlying data structure is a B-tree map from variables to exponents. Thus, the variable type is assumed to be ordered. Moreover, when the exponents are also ordered, as they almost always are, the monomials themselves become ordered under the lexicographic order. This is a valid monomial ordering as used in Groebner bases (IVA, Section 2.2).

Implementations

impl<Var, Exp> Monomial<Var, Exp>

where Var: Ord,

pub fn generator(var: Var) -> Self

where Exp: One,

Constructs the generating monomial corresponding to a variable.

pub fn variables(&self) -> impl ExactSizeIterator<Item = &Var>

Iterates over the variables used in the monomial.

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

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

Evaluates the monomial by substituting for the variables.

pub fn eval_with_order<A>(&self, values: impl IntoIterator<Item = A>) -> A

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

Evaluates the monomial by substituting from a sequence of values.

The order of the values should correspond to the order of the variables. Will panic if the number of values does not equal the length of the monomial.

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

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

Maps over the variables of the monomial.

The mapping need not be injective. This is conceptually equivalent to evaluating the monomial with a map that sends generators to generators.

Trait Implementations

impl<Var: Clone, Exp: Clone> Clone for Monomial<Var, Exp>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Var, Exp> Default for Monomial<Var, Exp>

fn default() -> Self

Returns the “default value” for a type.

impl<Var, Exp> Display for Monomial<Var, Exp>

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

Pretty print the monomial using ASCII.

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

Formats the value using the given formatter.

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

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

Constructs a monomial from a sequence of variable-exponent pairs.

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

Creates a value from an iterator.

impl<Var, Exp> Mul for Monomial<Var, Exp>

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

type Output = Monomial<Var, Exp>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Var, Exp> MulAssign<(Var, Exp)> for Monomial<Var, Exp>

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

fn mul_assign(&mut self, rhs: (Var, Exp))

Performs the *= operation.

impl<Var, Exp> MulAssign for Monomial<Var, Exp>

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

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<Var, Exp> One for Monomial<Var, Exp>

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

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

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

impl<Var: Ord, Exp: Ord> Ord for Monomial<Var, Exp>

fn cmp(&self, other: &Monomial<Var, Exp>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Var: PartialEq, Exp: PartialEq> PartialEq for Monomial<Var, Exp>

fn eq(&self, other: &Monomial<Var, 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: PartialOrd, Exp: PartialOrd> PartialOrd for Monomial<Var, Exp>

fn partial_cmp(&self, other: &Monomial<Var, Exp>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Var, Exp> Pow<Exp> for Monomial<Var, Exp>

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

type Output = Monomial<Var, Exp>

The result after applying the operator.

fn pow(self, a: Exp) -> Self::Output

Returns self to the power rhs.

impl<Var, Exp> CommMonoid for Monomial<Var, Exp>

where Var: Ord, Exp: AdditiveMonoid,

impl<Var: Eq, Exp: Eq> Eq for Monomial<Var, Exp>

impl<Var, Exp> Monoid for Monomial<Var, Exp>

where Var: Ord, Exp: AdditiveMonoid,

impl<Var, Exp> StructuralPartialEq for Monomial<Var, Exp>