Struct StaticRingBase 

pub struct StaticRingBase<T> { /* private fields */ }

The ring of integers Z, using the arithmetic of the primitive integer type T.

For the difference to StaticRing, see the documentation of crate::ring::RingStore.

Trait Implementations

impl CanHomFrom<StaticRingBase<i128>> for ZnBase

fn map_in( &self, _from: &StaticRingBase<i128>, el: i128, _hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

type Homomorphism

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

fn has_canonical_hom(&self, from: &S) -> 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: &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 CanHomFrom<StaticRingBase<i16>> for ZnBase

fn map_in( &self, _from: &StaticRingBase<i16>, el: i16, _hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

type Homomorphism

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

fn has_canonical_hom(&self, from: &S) -> 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: &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 CanHomFrom<StaticRingBase<i32>> for ZnBase

fn map_in( &self, _from: &StaticRingBase<i32>, el: i32, _hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

type Homomorphism

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

fn has_canonical_hom(&self, from: &S) -> 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: &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 CanHomFrom<StaticRingBase<i64>> for ZnBase

fn map_in( &self, _from: &StaticRingBase<i64>, el: i64, _hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

type Homomorphism

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

fn has_canonical_hom(&self, from: &S) -> 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: &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<const N: u64, const IS_FIELD: bool> CanHomFrom<StaticRingBase<i64>> for ZnBase<N, IS_FIELD>

type Homomorphism = ()

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

fn has_canonical_hom(&self, _: &StaticRingBase<i64>) -> Option<()>

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, _: &StaticRingBase<i64>, el: i64, _: &()) -> 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 CanHomFrom<StaticRingBase<i8>> for ZnBase

fn map_in( &self, _from: &StaticRingBase<i8>, el: i8, _hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

type Homomorphism

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

fn has_canonical_hom(&self, from: &S) -> 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: &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<T> Clone for StaticRingBase<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for StaticRingBase<T>

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

Formats the value using the given formatter.

impl<T: PrimitiveInt> Default for StaticRingBase<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: PrimitiveInt> Deserialize<'de> for StaticRingBase<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PrimitiveInt> DivisibilityRing for StaticRingBase<T>

type PreparedDivisorData = PrimitiveIntPreparedDivisorData<T>

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 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 prepare_divisor(&self, x: &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(&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 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<T: PrimitiveInt> EuclideanRing for StaticRingBase<T>

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<T> EvalPolyLocallyRing for StaticRingBase<T>

where T: PrimitiveInt,

type LocalComputationData<'ring> = RingValue<ZnBase<RingValue<AsFieldBase<RingValue<ZnBase>>>, RingRef<'ring, StaticRingBase<T>>>> 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.

type LocalRing<'ring> = RingValue<AsFieldBase<RingValue<ZnBase>>> where Self: 'ring

Available on crate feature unstable-enable only.

type LocalRingBase<'ring> = AsFieldBase<RingValue<ZnBase>> where Self: 'ring

Available on crate feature unstable-enable only.

The type of the ring we get once quotienting by a 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_bound: 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_at<'ring>( &self, computation: &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 local_ring_count<'ring>( &self, computation: &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 reduce<'ring>( &self, computation: &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, computation: &Self::LocalComputationData<'ring>, el: &[<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<T> FiniteRingSpecializable for StaticRingBase<T>

where T: PrimitiveInt,

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<T: PrimitiveInt> HashableElRing for StaticRingBase<T>

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

Hashes the given ring element.

impl<R> Homomorphism<StaticRingBase<i32>, <R as RingStore>::Type> for IntHom<R>

where R: RingStore,

type CodomainStore = R

The type of the RingStore used by this object to store the codomain ring.

type DomainStore = RingValue<StaticRingBase<i32>>

The type of the RingStore used by this object to store the domain ring.

fn domain<'a>(&'a self) -> &'a Self::DomainStore

Returns a reference to the domain ring.

fn codomain<'a>(&'a self) -> &'a Self::CodomainStore

Returns a reference to the codomain ring.

fn map(&self, x: i32) -> El<R>

Applies this homomorphism to the given element from the domain ring, resulting in an element in the codomain ring.

fn mul_assign_map(&self, lhs: &mut El<R>, rhs: i32)

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn mul_assign_ref_map( &self, lhs: &mut El<R>, rhs: &<StaticRingBase<i32> as RingBase>::Element, )

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn fma_map(&self, lhs: &El<R>, rhs: &i32, summand: El<R>) -> El<R>

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

fn map_ref(&self, x: &Domain::Element) -> Codomain::Element

Applies this homomorphism to the given element from the domain ring, resulting in an element in the codomain ring.

fn mul_map( &self, lhs: Codomain::Element, rhs: Domain::Element, ) -> Codomain::Element

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn mul_ref_fst_map( &self, lhs: &Codomain::Element, rhs: Domain::Element, ) -> Codomain::Element

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn mul_ref_snd_map( &self, lhs: Codomain::Element, rhs: &Domain::Element, ) -> Codomain::Element

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn mul_ref_map( &self, lhs: &Codomain::Element, rhs: &Domain::Element, ) -> Codomain::Element

Multiplies the given element in the codomain ring with an element obtained by applying this homomorphism to a given element from the domain ring.

fn compose<F, PrevDomain: ?Sized + RingBase>( self, prev: F, ) -> ComposedHom<PrevDomain, Domain, Codomain, F, Self>

where Self: Sized, F: Homomorphism<PrevDomain, Domain>,

Constructs the homomorphism x -> self.map(prev.map(x)).

fn mul_assign_ref_map_through_hom<First: ?Sized + RingBase, H: Homomorphism<First, Domain>>( &self, lhs: &mut Codomain::Element, rhs: &First::Element, hom: H, )

Multiplies the given element in the codomain ring with an element obtained by applying this and another homomorphism to a given element from another ring.

fn mul_assign_map_through_hom<First: ?Sized + RingBase, H: Homomorphism<First, Domain>>( &self, lhs: &mut Codomain::Element, rhs: First::Element, hom: H, )

Multiplies the given element in the codomain ring with an element obtained by applying this and another homomorphism to a given element from another ring.

impl IntCast<MPZBase> for StaticRingBase<i128>

Available on crate feature mpir only.

fn cast(&self, from: &MPZBase, el: MPZEl) -> i128

Maps the given integer into this ring.

impl IntCast<MPZBase> for StaticRingBase<i16>

Available on crate feature mpir only.

fn cast(&self, _: &MPZBase, el: MPZEl) -> i16

Maps the given integer into this ring.

impl IntCast<MPZBase> for StaticRingBase<i32>

Available on crate feature mpir only.

fn cast(&self, _: &MPZBase, el: MPZEl) -> i32

Maps the given integer into this ring.

impl IntCast<MPZBase> for StaticRingBase<i64>

Available on crate feature mpir only.

fn cast(&self, from: &MPZBase, el: MPZEl) -> i64

Maps the given integer into this ring.

impl IntCast<MPZBase> for StaticRingBase<i8>

Available on crate feature mpir only.

fn cast(&self, _: &MPZBase, el: MPZEl) -> i8

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<RustBigintRingBase<A>> for StaticRingBase<i128>

fn cast(&self, from: &RustBigintRingBase<A>, value: RustBigint<A>) -> i128

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<RustBigintRingBase<A>> for StaticRingBase<i16>

fn cast(&self, from: &RustBigintRingBase<A>, value: RustBigint<A>) -> i16

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<RustBigintRingBase<A>> for StaticRingBase<i32>

fn cast(&self, from: &RustBigintRingBase<A>, value: RustBigint<A>) -> i32

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<RustBigintRingBase<A>> for StaticRingBase<i64>

fn cast(&self, from: &RustBigintRingBase<A>, value: RustBigint<A>) -> i64

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<RustBigintRingBase<A>> for StaticRingBase<i8>

fn cast(&self, from: &RustBigintRingBase<A>, value: RustBigint<A>) -> i8

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i128>> for MPZBase

Available on crate feature mpir only.

fn cast(&self, _: &StaticRingBase<i128>, el: i128) -> MPZEl

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<StaticRingBase<i128>> for RustBigintRingBase<A>

fn cast(&self, _: &StaticRingBase<i128>, value: i128) -> RustBigint<A>

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i128>> for StaticRingBase<i128>

fn cast(&self, _: &StaticRingBase<i128>, value: i128) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i128>> for StaticRingBase<i16>

fn cast(&self, _: &StaticRingBase<i128>, value: i128) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i128>> for StaticRingBase<i32>

fn cast(&self, _: &StaticRingBase<i128>, value: i128) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i128>> for StaticRingBase<i64>

fn cast(&self, _: &StaticRingBase<i128>, value: i128) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i128>> for StaticRingBase<i8>

fn cast(&self, _: &StaticRingBase<i128>, value: i128) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i16>> for MPZBase

Available on crate feature mpir only.

fn cast(&self, _: &StaticRingBase<i16>, el: i16) -> MPZEl

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<StaticRingBase<i16>> for RustBigintRingBase<A>

fn cast(&self, _: &StaticRingBase<i16>, value: i16) -> RustBigint<A>

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i16>> for StaticRingBase<i128>

fn cast(&self, _: &StaticRingBase<i16>, value: i16) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i16>> for StaticRingBase<i16>

fn cast(&self, _: &StaticRingBase<i16>, value: i16) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i16>> for StaticRingBase<i32>

fn cast(&self, _: &StaticRingBase<i16>, value: i16) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i16>> for StaticRingBase<i64>

fn cast(&self, _: &StaticRingBase<i16>, value: i16) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i16>> for StaticRingBase<i8>

fn cast(&self, _: &StaticRingBase<i16>, value: i16) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i32>> for MPZBase

Available on crate feature mpir only.

fn cast(&self, _: &StaticRingBase<i32>, el: i32) -> MPZEl

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<StaticRingBase<i32>> for RustBigintRingBase<A>

fn cast(&self, _: &StaticRingBase<i32>, value: i32) -> RustBigint<A>

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i32>> for StaticRingBase<i128>

fn cast(&self, _: &StaticRingBase<i32>, value: i32) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i32>> for StaticRingBase<i16>

fn cast(&self, _: &StaticRingBase<i32>, value: i32) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i32>> for StaticRingBase<i32>

fn cast(&self, _: &StaticRingBase<i32>, value: i32) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i32>> for StaticRingBase<i64>

fn cast(&self, _: &StaticRingBase<i32>, value: i32) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i32>> for StaticRingBase<i8>

fn cast(&self, _: &StaticRingBase<i32>, value: i32) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i64>> for MPZBase

Available on crate feature mpir only.

fn cast(&self, _: &StaticRingBase<i64>, el: i64) -> Self::Element

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<StaticRingBase<i64>> for RustBigintRingBase<A>

fn cast(&self, _: &StaticRingBase<i64>, value: i64) -> RustBigint<A>

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i64>> for StaticRingBase<i128>

fn cast(&self, _: &StaticRingBase<i64>, value: i64) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i64>> for StaticRingBase<i16>

fn cast(&self, _: &StaticRingBase<i64>, value: i64) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i64>> for StaticRingBase<i32>

fn cast(&self, _: &StaticRingBase<i64>, value: i64) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i64>> for StaticRingBase<i64>

fn cast(&self, _: &StaticRingBase<i64>, value: i64) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i64>> for StaticRingBase<i8>

fn cast(&self, _: &StaticRingBase<i64>, value: i64) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i8>> for MPZBase

Available on crate feature mpir only.

fn cast(&self, _: &StaticRingBase<i8>, el: i8) -> MPZEl

Maps the given integer into this ring.

impl<A: Allocator + Clone> IntCast<StaticRingBase<i8>> for RustBigintRingBase<A>

fn cast(&self, _: &StaticRingBase<i8>, value: i8) -> RustBigint<A>

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i8>> for StaticRingBase<i128>

fn cast(&self, _: &StaticRingBase<i8>, value: i8) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i8>> for StaticRingBase<i16>

fn cast(&self, _: &StaticRingBase<i8>, value: i8) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i8>> for StaticRingBase<i32>

fn cast(&self, _: &StaticRingBase<i8>, value: i8) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i8>> for StaticRingBase<i64>

fn cast(&self, _: &StaticRingBase<i8>, value: i8) -> Self::Element

Maps the given integer into this ring.

impl IntCast<StaticRingBase<i8>> for StaticRingBase<i8>

fn cast(&self, _: &StaticRingBase<i8>, value: i8) -> Self::Element

Maps the given integer into this ring.

impl<T> IntegerPolyGCDRing for StaticRingBase<T>

where T: PrimitiveInt,

type LocalRingAsZnBase<'ring> = <StaticRingBase<T> as PolyGCDLocallyDomain>::LocalRingBase<'ring> where Self: 'ring

Available on crate feature unstable-enable only.

It would be much preferrable if we could restrict associated types from supertraits, this is just a workaround (and an ugly one at that)

type LocalRingAsZn<'ring> = <StaticRingBase<T> as PolyGCDLocallyDomain>::LocalRing<'ring> where Self: 'ring

Available on crate feature unstable-enable only.

fn local_ring_as_zn<'a, 'ring>( &self, local_field: &'a Self::LocalRing<'ring>, ) -> &'a Self::LocalRingAsZn<'ring>

where Self: 'ring,

Available on crate feature unstable-enable only.

fn local_ring_into_zn<'ring>( &self, local_field: Self::LocalRing<'ring>, ) -> Self::LocalRingAsZn<'ring>

where Self: 'ring,

Available on crate feature unstable-enable only.

fn principal_ideal_generator<'ring>( &self, p: &Self::SuitableIdeal<'ring>, ) -> El<BigIntRing>

where Self: 'ring,

Available on crate feature unstable-enable only.

impl<T: PrimitiveInt> IntegerRing for StaticRingBase<T>

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

Computes a float value that is “close” to the given integer.

fn from_float_approx(&self, value: f64) -> Option<Self::Element>

Computes a value that is “close” to the given float. However, no guarantees are made on the definition of close, in particular, this does not have to be the closest integer to the given float, and cannot be used to compute rounding. It is also implementation-defined when to return None, although this is usually the case on infinity and NaN.

fn abs_is_bit_set(&self, value: &Self::Element, i: usize) -> bool

Return whether the i-th bit in the two-complements representation of abs(value) is 1.

fn abs_highest_set_bit(&self, value: &Self::Element) -> Option<usize>

Returns the index of the highest set bit in the two-complements representation of abs(value), or None if the value is zero.

fn abs_lowest_set_bit(&self, value: &Self::Element) -> Option<usize>

Returns the index of the lowest set bit in the two-complements representation of abs(value), or None if the value is zero.

fn euclidean_div_pow_2(&self, value: &mut Self::Element, power: usize)

Computes the euclidean division by a power of two, always rounding to zero (note that euclidean division requires that |remainder| < |divisor|, and thus would otherwise leave multiple possible results).

fn mul_pow_2(&self, value: &mut Self::Element, power: usize)

Multiplies the element by a power of two.

fn get_uniformly_random_bits<G: FnMut() -> u64>( &self, log2_bound_exclusive: usize, rng: G, ) -> Self::Element

Computes a uniformly random integer in [0, 2^log_bound_exclusive - 1], assuming that rng provides uniformly random values in the whole range of u64.

fn representable_bits(&self) -> Option<usize>

Returns n such that this ring can represent at least [-2^n, ..., 2^n - 1]. Returning None means that the size of representable integers is unbounded.

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

Computes the rounded division, i.e. rounding to the closest integer. In the case of a tie (i.e. round(0.5)), we round towards +/- infinity.

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

Computes the division lhs / rhs, rounding towards + infinity.

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

Computes the division lhs / rhs, rounding towards - infinity.

fn power_of_two(&self, power: usize) -> Self::Element

Returns the value 2^power in this integer ring.

fn parse(&self, string: &str, base: u32) -> Result<Self::Element, ()>

Parses the given string as a number.

impl<T> InterpolationBaseRing for StaticRingBase<T>

where T: PrimitiveInt,

type ExtendedRing<'a> = RingRef<'a, StaticRingBase<T>> where Self: 'a

Available on crate feature unstable-enable only.

type ExtendedRingBase<'a> = StaticRingBase<T> where Self: 'a

Available on crate feature unstable-enable only.

The type of the extension ring we can switch to to get more points.

fn in_base<'a, S>(&self, _ext_ring: S, el: El<S>) -> Option<Self::Element>

where Self: 'a, S: RingStore<Type = Self::ExtendedRingBase<'a>>,

Available on crate feature unstable-enable only.

fn in_extension<'a, S>(&self, _ext_ring: S, el: Self::Element) -> El<S>

where Self: 'a, S: RingStore<Type = Self::ExtendedRingBase<'a>>,

Available on crate feature unstable-enable only.

fn interpolation_points<'a>( &'a self, count: usize, ) -> (Self::ExtendedRing<'a>, Vec<El<Self::ExtendedRing<'a>>>)

Available on crate feature unstable-enable only.

Returns count points such that the difference between any two of them is a non-zero-divisor.

impl KaratsubaHint for StaticRingBase<i128>

fn karatsuba_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on KaratsubaAlgorithm will use the Karatsuba algorithm.

impl KaratsubaHint for StaticRingBase<i16>

fn karatsuba_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on KaratsubaAlgorithm will use the Karatsuba algorithm.

impl KaratsubaHint for StaticRingBase<i32>

fn karatsuba_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on KaratsubaAlgorithm will use the Karatsuba algorithm.

impl KaratsubaHint for StaticRingBase<i64>

fn karatsuba_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on KaratsubaAlgorithm will use the Karatsuba algorithm.

impl KaratsubaHint for StaticRingBase<i8>

fn karatsuba_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on KaratsubaAlgorithm will use the Karatsuba algorithm.

impl<T: PrimitiveInt> OrderedRing for StaticRingBase<T>

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

Returns whether lhs is Ordering::Less, Ordering::Equal or Ordering::Greater than rhs.

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

Returns whether abs(lhs) is Ordering::Less, Ordering::Equal or Ordering::Greater than abs(rhs).

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

Returns whether lhs <= rhs.

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

Returns whether lhs >= rhs.

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

Returns whether lhs < rhs.

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

Returns whether lhs > rhs.

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

Returns whether value < 0.

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

Returns whether value > 0.

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

Returns the absolute value of value, i.e. value if value >= 0 and -value otherwise.

fn max<'a>( &self, fst: &'a Self::Element, snd: &'a Self::Element, ) -> &'a Self::Element

Returns the larger one of fst and snd.

impl<T> PartialEq for StaticRingBase<T>

fn eq(&self, _: &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<T> PolyGCDLocallyDomain for StaticRingBase<T>

where T: PrimitiveInt,

type LocalRing<'ring> = RingValue<ZnBase<RingValue<MPZBase>>> where Self: 'ring

Available on crate feature unstable-enable only.

type LocalRingBase<'ring> = ZnBase<RingValue<MPZBase>> where Self: 'ring

Available on crate feature unstable-enable only.

The type of the local ring once we quotiented out a power of a prime ideal.

type LocalFieldBase<'ring> = AsFieldBase<RingValue<ZnBase>> where Self: 'ring

Available on crate feature unstable-enable only.

The type of the field we get by quotienting out a power of a prime ideal.

type LocalField<'ring> = RingValue<AsFieldBase<RingValue<ZnBase>>> where Self: 'ring

Available on crate feature unstable-enable only.

type SuitableIdeal<'ring> = i64 where Self: 'ring

Available on crate feature unstable-enable only.

An ideal of the ring for which we know a decomposition into maximal ideals, and can use Hensel lifting to lift values to higher powers of this ideal.

fn reconstruct_ring_el<'local, 'element, 'ring, V1, V2>( &self, _p: &Self::SuitableIdeal<'ring>, from: V1, _e: usize, x: V2, ) -> Self::Element

where Self: 'ring, V1: VectorFn<&'local Self::LocalRing<'ring>>, V2: VectorFn<&'element El<Self::LocalRing<'ring>>>,

Available on crate feature unstable-enable only.

Computes a “small” element x in R such that x mod mi^e is equal to the given value, for every maximal ideal mi over I. In cases where the factors of polynomials in R[X] do not necessarily have coefficients in R, this function might have to do rational reconstruction.

fn maximal_ideal_factor_count<'ring>( &self, _p: &Self::SuitableIdeal<'ring>, ) -> usize

where Self: 'ring,

Available on crate feature unstable-enable only.

Returns the number of maximal ideals in the primary decomposition of ideal.

fn lift_partial<'ring>( &self, _p: &Self::SuitableIdeal<'ring>, from: (&Self::LocalRingBase<'ring>, usize), to: (&Self::LocalRingBase<'ring>, usize), max_ideal_idx: usize, x: El<Self::LocalRing<'ring>>, ) -> El<Self::LocalRing<'ring>>

where Self: 'ring,

Available on crate feature unstable-enable only.

Computes any element y in R / mi^to_e such that y = x mod mi^from_e. In particular, y does not have to be “short” in any sense, but any lift is a valid result.

fn local_field_at<'ring>( &self, p: &Self::SuitableIdeal<'ring>, max_ideal_idx: usize, ) -> Self::LocalField<'ring>

where Self: 'ring,

Available on crate feature unstable-enable only.

Returns R / mi, where mi is the i-th maximal ideal over I.

fn local_ring_at<'ring>( &self, p: &Self::SuitableIdeal<'ring>, e: usize, max_ideal_idx: usize, ) -> Self::LocalRing<'ring>

