Trait MultivariatePolyRing 

pub trait MultivariatePolyRing: RingExtension {
    type Monomial;
    type TermIter<'a>: Iterator<Item = (&'a El<Self::BaseRing>, &'a Self::Monomial)>
       where Self: 'a;

    // Required methods
    fn indeterminate_count(&self) -> usize;
    fn create_monomial<I>(&self, exponents: I) -> Self::Monomial
       where I: IntoIterator<Item = usize>,
             I::IntoIter: ExactSizeIterator;
    fn mul_assign_monomial(
        &self,
        f: &mut Self::Element,
        monomial: Self::Monomial,
    );
    fn coefficient_at<'a>(
        &'a self,
        f: &'a Self::Element,
        m: &Self::Monomial,
    ) -> &'a El<Self::BaseRing>;
    fn exponent_at(&self, m: &Self::Monomial, var_index: usize) -> usize;
    fn terms<'a>(&'a self, f: &'a Self::Element) -> Self::TermIter<'a>;

    // Provided methods
    fn indeterminate(&self, i: usize) -> Self::Monomial { ... }
    fn expand_monomial_to(&self, m: &Self::Monomial, out: &mut [usize]) { ... }
    fn create_term(
        &self,
        coeff: El<Self::BaseRing>,
        monomial: Self::Monomial,
    ) -> Self::Element { ... }
    fn LT<'a, O: MonomialOrder>(
        &'a self,
        f: &'a Self::Element,
        order: O,
    ) -> Option<(&'a El<Self::BaseRing>, &'a Self::Monomial)> { ... }
    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)> { ... }
    fn add_assign_from_terms<I>(&self, lhs: &mut Self::Element, rhs: I)
       where I: IntoIterator<Item = (El<Self::BaseRing>, Self::Monomial)> { ... }
    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> { ... }
    fn clone_monomial(&self, mon: &Self::Monomial) -> Self::Monomial { ... }
    fn appearing_indeterminates(&self, f: &Self::Element) -> Vec<(usize, usize)> { ... }
    fn monomial_mul(
        &self,
        lhs: Self::Monomial,
        rhs: &Self::Monomial,
    ) -> Self::Monomial { ... }
    fn monomial_deg(&self, mon: &Self::Monomial) -> usize { ... }
    fn monomial_lcm(
        &self,
        lhs: Self::Monomial,
        rhs: &Self::Monomial,
    ) -> Self::Monomial { ... }
    fn monomial_div(
        &self,
        lhs: Self::Monomial,
        rhs: &Self::Monomial,
    ) -> Result<Self::Monomial, Self::Monomial> { ... }
    fn evaluate<R, V, H>(
        &self,
        f: &Self::Element,
        value: V,
        hom: H,
    ) -> R::Element
       where R: ?Sized + RingBase,
             H: Homomorphism<<Self::BaseRing as RingStore>::Type, R>,
             V: VectorFn<R::Element> { ... }
    fn specialize(
        &self,
        f: &Self::Element,
        var: usize,
        val: &Self::Element,
    ) -> Self::Element { ... }
}

Trait for multivariate polynomial rings.

Required Associated Types

type Monomial

type TermIter<'a>: Iterator<Item = (&'a El<Self::BaseRing>, &'a Self::Monomial)> where Self: 'a

Required Methods

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.

Note that when building a polynomial, the most convenient method is usually to use MultivariatePolyRingStore::with_wrapped_indeterminates().

Example

let poly_ring = MultivariatePolyRingImpl::new(StaticRing::<i64>::RING, 3);
let x_as_monomial = poly_ring.create_monomial([1, 0, 0]);
let x_as_poly = poly_ring.create_term(1, x_as_monomial);
assert_eq!("X0", format!("{}", poly_ring.format(&x_as_poly)));

fn mul_assign_monomial(&self, f: &mut Self::Element, monomial: 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 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.

Provided Methods

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

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

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.

This is equivalent to performing out[i] = self.exponent_at(m, i) for every i in 0..self.indeterminate_count().

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

Creates a new single-term polynomial.

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 add_assign_from_terms<I>(&self, lhs: &mut Self::Element, rhs: I)

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

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 clone_monomial(&self, mon: &Self::Monomial) -> Self::Monomial

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.

Example

let poly_ring = MultivariatePolyRingImpl::new(StaticRing::<i64>::RING, 2);
let [f, g] =
    poly_ring.with_wrapped_indeterminates(|[X, Y]| [1 + X + X.pow_ref(2) * Y, X.pow_ref(3)]);
assert_eq!(vec![(0, 2), (1, 1)], poly_ring.appearing_indeterminates(&f));
assert_eq!(vec![(0, 3)], poly_ring.appearing_indeterminates(&g));

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

Multiplies two monomials.

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 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.

If lhs does not divide rhs, this returns Result::Err with the monomial lhs / gcd(rhs, lhs).

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

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

Evaluates the given polynomial at the given values.

Example

let poly_ring = MultivariatePolyRingImpl::new(StaticRing::<i64>::RING, 2);
let [f] = poly_ring.with_wrapped_indeterminates(|[X, Y]| [1 + X + X.pow_ref(2) * Y]);
assert_eq!(
    1 + 5 + 5 * 5 * 8,
    poly_ring.evaluate(
        &f,
        [5, 8].clone_ring_els(StaticRing::<i64>::RING),
        &poly_ring.base_ring().identity()
    )
);

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.

Conceptually, this is similar to MultivariatePolyRing::evaluate(), but less general, which can allow a faster implementation sometimes. In particular, this only replaces a single indeterminate, and does not change the ring.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

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