Struct AsFieldBase 

pub struct AsFieldBase<R: RingStore>
where
    R::Type: DivisibilityRing,
{ /* private fields */ }

A wrapper around a ring that marks this ring to be a perfect field. In particular, the functions provided by DivisibilityRing will be used to provide field-like division for the wrapped ring.

Example

A common case where you might encounter AsFieldBase is when working with rings which might or might not be a field depending on data only known at runtime. One example are implementations of ZnRing with modulus chosen at runtime.

// 7 is a prime, so this is a field - but must be checked at runtime
let Fp_as_ring = Zn::new(7);
// we use `ZnRing::as_field()` to make this a field
let Fp_as_field: AsField<Zn> = Fp_as_ring.as_field().ok().unwrap();
// in many cases (like here) we can use canonical isomorphisms to map elements
let iso = Fp_as_field.can_iso(&Fp_as_ring).unwrap();
assert_el_eq!(&Fp_as_ring, Fp_as_ring.one(), iso.map(Fp_as_field.one()));

Since the canonical isomorphisms are not given by blanket implementations (unfortunately there are some conflicts…), they are often not available in generic contexts. In this case, the currently best solution is to directly use the functions given by DelegateRing, e.g.

fn work_in_Fp<R>(ring: R)
    where R: RingStore,
        R::Type: ZnRing
{
    use crate::feanor_math::delegate::DelegateRing;
 
    let R_as_field = (&ring).as_field().ok().unwrap();
    let x = ring.one();
    // since `DelegateRing` does not have a corresponding `RingStore`, the access
    // through `get_ring()` is necessary
    let x_mapped = R_as_field.get_ring().rev_delegate(x);
    let x_mapped_back = R_as_field.get_ring().delegate(x_mapped);
}

The alternative is to explicitly use WrapHom and UnwrapHom.

Implementations

impl<R: RingStore> AsFieldBase<R>

where R::Type: DivisibilityRing,

pub fn promise_is_perfect_field(base: R) -> Self

Assumes that the given ring is a perfect field, and wraps it in AsFieldBase.

This function is not really unsafe, but users should be careful to only use it with rings that are perfect fields. This cannot be checked in here, so must be checked by the caller.

pub fn promise_is_field(base: R) -> Result<Self, R>

where R::Type: FiniteRingSpecializable,

Available on crate feature unstable-enable only.

Assumes that the given ring is a field and checks whether it is perfect. If this is the case, the function wraps it in AsFieldBase.

This function is not really unsafe, but users should be careful to only use it with rings that are fields. This cannot be checked in here, so must be checked by the caller.

Note that this function does check that the passed field is perfect. However, that check is too conservative, and might fail on some perfect fields. If you are sure that the field is also perfect, consider using AsFieldBase::promise_is_perfect_field() instead.

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.

pub fn unwrap_element(&self, el: <Self as RingBase>::Element) -> El<R>

pub fn unwrap_self(self) -> R

Removes the wrapper, returning the underlying base field.

impl<R: RingStore> AsFieldBase<R>

where R::Type: PerfectField,

pub fn from_field(base: R) -> Self

Creates a new AsFieldBase from a ring that is already known to be a perfect field.

Trait Implementations

impl<AsFieldRingStore, R1, V1, A1, C1, R2, V2, A2, C2> CanHomFrom<AsFieldBase<AsFieldRingStore>> for FreeAlgebraImplBase<R2, V2, A2, C2>

where AsFieldRingStore: RingStore<Type = FreeAlgebraImplBase<R1, V1, A1, C1>>, R1: RingStore, R1::Type: LinSolveRing, V1: VectorView<El<R1>>, A1: Allocator + Clone, C1: ConvolutionAlgorithm<R1::Type>, R2: RingStore, R2::Type: LinSolveRing + CanHomFrom<R1::Type>, V2: VectorView<El<R2>>, A2: Allocator + Clone, C2: ConvolutionAlgorithm<R2::Type>,

type Homomorphism = <FreeAlgebraImplBase<R2, V2, A2, C2> as CanHomFrom<FreeAlgebraImplBase<R1, V1, A1, C1>>>::Homomorphism

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

fn has_canonical_hom( &self, from: &AsFieldBase<AsFieldRingStore>, ) -> 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: &AsFieldBase<AsFieldRingStore>, el: FieldEl<AsFieldRingStore>, hom: &Self::Homomorphism, ) -> <Self as RingBase>::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<AsFieldRingStore> CanHomFrom<AsFieldBase<AsFieldRingStore>> for ZnBase

