Struct FFTConvolution

pub struct FFTConvolution<A = Global> { /* private fields */ }

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

where A: Allocator + Clone,

pub fn new_with(allocator: A) -> 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 has_sufficient_precision( &self, log2_len: usize, log2_input_size: usize, ) -> bool

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<A> Clone for FFTConvolution<A>

where A: Allocator + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, A> ConvolutionAlgorithm<I> for FFTConvolution<A>

where I: ?Sized + IntegerRing, A: Allocator + Clone,

type PreparedConvolutionOperand = PreparedConvolutionOperand<I, A>

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 = I>, V1: VectorView<I::Element>, V2: VectorView<I::Element>>( &self, lhs: V1, rhs: V2, dst: &mut [I::Element], ring: S, )

Elementwise adds the convolution of lhs and rhs to dst.

fn supports_ring<S: RingStore<Type = I> + 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 = I> + Copy, V: VectorView<I::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 [I::Element], ring: S, )

where S: RingStore<Type = I> + Copy, V1: VectorView<I::Element>, V2: VectorView<I::Element>,

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 [I::Element], ring: S, )

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

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

impl<'a, A> From<&'a FFTConvolution<A>> for &'a FFTConvolutionZn<A>

where A: Allocator,

fn from(value: &'a FFTConvolution<A>) -> Self

Converts to this type from the input type.

impl<'a, A> From<&'a FFTConvolutionZn<A>> for &'a FFTConvolution<A>

where A: Allocator,

fn from(value: &'a FFTConvolutionZn<A>) -> Self

Converts to this type from the input type.

impl<A> From<FFTConvolution<A>> for FFTConvolutionZn<A>

where A: Allocator,

fn from(value: FFTConvolution<A>) -> Self

Converts to this type from the input type.

impl<A> From<FFTConvolutionZn<A>> for FFTConvolution<A>

where A: Allocator,

fn from(value: FFTConvolutionZn<A>) -> Self

Converts to this type from the input type.