Struct feanor_math::ring::RingValue

pub struct RingValue<R: RingBase> { /* private fields */ }

The most fundamental crate::ring::RingStore. It is basically a no-op container, i.e. stores a crate::ring::RingBase object by value, and allows accessing it.

Why is this necessary?

In fact, that we need this trait is just the result of a technical detail. We cannot implement

impl<R: RingBase> RingStore for R {}
impl<'a, R: RingStore> RingStore for &;a R {}

since this might cause conflicting implementations. Instead, we implement

impl<R: RingBase> RingStore for RingValue<R> {}
impl<'a, R: RingStore> RingStore for &;a R {}

This causes some inconvenience, as now we cannot chain crate::ring::RingStore in the case of crate::ring::RingValue. Furthermore, this trait will be necessary everywhere - to define a reference to a ring of type A, we now have to write &RingValue<A>.

To simplify this, we propose to use the following simple pattern: Create your ring type as

struct ABase { ... }
impl RingBase for ABase { ... } 

and then provide a type alias

type A = RingValue<ABase>;

Implementations

impl<R: RingBase> RingValue<R>

pub const fn from(value: R) -> Self

impl<T: PrimitiveInt> RingValue<StaticRingBase<T>>

pub const RING: StaticRing<T> = _

impl RingValue<RustBigintRingBase>

pub const RING: RustBigintRing = _

impl<I: IntegerRingStore> RingValue<ZnBase<I>>

where I::Type: IntegerRing,

pub fn new(integer_ring: I, modulus: El<I>) -> Self

impl RingValue<ZnBase>

pub fn new(modulus: u64) -> Self

👎Deprecated since 1.6.1: Please use use zn_64 instead

impl RingValue<ZnFastmulBase>

pub fn new(base: Zn) -> Self

👎Deprecated since 1.6.1: Please use use zn_64 instead

impl RingValue<ZnBase>

pub fn new(modulus: u64) -> Self

impl RingValue<ZnFastmulBase>

pub fn new(base: Zn) -> Self

impl<const N: u64, const IS_FIELD: bool> RingValue<ZnBase<N, IS_FIELD>>

pub const RING: Self = _

impl<J: IntegerRingStore> RingValue<ZnBase<RingValue<ZnBase>, J>>

where J::Type: IntegerRing, ZnBase: CanHomFrom<J::Type>, StaticRingBase<i64>: CanIsoFromTo<J::Type>,

pub fn from_primes(large_integers: J, primes: Vec<u64>) -> Self

impl<J: IntegerRingStore> RingValue<ZnBase<RingValue<ZnBase>, J>>

where J::Type: IntegerRing, ZnBase: CanHomFrom<J::Type>, StaticRingBase<i64>: CanIsoFromTo<J::Type>,

pub fn create_from_primes(large_integers: J, primes: Vec<u64>) -> Self

impl<C: ZnRingStore, J: IntegerRingStore, M: MemoryProvider<El<C>>> RingValue<ZnBase<C, J, M>>

where C::Type: ZnRing + CanHomFrom<J::Type>, J::Type: IntegerRing, <C::Type as ZnRing>::IntegerRingBase: IntegerRing + CanIsoFromTo<J::Type>,

pub fn new(summands: Vec<C>, large_integers: J, memory_provider: M) -> Self

Creates a new ring for Z/nZ with n = m1 ... mr where the mi are the moduli of the given component rings. Furthermore, the corresponding large integer ring must be provided, which has to be able to store values of size at least n^3.

impl<R: RingStore> RingValue<DensePolyRingBase<R>>