where AsFieldRingStore: RingStore<Type = ZnBase>,

type Homomorphism = <ZnBase as CanHomFrom<ZnBase>>::Homomorphism

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

fn has_canonical_hom( &self, from: &AsFieldBase<AsFieldRingStore>, ) -> 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: &AsFieldBase<AsFieldRingStore>, el: FieldEl<AsFieldRingStore>, hom: &Self::Homomorphism, ) -> <Self as RingBase>::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<AsFieldRingStore, I, J> CanHomFrom<AsFieldBase<AsFieldRingStore>> for ZnBase<J>

where AsFieldRingStore: RingStore<Type = ZnBase<I>>, I: RingStore, I::Type: IntegerRing, J: RingStore, J::Type: IntegerRing,

type Homomorphism = <ZnBase<J> as CanHomFrom<ZnBase<I>>>::Homomorphism

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

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

Evaluates the homomorphism.

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

Evaluates the homomorphism, taking the element by reference.

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

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

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

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

impl<R1, R2> CanHomFrom<AsFieldBase<R1>> for AsLocalPIRBase<R2>

where R1: RingStore, R2: RingStore, R2::Type: CanHomFrom<R1::Type> + DivisibilityRing, R1::Type: DivisibilityRing,

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

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

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

Evaluates the homomorphism.

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

Evaluates the homomorphism, taking the element by reference.

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

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

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

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

impl<R: RingStore, S: RingStore> CanHomFrom<AsFieldBase<S>> for AsFieldBase<R>

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

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: &AsFieldBase<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( &self, from: &AsFieldBase<S>, el: FieldEl<S>, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

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

Evaluates the homomorphism, taking the element by reference.

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

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

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

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

impl<R1, R2> CanHomFrom<AsLocalPIRBase<R1>> for AsFieldBase<R2>

where R1: RingStore, R2: RingStore, R2::Type: CanHomFrom<R1::Type> + DivisibilityRing, R1::Type: DivisibilityRing,

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

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

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

Evaluates the homomorphism.

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

Evaluates the homomorphism, taking the element by reference.

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

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

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

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

impl<AsFieldRingStore, R1, V1, A1, C1, R2, V2, A2, C2> CanHomFrom<FreeAlgebraImplBase<R1, V1, A1, C1>> for AsFieldBase<AsFieldRingStore>

where AsFieldRingStore: RingStore<Type = FreeAlgebraImplBase<R2, V2, A2, C2>>, R1: RingStore, R1::Type: LinSolveRing, V1: VectorView<El<R1>>, A1: Allocator + Clone, C1: ConvolutionAlgorithm<R1::Type>, R2: RingStore, R2::Type: LinSolveRing + CanHomFrom<R1::Type>, V2: VectorView<El<R2>>, A2: Allocator + Clone, C2: ConvolutionAlgorithm<R2::Type>,

type Homomorphism = <FreeAlgebraImplBase<R2, V2, A2, C2> as CanHomFrom<FreeAlgebraImplBase<R1, V1, A1, C1>>>::Homomorphism

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

fn has_canonical_hom( &self, from: &FreeAlgebraImplBase<R1, V1, A1, C1>, ) -> Option<Self::Homomorphism>

If there is a canonical homomorphism from -> self, returns Some(data), where data is additional data that can be used to compute the action of the homomorphism on ring elements. Otherwise, None is returned.

fn map_in( &self, from: &FreeAlgebraImplBase<R1, V1, A1, C1>, el: <FreeAlgebraImplBase<R1, V1, A1, C1> as RingBase>::Element, hom: &Self::Homomorphism, ) -> <Self as RingBase>::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<Impl, R, A, V, C> CanHomFrom<GaloisFieldBase<Impl>> for AsFieldBase<FreeAlgebraImpl<R, V, A, C>>

where Impl: RingStore, Impl::Type: Field + FreeAlgebra + FiniteRing, <<Impl::Type as RingExtension>::BaseRing as RingStore>::Type: ZnRing + Field, R: RingStore, R::Type: LinSolveRing, V: VectorView<El<R>>, C: ConvolutionAlgorithm<R::Type>, A: Allocator + Clone, FreeAlgebraImplBase<R, V, A, C>: CanHomFrom<Impl::Type>,

For the rationale which blanket implementations I chose, see the GaloisFieldBase.

type Homomorphism = <FreeAlgebraImplBase<R, V, A, C> as CanHomFrom<<Impl as RingStore>::Type>>::Homomorphism

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

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

Evaluates the homomorphism.

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

Evaluates the homomorphism, taking the element by reference.

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

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

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

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

impl<R: RingStore, S: IntegerRing + ?Sized> CanHomFrom<S> for AsFieldBase<R>

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

Necessary to potentially implement crate::rings::zn::ZnRing.

type Homomorphism = <<R as RingStore>::Type as CanHomFrom<S>>::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( &self, from: &S, el: S::Element, hom: &Self::Homomorphism, ) -> Self::Element

Evaluates the homomorphism.

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

Evaluates the homomorphism, taking the element by reference.

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

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

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

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

impl<AsFieldRingStore, I, J> CanHomFrom<ZnBase<I>> for AsFieldBase<AsFieldRingStore>

where AsFieldRingStore: RingStore<Type = ZnBase<J>>, I: RingStore, I::Type: IntegerRing, J: RingStore, J::Type: IntegerRing,

type Homomorphism = <ZnBase<J> as CanHomFrom<ZnBase<I>>>::Homomorphism

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

fn has_canonical_hom(&self, from: &ZnBase<I>) -> 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: &ZnBase<I>, el: <ZnBase<I> as RingBase>::Element, hom: &Self::Homomorphism, ) -> <Self as RingBase>::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<I> CanHomFrom<ZnBase<I>> for AsFieldBase<Zn>

