Struct Combination

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

A formal linear combination.

This data structure is for linear combinations of indeterminates/variables (Var) with coefficients (Coef) valued in a rig or at minimum in an additive monoid. For example, the coefficients could be natural numbers, integers, real numbers, or nonnegative real numbers.

Linear combinations are the data structure for free modules. That is, for any rig R, the free R-module on a set consists of formal R-linear combinations on elements of the set.

Combinations have exactly the same underlying data structure as monomials, but are written additively rather than multiplicatively.

Implementations

impl<Var, Coef> Combination<Var, Coef>

where Var: Ord,

pub fn generator(var: Var) -> Self

where Coef: One,

Constructs the generating combination corresponding to a variable.

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

Iterates over the variables used in the combination.

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

where F: FnMut(Coef) -> NewCoef,

Maps the coefficients in the combination.

In the usual situation when the coefficients form rigs and the mapping is a rig homomorphism, this operation is extension of scalars applied to free modules.

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

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

Evaluates the combination by substituting for the variables.

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

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

Evaluates the combination 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 combination.

Trait Implementations

impl<Var, Coef> Add for Combination<Var, Coef>

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

type Output = Combination<Var, Coef>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Var, Coef> AddAssign<(Coef, Var)> for Combination<Var, Coef>

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

fn add_assign(&mut self, rhs: (Coef, Var))

Performs the += operation.

impl<Var, Coef> AddAssign for Combination<Var, Coef>

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<Var: Clone, Coef: Clone> Clone for Combination<Var, Coef>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Var, Coef> Default for Combination<Var, Coef>

fn default() -> Self

Returns the “default value” for a type.

impl<Var, Coef> Display for Combination<Var, Coef>

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

Pretty print the combination using ASCII.

Intended for debugging/testing rather than any serious use.

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

Formats the value using the given formatter.

impl<Var, Coef> FromIterator<(Coef, Var)> for Combination<Var, Coef>

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

Constructs a combination from a list of terms (coefficient-variable pairs).

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

Creates a value from an iterator.

impl<'a, Var, Coef> IntoIterator for &'a Combination<Var, Coef>

type Item = (&'a Coef, &'a Var)

The type of the elements being iterated over.

type IntoIter = Map<Iter<'a, Var, Coef>, fn(_: (&'a Var, &'a Coef)) -> (&'a Coef, &'a Var)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Var, Coef> IntoIterator for Combination<Var, Coef>

Iterates over the terms (coefficient-variable pairs) of the polynomial.

type Item = (Coef, Var)

The type of the elements being iterated over.

type IntoIter = Map<IntoIter<Var, Coef>, fn(_: (Var, Coef)) -> (Coef, Var)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Var, Coef> Module for Combination<Var, Coef>

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

type Ring = Coef

Base ring for the module.

impl<Var, Coef> Mul<Coef> for Combination<Var, Coef>

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

type Output = Combination<Var, Coef>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Var, Coef> Neg for Combination<Var, Coef>

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

type Output = Combination<Var, Coef>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<Var: PartialEq, Coef: PartialEq> PartialEq for Combination<Var, Coef>

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

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

type Rig = Coef

Base rig for the module.

impl<Var, Coef> Zero for Combination<Var, Coef>

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

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

where Var: Ord, Coef: Default + AbGroup,

impl<Var, Coef> AdditiveMonoid for Combination<Var, Coef>

where Var: Ord, Coef: AdditiveMonoid,

impl<Var: Eq, Coef: Eq> Eq for Combination<Var, Coef>

impl<Var, Coef> StructuralPartialEq for Combination<Var, Coef>