Struct MultivariatePolyRingImplBase 

pub struct MultivariatePolyRingImplBase<R, A = Global>
where
    R: RingStore,
    A: Clone + Allocator + Send,
{ /* private fields */ }

Implementation of multivariate polynomial rings.

Implementations

impl<R, A> MultivariatePolyRingImplBase<R, A>

where R: RingStore, A: Clone + Allocator + Send,

pub fn allocator(&self) -> &A

Available on crate feature unstable-enable only.

Availability

This API is marked as unstable and is only available when the unstable-enable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

Trait Implementations

impl<P, R, A> CanHomFrom<P> for MultivariatePolyRingImplBase<R, A>

where R: RingStore, A: Clone + Allocator + Send, P: MultivariatePolyRing, R::Type: CanHomFrom<<P::BaseRing as RingStore>::Type>,

type Homomorphism = <<R as RingStore>::Type as CanHomFrom<<<P as RingExtension>::BaseRing as RingStore>::Type>>::Homomorphism

Data required to compute the action of the canonical homomorphism on ring elements.

fn has_canonical_hom(&self, from: &P) -> Option<Self::Homomorphism>

If there is a canonical homomorphism from -> self, returns Some(data), where data is additional data that can be used to compute the action of the homomorphism on ring elements. Otherwise, None is returned.

