Struct AsLocalPIRBase

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

A wrapper around a ring that marks this ring to be a local principal ideal ring.

The design is analogous to crate::rings::field::AsFieldBase.

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.

Implementations

impl<R: DivisibilityRingStore> AsLocalPIRBase<R>

where R::Type: DivisibilityRing,

pub fn promise_is_local_pir( base: R, max_ideal_gen: El<R>, nilpotent_power: Option<usize>, ) -> Self

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>

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_self(self) -> R

Availability

This API is marked as unstable and is only available when the unstable-enable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

Trait Implementations

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

fn has_canonical_hom( &self, from: &AsFieldBase<R1>, ) -> Option<Self::Homomorphism>

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

where AsLocalPIRStore: 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

fn has_canonical_hom( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, ) -> Option<Self::Homomorphism>

fn map_in( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, el: LocalPIREl<AsLocalPIRStore>, hom: &Self::Homomorphism, ) -> <Self as RingBase>::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<AsLocalPIRStore> CanHomFrom<AsLocalPIRBase<AsLocalPIRStore>> for ZnBase

where AsLocalPIRStore: RingStore<Type = ZnBase>,

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

fn has_canonical_hom( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, ) -> Option<Self::Homomorphism>

fn map_in( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, el: LocalPIREl<AsLocalPIRStore>, hom: &Self::Homomorphism, ) -> <Self as RingBase>::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<AsLocalPIRStore, I, J> CanHomFrom<AsLocalPIRBase<AsLocalPIRStore>> for ZnBase<J>

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

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

fn has_canonical_hom( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, ) -> Option<Self::Homomorphism>

fn map_in( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, el: LocalPIREl<AsLocalPIRStore>, hom: &Self::Homomorphism, ) -> <Self as RingBase>::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<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

fn has_canonical_hom( &self, from: &AsLocalPIRBase<R1>, ) -> Option<Self::Homomorphism>

fn map_in( &self, from: &AsLocalPIRBase<R1>, el: <AsLocalPIRBase<R1> as RingBase>::Element, hom: &Self::Homomorphism, ) -> 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<R: DivisibilityRingStore, S: DivisibilityRingStore> CanHomFrom<AsLocalPIRBase<S>> for AsLocalPIRBase<R>

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

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

fn has_canonical_hom( &self, from: &AsLocalPIRBase<S>, ) -> Option<Self::Homomorphism>

fn map_in( &self, from: &AsLocalPIRBase<S>, el: LocalPIREl<S>, hom: &Self::Homomorphism, ) -> 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<AsLocalPIRStore, R1, V1, A1, C1, R2, V2, A2, C2> CanHomFrom<FreeAlgebraImplBase<R1, V1, A1, C1>> for AsLocalPIRBase<AsLocalPIRStore>

where AsLocalPIRStore: 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

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

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

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<R: DivisibilityRingStore, S: IntegerRing + ?Sized> CanHomFrom<S> for AsLocalPIRBase<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

fn has_canonical_hom(&self, from: &S) -> Option<Self::Homomorphism>

fn map_in( &self, from: &S, el: S::Element, hom: &Self::Homomorphism, ) -> 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<AsLocalPIRStore, I, J> CanHomFrom<ZnBase<I>> for AsLocalPIRBase<AsLocalPIRStore>

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

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

fn has_canonical_hom(&self, from: &ZnBase<I>) -> Option<Self::Homomorphism>

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

where AsLocalPIRStore: RingStore<Type = ZnBase>,

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

fn has_canonical_hom(&self, from: &ZnBase) -> Option<Self::Homomorphism>

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

fn has_canonical_iso(&self, from: &AsFieldBase<R1>) -> Option<Self::Isomorphism>

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

impl<AsLocalPIRStore, R1, V1, A1, C1, R2, V2, A2, C2> CanIsoFromTo<AsLocalPIRBase<AsLocalPIRStore>> for FreeAlgebraImplBase<R2, V2, A2, C2>

where AsLocalPIRStore: 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

fn has_canonical_iso( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, ) -> Option<Self::Isomorphism>

fn map_out( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, el: <Self as RingBase>::Element, hom: &Self::Isomorphism, ) -> LocalPIREl<AsLocalPIRStore>

impl<AsLocalPIRStore> CanIsoFromTo<AsLocalPIRBase<AsLocalPIRStore>> for ZnBase

where AsLocalPIRStore: RingStore<Type = ZnBase>,

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

fn has_canonical_iso( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, ) -> Option<Self::Isomorphism>

fn map_out( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, el: <Self as RingBase>::Element, hom: &Self::Isomorphism, ) -> LocalPIREl<AsLocalPIRStore>

impl<AsLocalPIRStore, I, J> CanIsoFromTo<AsLocalPIRBase<AsLocalPIRStore>> for ZnBase<J>

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

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

fn has_canonical_iso( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, ) -> Option<Self::Isomorphism>

fn map_out( &self, from: &AsLocalPIRBase<AsLocalPIRStore>, el: <Self as RingBase>::Element, hom: &Self::Isomorphism, ) -> LocalPIREl<AsLocalPIRStore>

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

fn has_canonical_iso( &self, from: &AsLocalPIRBase<R1>, ) -> Option<Self::Isomorphism>

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

