Struct SplitPlan 

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

A plan for split-complex format (separate real and imaginary arrays).

Split-complex format stores the real parts in one array and the imaginary parts in another, rather than interleaving them:

• Interleaved: [re0, im0, re1, im1, re2, im2, ...]
• Split: real = [re0, re1, re2, ...], imag = [im0, im1, im2, ...]

This format can be more efficient for SIMD processing and is used by some numerical libraries.

Example

use oxifft::{SplitPlan, Direction, Flags};

let n = 256;
let plan = SplitPlan::<f64>::dft_1d(n, Direction::Forward, Flags::ESTIMATE).unwrap();

let mut in_real = vec![0.0; n];
let mut in_imag = vec![0.0; n];
let mut out_real = vec![0.0; n];
let mut out_imag = vec![0.0; n];

// Initialize input...
in_real[0] = 1.0;

plan.execute(&in_real, &in_imag, &mut out_real, &mut out_imag);

Implementations

impl<T: Float> SplitPlan<T>

pub fn dft_1d(n: usize, direction: Direction, flags: Flags) -> Option<Self>

Create a 1D DFT plan for split-complex format.

Arguments

• n - Transform size
• direction - Forward or Backward
• flags - Planning flags

pub fn size(&self) -> usize

Get the transform size.

pub fn direction(&self) -> Direction

Get the transform direction.

pub fn execute( &self, in_real: &[T], in_imag: &[T], out_real: &mut [T], out_imag: &mut [T], )

Execute the transform on split-complex input/output.

Arguments

• in_real - Input real parts
• in_imag - Input imaginary parts
• out_real - Output real parts
• out_imag - Output imaginary parts

Panics

Panics if any buffer size doesn’t match the plan size.

pub fn execute_inplace(&self, real: &mut [T], imag: &mut [T])

Execute the transform in-place on split-complex data.

Arguments

• real - Real parts (in-place)
• imag - Imaginary parts (in-place)

Panics

Panics if any buffer size doesn’t match the plan size.

Trait Implementations

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

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

Formats the value using the given formatter.