Struct RNSConvolutionZn

pub struct RNSConvolutionZn<I = BigIntRing, C = NTTConvolution<ZnBase, ZnFastmulBase, CanHom<ZnFastmul, Zn>>, A = Global, CreateC = CreateNTTConvolution>
where
    I: RingStore + Clone,
    I::Type: IntegerRing,
    C: ConvolutionAlgorithm<ZnBase>,
    A: Allocator + Clone,
    CreateC: Fn(Zn) -> C,
{ /* private fields */ }

Same as RNSConvolution, but computes convolutions over ZnRings.

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<R, I, C, A, CreateC> ConvolutionAlgorithm<R> for RNSConvolutionZn<I, C, A, CreateC>

where I: RingStore + Clone, I::Type: IntegerRing, C: ConvolutionAlgorithm<ZnBase>, A: Allocator + Clone, CreateC: Fn(Zn) -> C, R: ?Sized + ZnRing + CanHomFrom<I::Type>,

type PreparedConvolutionOperand = PreparedConvolutionOperand<R, C>

Additional data associated to a list of ring elements, which can be used to compute a convolution where this list is one of the operands faster.

fn compute_convolution<S: RingStore<Type = R> + Copy, V1: VectorView<<R as RingBase>::Element>, V2: VectorView<<R as RingBase>::Element>>( &self, lhs: V1, rhs: V2, dst: &mut [<R as RingBase>::Element], ring: S, )

Elementwise adds the convolution of lhs and rhs to dst.

fn supports_ring<S: RingStore<Type = R> + Copy>(&self, _ring: S) -> bool

Returns whether this convolution algorithm supports computations of the given ring.

fn prepare_convolution_operand<S, V>( &self, val: V, len_hint: Option<usize>, ring: S, ) -> Self::PreparedConvolutionOperand

where S: RingStore<Type = R> + Copy, V: VectorView<R::Element>,

Takes an input list of values and computes an opaque ConvolutionAlgorithm::PreparedConvolutionOperand, which can be used to compute future convolutions with this list of values faster.

fn compute_convolution_prepared<S, V1, V2>( &self, lhs: V1, lhs_prep: Option<&Self::PreparedConvolutionOperand>, rhs: V2, rhs_prep: Option<&Self::PreparedConvolutionOperand>, dst: &mut [R::Element], ring: S, )

where S: RingStore<Type = R> + Copy, V1: VectorView<El<S>>, V2: VectorView<El<S>>,

Elementwise adds the convolution of lhs and rhs to dst. If provided, the given prepared convolution operands are used for a faster computation.

fn compute_convolution_sum<'a, S, J, V1, V2>( &self, values: J, dst: &mut [R::Element], ring: S, )

where S: RingStore<Type = R> + Copy, J: ExactSizeIterator<Item = (V1, Option<&'a Self::PreparedConvolutionOperand>, V2, Option<&'a Self::PreparedConvolutionOperand>)>, V1: VectorView<R::Element>, V2: VectorView<R::Element>, Self: 'a, R: 'a,

Computes a convolution for each tuple in the given sequence, and sums the result of each convolution to dst.

impl<'a, I, C, A, CreateC> From<&'a RNSConvolution<I, C, A, CreateC>> for &'a RNSConvolutionZn<I, C, A, CreateC>

where I: RingStore + Clone, I::Type: IntegerRing, C: ConvolutionAlgorithm<ZnBase>, A: Allocator + Clone, CreateC: Fn(Zn) -> C,

fn from(value: &'a RNSConvolution<I, C, A, CreateC>) -> Self

Converts to this type from the input type.

impl<'a, I, C, A, CreateC> From<&'a RNSConvolutionZn<I, C, A, CreateC>> for &'a RNSConvolution<I, C, A, CreateC>

where I: RingStore + Clone, I::Type: IntegerRing, C: ConvolutionAlgorithm<ZnBase>, A: Allocator + Clone, CreateC: Fn(Zn) -> C,

fn from(value: &'a RNSConvolutionZn<I, C, A, CreateC>) -> Self

Converts to this type from the input type.

impl<I, C, A, CreateC> From<RNSConvolution<I, C, A, CreateC>> for RNSConvolutionZn<I, C, A, CreateC>

where I: RingStore + Clone, I::Type: IntegerRing, C: ConvolutionAlgorithm<ZnBase>, A: Allocator + Clone, CreateC: Fn(Zn) -> C,

fn from(value: RNSConvolution<I, C, A, CreateC>) -> Self

Converts to this type from the input type.

impl<I, C, A, CreateC> From<RNSConvolutionZn<I, C, A, CreateC>> for RNSConvolution<I, C, A, CreateC>

where I: RingStore + Clone, I::Type: IntegerRing, C: ConvolutionAlgorithm<ZnBase>, A: Allocator + Clone, CreateC: Fn(Zn) -> C,

fn from(value: RNSConvolutionZn<I, C, A, CreateC>) -> Self

Converts to this type from the input type.