Struct Lc 

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

Implementations

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

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

pub fn new() -> Self

pub fn clean(&mut self)

pub fn nterms(&self) -> usize

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

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

pub fn is_gen(&self) -> bool

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

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

pub fn iter(&self) -> impl Iterator<Item = (&X, &R)>

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

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

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

where Y: Gen, 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 into_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_gens<Y, F>(&self, f: F) -> Lc<Y, R>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Trait Implementations

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

where X: Gen, 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: Gen, 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: Gen, 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 for Lc<X, R>

where X: Gen, 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> AddAssign<&Lc<X, R>> for Lc<X, R>

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

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

Performs the += operation.

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

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

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

Performs the += operation.

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

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

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

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

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

where X: Gen + 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: Gen + 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: Gen + 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: Gen, 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> Elem for Lc<X, R>

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

fn math_symbol() -> String

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

where X: Gen, 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: Gen, 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: Gen, 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: Gen, 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: Gen, R: Ring, for<'x> &'x R: RingOps<R>,

type Item = (X, R)

The type of the elements being iterated over.

type IntoIter = IntoIter<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> Mul<&Lc<X, R>> for Lc<X, R>

where X: Gen + Mul<Output = X>, 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: Gen, 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: Gen, 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: Gen + Mul<Output = X>, 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: Gen, 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: Gen, 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 for &Lc<X, R>

where X: Gen + Mul<Output = X>, 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: Gen + Mul<Output = X>, 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> MulAssign<&Lc<X, R>> for Lc<X, R>

where X: Gen + Mul<Output = X>, 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: Gen, 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: Gen, R: Ring, for<'x> &'x R: RingOps<R>,

fn mul_assign(&mut self, rhs: R)

Performs the *= operation.

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

where X: Gen + Mul<Output = X>, R: Ring, for<'x> &'x R: RingOps<R>,

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

Performs the *= operation.

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

where X: Gen, 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: Gen, 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: Gen + PartialEq, R: Ring + PartialEq, for<'x> &'x R: RingOps<R>,

fn eq(&self, other: &Lc<X, R>) -> 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<X, R> RMod for Lc<X, R>

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

type R = R

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

where X: Gen, 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: Gen, 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: Gen, 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 for Lc<X, R>

where X: Gen, 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> SubAssign<&Lc<X, R>> for Lc<X, R>

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

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

Performs the -= operation.

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

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

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

Performs the -= operation.

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

where X: Gen, 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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