Struct Lc 

pub struct Lc<X, R>
where
    X: LcKey,
    R: Ring,
    for<'x> &'x R: RingOps<R>,
{ /* private fields */ }

A linear combination Σ rᵢ · xᵢ with keys X: LcKey and coefficients in a ring R. Stored via a private LcData, which specializes the empty and single-term cases to avoid hashmap allocation.

Implementations

impl<X, R> Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

pub fn new() -> Self

pub fn nterms(&self) -> usize

pub fn any_term(&self) -> Option<(&X, &R)>

pub fn keys(&self) -> impl Iterator<Item = &X>

pub fn is_singleton(&self) -> bool

pub fn as_singleton(&self) -> Option<X>

pub fn coeff(&self, x: &X) -> &R

pub fn iter(&self) -> LcDataIter<'_, X, R>

pub fn map<Y, S, F>(self, f: F) -> Lc<Y, S>

where Y: LcKey, S: Ring, for<'x> &'x S: RingOps<S>, F: Fn(X, R) -> (Y, S),

pub fn map_coeffs<S, F>(self, f: F) -> Lc<X, S>

where S: Ring, for<'x> &'x S: RingOps<S>, F: Fn(R) -> S,

pub fn map_keys<Y, F>(self, f: F) -> Lc<Y, R>

where Y: LcKey, F: Fn(X) -> Y,

pub fn map_ref<Y, S, F>(&self, f: F) -> Lc<Y, S>

where Y: LcKey, S: Ring, for<'x> &'x S: RingOps<S>, F: Fn(&X, &R) -> (Y, S),

pub fn filter<F>(self, f: F) -> Self

where F: Fn(&X) -> bool,

pub fn filtered<F>(&self, f: F) -> Self

where F: Fn(&X) -> bool,

pub fn add_pairs<I>(&mut self, pairs: I)

where I: IntoIterator<Item = (X, R)>,

Add all pairs at once. Terms may cancel along the way, so the reduced form is restored once at the end — prefer this over repeated add_pair in a hot loop.

pub fn add_pairs_ref<'a, I>(&mut self, pairs: I)

where I: IntoIterator<Item = (&'a X, R)>, X: 'a,

Same, taking each key by reference — the coefficient is generally the cheaper of the two to clone (compare a Cob key in yui-kh), so it is passed by value.

pub fn add_pair(&mut self, rhs: (X, R))

pub fn add_pair_ref(&mut self, rhs: (&X, R))

pub fn apply<F, Y: LcKey>(&self, f: F) -> Lc<Y, R>

where F: Fn(&X) -> Lc<Y, R>,

pub fn apply_bilin<Y, Z, F>(&self, other: &Lc<Y, R>, x_map: F) -> Lc<Z, R>

where Y: LcKey, Z: LcKey, F: Fn(&X, &Y) -> Z,

pub fn sort_terms_by<F>(&self, cmp: F) -> impl Iterator<Item = (&X, &R)>

where F: Fn(&X, &X) -> Ordering,

pub fn to_string_by<F>(&self, cmp: F, descending: bool) -> String

where F: Fn(&X, &X) -> Ordering,

pub fn is_homogeneous<T, F>(&self, f: F) -> bool

where T: PartialEq, F: Fn(&X) -> T,

pub fn homogeneous_value<T, F>(&self, f: F) -> Option<T>

where T: PartialEq, F: Fn(&X) -> T,

Trait Implementations

impl<X, R> Add for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the + operator.

fn add(self, rhs: Lc<X, R>) -> Self::Output

Performs the + operation.

impl<X, R> Add<&Lc<X, R>> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Lc<X, R>) -> Self::Output

Performs the + operation.

impl<X, R> Add<&Lc<X, R>> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>, Lc<X, R>: Clone,

type Output = Lc<X, R>

The resulting type after applying the + operator.

fn add(self, rhs: &Lc<X, R>) -> Self::Output

Performs the + operation.

impl<X, R> Add<Lc<X, R>> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>, Lc<X, R>: Clone,

type Output = Lc<X, R>

The resulting type after applying the + operator.

fn add(self, rhs: Lc<X, R>) -> Self::Output

Performs the + operation.

impl<X, R> AddAssign for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<X, R> AddAssign<&Lc<X, R>> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

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

Performs the += operation.

impl<X, R> AddGrp for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

impl<X, R> AddGrpOps for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

impl<X, R> AddGrpOps<Lc<X, R>> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

impl<X, R> AddMon for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn sum<A, I>(itr: I) -> Self

where Self: AddAssign<A>, I: IntoIterator<Item = A>,

Sum an iterator into Self, folding with +=.

impl<X, R> AddMonOps for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

impl<X, R> AddMonOps<Lc<X, R>> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

impl<X, R> Clone for Lc<X, R>

where X: LcKey + Clone, R: Ring + Clone, for<'x> &'x R: RingOps<R>,