where I: RingStore, I::Type: IntegerRing,

type Homomorphism = <ZnBase as CanHomFrom<ZnBase<I>>>::Homomorphism

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

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

Evaluates the homomorphism.

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

Evaluates the homomorphism, taking the element by reference.

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

Evaluates the homomorphism on rhs, and multiplies the result to lhs.

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

Evaluates the homomorphism on rhs, taking it by reference, and multiplies the result to lhs.

fn fma_map_in( &self, from: &S, lhs: &Self::Element, rhs: &S::Element, summand: Self::Element, hom: &Self::Homomorphism, ) -> Self::Element

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

impl<AsFieldRingStore> CanHomFrom<ZnBase> for AsFieldBase<AsFieldRingStore>

where AsFieldRingStore: RingStore<Type = ZnBase>,

type Homomorphism = <ZnBase as CanHomFrom<ZnBase>>::Homomorphism

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

fn has_canonical_hom(&self, from: &ZnBase) -> 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: &ZnBase, el: <ZnBase as RingBase>::Element, hom: &Self::Homomorphism, ) -> <Self as RingBase>::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<AsFieldRingStore, R1, V1, A1, C1, R2, V2, A2, C2> CanIsoFromTo<AsFieldBase<AsFieldRingStore>> for FreeAlgebraImplBase<R2, V2, A2, C2>

where AsFieldRingStore: RingStore<Type = FreeAlgebraImplBase<R1, V1, A1, C1>>, R1: RingStore, R1::Type: LinSolveRing, V1: VectorView<El<R1>>, A1: Allocator + Clone, C1: ConvolutionAlgorithm<R1::Type>, R2: RingStore, R2::Type: LinSolveRing + CanIsoFromTo<R1::Type>, V2: VectorView<El<R2>>, A2: Allocator + Clone, C2: ConvolutionAlgorithm<R2::Type>,

type Isomorphism = <FreeAlgebraImplBase<R2, V2, A2, C2> as CanIsoFromTo<FreeAlgebraImplBase<R1, V1, A1, C1>>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso( &self, from: &AsFieldBase<AsFieldRingStore>, ) -> 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: &AsFieldBase<AsFieldRingStore>, el: <Self as RingBase>::Element, hom: &Self::Isomorphism, ) -> FieldEl<AsFieldRingStore>

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

impl<AsFieldRingStore> CanIsoFromTo<AsFieldBase<AsFieldRingStore>> for ZnBase

where AsFieldRingStore: RingStore<Type = ZnBase>,

type Isomorphism = <ZnBase as CanIsoFromTo<ZnBase>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso( &self, from: &AsFieldBase<AsFieldRingStore>, ) -> 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: &AsFieldBase<AsFieldRingStore>, el: <Self as RingBase>::Element, hom: &Self::Isomorphism, ) -> FieldEl<AsFieldRingStore>

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

