Struct GuruPlan 

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

Guru interface for maximum flexibility.

Allows specifying arbitrary dimensions, strides, and batch parameters. This is the most general FFT interface, supporting:

• Arbitrary transform dimensions (1D, 2D, 3D, ND)
• Arbitrary strides for input and output
• Batched transforms with arbitrary batch dimensions
• In-place or out-of-place operation

Example

use oxifft::{Complex, Direction, Flags, IoDim, Tensor};
use oxifft::api::GuruPlan;

// Create a batched 1D FFT: 10 transforms of size 256
let dims = Tensor::new(vec![IoDim::contiguous(256)]);
let howmany = Tensor::new(vec![IoDim::new(10, 256, 256)]); // 10 batches, stride=256

let mut input = vec![Complex::new(0.0, 0.0); 2560];
let mut output = vec![Complex::new(0.0, 0.0); 2560];

let plan = GuruPlan::<f64>::dft(
    &dims,
    &howmany,
    Direction::Forward,
    Flags::ESTIMATE,
).unwrap();

plan.execute(&input, &mut output);

Implementations

impl<T: Float> GuruPlan<T>

pub fn dft( dims: &Tensor, howmany: &Tensor, direction: Direction, flags: Flags, ) -> Option<Self>

Create a guru DFT plan with full control over dimensions and strides.

Arguments

• dims - Transform dimensions with input/output strides
• howmany - Batch dimensions (vector rank). Can be empty for single transform.
• direction - Forward or Backward
• flags - Planning flags

Returns

A plan that can be executed on buffers with the specified layout. Returns None if any dimension has size 0.

Memory Layout

• dims specifies the transform dimensions (innermost dimensions transform)
• howmany specifies the batch dimensions (outermost dimensions iterate)
• Strides can be different for input and output (for in-place: use same strides)

pub fn dims(&self) -> &Tensor

Get the transform dimensions.

pub fn howmany(&self) -> &Tensor

Get the batch dimensions.

pub fn direction(&self) -> Direction

Get the transform direction.

pub fn transform_size(&self) -> usize

Get the total number of elements in one transform.

pub fn batch_count(&self) -> usize

Get the total number of transforms (batch count).

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

Execute the guru plan on the given buffers.

Arguments

• input - Input buffer with layout matching dims and howmany
• output - Output buffer with layout matching dims and howmany

Panics

Panics if buffers are too small for the specified layout.

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

Execute the plan in-place.

For in-place execution, input and output strides must be identical.