Struct Plan

pub struct Plan { /* private fields */ }

Unordered 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.

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.
• If the method is user-provided, panics if n is not equal to the base ordered FFT size, and the base FFT size is less than 32.

Example

use tfhe_fft::unordered::{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 tfhe_fft::unordered::{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, usize)

Returns the algorithm and size of the internal ordered FFT plan.

Example

use tfhe_fft::{
    ordered::FftAlgo,
    unordered::{Method, Plan},
};

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

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

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

Example

use tfhe_fft::unordered::{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.

Note

The values in buf must be in standard order prior to calling this function. When this function returns, the values in buf will contain the terms of the forward transform in permuted order.

Example

use tfhe_fft::c64;
use tfhe_fft::unordered::{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 fwd_monomial(&self, degree: usize, buf: &mut [c64])

Performs a forward FFT on the implicit polynomial X^degree, storing the result in buf. The coefficients are permuted so that they’re compatible with other FFTs produced by the same plan.

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

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

Note

The values in buf must be in permuted order prior to calling this function. When this function returns, the values in buf will contain the terms of the forward transform in standard order.

Example

use tfhe_fft::c64;
use tfhe_fft::unordered::{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);

pub fn serialize_fourier_buffer<S: Serializer>( &self, serializer: S, buf: &[c64], ) -> Result<S::Ok, S::Error>

Available on crate feature serde only.

Serialize a buffer containing data in the Fourier domain that is stored in the plan-specific permuted order, and store the result with the serializer in the standard order.

Panics

• Panics if the length of buf is not equal to the FFT size.

pub fn deserialize_fourier_buffer<'de, D: Deserializer<'de>>( &self, deserializer: D, buf: &mut [c64], ) -> Result<(), D::Error>

Available on crate feature serde only.

Deserialize data in the Fourier domain that is produced by the deserializer in the standard order into a buffer so that it will contain the data in the plan-specific permuted order

Panics

• Panics if the length of buf is not equal to the FFT size.

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.