Struct Plan2D 

pub struct Plan2D<T: Float> { /* private fields */ }

A plan for executing 2D FFT transforms.

Implements row-column decomposition: apply 1D FFT to all rows, then to all columns. When the threading feature is enabled, row and column passes are executed in parallel using rayon’s work-stealing scheduler. Supply a custom pool via Plan2D::with_rayon_pool to isolate FFT work from other rayon tasks in the same process.

Implementations

impl<T: Float> Plan2D<T>

pub fn new( n0: usize, n1: usize, direction: Direction, flags: Flags, ) -> Option<Self>

Create a 2D complex-to-complex DFT plan.

Arguments

• n0 - Number of rows
• n1 - Number of columns
• direction - Forward or Backward transform
• flags - Planning flags

Returns

A plan that can be executed on row-major input/output buffers of size n0 × n1.

Examples

use oxifft::{Complex, Direction, Flags, Plan2D};

// 4×4 2D forward FFT
let plan = Plan2D::<f64>::new(4, 4, Direction::Forward, Flags::ESTIMATE)
    .expect("plan construction failed");
// All-ones input: DC bin = 16
let input = vec![Complex::<f64>::new(1.0, 0.0); 16];
let mut output = vec![Complex::<f64>::zero(); 16];
plan.execute(&input, &mut output);
// DC bin (index 0) = sum of all 16 elements
assert!((output[0].re - 16.0_f64).abs() < 1e-9);
// All non-DC bins should be zero for constant input
assert!(output[1].re.abs() < 1e-9);

pub fn with_rayon_pool(self, pool: Arc<ThreadPool>) -> Self

Override the rayon thread pool used for parallel row/column transforms.

By default Plan2D uses the global rayon pool. Pass a dedicated pool here to keep FFT work isolated from other parallel tasks in the process.

Requires the threading feature to be enabled.

pub fn rows(&self) -> usize

Get the number of rows.

pub fn cols(&self) -> usize

Get the number of columns.

pub fn size(&self) -> usize

Get the total size (n0 × n1).

pub fn direction(&self) -> Direction

Get the transform direction.

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

Execute the 2D FFT on the given input/output buffers.

Input and output are row-major: element at (i, j) is at index i*n1 + j.

When the threading feature is enabled, row transforms are parallelised over rayon workers using work-stealing; column transforms are parallelised similarly with per-thread scratch buffers.

Panics

Panics if buffer sizes don’t match n0 × n1.

pub fn execute_inplace(&self, data: &mut [Complex<T>])

Execute the 2D FFT in-place.

When the threading feature is enabled, both the row and column passes are parallelised over rayon workers.

Panics

Panics if buffer size doesn’t match n0 × n1.

Trait Implementations

impl<T: Float> Debug for Plan2D<T>

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

Formats the value using the given formatter.