impl<AsFieldRingStore, I, J> CanIsoFromTo<AsFieldBase<AsFieldRingStore>> for ZnBase<J>

where AsFieldRingStore: RingStore<Type = ZnBase<I>>, I: RingStore, I::Type: IntegerRing, J: RingStore, J::Type: IntegerRing,

type Isomorphism = <ZnBase<J> as CanIsoFromTo<ZnBase<I>>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso( &self, from: &AsFieldBase<AsFieldRingStore>, ) -> 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: &AsFieldBase<AsFieldRingStore>, el: <Self as RingBase>::Element, hom: &Self::Isomorphism, ) -> FieldEl<AsFieldRingStore>

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

impl<R1, R2> CanIsoFromTo<AsFieldBase<R1>> for AsLocalPIRBase<R2>

where R1: RingStore, R2: RingStore, R2::Type: CanIsoFromTo<R1::Type> + DivisibilityRing, R1::Type: DivisibilityRing,

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

Data required to compute a preimage under the canonical homomorphism.

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

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

impl<R: RingStore, S: RingStore> CanIsoFromTo<AsFieldBase<S>> for AsFieldBase<R>

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

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: &AsFieldBase<S>) -> 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: &AsFieldBase<S>, el: Self::Element, iso: &Self::Isomorphism, ) -> FieldEl<S>

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

impl<R1, R2> CanIsoFromTo<AsLocalPIRBase<R1>> for AsFieldBase<R2>

where R1: RingStore, R2: RingStore, R2::Type: CanIsoFromTo<R1::Type> + DivisibilityRing, R1::Type: DivisibilityRing,

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

Data required to compute a preimage under the canonical homomorphism.

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

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

impl<AsFieldRingStore, R1, V1, A1, C1, R2, V2, A2, C2> CanIsoFromTo<FreeAlgebraImplBase<R1, V1, A1, C1>> for AsFieldBase<AsFieldRingStore>

where AsFieldRingStore: RingStore<Type = FreeAlgebraImplBase<R2, V2, A2, C2>>, R1: RingStore, R1::Type: LinSolveRing, V1: VectorView<El<R1>>, A1: Allocator + Clone, C1: ConvolutionAlgorithm<R1::Type>, R2: RingStore, R2::Type: LinSolveRing + CanIsoFromTo<R1::Type>, V2: VectorView<El<R2>>, A2: Allocator + Clone, C2: ConvolutionAlgorithm<R2::Type>,

type Isomorphism = <FreeAlgebraImplBase<R2, V2, A2, C2> as CanIsoFromTo<FreeAlgebraImplBase<R1, V1, A1, C1>>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso( &self, from: &FreeAlgebraImplBase<R1, V1, A1, C1>, ) -> Option<Self::Isomorphism>

If there is a canonical homomorphism from -> self, and this homomorphism is an isomorphism, returns Some(data), where data is additional data that can be used to compute preimages under the homomorphism. Otherwise, None is returned.

fn map_out( &self, from: &FreeAlgebraImplBase<R1, V1, A1, C1>, el: <Self as RingBase>::Element, iso: &Self::Isomorphism, ) -> <FreeAlgebraImplBase<R1, V1, A1, C1> as RingBase>::Element

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

impl<Impl, R, A, V, C> CanIsoFromTo<GaloisFieldBase<Impl>> for AsFieldBase<FreeAlgebraImpl<R, V, A, C>>

where Impl: RingStore, Impl::Type: Field + FreeAlgebra + FiniteRing, <<Impl::Type as RingExtension>::BaseRing as RingStore>::Type: ZnRing + Field, R: RingStore, R::Type: LinSolveRing, V: VectorView<El<R>>, C: ConvolutionAlgorithm<R::Type>, A: Allocator + Clone, FreeAlgebraImplBase<R, V, A, C>: CanIsoFromTo<Impl::Type>,

For the rationale which blanket implementations I chose, see the GaloisFieldBase.

type Isomorphism = <FreeAlgebraImplBase<R, V, A, C> as CanIsoFromTo<<Impl as RingStore>::Type>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

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

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

impl<AsFieldRingStore, I, J> CanIsoFromTo<ZnBase<I>> for AsFieldBase<AsFieldRingStore>