fn clone(&self) -> Lc<X, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X, R> Debug for Lc<X, R>

where X: LcKey + Debug, R: Ring + Debug, for<'x> &'x R: RingOps<R>,

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

Formats the value using the given formatter.

impl<X, R> Default for Lc<X, R>

where X: LcKey + Default, R: Ring + Default, for<'x> &'x R: RingOps<R>,

fn default() -> Lc<X, R>

Returns the “default value” for a type.

impl<X, R> Display for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

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

Formats the value using the given formatter.

impl<X, R> Eq for Lc<X, R>

where X: LcKey + Eq, R: Ring + Eq, for<'x> &'x R: RingOps<R>,

impl<X, R> From<(X, R)> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn from(value: (X, R)) -> Self

Converts to this type from the input type.

impl<X, R> From<HashMap<X, R>> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn from(value: HashMap<X, R>) -> Self

Converts to this type from the input type.

impl<X, R> From<Lc<X, R>> for PolyBase<X, R>

where X: Mono, R: Ring, for<'x> &'x R: RingOps<R>,

fn from(data: Lc<X, R>) -> Self

Converts to this type from the input type.

impl<X, R> From<PolyBase<X, R>> for Lc<X, R>

where X: Mono, R: Ring, for<'x> &'x R: RingOps<R>,

fn from(poly: PolyBase<X, R>) -> Self

Converts to this type from the input type.

impl<X, R> From<X> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn from(x: X) -> Self

Converts to this type from the input type.

impl<X, R> FromIterator<(X, R)> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn from_iter<T: IntoIterator<Item = (X, R)>>(iter: T) -> Self

Creates a value from an iterator.

impl<X, R> IntoIterator for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Item = (X, R)

The type of the elements being iterated over.

type IntoIter = LcDataIntoIter<X, R>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<X, R> MathType for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn math_symbol() -> String

impl<X, R> Mul for &Lc<X, R>

where X: LcMulKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<X, R> Mul for Lc<X, R>

where X: LcMulKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Lc<X, R>) -> Self::Output

Performs the * operation.

impl<X, R> Mul<&Lc<X, R>> for Lc<X, R>

where X: LcMulKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the * operator.

fn mul(self, rhs: &Lc<X, R>) -> Self::Output

Performs the * operation.

impl<X, R> Mul<&R> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>, Lc<X, R>: Clone,

type Output = Lc<X, R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<X, R> Mul<&R> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<X, R> Mul<Lc<X, R>> for &Lc<X, R>

where X: LcMulKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the * operator.

fn mul(self, rhs: Lc<X, R>) -> Self::Output

Performs the * operation.

impl<X, R> Mul<R> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>, Lc<X, R>: Clone,

type Output = Lc<X, R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<X, R> Mul<R> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<X, R> MulAssign for Lc<X, R>

where X: LcMulKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn mul_assign(&mut self, rhs: Lc<X, R>)

Performs the *= operation.

impl<X, R> MulAssign<&Lc<X, R>> for Lc<X, R>

where X: LcMulKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn mul_assign(&mut self, rhs: &Lc<X, R>)

Performs the *= operation.

impl<X, R> MulAssign<&R> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

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

Performs the *= operation.

impl<X, R> MulAssign<R> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn mul_assign(&mut self, rhs: R)

Performs the *= operation.

impl<X, R> Neg for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<X, R> Neg for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<X, R> PartialEq for Lc<X, R>

where X: LcKey + PartialEq, R: Ring + PartialEq, for<'x> &'x R: RingOps<R>,

fn eq(&self, other: &Lc<X, R>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<X, R> RMod for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type R = R

The scalar ring.

impl<X, R> RModOps<R, Lc<X, R>> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

impl<X, R> RModOps<R, Lc<X, R>> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

impl<X, R> StructuralPartialEq for Lc<X, R>

where X: LcKey + PartialEq, R: Ring + PartialEq, for<'x> &'x R: RingOps<R>,

impl<X, R> Sub for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Lc<X, R>) -> Self::Output

Performs the - operation.

impl<X, R> Sub<&Lc<X, R>> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

type Output = Lc<X, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Lc<X, R>) -> Self::Output

Performs the - operation.

impl<X, R> Sub<&Lc<X, R>> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>, Lc<X, R>: Clone,

type Output = Lc<X, R>

The resulting type after applying the - operator.

fn sub(self, rhs: &Lc<X, R>) -> Self::Output

Performs the - operation.

impl<X, R> Sub<Lc<X, R>> for &Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>, Lc<X, R>: Clone,

type Output = Lc<X, R>

The resulting type after applying the - operator.

fn sub(self, rhs: Lc<X, R>) -> Self::Output

Performs the - operation.

impl<X, R> SubAssign for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<X, R> SubAssign<&Lc<X, R>> for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

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

Performs the -= operation.

impl<X, R> Zero for Lc<X, R>

where X: LcKey, R: Ring, for<'x> &'x R: RingOps<R>,

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.