Struct concrete_fft::ordered::Plan

pub struct Plan { /* private fields */ }

Ordered FFT plan.

This type holds a forward and inverse FFT plan and twiddling factors for a specific size. The size must be a power of two, and can be as large as 2^16 (inclusive).

Implementations

impl Plan

pub fn new(n: usize, method: Method) -> Self

Returns a new FFT plan for the given vector size, selected by the provided method.

Panics

• Panics if n is not a power of two.
• Panics if n is greater than 2^10.

Example

use concrete_fft::ordered::{Method, Plan};
use core::time::Duration;

let plan = Plan::new(4, Method::Measure(Duration::from_millis(10)));

pub fn fft_size(&self) -> usize

Returns the vector size of the FFT.

Example

use concrete_fft::ordered::{Method, Plan};
use core::time::Duration;

let plan = Plan::new(4, Method::Measure(Duration::from_millis(10)));
assert_eq!(plan.fft_size(), 4);

pub fn algo(&self) -> FftAlgo

Returns the algorithm that’s internally used by the FFT.

Example

use concrete_fft::ordered::{FftAlgo, Method, Plan};

let plan = Plan::new(4, Method::UserProvided(FftAlgo::Dif2));
assert_eq!(plan.algo(), FftAlgo::Dif2);

pub fn fft_scratch(&self) -> Result<StackReq, SizeOverflow>

Returns the size and alignment of the scratch memory needed to perform an FFT.

Example

use concrete_fft::ordered::{Method, Plan};
use core::time::Duration;

let plan = Plan::new(4, Method::Measure(Duration::from_millis(10)));
let scratch = plan.fft_scratch().unwrap();

pub fn fwd(&self, buf: &mut [c64], stack: PodStack<'_>)

Performs a forward FFT in place, using the provided stack as scratch space.

Example

use concrete_fft::c64;
use concrete_fft::ordered::{Method, Plan};
use dyn_stack::{PodStack, GlobalPodBuffer};
use core::time::Duration;

let plan = Plan::new(4, Method::Measure(Duration::from_millis(10)));

let mut memory = GlobalPodBuffer::new(plan.fft_scratch().unwrap());
let stack = PodStack::new(&mut memory);

let mut buf = [c64::default(); 4];
plan.fwd(&mut buf, stack);

pub fn inv(&self, buf: &mut [c64], stack: PodStack<'_>)

Performs an inverse FFT in place, using the provided stack as scratch space.

Example

use concrete_fft::c64;
use concrete_fft::ordered::{Method, Plan};
use dyn_stack::{PodStack, GlobalPodBuffer, ReborrowMut};
use core::time::Duration;

let plan = Plan::new(4, Method::Measure(Duration::from_millis(10)));

let mut memory = GlobalPodBuffer::new(plan.fft_scratch().unwrap());
let mut stack = PodStack::new(&mut memory);

let mut buf = [c64::default(); 4];
plan.fwd(&mut buf, stack.rb_mut());
plan.inv(&mut buf, stack);

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.