where AsFieldRingStore: RingStore<Type = ZnBase<J>>, I: RingStore, I::Type: IntegerRing, J: RingStore, J::Type: IntegerRing,

type Isomorphism = <ZnBase<J> as CanIsoFromTo<ZnBase<I>>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

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

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

impl<I> CanIsoFromTo<ZnBase<I>> for AsFieldBase<Zn>

where I: RingStore, I::Type: IntegerRing,

type Isomorphism = <ZnBase as CanIsoFromTo<ZnBase<I>>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

fn has_canonical_iso(&self, from: &ZnBase<I>) -> 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: &ZnBase<I>, el: Self::Element, hom: &Self::Isomorphism, ) -> <ZnBase<I> as RingBase>::Element

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

impl<AsFieldRingStore> CanIsoFromTo<ZnBase> for AsFieldBase<AsFieldRingStore>

where AsFieldRingStore: RingStore<Type = ZnBase>,

type Isomorphism = <ZnBase as CanIsoFromTo<ZnBase>>::Isomorphism

Data required to compute a preimage under the canonical homomorphism.

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

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

impl<R> Clone for AsFieldBase<R>

where R: RingStore + Clone, R::Type: DivisibilityRing,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: RingStore> ComputeInnerProduct for AsFieldBase<R>

where R::Type: DivisibilityRing,

fn inner_product<I: Iterator<Item = (Self::Element, Self::Element)>>( &self, els: I, ) -> Self::Element

Available on crate feature unstable-enable only.

Computes the inner product sum_i lhs[i] * rhs[i].

fn inner_product_ref<'a, I: Iterator<Item = (&'a Self::Element, &'a Self::Element)>>( &self, els: I, ) -> Self::Element

where Self::Element: 'a, Self: 'a,

Available on crate feature unstable-enable only.

Computes the inner product sum_i lhs[i] * rhs[i].

fn inner_product_ref_fst<'a, I: Iterator<Item = (&'a Self::Element, Self::Element)>>( &self, els: I, ) -> Self::Element

where Self::Element: 'a, Self: 'a,

Available on crate feature unstable-enable only.

Computes the inner product sum_i lhs[i] * rhs[i].

impl<R> Debug for AsFieldBase<R>

where R: RingStore, R::Type: DivisibilityRing + Debug,

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

Formats the value using the given formatter.

impl<R: RingStore> DelegateRing for AsFieldBase<R>

where R::Type: DivisibilityRing,

type Element = FieldEl<R>

Type of elements of this ring. These should always wrap elements from the delegated-to ring, but may store additional data.

type Base = <R as RingStore>::Type

Type of the delegated-to ring.

fn get_delegate(&self) -> &Self::Base

Returns a reference to the delegated-to ring, which is used by all other default implementations to actually implement arithmetic operations.

fn delegate(&self, el: Self::Element) -> <Self::Base as RingBase>::Element

Creates an element of the delegated-to ring, representing the given element from this ring.

fn delegate_mut<'a>( &self, el: &'a mut Self::Element, ) -> &'a mut <Self::Base as RingBase>::Element

Provides a mutable reference to the delegated-to ring element stored in the given element from this ring.

fn delegate_ref<'a>( &self, el: &'a Self::Element, ) -> &'a <Self::Base as RingBase>::Element

Provides a reference to the delegated-to ring element stored in the given element from this ring.

fn rev_delegate(&self, el: <Self::Base as RingBase>::Element) -> Self::Element

Creates an element of this ring, representing the given element from the delegated-to ring.

fn postprocess_delegate_mut(&self, el: &mut Self::Element)

Called after every operation of the delegated-to ring that accepts a mutable reference (which is acquired using DelegateRing::delegate_mut()).

fn element_cast(&self, el: Self::Element) -> <Self as RingBase>::Element

Necessary in some locations to satisfy the type system

fn rev_element_cast(&self, el: <Self as RingBase>::Element) -> Self::Element

Necessary in some locations to satisfy the type system

fn rev_element_cast_ref<'a>( &self, el: &'a <Self as RingBase>::Element, ) -> &'a Self::Element

Necessary in some locations to satisfy the type system

fn rev_element_cast_mut<'a>( &self, el: &'a mut <Self as RingBase>::Element, ) -> &'a mut Self::Element

Necessary in some locations to satisfy the type system

impl<'de, R> Deserialize<'de> for AsFieldBase<R>

