Struct feanor_math::primitive_int::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

type Homomorphism = (i128, i128)

fn has_canonical_hom( &self, _from: &StaticRingBase<i128>, ) -> Option<Self::Homomorphism>

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl CanHomFrom<StaticRingBase<i16>> for ZnBase

type Homomorphism = ()

fn has_canonical_hom( &self, _from: &StaticRingBase<i16>, ) -> Option<Self::Homomorphism>

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl CanHomFrom<StaticRingBase<i16>> for ZnBase

type Homomorphism = (i16, i16)

fn has_canonical_hom( &self, _from: &StaticRingBase<i16>, ) -> Option<Self::Homomorphism>

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl CanHomFrom<StaticRingBase<i32>> for ZnBase

type Homomorphism = (i32, i32)

fn has_canonical_hom( &self, _from: &StaticRingBase<i32>, ) -> Option<Self::Homomorphism>

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl CanHomFrom<StaticRingBase<i32>> for ZnBase

type Homomorphism = I32ToZnHom

fn has_canonical_hom( &self, _from: &StaticRingBase<i32>, ) -> Option<Self::Homomorphism>

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl CanHomFrom<StaticRingBase<i64>> for ZnBase

type Homomorphism = (i64, i64)

fn has_canonical_hom( &self, _from: &StaticRingBase<i64>, ) -> Option<Self::Homomorphism>

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl<const N: u64, const IS_FIELD: bool> CanHomFrom<StaticRingBase<i64>> for ZnBase<N, IS_FIELD>

type Homomorphism = ()

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

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl CanHomFrom<StaticRingBase<i8>> for ZnBase

type Homomorphism = (i8, i8)

fn has_canonical_hom( &self, _from: &StaticRingBase<i8>, ) -> Option<Self::Homomorphism>

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl CanHomFrom<StaticRingBase<i8>> for ZnBase

type Homomorphism = ()

fn has_canonical_hom( &self, _from: &StaticRingBase<i8>, ) -> Option<Self::Homomorphism>

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

fn map_in_ref( &self, from: &S, el: &S::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

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

impl<T> Clone for StaticRingBase<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConvMulComputation for StaticRingBase<i128>

fn karatsuba_threshold(&self) -> usize

Define a threshold from which on the default implementation of ConvMulComputation::add_assign_conv_mul() will use the Karatsuba algorithm.

fn add_assign_conv_mul<M: MemoryProvider<Self::Element>>( &self, dst: &mut [Self::Element], lhs: &[Self::Element], rhs: &[Self::Element], memory_provider: &M, )

Computes the convolution of lhs and rhs, and adds the result to dst.

impl ConvMulComputation for StaticRingBase<i16>

fn karatsuba_threshold(&self) -> usize

Define a threshold from which on the default implementation of ConvMulComputation::add_assign_conv_mul() will use the Karatsuba algorithm.

fn add_assign_conv_mul<M: MemoryProvider<Self::Element>>( &self, dst: &mut [Self::Element], lhs: &[Self::Element], rhs: &[Self::Element], memory_provider: &M, )

Computes the convolution of lhs and rhs, and adds the result to dst.

impl ConvMulComputation for StaticRingBase<i32>

fn karatsuba_threshold(&self) -> usize

Define a threshold from which on the default implementation of ConvMulComputation::add_assign_conv_mul() will use the Karatsuba algorithm.

fn add_assign_conv_mul<M: MemoryProvider<Self::Element>>( &self, dst: &mut [Self::Element], lhs: &[Self::Element], rhs: &[Self::Element], memory_provider: &M, )

Computes the convolution of lhs and rhs, and adds the result to dst.

impl ConvMulComputation for StaticRingBase<i64>

fn karatsuba_threshold(&self) -> usize

Define a threshold from which on the default implementation of ConvMulComputation::add_assign_conv_mul() will use the Karatsuba algorithm.

fn add_assign_conv_mul<M: MemoryProvider<Self::Element>>( &self, dst: &mut [Self::Element], lhs: &[Self::Element], rhs: &[Self::Element], memory_provider: &M, )

Computes the convolution of lhs and rhs, and adds the result to dst.

impl ConvMulComputation for StaticRingBase<i8>

fn karatsuba_threshold(&self) -> usize

Define a threshold from which on the default implementation of ConvMulComputation::add_assign_conv_mul() will use the Karatsuba algorithm.

fn add_assign_conv_mul<M: MemoryProvider<Self::Element>>( &self, dst: &mut [Self::Element], lhs: &[Self::Element], rhs: &[Self::Element], memory_provider: &M, )

Computes the convolution of lhs and rhs, and adds the result to dst.

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

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. Note that this does not have to be unique, if rhs is a left zero-divisor. In particular, this function will return any element in the ring if lhs = rhs = 0.

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

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

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

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

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

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

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

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

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

where R: RingStore,

type CodomainStore = R

type DomainStore = RingValue<StaticRingBase<i32>>

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

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

fn map(&self, x: i32) -> <R::Type as RingBase>::Element

fn mul_assign_map(&self, lhs: &mut <R::Type as RingBase>::Element, rhs: i32)

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

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

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

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

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

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

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

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

impl IntCast<RustBigintRingBase> for StaticRingBase<i128>

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

impl IntCast<RustBigintRingBase> for StaticRingBase<i16>

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

impl IntCast<RustBigintRingBase> for StaticRingBase<i32>

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

impl IntCast<RustBigintRingBase> for StaticRingBase<i64>

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

impl IntCast<RustBigintRingBase> for StaticRingBase<i8>

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

impl IntCast<StaticRingBase<i128>> for RustBigintRingBase

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

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

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

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

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

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

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

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

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

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

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

impl IntCast<StaticRingBase<i16>> for RustBigintRingBase

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

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

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

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

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

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

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

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

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

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

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

impl IntCast<StaticRingBase<i32>> for RustBigintRingBase

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

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

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

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

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

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

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

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

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

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

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

impl IntCast<StaticRingBase<i64>> for RustBigintRingBase

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

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

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

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

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

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

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

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

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

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

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

impl IntCast<StaticRingBase<i8>> for RustBigintRingBase

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

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

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

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

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

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

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

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

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

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

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

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

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

Computes a float value that is supposed to be close to value. However, no guarantees are made on how close it must be, in particular, this function may also always return 0. (this is just an example - it’s not a good idea).

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 power_of_two(&self, power: usize) -> Self::Element

Returns the value 2^power in this integer ring.

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

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

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

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

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

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

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

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

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

impl<T> PartialEq for StaticRingBase<T>

fn eq(&self, _: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: 'static + PrimitiveInt> PreparedDivisibilityRing for StaticRingBase<T>

type PreparedDivisor = PrimitiveIntPreparedDivisor<T>

fn prepare_divisor(&self, x: &Self::Element) -> Self::PreparedDivisor

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

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

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

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

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

fn is_noetherian(&self) -> bool

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

fn characteristic<I: IntegerRingStore>(&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 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 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 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 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 pow_gen<R: IntegerRingStore>( &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: Iterator<Item = Self::Element>,

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

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

impl<T> Copy for StaticRingBase<T>

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