Struct DirectPowerRingBase 

pub struct DirectPowerRingBase<R: RingStore, const N: usize> { /* private fields */ }

Available on crate feature unstable-enable only.

The N-fold direct product ring R x ... x R.

Currently, this is a quite naive implementation, which just repeats operations along each component. In the future, this might become an entrypoint for vectorization or similar. Hence, it might remain unstable for a while.

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<S: RingStore, R: RingStore, const N: usize> CanHomFrom<DirectPowerRingBase<S, N>> for DirectPowerRingBase<R, N>

where R::Type: CanHomFrom<S::Type>,

type Homomorphism = <<R as RingStore>::Type as CanHomFrom<<S as RingStore>::Type>>::Homomorphism

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

fn has_canonical_hom( &self, from: &DirectPowerRingBase<S, N>, ) -> 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: &DirectPowerRingBase<S, N>, el: <DirectPowerRingBase<S, N> as RingBase>::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

fn map_in_ref( &self, from: &DirectPowerRingBase<S, N>, el: &<DirectPowerRingBase<S, N> 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<S: RingStore, R: RingStore, const N: usize> CanIsoFromTo<DirectPowerRingBase<S, N>> for DirectPowerRingBase<R, N>

where R::Type: CanIsoFromTo<S::Type>,

type Isomorphism = <<R as RingStore>::Type as CanIsoFromTo<<S as RingStore>::Type>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso( &self, from: &DirectPowerRingBase<S, N>, ) -> 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: &DirectPowerRingBase<S, N>, el: Self::Element, iso: &Self::Isomorphism, ) -> <DirectPowerRingBase<S, N> as RingBase>::Element

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

impl<R, const N: usize> Clone for DirectPowerRingBase<R, N>

where R: Clone + RingStore,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 1>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 1])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 1])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 16>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 16])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 16])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 2>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 2])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 2])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 3>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 3])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 3])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 4>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 4])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 4])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 5>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 5])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 5])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 6>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 6])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 6])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 7>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 7])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 7])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl CooleyTuckeyButterfly<ZnFastmulBase> for DirectPowerRingBase<Zn, 8>

fn butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + twiddle * y, x - twiddle * y).

fn inv_butterfly_new<H: Homomorphism<ZnFastmulBase, Self>>( hom: H, x: &mut Self::Element, y: &mut Self::Element, twiddle: &ZnFastmulEl, )

Should compute (x, y) := (x + y, (x - y) * twiddle)

fn prepare_for_fft(&self, value: &mut [ZnEl; 8])

Possibly pre-processes elements before the FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::butterfly_new() that the inputs are in this form.

fn prepare_for_inv_fft(&self, value: &mut [ZnEl; 8])

Possibly pre-processes elements before the inverse FFT starts. Here you can bring ring element into a certain form, and assume during CooleyTuckeyButterfly::inv_butterfly_new() that the inputs are in this form.

fn butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + twiddle * values[i2], values[i1] - twiddle * values[i2]).

fn inv_butterfly<V: VectorViewMut<Self::Element>, H: Homomorphism<S, Self>>( &self, hom: H, values: &mut V, twiddle: &S::Element, i1: usize, i2: usize, )

👎Deprecated

Should compute (values[i1], values[i2]) := (values[i1] + values[i2], (values[i1] - values[i2]) * twiddle)

impl<R: RingStore, const N: usize> DivisibilityRing for DirectPowerRingBase<R, N>

where R::Type: DivisibilityRing,

type PreparedDivisorData = [<<R as RingStore>::Type as DivisibilityRing>::PreparedDivisorData; N]

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

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 prepare_divisor(&self, el: &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 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 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 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.

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: RingStore, const N: usize> FiniteRing for DirectPowerRingBase<R, N>

where R::Type: FiniteRing,

type ElementsIter<'a> = MultiProduct<<<R as RingStore>::Type as FiniteRing>::ElementsIter<'a>, DirectPowerRingElCreator<'a, R, N>, CloneRingEl<&'a R>, [<<R as RingStore>::Type as RingBase>::Element; N]> where Self: 'a

Type of the iterator returned by FiniteRing::elements(), which should iterate over all elements of the ring.

fn elements<'a>(&'a self) -> Self::ElementsIter<'a>

Returns an iterator over all elements of this ring. The order is not specified.

fn random_element<G: FnMut() -> u64>( &self, rng: G, ) -> <Self as RingBase>::Element

Returns a uniformly random element from this ring, using the randomness provided by rng.

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

where I::Type: IntegerRing,

Returns the number of elements in this ring, if it fits within the given integer ring.

impl<R: RingStore, const N: usize> FiniteRingSpecializable for DirectPowerRingBase<R, N>

where R::Type: FiniteRingSpecializable,

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: RingStore, const N: usize> HashableElRing for DirectPowerRingBase<R, N>

where R::Type: HashableElRing,

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

Hashes the given ring element.

impl<R: RingStore, const N: usize> PartialEq for DirectPowerRingBase<R, N>

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: RingStore, const N: usize> RingBase for DirectPowerRingBase<R, N>

type Element = [<<R as RingStore>::Type as RingBase>::Element; N]

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 one(&self) -> Self::Element

fn neg_one(&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 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 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 square(&self, value: &mut 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 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 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.

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

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

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

Writes a human-readable representation of value to out.

fn negate(&self, value: Self::Element) -> 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 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(&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.

impl<R: RingStore, const N: usize> RingExtension for DirectPowerRingBase<R, N>

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 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(&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 mul_assign_base_through_hom<S: ?Sized + RingBase, H: Homomorphism<S, R::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()).

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

impl<R: RingStore, const N: usize> SerializableElementRing for DirectPowerRingBase<R, N>

where 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, const N: usize> Copy for DirectPowerRingBase<R, N>

where R: Copy + RingStore, El<R>: Copy,