Struct DensePolyRingBase 

pub struct DensePolyRingBase<R: RingStore, A: Allocator + Clone = Global, C: ConvolutionAlgorithm<R::Type> = KaratsubaAlgorithm<Global>> { /* private fields */ }

The univariate polynomial ring R[X]. Polynomials are stored as dense vectors of coefficients, allocated by the given memory provider.

If most of the coefficients will be zero, consider using sparse_poly::SparsePolyRingBase instead for improved performance.

Example

let ZZ = StaticRing::<i32>::RING;
let P = DensePolyRing::new(ZZ, "X");
let x_plus_1 = P.add(P.indeterminate(), P.int_hom().map(1));
let binomial_coefficients = P.pow(x_plus_1, 10);
assert_eq!(10 * 9 * 8 * 7 * 6 / 120, *P.coefficient_at(&binomial_coefficients, 5));

This ring has a CanIsoFromTo to sparse_poly::SparsePolyRingBase.

let ZZ = StaticRing::<i32>::RING;
let P = DensePolyRing::new(ZZ, "X");
let P2 = SparsePolyRing::new(ZZ, "X");
let high_power_of_x = P.pow(P.indeterminate(), 10);
assert_el_eq!(P2, P2.pow(P2.indeterminate(), 10), &P.can_iso(&P2).unwrap().map(high_power_of_x));

Implementations

impl<R: RingStore, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> DensePolyRingBase<R, A, C>

pub fn into_base_ring(self) -> R

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<R1, A1, R2, A2, C1, C2> CanHomFrom<DensePolyRingBase<R1, A1, C1>> for DensePolyRingBase<R2, A2, C2>

where R1: RingStore, A1: Allocator + Clone, C1: ConvolutionAlgorithm<R1::Type>, R2: RingStore, A2: Allocator + Clone, C2: ConvolutionAlgorithm<R2::Type>, R2::Type: CanHomFrom<R1::Type>,

type Homomorphism = <<R2 as RingStore>::Type as CanHomFrom<<R1 as RingStore>::Type>>::Homomorphism

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

