Trait TensorFftExt 

pub trait TensorFftExt {
    // Required methods
    fn fft<B: FftBackend>(
        &self,
        n: Option<usize>,
        axis: isize,
        norm: FftNorm,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn ifft<B: FftBackend>(
        &self,
        n: Option<usize>,
        axis: isize,
        norm: FftNorm,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn rfft<B: FftBackend>(
        &self,
        n: Option<usize>,
        axis: isize,
        norm: FftNorm,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn irfft<B: FftBackend>(
        &self,
        n: Option<usize>,
        axis: isize,
        norm: FftNorm,
        backend: &mut B,
    ) -> Result<Tensor>;
}

Backend-explicit FFT methods for concrete Tensor values.

This is the non-AD immediate execution surface. It uses unsuffixed method names because the receiver is an owned compact tensor value. Use TensorReadFftExt when the input is a borrowed view or other TensorRead value.

Direct calls intentionally use a call-local one-shot FFT plan cache. Use FftExecutor for repeated concrete calls with stable transform lengths, or traced/runtime execution when the runtime should own the extension cache.

Examples

use num_complex::Complex64;
use tenferro_cpu::{with_cpu_exec_session, CpuBackend};
use tenferro_fft::{FftNorm, TensorFftExt};
use tenferro_tensor::{BackendSessionHost, Tensor};

let input = Tensor::from_vec_col_major(vec![4], vec![1.0_f64, 2.0, 3.0, 4.0])?;
let mut backend = CpuBackend::new();

let spectrum = backend.with_backend_session(|session| {
    with_cpu_exec_session(session, |exec_session| {
        input.fft(None, -1, FftNorm::Backward, exec_session)
    })
    .expect("CpuBackend must expose a CPU execution session")
})?;
assert_eq!(spectrum.shape(), &[4]);
assert_eq!(spectrum.as_slice::<Complex64>()?[0], Complex64::new(10.0, 0.0));

Required Methods

fn fft<B: FftBackend>( &self, n: Option<usize>, axis: isize, norm: FftNorm, backend: &mut B, ) -> Result<Tensor>

Execute a one-dimensional FFT along axis.

Errors

Returns Error::Validation with AxisOutOfBounds or InvalidArgument for axis/n, Error::Extension with ErrorKind::Unsupported for an integer or boolean input, or a typed backend source for execution.

fn ifft<B: FftBackend>( &self, n: Option<usize>, axis: isize, norm: FftNorm, backend: &mut B, ) -> Result<Tensor>

Execute a one-dimensional inverse FFT along axis.

Errors

Returns Error::Validation with AxisOutOfBounds or InvalidArgument for axis/n, Error::Extension with ErrorKind::Unsupported for a non-complex input, or a typed backend source for execution.

fn rfft<B: FftBackend>( &self, n: Option<usize>, axis: isize, norm: FftNorm, backend: &mut B, ) -> Result<Tensor>

Execute a one-dimensional real FFT along axis.

Errors

Returns Error::Validation with AxisOutOfBounds or InvalidArgument for axis/n, Error::Extension with ErrorKind::Unsupported for a non-F32/F64 input, or a typed backend source for execution.

fn irfft<B: FftBackend>( &self, n: Option<usize>, axis: isize, norm: FftNorm, backend: &mut B, ) -> Result<Tensor>

Execute a one-dimensional inverse real FFT along axis.

Errors

Returns Error::Validation with AxisOutOfBounds, InvalidArgument, or spectrum-length details, Error::Extension with ErrorKind::Unsupported for a non-complex input, or a typed backend source for execution.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl TensorFftExt for Tensor

fn fft<B: FftBackend>( &self, n: Option<usize>, axis: isize, norm: FftNorm, backend: &mut B, ) -> Result<Tensor>

fn ifft<B: FftBackend>( &self, n: Option<usize>, axis: isize, norm: FftNorm, backend: &mut B, ) -> Result<Tensor>

fn rfft<B: FftBackend>( &self, n: Option<usize>, axis: isize, norm: FftNorm, backend: &mut B, ) -> Result<Tensor>

fn irfft<B: FftBackend>( &self, n: Option<usize>, axis: isize, norm: FftNorm, backend: &mut B, ) -> Result<Tensor>

Implementors