pub fn new(base_ring: R, unknown_name: &'static str) -> Self

impl<R: RingStore> RingValue<SparsePolyRingBase<R>>

pub fn new(base_ring: R, unknown_name: &'static str) -> Self

impl RingValue<Complex64Base>

pub const RING: Self = _

pub const I: Complex64El = _

impl RingValue<Complex64Base>

pub fn abs(&self, val: Complex64El) -> f64

pub fn conjugate(&self, val: Complex64El) -> Complex64El

pub fn exp(&self, exp: Complex64El) -> Complex64El

pub fn closest_gaussian_int(&self, val: Complex64El) -> (i64, i64)

pub fn ln_main_branch(&self, val: Complex64El) -> Complex64El

pub fn is_absolute_approx_eq( &self, lhs: Complex64El, rhs: Complex64El, absolute_threshold: f64, ) -> bool

pub fn is_relative_approx_eq( &self, lhs: Complex64El, rhs: Complex64El, relative_limit: f64, ) -> bool

pub fn is_approx_eq( &self, lhs: Complex64El, rhs: Complex64El, precision: u64, ) -> bool

pub fn from_f64(&self, x: f64) -> Complex64El

pub fn root_of_unity(&self, i: i64, n: i64) -> Complex64El

pub fn re(&self, x: Complex64El) -> f64

pub fn im(&self, x: Complex64El) -> f64

impl RingValue<Real64Base>

pub const RING: RingValue<Real64Base> = _

impl<R, V, M> RingValue<FreeAlgebraImplBase<R, V, M>>

where R: RingStore, V: VectorView<El<R>>, M: MemoryProvider<El<R>>,

pub const fn new( base_ring: R, x_pow_rank: V, memory_provider: M, ) -> FreeAlgebraImpl<R, V, M>

impl<R, V, M> RingValue<FreeAlgebraImplBase<R, V, M>>

where R: RingStore, R::Type: FactorPolyField, V: VectorView<El<R>>, M: MemoryProvider<El<R>>,

pub fn as_field(self) -> Result<AsField<Self>, Self>

impl<R, O, M, const N: usize> RingValue<MultivariatePolyRingImplBase<R, O, M, N>>

where R: RingStore, O: MonomialOrder, M: GrowableMemoryProvider<(El<R>, Monomial<[u16; N]>)>,

pub fn new(base_ring: R, monomial_order: O, memory_provider: M) -> Self

impl<I> RingValue<RationalFieldBase<I>>

where I: IntegerRingStore, I::Type: IntegerRing,

pub const fn new(integers: I) -> Self

Trait Implementations

impl<R: Clone + RingBase> Clone for RingValue<R>

fn clone(&self) -> RingValue<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: RingBase> RingStore for RingValue<R>

type Type = R

fn get_ring(&self) -> &R

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

See RingBase::clone_el()

fn add_assign_ref(&self, lhs: &mut El<Self>, rhs: &El<Self>)

See RingBase::add_assign_ref()

fn add_assign(&self, lhs: &mut El<Self>, rhs: El<Self>)

See RingBase::add_assign()

fn sub_assign_ref(&self, lhs: &mut El<Self>, rhs: &El<Self>)

See RingBase::sub_assign_ref()

fn sub_self_assign(&self, lhs: &mut El<Self>, rhs: El<Self>)

See RingBase::sub_self_assign()

fn sub_self_assign_ref(&self, lhs: &mut El<Self>, rhs: &El<Self>)

See RingBase::sub_self_assign_ref()

fn negate_inplace(&self, lhs: &mut El<Self>)

See RingBase::negate_inplace()

fn mul_assign(&self, lhs: &mut El<Self>, rhs: El<Self>)

See RingBase::mul_assign()

fn mul_assign_ref(&self, lhs: &mut El<Self>, rhs: &El<Self>)

See RingBase::mul_assign_ref()

fn zero(&self) -> El<Self>

See RingBase::zero()

fn one(&self) -> El<Self>

See RingBase::one()

fn neg_one(&self) -> El<Self>

See RingBase::neg_one()

fn eq_el(&self, lhs: &El<Self>, rhs: &El<Self>) -> bool

See RingBase::eq_el()

fn is_zero(&self, value: &El<Self>) -> bool

See RingBase::is_zero()

fn is_one(&self, value: &El<Self>) -> bool

See RingBase::is_one()

fn is_neg_one(&self, value: &El<Self>) -> bool

See RingBase::is_neg_one()

fn is_commutative(&self) -> bool

See RingBase::is_commutative()

fn is_noetherian(&self) -> bool

See RingBase::is_noetherian()

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

See RingBase::negate()

fn sub_assign(&self, lhs: &mut El<Self>, rhs: El<Self>)

See RingBase::sub_assign()

fn add_ref(&self, lhs: &El<Self>, rhs: &El<Self>) -> El<Self>

See RingBase::add_ref()

fn add_ref_fst(&self, lhs: &El<Self>, rhs: El<Self>) -> El<Self>

See RingBase::add_ref_fst()

fn add_ref_snd(&self, lhs: El<Self>, rhs: &El<Self>) -> El<Self>

See RingBase::add_ref_snd()

fn add(&self, lhs: El<Self>, rhs: El<Self>) -> El<Self>

See RingBase::add()

fn sub_ref(&self, lhs: &El<Self>, rhs: &El<Self>) -> El<Self>

See RingBase::sub_ref()

fn sub_ref_fst(&self, lhs: &El<Self>, rhs: El<Self>) -> El<Self>

See RingBase::sub_ref_fst()

fn sub_ref_snd(&self, lhs: El<Self>, rhs: &El<Self>) -> El<Self>

See RingBase::sub_ref_snd()

fn sub(&self, lhs: El<Self>, rhs: El<Self>) -> El<Self>

See RingBase::sub()

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

See RingBase::mul_ref()

fn mul_ref_fst(&self, lhs: &El<Self>, rhs: El<Self>) -> El<Self>

See RingBase::mul_ref_fst()

fn mul_ref_snd(&self, lhs: El<Self>, rhs: &El<Self>) -> El<Self>

See RingBase::mul_ref_snd()

fn mul(&self, lhs: El<Self>, rhs: El<Self>) -> El<Self>

See RingBase::mul()

fn square(&self, value: &mut El<Self>)

See RingBase::square()

fn coerce<S>(&self, from: &S, el: El<S>) -> El<Self>

where S: RingStore, Self::Type: CanHomFrom<S::Type>,

fn into_identity(self) -> Identity<Self>

Returns the identity map self -> self.

fn identity<'a>(&'a self) -> Identity<&'a Self>

Returns the identity map self -> self.

fn into_can_hom<S>(self, from: S) -> Result<CanHom<S, Self>, (S, Self)>

where Self: Sized, S: RingStore, Self::Type: CanHomFrom<S::Type>,

Returns the canonical homomorphism from -> self, if it exists, moving both rings into the CanHom object.

fn into_can_iso<S>(self, from: S) -> Result<CanIso<S, Self>, (S, Self)>

where Self: Sized, S: RingStore, Self::Type: CanIsoFromTo<S::Type>,

Returns the canonical isomorphism from -> self, if it exists, moving both rings into the CanHom object.

fn can_hom<'a, S>(&'a self, from: &'a S) -> Option<CanHom<&'a S, &'a Self>>

where S: RingStore, Self::Type: CanHomFrom<S::Type>,

Returns the canonical homomorphism from -> self, if it exists.

fn can_iso<'a, S>(&'a self, from: &'a S) -> Option<CanIso<&'a S, &'a Self>>

where S: RingStore, Self::Type: CanIsoFromTo<S::Type>,

Returns the canonical isomorphism from -> self, if it exists.

fn into_int_hom(self) -> IntHom<Self>

Returns the homomorphism Z -> self that exists for any ring.

fn int_hom<'a>(&'a self) -> IntHom<&'a Self>

Returns the homomorphism Z -> self that exists for any ring.

fn sum<I>(&self, els: I) -> El<Self>

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

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

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

fn pow(&self, x: El<Self>, power: usize) -> El<Self>

fn pow_gen<R: IntegerRingStore>( &self, x: El<Self>, power: &El<R>, integers: R, ) -> El<Self>

where R::Type: IntegerRing,

fn format<'a>( &'a self, value: &'a El<Self>, ) -> RingElementDisplayWrapper<'a, Self>

Returns an object that represents the given ring element and implements std::fmt::Display, to use as formatting parameter.

fn println(&self, value: &El<Self>)

fn characteristic<I: IntegerRingStore>(&self, ZZ: &I) -> Option<El<I>>

where I::Type: IntegerRing,

impl<R: Copy + RingBase> Copy for RingValue<R>