Struct MixedRadix9xnAvx 

pub struct MixedRadix9xnAvx<A: AvxNum, T> {
    twiddles_butterfly9: [A::VectorType; 3],
    twiddles_butterfly9_lo: [A::VectorType; 2],
    twiddles_butterfly3: A::VectorType,
    common_data: CommonSimdData<T, A::VectorType>,
    _phantom: PhantomData<T>,
}

Fields

twiddles_butterfly9: [A::VectorType; 3]

twiddles_butterfly9_lo: [A::VectorType; 2]

twiddles_butterfly3: A::VectorType

common_data: CommonSimdData<T, A::VectorType>

_phantom: PhantomData<T>

Implementations

impl<A: AvxNum, T: FftNum> MixedRadix9xnAvx<A, T>

unsafe fn new_with_avx(inner_fft: Arc<dyn Fft<T>>) -> Self

unsafe fn perform_column_butterflies_immut( &self, input: impl AvxArray<A>, buffer: impl AvxArrayMut<A>, )

unsafe fn perform_column_butterflies(&self, buffer: impl AvxArrayMut<A>)

unsafe fn transpose(&self, input: &[Complex<A>], output: &mut [Complex<A>])

pub fn new(inner_fft: Arc<dyn Fft<T>>) -> Result<Self, ()>

Preallocates necessary arrays and precomputes necessary data to efficiently compute the FFT Returns Ok() if this machine has the required instruction sets, Err() if some instruction sets are missing

unsafe fn perform_fft_inplace( &self, buffer: &mut [Complex<T>], scratch: &mut [Complex<T>], )

unsafe fn perform_fft_immut( &self, input: &[Complex<T>], output: &mut [Complex<T>], scratch: &mut [Complex<T>], )

unsafe fn perform_fft_out_of_place( &self, input: &mut [Complex<T>], output: &mut [Complex<T>], scratch: &mut [Complex<T>], )

Trait Implementations

impl<A: AvxNum, T> Direction for MixedRadix9xnAvx<A, T>

fn fft_direction(&self) -> FftDirection

Returns FftDirection::Forward if this instance computes forward FFTs, or FftDirection::Inverse for inverse FFTs

impl<A: AvxNum, T: FftNum> Fft<T> for MixedRadix9xnAvx<A, T>

fn process_immutable_with_scratch( &self, input: &[Complex<T>], output: &mut [Complex<T>], scratch: &mut [Complex<T>], )

Divides input and output into chunks of self.len(), and computes a FFT on each chunk while keeping input untouched.

fn process_outofplace_with_scratch( &self, input: &mut [Complex<T>], output: &mut [Complex<T>], scratch: &mut [Complex<T>], )

Divides input and output into chunks of size self.len(), and computes a FFT on each chunk.

fn process_with_scratch( &self, buffer: &mut [Complex<T>], scratch: &mut [Complex<T>], )

Divides buffer into chunks of size self.len(), and computes a FFT on each chunk.

fn get_inplace_scratch_len(&self) -> usize

Returns the size of the scratch buffer required by process_with_scratch

fn get_outofplace_scratch_len(&self) -> usize

Returns the size of the scratch buffer required by process_outofplace_with_scratch

fn get_immutable_scratch_len(&self) -> usize

Returns the size of the scratch buffer required by process_immutable_with_scratch

fn process(&self, buffer: &mut [Complex<T>])

Computes a FFT in-place.

impl<A: AvxNum, T> Length for MixedRadix9xnAvx<A, T>

fn len(&self) -> usize

The FFT size that this algorithm can process