fn map_in( &self, from: &P, el: <P as RingBase>::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

fn map_in_ref( &self, from: &P, el: &<P as RingBase>::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism, taking the element by reference.

fn mul_assign_map_in( &self, from: &S, lhs: &mut Self::Element, rhs: S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

fn mul_assign_map_in_ref( &self, from: &S, lhs: &mut Self::Element, rhs: &S::Element, hom: &Self::Homomorphism, )

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

Fused-multiply-add. Computes summand + lhs * rhs, where rhs is mapped into the ring via the homomorphism.

impl<P, R, A> CanIsoFromTo<P> for MultivariatePolyRingImplBase<R, A>

where R: RingStore, A: Clone + Allocator + Send, P: MultivariatePolyRing, R::Type: CanIsoFromTo<<P::BaseRing as RingStore>::Type>,

type Isomorphism = <<R as RingStore>::Type as CanIsoFromTo<<<P as RingExtension>::BaseRing as RingStore>::Type>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso(&self, from: &P) -> Option<Self::Isomorphism>

If there is a canonical homomorphism from -> self, and this homomorphism is an isomorphism, returns Some(data), where data is additional data that can be used to compute preimages under the homomorphism. Otherwise, None is returned.

fn map_out( &self, from: &P, el: Self::Element, iso: &Self::Isomorphism, ) -> <P as RingBase>::Element

Computes the preimage of el under the canonical homomorphism from -> self.

impl<R, A> Debug for MultivariatePolyRingImplBase<R, A>

where R: RingStore, R::Type: Debug, A: Clone + Allocator + Send,

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

Formats the value using the given formatter.

impl<R, A> MultivariatePolyRing for MultivariatePolyRingImplBase<R, A>

where R: RingStore, A: Clone + Allocator + Send,

type Monomial = MonomialIdentifier

type TermIter<'a> = TermIterImpl<'a, R> where Self: 'a

fn indeterminate_count(&self) -> usize

Returns the number of variables of this polynomial ring, i.e. the transcendence degree of the base ring.

fn create_monomial<I>(&self, exponents: I) -> Self::Monomial

where I: IntoIterator<Item = usize>, I::IntoIter: ExactSizeIterator,

Creates a monomial with the given exponents.

fn clone_monomial(&self, mon: &Self::Monomial) -> Self::Monomial

fn add_assign_from_terms<I>(&self, lhs: &mut Self::Element, terms: I)

where I: IntoIterator<Item = (El<Self::BaseRing>, Self::Monomial)>,

fn mul_assign_monomial(&self, f: &mut Self::Element, rhs: Self::Monomial)

Multiplies the given polynomial with the given monomial.

fn coefficient_at<'a>( &'a self, f: &'a Self::Element, m: &Self::Monomial, ) -> &'a El<Self::BaseRing>

Returns the coefficient corresponding to the given monomial in the given polynomial. If the polynomial does not contain a term with that monomial, zero is returned.

fn expand_monomial_to(&self, m: &Self::Monomial, out: &mut [usize])

Writes the powers of each variable in the given monomial into the given output slice.

fn exponent_at(&self, m: &Self::Monomial, var_index: usize) -> usize

Returns the power of the var_index-th variable in the given monomial. In other words, this maps X1^i1 ... Xm^im to i(var_index).

fn terms<'a>(&'a self, f: &'a Self::Element) -> Self::TermIter<'a>

Returns an iterator over all nonzero terms of the given polynomial.

fn monomial_deg(&self, mon: &Self::Monomial) -> usize

Returns the degree of a monomial, i.e. the sum of the exponents of all variables.

fn LT<'a, O: MonomialOrder>( &'a self, f: &'a Self::Element, order: O, ) -> Option<(&'a El<Self::BaseRing>, &'a Self::Monomial)>

Returns the Leading Term of f, i.e. the term whose monomial is largest w.r.t. the given order.

fn largest_term_lt<'a, O: MonomialOrder>( &'a self, f: &'a Self::Element, order: O, lt_than: &Self::Monomial, ) -> Option<(&'a El<Self::BaseRing>, &'a Self::Monomial)>

Returns the term of f whose monomial is largest (w.r.t. the given order) among all monomials smaller than lt_than.

fn monomial_mul( &self, lhs: Self::Monomial, rhs: &Self::Monomial, ) -> Self::Monomial

Multiplies two monomials.

fn monomial_lcm( &self, lhs: Self::Monomial, rhs: &Self::Monomial, ) -> Self::Monomial

Returns the least common multiple of two monomials.

fn monomial_div( &self, lhs: Self::Monomial, rhs: &Self::Monomial, ) -> Result<Self::Monomial, Self::Monomial>

Computes the quotient of two monomials.

fn evaluate<S, V, H>(&self, f: &Self::Element, values: V, hom: H) -> S::Element

where S: ?Sized + RingBase, H: Homomorphism<<Self::BaseRing as RingStore>::Type, S>, V: VectorFn<S::Element>,

Evaluates the given polynomial at the given values.

fn indeterminate(&self, i: usize) -> Self::Monomial

Returns the monomial Xi, where Xi is the i-th generator of this ring.

fn create_term( &self, coeff: El<Self::BaseRing>, monomial: Self::Monomial, ) -> Self::Element

Creates a new single-term polynomial.

fn map_terms<P, H>(&self, from: &P, el: &P::Element, hom: H) -> Self::Element

where P: ?Sized + MultivariatePolyRing, H: Homomorphism<<P::BaseRing as RingStore>::Type, <Self::BaseRing as RingStore>::Type>,

Applies the given homomorphism R -> S to each coefficient of the given polynomial in R[X1, ..., Xm] to produce a monomial in S[X1, ..., Xm].

fn appearing_indeterminates(&self, f: &Self::Element) -> Vec<(usize, usize)>

Returns a list of all variables appearing in the given polynomial. Associated with each variable is the highest degree in which it appears in some term.

fn specialize( &self, f: &Self::Element, var: usize, val: &Self::Element, ) -> Self::Element

Replaces the given indeterminate in the given polynomial by the value val.

impl<R, A> PartialEq for MultivariatePolyRingImplBase<R, A>

where R: RingStore, A: Clone + Allocator + Send,

fn eq(&self, other: &Self) -> 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<R, A> RingBase for MultivariatePolyRingImplBase<R, A>

where R: RingStore, A: Clone + Allocator + Send,

type Element = MultivariatePolyRingEl<R, A>

Type of elements of the ring

fn clone_el(&self, val: &Self::Element) -> Self::Element

fn add_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn add_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

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

fn sub_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn negate_inplace(&self, lhs: &mut Self::Element)

fn mul_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

fn mul_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn mul_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn zero(&self) -> Self::Element

fn from_int(&self, value: i32) -> Self::Element

fn eq_el(&self, lhs: &Self::Element, rhs: &Self::Element) -> bool

fn is_zero(&self, value: &Self::Element) -> bool

fn is_one(&self, value: &Self::Element) -> bool

fn is_neg_one(&self, value: &Self::Element) -> bool

fn is_commutative(&self) -> bool

Returns whether the ring is commutative, i.e. a * b = b * a for all elements a, b. Note that addition is assumed to be always commutative.

fn is_noetherian(&self) -> bool

Returns whether the ring is noetherian, i.e. every ideal is finitely generated.

fn dbg(&self, value: &Self::Element, out: &mut Formatter<'_>) -> Result

Writes a human-readable representation of value to out.

fn dbg_within<'a>( &self, value: &Self::Element, out: &mut Formatter<'a>, env: EnvBindingStrength, ) -> Result

Writes a human-readable representation of value to out, taking into account the possible context to place parenthesis as needed.

fn characteristic<I: IntegerRingStore + Copy>(&self, ZZ: I) -> Option<El<I>>

where I::Type: IntegerRing,

Returns the characteristic of this ring as an element of the given implementation of ZZ.

fn is_approximate(&self) -> bool

Returns whether this ring computes with approximations to elements. This would usually be the case for rings that are based on f32 or f64, to represent real or complex numbers.

fn one(&self) -> Self::Element

fn neg_one(&self) -> Self::Element

fn fma( &self, lhs: &Self::Element, rhs: &Self::Element, summand: Self::Element, ) -> Self::Element

Fused-multiply-add. This computes summand + lhs * rhs.

fn square(&self, value: &mut Self::Element)

fn negate(&self, value: Self::Element) -> Self::Element

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

fn mul_assign_int(&self, lhs: &mut Self::Element, rhs: i32)

fn mul_int(&self, lhs: Self::Element, rhs: i32) -> Self::Element

fn mul_int_ref(&self, lhs: &Self::Element, rhs: i32) -> Self::Element

fn fma_int( &self, lhs: &Self::Element, rhs: i32, summand: Self::Element, ) -> Self::Element

Fused-multiply-add with an integer. This computes summand + lhs * rhs.

fn sub_self_assign(&self, lhs: &mut Self::Element, rhs: Self::Element)

Computes lhs := rhs - lhs.

fn sub_self_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

Computes lhs := rhs - lhs.

fn add_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn add_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn add(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn sub_ref(&self, lhs: &Self::Element, rhs: &Self::Element) -> Self::Element

fn sub_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn sub_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn sub(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn mul_ref_fst(&self, lhs: &Self::Element, rhs: Self::Element) -> Self::Element

fn mul_ref_snd(&self, lhs: Self::Element, rhs: &Self::Element) -> Self::Element

fn mul(&self, lhs: Self::Element, rhs: Self::Element) -> Self::Element

fn pow_gen<R: RingStore>( &self, x: Self::Element, power: &El<R>, integers: R, ) -> Self::Element

where R::Type: IntegerRing,

Raises x to the power of an arbitrary, nonnegative integer given by a custom integer ring implementation.

fn sum<I>(&self, els: I) -> Self::Element

where I: IntoIterator<Item = Self::Element>,

Sums the elements given by the iterator.

fn prod<I>(&self, els: I) -> Self::Element

where I: IntoIterator<Item = Self::Element>,

Computes the product of the elements given by the iterator.

impl<R, A> RingExtension for MultivariatePolyRingImplBase<R, A>

where R: RingStore, A: Clone + Allocator + Send,

type BaseRing = R

Type of the base ring;

fn base_ring<'b>(&'b self) -> &'b Self::BaseRing

Returns a reference to the base ring.

fn from(&self, x: El<Self::BaseRing>) -> Self::Element

Maps an element of the base ring into this ring.

fn mul_assign_base(&self, lhs: &mut Self::Element, rhs: &El<Self::BaseRing>)

Computes lhs := lhs * rhs, where rhs is mapped into this ring via RingExtension::from_ref(). Note that this may be faster than self.mul_assign(lhs, self.from_ref(rhs)).

fn from_ref(&self, x: &El<Self::BaseRing>) -> Self::Element

Maps an element of the base ring (given as reference) into this ring.

fn fma_base( &self, lhs: &Self::Element, rhs: &El<Self::BaseRing>, summand: Self::Element, ) -> Self::Element

fn mul_assign_base_through_hom<S: ?Sized + RingBase, H: Homomorphism<S, <Self::BaseRing as RingStore>::Type>>( &self, lhs: &mut Self::Element, rhs: &S::Element, hom: H, )

Computes lhs := lhs * rhs, where rhs is mapped into this ring via the given homomorphism, followed by the inclusion (as specified by RingExtension::from_ref()).