fn has_canonical_hom( &self, from: &DensePolyRingBase<R1, A1, C1>, ) -> 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_ref( &self, from: &DensePolyRingBase<R1, A1, C1>, el: &DensePolyRingEl<R1, A1>, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism, taking the element by reference.

fn map_in( &self, from: &DensePolyRingBase<R1, A1, C1>, el: DensePolyRingEl<R1, A1>, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

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<R, P, A, C> CanHomFrom<P> for DensePolyRingBase<R, A, C>

where R: RingStore, R::Type: CanHomFrom<<P::BaseRing as RingStore>::Type>, P: ImplGenericCanIsoFromToMarker, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>,

type Homomorphism = <<<DensePolyRingBase<R, A, C> as RingExtension>::BaseRing 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::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

fn map_in_ref( &self, from: &S, el: &S::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<R1, A1, R2, A2, C1, C2> CanIsoFromTo<DensePolyRingBase<R1, A1, C1>> for DensePolyRingBase<R2, A2, C2>

where R1: RingStore, A1: Allocator + Clone, C1: ConvolutionAlgorithm<R1::Type>, R2: RingStore, A2: Allocator + Clone, C2: ConvolutionAlgorithm<R2::Type>, R2::Type: CanIsoFromTo<R1::Type>,

type Isomorphism = <<R2 as RingStore>::Type as CanIsoFromTo<<R1 as RingStore>::Type>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso( &self, from: &DensePolyRingBase<R1, A1, C1>, ) -> 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: &DensePolyRingBase<R1, A1, C1>, el: DensePolyRingEl<R2, A2>, hom: &Self::Isomorphism, ) -> DensePolyRingEl<R1, A1>

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

impl<R, P, A, C> CanIsoFromTo<P> for DensePolyRingBase<R, A, C>

where R: RingStore, R::Type: CanIsoFromTo<<P::BaseRing as RingStore>::Type>, P: ImplGenericCanIsoFromToMarker, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>,

type Isomorphism = <<<DensePolyRingBase<R, A, C> as RingExtension>::BaseRing 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::Element

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

impl<R: RingStore + Clone, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type> + Clone> Clone for DensePolyRingBase<R, A, C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: RingStore, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> Debug for DensePolyRingBase<R, A, C>

where R::Type: Debug,

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

Formats the value using the given formatter.

impl<R, A: Allocator + Clone, C> DivisibilityRing for DensePolyRingBase<R, A, C>

where R: RingStore, R::Type: DivisibilityRing + Domain, C: ConvolutionAlgorithm<R::Type>,

fn checked_left_div( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Checks whether there is an element x such that rhs * x = lhs, and returns it if it exists.

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

Returns whether there is an element x such that rhs * x = lhs. If you need such an element, consider using DivisibilityRing::checked_left_div().

fn balance_factor<'a, I>(&self, elements: I) -> Option<Self::Element>

where I: Iterator<Item = &'a Self::Element>, Self: 'a,

Function that computes a “balancing” factor of a sequence of ring elements. The only use of the balancing factor is to increase performance, in particular, dividing all elements in the sequence by this factor should make them “smaller” resp. cheaper to process.

type PreparedDivisorData = ()

Additional data associated to a fixed ring element that can be used to speed up division by this ring element.

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

Same as DivisibilityRing::divides_left(), but requires a commutative ring.

fn checked_div( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Same as DivisibilityRing::checked_left_div(), but requires a commutative ring.

fn is_unit(&self, x: &Self::Element) -> bool

Returns whether the given element is a unit, i.e. has an inverse.

fn prepare_divisor(&self, _: &Self::Element) -> Self::PreparedDivisorData

“Prepares” an element of this ring for division.

fn checked_left_div_prepared( &self, lhs: &Self::Element, rhs: &Self::Element, _rhs_prep: &Self::PreparedDivisorData, ) -> Option<Self::Element>

Same as DivisibilityRing::checked_left_div() but for a prepared divisor.

fn divides_left_prepared( &self, lhs: &Self::Element, rhs: &Self::Element, _rhs_prep: &Self::PreparedDivisorData, ) -> bool

Same as DivisibilityRing::divides_left() but for a prepared divisor.

fn is_unit_prepared(&self, x: &PreparedDivisor<Self>) -> bool

Same as DivisibilityRing::is_unit() but for a prepared divisor.

fn invert(&self, el: &Self::Element) -> Option<Self::Element>

If the given element is a unit, returns its inverse, otherwise None.

impl<R, A, C> EuclideanRing for DensePolyRingBase<R, A, C>

where A: Allocator + Clone, R: RingStore, R::Type: Field + PolyTFracGCDRing, C: ConvolutionAlgorithm<R::Type>,

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

Computes euclidean division with remainder.

fn euclidean_deg(&self, val: &Self::Element) -> Option<usize>

Defines how “small” an element is. For details, see EuclideanRing.

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

Computes euclidean division without remainder.

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

Computes only the remainder of euclidean division.

impl<R, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> EvalPolyLocallyRing for DensePolyRingBase<R, A, C>

where R: RingStore, R::Type: InterpolationBaseRing,

type LocalRing<'ring> = <<R as RingStore>::Type as InterpolationBaseRing>::ExtendedRing<'ring> where Self: 'ring

Available on crate feature unstable-enable only.

type LocalRingBase<'ring> = <<R as RingStore>::Type as InterpolationBaseRing>::ExtendedRingBase<'ring> where Self: 'ring

Available on crate feature unstable-enable only.

The type of the ring we get once quotienting by a prime ideal.

type LocalComputationData<'ring> = (ToExtRingMap<'ring, <R as RingStore>::Type>, Vec<<<<<R as RingStore>::Type as InterpolationBaseRing>::ExtendedRing<'ring> as RingStore>::Type as RingBase>::Element>) where Self: 'ring

Available on crate feature unstable-enable only.

A collection of prime ideals of the ring, and additionally any data required to reconstruct a small ring element from its projections onto each prime ideal.

fn ln_pseudo_norm(&self, el: &Self::Element) -> f64

Available on crate feature unstable-enable only.

Computes (an upper bound of) the natural logarithm of the pseudo norm of a ring element.

fn local_computation<'ring>( &'ring self, ln_pseudo_norm: f64, ) -> Self::LocalComputationData<'ring>

Available on crate feature unstable-enable only.

Sets up the context for a new polynomial evaluation, whose output should have pseudo norm less than the given bound.

fn local_ring_count<'ring>( &self, data: &Self::LocalComputationData<'ring>, ) -> usize

where Self: 'ring,

Available on crate feature unstable-enable only.

Returns the number k of local rings that are required to get the correct result of the given computation.

fn local_ring_at<'ring>( &self, data: &Self::LocalComputationData<'ring>, i: usize, ) -> Self::LocalRing<'ring>

where Self: 'ring,

Available on crate feature unstable-enable only.

Returns the i-th local ring belonging to the given computation.

fn reduce<'ring>( &self, data: &Self::LocalComputationData<'ring>, el: &Self::Element, ) -> Vec<<Self::LocalRingBase<'ring> as RingBase>::Element>