impl<R: DivisibilityRingStore, S: DivisibilityRingStore> CanIsoFromTo<AsLocalPIRBase<S>> for AsLocalPIRBase<R>

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

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

fn has_canonical_iso( &self, from: &AsLocalPIRBase<S>, ) -> Option<Self::Isomorphism>

fn map_out( &self, from: &AsLocalPIRBase<S>, el: Self::Element, iso: &Self::Isomorphism, ) -> LocalPIREl<S>

impl<AsLocalPIRStore, R1, V1, A1, C1, R2, V2, A2, C2> CanIsoFromTo<FreeAlgebraImplBase<R1, V1, A1, C1>> for AsLocalPIRBase<AsLocalPIRStore>

where AsLocalPIRStore: 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

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

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

impl<AsLocalPIRStore, I, J> CanIsoFromTo<ZnBase<I>> for AsLocalPIRBase<AsLocalPIRStore>

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

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

fn has_canonical_iso(&self, from: &ZnBase<I>) -> Option<Self::Isomorphism>

fn map_out( &self, from: &ZnBase<I>, el: <Self as RingBase>::Element, iso: &Self::Isomorphism, ) -> <ZnBase<I> as RingBase>::Element

impl<AsLocalPIRStore> CanIsoFromTo<ZnBase> for AsLocalPIRBase<AsLocalPIRStore>

where AsLocalPIRStore: RingStore<Type = ZnBase>,

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

fn has_canonical_iso(&self, from: &ZnBase) -> Option<Self::Isomorphism>

fn map_out( &self, from: &ZnBase, el: <Self as RingBase>::Element, iso: &Self::Isomorphism, ) -> <ZnBase as RingBase>::Element

impl<R> Clone for AsLocalPIRBase<R>

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: DivisibilityRingStore> ComputeInnerProduct for AsLocalPIRBase<R>

where R::Type: DivisibilityRing,

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

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,

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,

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

impl<R: DivisibilityRingStore> DelegateRing for AsLocalPIRBase<R>

where R::Type: DivisibilityRing,

type Element = LocalPIREl<R>

type Base = <R as RingStore>::Type

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

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

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

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

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

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

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

impl<R: DivisibilityRingStore> DivisibilityRing for AsLocalPIRBase<R>

where R::Type: DivisibilityRing,

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.

type PreparedDivisorData = ()

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

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

Returns whether there is an element x such that rhs * x = lhs. If you need such an element, consider using DivisibilityRing::checked_left_div().

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

Same as DivisibilityRing::divides_left(), but requires a commutative ring.

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

Same as DivisibilityRing::checked_left_div(), but requires a commutative ring.

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

Returns whether the given element is a unit, i.e. has an inverse.

fn balance_factor<'a, I>(&self, _elements: I) -> Option<Self::Element>

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

Function that computes a “balancing” factor of a sequence of ring elements. The only use of the balancing factor is to increase performance, in particular, dividing all elements in the sequence by this factor should make them “smaller” resp. cheaper to process.

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

“Prepares” an element of this ring for division.

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

Same as DivisibilityRing::checked_left_div() but for a prepared divisor.

fn divides_left_prepared( &self, lhs: &Self::Element, rhs: &PreparedDivisor<Self>, ) -> 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<R: DivisibilityRingStore> EuclideanRing for AsLocalPIRBase<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_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<R: DivisibilityRingStore> Field for AsLocalPIRBase<R>

where R::Type: DivisibilityRing + Field,

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

impl<R> FromModulusCreateableZnRing for AsLocalPIRBase<RingValue<R>>

where R: DivisibilityRing + ZnRing + FromModulusCreateableZnRing,

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

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

impl<R> InterpolationBaseRing for AsLocalPIRBase<R>

where R: RingStore, R::Type: InterpolationBaseRing,

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

Restricting this here to be DivisibilityRing + PrincipalIdealRing + Domain is necessary, because of a compiler bug, see also crate::compute_locally::EvaluatePolyLocallyRing::LocalRingBase

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

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

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

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

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

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

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

impl<R: DivisibilityRingStore> KaratsubaHint for AsLocalPIRBase<R>

where R::Type: DivisibilityRing,

fn karatsuba_threshold(&self) -> usize

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

impl<R> PartialEq for AsLocalPIRBase<R>

where R: DivisibilityRingStore, 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: DivisibilityRingStore> PrincipalIdealRing for AsLocalPIRBase<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 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 annihilator(&self, val: &Self::Element) -> Self::Element

Returns the (w.r.t. divisibility) smallest element x such that x * val = 0.

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<R: DivisibilityRingStore> PrincipalLocalRing for AsLocalPIRBase<R>

where R::Type: DivisibilityRing,

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

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

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

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>

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

impl<R: DivisibilityRingStore> StrassenHint for AsLocalPIRBase<R>

where R::Type: DivisibilityRing,

fn strassen_threshold(&self) -> usize

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

impl<R> Copy for AsLocalPIRBase<R>

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

impl<R: DivisibilityRingStore> DelegateRingImplFiniteRing for AsLocalPIRBase<R>

where R::Type: DivisibilityRing,

impl<R: DivisibilityRingStore> Domain for AsLocalPIRBase<R>

where R::Type: DivisibilityRing + Domain,