Trait TensorReadFftExt 

pub trait TensorReadFftExt {
    // Required methods
    fn fft_read<B: FftBackend>(
        &self,
        n: Option<usize>,
        axis: isize,
        norm: FftNorm,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn ifft_read<B: FftBackend>(
        &self,
        n: Option<usize>,
        axis: isize,
        norm: FftNorm,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn rfft_read<B: FftBackend>(
        &self,
        n: Option<usize>,
        axis: isize,
        norm: FftNorm,
        backend: &mut B,
    ) -> Result<Tensor>;
    fn irfft_read<B: FftBackend>(
        &self,
        n: Option<usize>,
        axis: isize,
        norm: FftNorm,
        backend: &mut B,
    ) -> Result<Tensor>;
}

Backend-explicit FFT methods for read-only tensor inputs.

The _read suffix follows the repository convention for APIs that explicitly accept TensorRead values such as borrowed views.

Direct read calls intentionally materialize through a call-local one-shot FFT plan cache. Use FftExecutor on compact owned tensors when repeated concrete calls should retain backend plans across calls.

Examples

use num_complex::Complex64;
use tenferro_cpu::{with_cpu_exec_session, CpuBackend};
use tenferro_fft::{FftNorm, TensorReadFftExt};
use tenferro_tensor::{BackendSessionHost, TensorRead, TensorView};

let shape = [4usize];
let data = [1.0_f64, 2.0, 3.0, 4.0];
let input = TensorRead::from_view(TensorView::f64(&shape, &data)?);
let mut backend = CpuBackend::new();

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

Required Methods

fn fft_read<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 materialization or execution.

fn ifft_read<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 materialization.

fn rfft_read<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 materialization.

fn irfft_read<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 materialization.

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 TensorReadFftExt for TensorRead<'_>

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

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

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

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

Implementors