where Self: 'ring,

Available on crate feature unstable-enable only.

Computes the map R -> R1 x ... x Rk, i.e. maps the given element into each of the local rings.

fn lift_combine<'ring>( &self, data: &Self::LocalComputationData<'ring>, els: &[<Self::LocalRingBase<'ring> as RingBase>::Element], ) -> Self::Element

where Self: 'ring,

Available on crate feature unstable-enable only.

Computes a preimage under the map R -> R1 x ... x Rk, i.e. a ring element x that reduces to each of the given local rings under the map EvalPolyLocallyRing::reduce().

impl<R: RingStore, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> FiniteRingSpecializable for DensePolyRingBase<R, A, C>

fn specialize<O: FiniteRingOperation<Self>>(op: O) -> O::Output

Available on crate feature unstable-enable only.

fn is_finite_ring() -> bool

Available on crate feature unstable-enable only.

impl<R, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> HashableElRing for DensePolyRingBase<R, A, C>

where R: RingStore, R::Type: HashableElRing,

fn hash<H: Hasher>(&self, el: &Self::Element, h: &mut H)

Hashes the given ring element.

impl<R, A, C> PartialEq for DensePolyRingBase<R, A, C>

where R: RingStore, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>,

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: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> PolyRing for DensePolyRingBase<R, A, C>

where R: RingStore,

type TermsIterator<'a> = TermIterator<'a, R> where Self: 'a

Type of the iterator over all non-zero terms of a polynomial in this ring, as returned by PolyRing::terms().

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

Returns the indeterminate X generating this polynomial ring.

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

Returns all the nonzero terms of the given polynomial.

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

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

Adds the given terms to the given polynomial.

fn truncate_monomials( &self, lhs: &mut Self::Element, truncated_at_degree: usize, )

Truncates the monomials of the given polynomial from the given position on, i.e. computes the remainder of the polynomial division of lhs by X^truncated_at_inclusive.

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

Returns the coefficient of f that corresponds to the monomial X^i.

fn mul_assign_monomial(&self, lhs: &mut Self::Element, rhs_power: usize)

Multiplies the given polynomial with X^rhs_power.

fn degree(&self, f: &Self::Element) -> Option<usize>

Returns the degree of the polynomial f, i.e. the value d such that f can be written as f(X) = a0 + a1 * X + a2 * X^2 + ... + ad * X^d. Returns None if f is zero.

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

Compute the euclidean division by a monic polynomial rhs.

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

where S: ?Sized + RingBase, H: Homomorphism<R::Type, S>,

Evaluates the given polynomial at the given values.

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

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

Computes the polynomial whose coefficients are the images of the coefficients of el under the given homomorphism.

fn balance_poly(&self, f: &mut Self::Element) -> Option<El<Self::BaseRing>>

where <Self::BaseRing as RingStore>::Type: DivisibilityRing,

Possibly divides all coefficients of the polynomial by a common factor, in order to make them “smaller”.

impl<R, A, C> PrincipalIdealRing for DensePolyRingBase<R, A, C>

where A: Allocator + Clone, R: RingStore, R::Type: Field + PolyTFracGCDRing, C: ConvolutionAlgorithm<R::Type>,

fn checked_div_min( &self, lhs: &Self::Element, rhs: &Self::Element, ) -> Option<Self::Element>

Similar to DivisibilityRing::checked_left_div() this computes a “quotient” q of lhs and rhs, if it exists. However, we impose the additional constraint that this quotient be minimal, i.e. there is no q' with q' | q properly and q' * rhs = lhs.

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

Computes a Bezout identity for the generator g of the ideal (lhs, rhs) as g = s * lhs + t * rhs.

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

Computes a generator g of the ideal (lhs, rhs) = (g), also known as greatest common divisor.

fn ideal_gen_with_controller<Controller>( &self, lhs: &Self::Element, rhs: &Self::Element, controller: Controller, ) -> Self::Element

where Controller: ComputationController,

As PrincipalIdealRing::ideal_gen(), this computes a generator of the ideal (lhs, rhs). However, it additionally accepts a ComputationController to customize the performed computation.

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

Returns the (w.r.t. divisibility) smallest element x such that x * val = 0.

fn create_elimination_matrix( &self, a: &Self::Element, b: &Self::Element, ) -> ([Self::Element; 4], Self::Element)

Creates a matrix A of unit determinant such that A * (a, b)^T = (d, 0). Returns (A, d).

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

Computes a generator of the ideal (lhs) ∩ (rhs), also known as least common multiple.

impl<R: RingStore, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> RingBase for DensePolyRingBase<R, A, C>

type Element = DensePolyRingEl<R, A>

Type of elements of the ring

fn clone_el(&self, val: &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 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_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_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 dbg<'a>(&self, value: &Self::Element, out: &mut Formatter<'a>) -> Result

Writes a human-readable representation of value to out.

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

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

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

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 prod<I>(&self, els: I) -> Self::Element

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

Computes the product of the elements given by the iterator.

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 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 fma( &self, lhs: &Self::Element, rhs: &Self::Element, summand: Self::Element, ) -> Self::Element

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

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

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

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

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.

impl<R: RingStore, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> RingExtension for DensePolyRingBase<R, A, C>

type BaseRing = R

Type of the base ring;

fn base_ring<'a>(&'a self) -> &'a 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 fma_base( &self, lhs: &Self::Element, rhs: &El<Self::BaseRing>, summand: Self::Element, ) -> Self::Element

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

impl<R, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> SerializableElementRing for DensePolyRingBase<R, A, C>

where R: RingStore, R::Type: SerializableElementRing,

fn deserialize<'de, D>( &self, deserializer: D, ) -> Result<Self::Element, D::Error>

where D: Deserializer<'de>,

Available on crate feature unstable-enable only.

Deserializes an element of this ring from the given deserializer.

fn serialize<S>( &self, el: &Self::Element, serializer: S, ) -> Result<S::Ok, S::Error>

where S: Serializer,

Available on crate feature unstable-enable only.

Serializes an element of this ring to the given serializer.

impl<R, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>> Domain for DensePolyRingBase<R, A, C>

where R: RingStore, R::Type: Domain,

impl<R, A, C> ImplGenericCanIsoFromToMarker for DensePolyRingBase<R, A, C>

where R: RingStore, A: Allocator + Clone, C: ConvolutionAlgorithm<R::Type>,