where Self: 'ring,

Available on crate feature unstable-enable only.

Returns R / mi^e, where mi is the i-th maximal ideal over I.

fn random_suitable_ideal<'ring, F>( &'ring self, rng: F, ) -> Self::SuitableIdeal<'ring>

where F: FnMut() -> u64,

Available on crate feature unstable-enable only.

Returns an ideal sampled at random from the interval of all supported ideals.

fn base_ring_to_field<'ring>( &self, _ideal: &Self::SuitableIdeal<'ring>, from: &Self::LocalRingBase<'ring>, to: &Self::LocalFieldBase<'ring>, max_ideal_idx: usize, x: El<Self::LocalRing<'ring>>, ) -> El<Self::LocalField<'ring>>

where Self: 'ring,

Available on crate feature unstable-enable only.

Computes the isomorphism between the ring and field representations of R / mi

fn field_to_base_ring<'ring>( &self, _ideal: &Self::SuitableIdeal<'ring>, from: &Self::LocalFieldBase<'ring>, to: &Self::LocalRingBase<'ring>, max_ideal_idx: usize, x: El<Self::LocalField<'ring>>, ) -> El<Self::LocalRing<'ring>>

where Self: 'ring,

Available on crate feature unstable-enable only.

Computes the isomorphism between the ring and field representations of R / mi