where R: RingStore + Deserialize<'de>, R::Type: DivisibilityRing,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: RingStore> EuclideanRing for AsFieldBase<R>

where R::Type: DivisibilityRing,

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

Computes only the remainder of euclidean division.

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

Computes euclidean division without remainder.

impl<R: RingStore> Field for AsFieldBase<R>

where R::Type: DivisibilityRing,

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

Computes the division lhs / rhs, where rhs != 0.

impl<R> FromModulusCreateableZnRing for AsFieldBase<RingValue<R>>

where R: DivisibilityRing + ZnRing + FromModulusCreateableZnRing,

fn from_modulus<F, E>(create_modulus: F) -> Result<Self, E>

where F: FnOnce(&Self::IntegerRingBase) -> Result<El<Self::IntegerRing>, E>,

Available on crate feature unstable-enable only.

impl<R> InterpolationBaseRing for AsFieldBase<R>

where R: InterpolationBaseRingStore, R::Type: InterpolationBaseRing,

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

Available on crate feature unstable-enable only.

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

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

Available on crate feature unstable-enable only.

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<I: RingStore> InterpolationBaseRing for AsFieldBase<Zn<I>>

where I::Type: IntegerRing,

type ExtendedRingBase<'a> = GaloisFieldBase<RingValue<AsFieldBase<RingValue<FreeAlgebraImplBase<RingRef<'a, AsFieldBase<RingValue<ZnBase<I>>>>, SparseMapVector<RingRef<'a, AsFieldBase<RingValue<ZnBase<I>>>>>>>>>> where Self: 'a

Available on crate feature unstable-enable only.

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

type ExtendedRing<'a> = RingValue<GaloisFieldBase<RingValue<AsFieldBase<RingValue<FreeAlgebraImplBase<RingRef<'a, AsFieldBase<RingValue<ZnBase<I>>>>, SparseMapVector<RingRef<'a, AsFieldBase<RingValue<ZnBase<I>>>>>>>>>>> where Self: 'a

Available on crate feature unstable-enable only.

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 InterpolationBaseRing for AsFieldBase<Zn>

type ExtendedRingBase<'a> = GaloisFieldBase<RingValue<AsFieldBase<RingValue<FreeAlgebraImplBase<RingRef<'a, AsFieldBase<RingValue<ZnBase>>>, SparseMapVector<RingRef<'a, AsFieldBase<RingValue<ZnBase>>>>>>>>> where Self: 'a

Available on crate feature unstable-enable only.

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

type ExtendedRing<'a> = RingValue<GaloisFieldBase<RingValue<AsFieldBase<RingValue<FreeAlgebraImplBase<RingRef<'a, AsFieldBase<RingValue<ZnBase>>>, SparseMapVector<RingRef<'a, AsFieldBase<RingValue<ZnBase>>>>>>>>>> where Self: 'a

Available on crate feature unstable-enable only.

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<R: RingStore> KaratsubaHint for AsFieldBase<R>

where R::Type: DivisibilityRing,

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<R> PartialEq for AsFieldBase<R>

where R: RingStore, R::Type: DivisibilityRing,

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> PrincipalIdealRing for AsFieldBase<R>

where R::Type: DivisibilityRing,

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<R: RingStore> PrincipalLocalRing for AsFieldBase<R>

where R::Type: DivisibilityRing,

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

Available on crate feature unstable-enable only.

Returns a generator p or the unique maximal ideal (p) of this ring.

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

Available on crate feature unstable-enable only.

Returns the smallest nonnegative integer e such that p^e = 0 where p is the generator of the maximal ideal.

fn valuation(&self, x: &Self::Element) -> Option<usize>

Available on crate feature unstable-enable only.

Returns the largest nonnegative integer e such that p^e | x where p is the generator of the maximal ideal.

impl<R> Serialize for AsFieldBase<R>

where R: RingStore + Serialize, R::Type: DivisibilityRing,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: RingStore> StrassenHint for AsFieldBase<R>

where R::Type: DivisibilityRing,

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<R> Copy for AsFieldBase<R>

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

impl<R: RingStore> DelegateRingImplFiniteRing for AsFieldBase<R>

where R::Type: DivisibilityRing,

impl<R: RingStore> Domain for AsFieldBase<R>

where R::Type: DivisibilityRing,

impl<R> PerfectField for AsFieldBase<R>

where R: RingStore, R::Type: DivisibilityRing,