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)

Examples

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

// Simple 1D forward FFT via the guru interface
let dims = Tensor::rank1(8);
let howmany = Tensor::empty();
let plan = GuruPlan::<f64>::dft(&dims, &howmany, Direction::Forward, Flags::ESTIMATE)
    .expect("plan construction failed");

let input = vec![Complex::<f64>::new(1.0, 0.0); 8];
let mut output = vec![Complex::<f64>::zero(); 8];
plan.execute(&input, &mut output);
// DC bin = sum of all ones = 8
assert!((output[0].re - 8.0_f64).abs() < 1e-9);

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.

Panics (in debug builds with an earlier diagnostic; in release builds via an out-of-bounds slice index) if the computed element offset is negative. This can happen when crate::IoDim strides are negative and the batch index is large enough that base_offset + i * stride < 0. Always ensure that for every element i in 0..n, the expression in_offset + i * is and out_offset + i * os evaluate to a non-negative value.

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.

Trait Implementations

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

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

Formats the value using the given formatter.