fn reduce_ring_el<'ring>( &self, _p: &Self::SuitableIdeal<'ring>, to: (&Self::LocalRingBase<'ring>, usize), max_ideal_idx: usize, x: Self::Element, ) -> El<Self::LocalRing<'ring>>

where Self: 'ring,

Available on crate feature unstable-enable only.

Computes the reduction map

fn reduce_partial<'ring>( &self, _p: &Self::SuitableIdeal<'ring>, from: (&Self::LocalRingBase<'ring>, usize), to: (&Self::LocalRingBase<'ring>, usize), max_ideal_idx: usize, x: El<Self::LocalRing<'ring>>, ) -> El<Self::LocalRing<'ring>>

where Self: 'ring,

Available on crate feature unstable-enable only.

Computes the reduction map

fn heuristic_exponent<'ring, 'a, I>( &self, p: &i64, poly_deg: usize, coefficients: I, ) -> usize

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

Available on crate feature unstable-enable only.

Returns an exponent e such that we hope that the factors of a polynomial of given degree, involving the given coefficient can already be read of (via PolyGCDLocallyDomain::reconstruct_ring_el()) their reductions modulo I^e. Note that this is just a heuristic, and if it does not work, the implementation will gradually try larger e. Thus, even if this function returns constant 1, correctness will not be affected, but giving a good guess can improve performance

fn dbg_ideal<'ring>( &self, p: &Self::SuitableIdeal<'ring>, out: &mut Formatter<'_>, ) -> Result

where Self: 'ring,

Available on crate feature unstable-enable only.

impl<T: PrimitiveInt> PrincipalIdealRing for StaticRingBase<T>

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 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 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, ) -> 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 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<T: PrimitiveInt> RingBase for StaticRingBase<T>

type Element = T

Type of elements of the ring

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

fn add_assign(&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 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>, _: 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: RingStore>(&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 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 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 add_assign_ref(&self, lhs: &mut Self::Element, rhs: &Self::Element)

fn sub_assign_ref(&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 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 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 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(&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 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<T: PrimitiveInt> SerializableElementRing for StaticRingBase<T>

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<T: PrimitiveInt> Serialize for StaticRingBase<T>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StrassenHint for StaticRingBase<i128>

fn strassen_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on StrassenAlgorithm will use the Strassen algorithm.

impl StrassenHint for StaticRingBase<i16>

fn strassen_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on StrassenAlgorithm will use the Strassen algorithm.

impl StrassenHint for StaticRingBase<i32>

fn strassen_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on StrassenAlgorithm will use the Strassen algorithm.

impl StrassenHint for StaticRingBase<i64>

fn strassen_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on StrassenAlgorithm will use the Strassen algorithm.

impl StrassenHint for StaticRingBase<i8>

fn strassen_threshold(&self) -> usize

Available on crate feature unstable-enable only.

Define a threshold from which on StrassenAlgorithm will use the Strassen algorithm.

impl<T> Copy for StaticRingBase<T>

impl<T: PrimitiveInt> Domain for StaticRingBase<T>