Crate scirs2_fft 

SciRS2 FFT - High-Performance Fourier Transforms

scirs2-fft provides comprehensive Fast Fourier Transform (FFT) implementations modeled after SciPy’s fft module, with support for 1D/2D/ND transforms, DCT/DST, STFT, NUFFT, and advanced features including plan caching, GPU acceleration, and adaptive planning.

🎯 Key Features

• SciPy Compatibility: Drop-in replacement for scipy.fft functions
• Comprehensive Transforms: FFT, RFFT, DCT, DST, fractional FFT, NUFFT
• Multi-dimensional: Efficient 1D, 2D, and N-dimensional transforms
• Plan Caching: Automatic plan reuse for repeated transforms
• GPU Acceleration: CUDA/ROCm support for large transforms
• Parallel Processing: Multi-threaded execution with worker pools
• SIMD Optimization: AVX/AVX2/AVX-512 vectorization

📦 Module Overview

SciRS2 Module	SciPy Equivalent	Description
fft	scipy.fft.fft	Complex-to-complex FFT
rfft	scipy.fft.rfft	Real-to-complex FFT (optimized)
fft2	scipy.fft.fft2	2D FFT
fftn	scipy.fft.fftn	N-dimensional FFT
dct	scipy.fft.dct	Discrete Cosine Transform
dst	scipy.fft.dst	Discrete Sine Transform
stft	scipy.signal.stft	Short-Time Fourier Transform
nufft	-	Non-Uniform FFT
frfft	-	Fractional Fourier Transform

🚀 Quick Start

Add to your Cargo.toml:

[dependencies]
scirs2-fft = "0.4.1"

Basic FFT

use scirs2_fft::{fft, ifft};

// Time-domain signal
let signal = vec![1.0, 2.0, 3.0, 4.0];

// Forward FFT: time → frequency
let spectrum = fft(&signal, None).expect("Operation failed");

// Inverse FFT: frequency → time
let recovered = ifft(&spectrum, None).expect("Operation failed");

Real-valued FFT (RFFT)

use scirs2_fft::{rfft, irfft};

// Real-valued signal (typical use case)
let signal = vec![1.0, 0.5, -0.5, -1.0];

// RFFT: optimized for real inputs, returns only positive frequencies
let spectrum = rfft(&signal, None).expect("Operation failed");  // Length: n/2 + 1

// Inverse RFFT
let recovered = irfft(&spectrum, Some(signal.len())).expect("Operation failed");

2D FFT (Image Processing)

use scirs2_core::ndarray::Array2;
use scirs2_fft::{fft2, ifft2};

// 2D signal (e.g., image)
let image = Array2::<f64>::zeros((256, 256));

// 2D FFT
let spectrum = fft2(&image, None, None, None).expect("Operation failed");

// Apply frequency-domain filter...
// let filtered_spectrum = apply_filter(spectrum);

// Inverse 2D FFT
// let filtered_image = ifft2(&filtered_spectrum, None, None).expect("Operation failed");

Short-Time Fourier Transform (STFT)

use scirs2_fft::{stft, Window};

// Long signal for time-frequency analysis
let signal: Vec<f64> = vec![0.0; 10000];

// Compute STFT with Hann window
let (times, freqs, stft_matrix) = stft(&signal, Window::Hann, 256, Some(128), None, Some(44100.0), None, None).expect("Operation failed");
// Result: time-frequency representation (spectrogram)

🏗️ Architecture

scirs2-fft
├── Core Transforms
│   ├── FFT/IFFT (complex-to-complex)
│   ├── RFFT/IRFFT (real-optimized)
│   ├── FFT2/FFTN (multi-dimensional)
│   └── Hermitian FFT (real spectrum)
├── Specialized Transforms
│   ├── DCT (Types I-IV)
│   ├── DST (Types I-IV)
│   ├── Fractional FFT (FrFT)
│   └── Non-Uniform FFT (NUFFT)
├── Time-Frequency Analysis
│   ├── STFT (Short-Time Fourier Transform)
│   ├── Spectrogram computation
│   └── Waterfall plots
├── Performance Features
│   ├── Plan caching (automatic reuse)
│   ├── Worker pools (parallel execution)
│   ├── Backend selection (CPU/GPU)
│   ├── Adaptive planning (runtime optimization)
│   └── SIMD acceleration
└── Utilities
    ├── Window functions (Hann, Hamming, etc.)
    ├── Frequency helpers (fftfreq, rfftfreq)
    └── Zero padding & normalization

📊 Performance

Transform	Size	CPU	GPU	Speedup
FFT	2²⁰ points	85ms	4ms	21×
RFFT	2²⁰ points	45ms	2.5ms	18×
2D FFT	1024×1024	180ms	8ms	22.5×
STFT	10⁶ points	420ms	25ms	17×

Note: Benchmarks on AMD Ryzen 9 5950X + NVIDIA RTX 3090. GPU uses cuFFT.

🔗 Integration

• scirs2-signal: FFT-based filtering, spectral analysis
• scirs2-interpolate: Spectral interpolation methods
• scirs2-integrate: Spectral PDE solvers
• scirs2-ndimage: Fourier-domain image filtering

🔒 Version Information

• Version: 0.4.1
• Release Date: March 27, 2026
• MSRV (Minimum Supported Rust Version): 1.70.0
• Documentation: docs.rs/scirs2-fft
• Repository: github.com/cool-japan/scirs

Re-exports

pub use error::FFTError;

pub use error::FFTResult;

pub use plan_cache::get_global_cache;

pub use plan_cache::init_global_cache;

pub use plan_cache::CacheStats;

pub use plan_cache::PlanCache;

pub use worker_pool::get_global_pool;

pub use worker_pool::get_workers;

pub use worker_pool::init_global_pool;

pub use worker_pool::set_workers;

pub use worker_pool::with_workers;

pub use worker_pool::WorkerConfig;

pub use worker_pool::WorkerPool;

pub use worker_pool::WorkerPoolInfo;

pub use backend::get_backend_info;

pub use backend::get_backend_manager;

pub use backend::get_backend_name;

pub use backend::init_backend_manager;

pub use backend::list_backends;

pub use backend::set_backend;

pub use backend::BackendContext;

pub use backend::BackendInfo;

pub use backend::BackendManager;

pub use backend::FftBackend;

pub use context::fft_context;

pub use context::with_backend;

pub use context::with_fft_settings;

pub use context::without_cache;

pub use context::FftContext;

pub use context::FftContextBuilder;

pub use context::FftSettingsGuard;

pub use strided_fft::fft_strided;

pub use strided_fft::fft_strided_complex;

pub use strided_fft::ifft_strided;

pub use plan_serialization::PlanDatabaseStats;

pub use plan_serialization::PlanInfo;

pub use plan_serialization::PlanMetrics;

pub use plan_serialization::PlanSerializationManager;

pub use planning::get_global_planner;

pub use planning::init_global_planner;

pub use planning::plan_ahead_of_time;

pub use planning::AdvancedFftPlanner as FftPlanner;

pub use planning::FftPlan;

pub use planning::FftPlanExecutor;

pub use planning::PlanBuilder;

pub use planning::PlannerBackend;

pub use planning::PlanningConfig;

pub use planning::PlanningStrategy;

pub use planning_parallel::ParallelExecutor;

pub use planning_parallel::ParallelPlanResult;

pub use planning_parallel::ParallelPlanner;

pub use planning_parallel::ParallelPlanningConfig;

pub use auto_tuning::auto_fft;

pub use auto_tuning::auto_select_algorithm;

pub use auto_tuning::AutoTuneConfig;

pub use auto_tuning::AutoTuner;

pub use auto_tuning::FftVariant;

pub use auto_tuning::IntegratedAutoSelector;

pub use auto_tuning::SelectionResult;

pub use auto_tuning::SelectionSource;

pub use auto_tuning::SizeRange;

pub use auto_tuning::SizeStep;

pub use algorithm_selector::AlgorithmRecommendation;

pub use algorithm_selector::AlgorithmSelector;

pub use algorithm_selector::CacheInfo;

pub use algorithm_selector::FftAlgorithm;

pub use algorithm_selector::HardwareInfo;

pub use algorithm_selector::InputCharacteristics;

pub use algorithm_selector::PerformanceEntry;

pub use algorithm_selector::PerformanceHistory;

pub use algorithm_selector::SelectionConfig;

pub use algorithm_selector::SimdCapabilities;

pub use algorithm_selector::SizeCharacteristic;

pub use performance_profiler::estimate_fft_memory;

pub use performance_profiler::AlgorithmComparison;

pub use performance_profiler::Measurement;

pub use performance_profiler::MemoryProfiler;

pub use performance_profiler::PerformanceProfiler;

pub use performance_profiler::PerformanceReport;

pub use performance_profiler::ProfileConfig;

pub use performance_profiler::ProfileResult;

pub use large_fft::LargeFft;

pub use large_fft::LargeFftConfig;

pub use large_fft::LargeFftMethod;

pub use large_fft::LargeFftNd;

pub use large_fft::LargeFftStats;

pub use real_planner::ComplexToReal;

pub use real_planner::RealFftPlanner;

pub use real_planner::RealToComplex;

pub use dct::dct;

pub use dct::dct2;

pub use dct::dct2_fft;

pub use dct::dctn;

pub use dct::idct;

pub use dct::idct2;

pub use dct::idct2_fft;

pub use dct::idctn;

pub use dct::DCTType;

pub use dst::dst;

pub use dst::dst2;

pub use dst::dst2_fft;

pub use dst::dstn;

pub use dst::idst;

pub use dst::idst2;

pub use dst::idst2_fft;

pub use dst::idstn;

pub use dst::DSTType;

pub use fft::fft;

pub use fft::fft2;

pub use fft::fftn;

pub use fft::ifft;

pub use fft::ifft2;

pub use fft::ifftn;

pub use fht::fht;

pub use fht::fht_sample_points;

pub use fht::fhtoffset;

pub use fht::ifht;

pub use hfft::hfft;

pub use hfft::hfft2;

pub use hfft::hfftn;

pub use hfft::ihfft;

pub use hfft::ihfft2;

pub use hfft::ihfftn;

pub use fft::fft2_parallel;

pub use fft::ifft2_parallel;

pub use rfft::irfft;

pub use rfft::irfft2;

pub use rfft::irfftn;

pub use rfft::rfft;

pub use rfft::rfft2;

pub use rfft::rfftn;

pub use simd_fft::fft2_adaptive;

pub use simd_fft::fft2_simd;

pub use simd_fft::fft_adaptive;

pub use simd_fft::fft_simd;

pub use simd_fft::fftn_adaptive;

pub use simd_fft::fftn_simd;

pub use simd_fft::ifft2_adaptive;

pub use simd_fft::ifft2_simd;

pub use simd_fft::ifft_adaptive;

pub use simd_fft::ifft_simd;

pub use simd_fft::ifftn_adaptive;

pub use simd_fft::ifftn_simd;

pub use simd_fft::simd_support_available;

pub use simd_rfft::irfft_adaptive;

pub use simd_rfft::irfft_simd;

pub use simd_rfft::rfft_adaptive;

pub use simd_rfft::rfft_simd;

pub use helper::fftfreq;

pub use helper::fftshift;

pub use helper::ifftshift;

pub use helper::next_fast_len;

pub use helper::prev_fast_len;

pub use helper::rfftfreq;

pub use frft::frft;

pub use frft::frft_complex;

pub use frft::frft_dft;

pub use frft::frft_stable;

pub use spectrogram::spectrogram;

pub use spectrogram::spectrogram_normalized;

pub use spectrogram::stft as spectrogram_stft;

pub use waterfall::apply_colormap;

pub use waterfall::waterfall_3d;

pub use waterfall::waterfall_lines;

pub use waterfall::waterfall_mesh;

pub use waterfall::waterfall_mesh_colored;

pub use distributed::CommunicationPattern;

pub use distributed::DecompositionStrategy;

pub use distributed::DistributedConfig;

pub use distributed::DistributedFFT;

pub use optimized_fft::OptimizationLevel;

pub use optimized_fft::OptimizedConfig;

pub use optimized_fft::OptimizedFFT;

pub use signal_processing::convolve;

pub use signal_processing::cross_correlate;

pub use signal_processing::design_fir_filter;

pub use signal_processing::fir_filter;

pub use signal_processing::frequency_filter;

pub use signal_processing::FilterSpec;

pub use signal_processing::FilterType;

pub use signal_processing::FilterWindow;

pub use sparse_fft::WindowFunction;

pub use sparse_fft::adaptive_sparse_fft;

pub use sparse_fft::frequency_pruning_sparse_fft;

pub use sparse_fft::reconstruct_filtered;

pub use sparse_fft::reconstruct_high_resolution;

pub use sparse_fft::reconstruct_spectrum;

pub use sparse_fft::reconstruct_time_domain;

pub use sparse_fft::sparse_fft;

pub use sparse_fft::sparse_fft2;

pub use sparse_fft::sparse_fftn;

pub use sparse_fft::spectral_flatness_sparse_fft;

pub use sparse_fft_cuda_kernels::execute_cuda_compressed_sensing_sparse_fft;

pub use sparse_fft_cuda_kernels::execute_cuda_sublinear_sparse_fft;

pub use sparse_fft_cuda_kernels::CUDACompressedSensingSparseFFTKernel;

pub use sparse_fft_cuda_kernels::CUDASublinearSparseFFTKernel;

pub use sparse_fft_cuda_kernels::CUDAWindowKernel;

pub use sparse_fft_cuda_kernels_frequency_pruning::execute_cuda_frequency_pruning_sparse_fft;

pub use sparse_fft_cuda_kernels_frequency_pruning::CUDAFrequencyPruningSparseFFTKernel;

pub use sparse_fft_cuda_kernels_iterative::execute_cuda_iterative_sparse_fft;

pub use sparse_fft_cuda_kernels_iterative::CUDAIterativeSparseFFTKernel;

pub use sparse_fft_cuda_kernels_spectral_flatness::execute_cuda_spectral_flatness_sparse_fft;

pub use sparse_fft_cuda_kernels_spectral_flatness::CUDASpectralFlatnessSparseFFTKernel;

pub use sparse_fft_gpu::gpu_batch_sparse_fft;

pub use sparse_fft_gpu::gpu_sparse_fft;

pub use sparse_fft_gpu::GPUBackend;

pub use sparse_fft_gpu_cuda::cuda_batch_sparse_fft;

pub use sparse_fft_gpu_cuda::cuda_sparse_fft;

pub use sparse_fft_gpu_cuda::get_cuda_devices;

pub use sparse_fft_gpu_cuda::FftGpuContext;

pub use sparse_fft_gpu_cuda::GpuDeviceInfo;

pub use sparse_fft_gpu_kernels::execute_sparse_fft_kernel;

pub use sparse_fft_gpu_kernels::GPUKernel;

pub use sparse_fft_gpu_kernels::KernelConfig;

pub use sparse_fft_gpu_kernels::KernelFactory;

pub use sparse_fft_gpu_kernels::KernelImplementation;

pub use sparse_fft_gpu_kernels::KernelLauncher;

pub use sparse_fft_gpu_kernels::KernelStats;

pub use sparse_fft_gpu_memory::get_global_memory_manager;

pub use sparse_fft_gpu_memory::init_global_memory_manager;

pub use sparse_fft_gpu_memory::memory_efficient_gpu_sparse_fft;

pub use sparse_fft_gpu_memory::AllocationStrategy;

pub use sparse_fft_gpu_memory::BufferLocation;

pub use sparse_fft_gpu_memory::BufferType;

pub use sparse_fft_gpu_memory::is_cuda_available;

pub use sparse_fft_gpu_memory::is_hip_available;

pub use sparse_fft_gpu_memory::is_sycl_available;

pub use sparse_fft_multi_gpu::multi_gpu_sparse_fft;

pub use sparse_fft_multi_gpu::GPUDeviceInfo;

pub use sparse_fft_multi_gpu::MultiGPUConfig;

pub use sparse_fft_multi_gpu::MultiGPUSparseFFT;

pub use sparse_fft_multi_gpu::WorkloadDistribution;

pub use sparse_fft_specialized_hardware::specialized_hardware_sparse_fft;

pub use sparse_fft_specialized_hardware::AcceleratorCapabilities;

pub use sparse_fft_specialized_hardware::AcceleratorInfo;

pub use sparse_fft_specialized_hardware::AcceleratorType;

pub use sparse_fft_specialized_hardware::HardwareAbstractionLayer;

pub use sparse_fft_specialized_hardware::SpecializedHardwareManager;

pub use sparse_fft_batch::batch_sparse_fft;

pub use sparse_fft_batch::spectral_flatness_batch_sparse_fft;

pub use sparse_fft_batch::BatchConfig;

pub use time_frequency::time_frequency_transform;

pub use time_frequency::TFConfig;

pub use time_frequency::TFTransform;

pub use time_frequency::WaveletType;

pub use memory_efficient::fft2_efficient;

pub use memory_efficient::fft_inplace;

pub use memory_efficient::fft_streaming;

pub use memory_efficient::process_in_chunks;

pub use memory_efficient::FftMode;

pub use ndim_optimized::fftn_memory_efficient;

pub use ndim_optimized::fftn_optimized;

pub use ndim_optimized::rfftn_optimized;

pub use hartley::dht;

pub use hartley::dht2;

pub use hartley::fht as hartley_fht;

pub use hartley::idht;

pub use higher_order_dct_dst::dct_v;

pub use higher_order_dct_dst::dct_vi;

pub use higher_order_dct_dst::dct_vii;

pub use higher_order_dct_dst::dct_viii;

pub use higher_order_dct_dst::dst_v;

pub use higher_order_dct_dst::dst_vi;

pub use higher_order_dct_dst::dst_vii;

pub use higher_order_dct_dst::dst_viii;

pub use higher_order_dct_dst::idct_v;

pub use higher_order_dct_dst::idct_vi;

pub use higher_order_dct_dst::idct_vii;

pub use higher_order_dct_dst::idct_viii;

pub use higher_order_dct_dst::idst_v;

pub use higher_order_dct_dst::idst_vi;

pub use higher_order_dct_dst::idst_vii;

pub use higher_order_dct_dst::idst_viii;

pub use mdct::imdct;

pub use mdct::imdst;

pub use mdct::mdct;

pub use mdct::mdct_overlap_add;

pub use mdct::mdst;

pub use window::apply_window;

pub use window::get_window;

pub use window::Window;

pub use window_extended::analyze_window;

pub use window_extended::compare_windows;

pub use window_extended::get_extended_window;

pub use window_extended::visualize_window;

pub use window_extended::ExtendedWindow;

pub use window_extended::WindowProperties;

pub use hilbert::analytic_signal;

pub use hilbert::envelope;

pub use hilbert::instantaneous_frequency;

pub use hilbert::instantaneous_frequency_central;

pub use hilbert::instantaneous_phase;

pub use hilbert::instantaneous_phase_unwrapped;

pub use czt::czt;

pub use czt::czt_points;

pub use czt::zoom_fft;

pub use czt::CZT;

pub use czt_enhanced::adaptive_zoom_fft;

pub use czt_enhanced::czt_convolve;

pub use czt_enhanced::iczt;

pub use czt_enhanced::EnhancedCZT;

pub use czt_enhanced::SpiralContour;

pub use frft_enhanced::frft_eigenvector;

pub use frft_enhanced::frft_multi_angle;

pub use frft_enhanced::frft_omk;

pub use frft_enhanced::frft_omk_complex;

pub use frft_enhanced::optimal_frft_angle;

pub use frft_enhanced::wvd_projection;

pub use stft_enhanced::dolph_chebyshev_window;

pub use stft_enhanced::dpss_window;

pub use stft_enhanced::griffin_lim;

pub use stft_enhanced::istft;

pub use stft_enhanced::reassigned_spectrogram;

pub use stft_enhanced::spectral_coherence;

pub use stft_enhanced::synchrosqueezing;

pub use dct_dst_enhanced::batch_dct2 as fast_batch_dct2;

pub use dct_dst_enhanced::dequantized_idct;

pub use dct_dst_enhanced::fast_dct1;

pub use dct_dst_enhanced::fast_dct2;

pub use dct_dst_enhanced::fast_dct3;

pub use dct_dst_enhanced::fast_dct4;

pub use dct_dst_enhanced::fast_dst1;

pub use dct_dst_enhanced::fast_dst2;

pub use dct_dst_enhanced::fast_dst3;

pub use dct_dst_enhanced::fast_dst4;

pub use dct_dst_enhanced::imdct_stream;

pub use dct_dst_enhanced::mdct_stream;

pub use dct_dst_enhanced::quantized_dct;

pub use hilbert_enhanced::analytic_signal_padded;

pub use hilbert_enhanced::degree_of_stationarity;

pub use hilbert_enhanced::eemd;

pub use hilbert_enhanced::emd;

pub use hilbert_enhanced::hht;

pub use hilbert_enhanced::hilbert_spectrum;

pub use hilbert_enhanced::hilbert_transform;

pub use hilbert_enhanced::instantaneous_energy;

pub use hilbert_enhanced::marginal_spectrum;

pub use hilbert_enhanced::mean_frequency;

pub use hilbert_enhanced::teager_energy;

pub use hilbert_enhanced::teager_esa;

pub use hilbert_enhanced::EMDConfig;

pub use hilbert_enhanced::EMDResult;

pub use hilbert_enhanced::EnvelopeMethod;

pub use hilbert_enhanced::HHTResult;

pub use hilbert_enhanced::HilbertSpectrum;

pub use padding::auto_pad_1d;

pub use padding::auto_pad_complex;

pub use padding::auto_pad_nd;

pub use padding::remove_padding_1d;

pub use padding::AutoPadConfig;

pub use padding::PaddingMode;

pub use butterfly::butterfly2;

pub use butterfly::butterfly4;

pub use butterfly::butterfly8;

pub use butterfly::direct_dft;

pub use butterfly::direct_idft;

pub use butterfly::generate_inverse_twiddle_table;

pub use butterfly::generate_twiddle_table;

pub use butterfly::split_radix_butterfly;

pub use cache_oblivious::cache_oblivious_fft;

pub use cache_oblivious::cache_oblivious_fft_with_config;

pub use cache_oblivious::cache_oblivious_ifft;

pub use cache_oblivious::cache_oblivious_ifft_with_config;

pub use cache_oblivious::CacheObliviousConfig;

pub use fft_plan::create_plan;

pub use fft_plan::deserialize_plan;

pub use fft_plan::execute_plan;

pub use fft_plan::serialize_plan;

pub use fft_plan::FftAlgorithm as PlanAlgorithm;

pub use fft_plan::FftPlan as SerializableFftPlan;

pub use fft_plan::FftPlanConfig as SerializablePlanConfig;

pub use fft_plan::PlanNode;

pub use scattering::FeatureNormalization;

pub use scattering::FilterBank;

pub use scattering::FilterBankConfig;

pub use scattering::JointScatteringFeatures;

pub use scattering::MorletWavelet;

pub use scattering::ScatteringCoefficients;

pub use scattering::ScatteringConfig;

pub use scattering::ScatteringFeatureExtractor;

pub use scattering::ScatteringFeatures;

pub use scattering::ScatteringOrder;

pub use scattering::ScatteringResult;

pub use scattering::ScatteringTransform;

pub use scattering::TimeFrequencyMode;

Modules

adaptive_sparse_fft

Adaptive Sparse FFT with parameter-free sparsity estimation.

algorithm_selector

FFT Algorithm Auto-Selection Module

ambiguity

Radar Ambiguity Function.

auto_tuning

Auto-tuning for hardware-specific FFT optimizations

backend

FFT Backend System

bluestein

Bluestein’s FFT Algorithm (Chirp-Z Transform approach for arbitrary lengths)

butterfly

Enhanced Butterfly Operations for FFT

cache_oblivious

Cache-Oblivious FFT (Frigo-Johnson style)

compressed_sensing

Compressed sensing recovery via FFT-based measurements.

context

FFT Context Managers

cyclostationary

Cyclostationary Spectral Analysis.

czt

Chirp Z-Transform (CZT) implementation

czt_enhanced

Enhanced Chirp Z-Transform (CZT) module

dct

Discrete Cosine Transform (DCT) module

dct_dst_enhanced

Enhanced DCT/DST module with fast FFT-based implementations

distributed

Distributed FFT Computation Support

dst

Discrete Sine Transform (DST) module

error

Error types for the SciRS2 FFT module

fft

Fast Fourier Transform (FFT) module

fft_plan

FFT Plan Serialization — Algorithm-Agnostic Plan Creation and Execution

fht

Fast Hankel Transform (FHT) module

fractional

Short-Time Fractional Fourier Transform (STFRFT) and related algorithms.

frft

Fractional Fourier Transform module

frft_dft

DFT-based Fractional Fourier Transform

frft_enhanced

Enhanced Fractional Fourier Transform (FrFT) module

frft_ozaktas

Ozaktas-Kutay Algorithm for Fractional Fourier Transform

gpu_fft

GPU-accelerated FFT pipeline for large-scale signal processing.

gpu_kernel_stub

GPU kernel stub module for FFT operations

hartley

Hartley Transform implementation

helper

Helper functions for the FFT module

hfft

Hermitian Fast Fourier Transform (HFFT) module

higher_order_dct_dst

Higher-order DCT and DST implementations (Types V-VIII)

hilbert

Hilbert Transform and analytic signal utilities

hilbert_enhanced

Enhanced Hilbert Transform module with Hilbert-Huang Transform (HHT)

large_fft

Large FFT Module - Memory-Efficient FFT for Very Large Inputs

mdct

Modified Discrete Cosine Transform (MDCT) and Modified Discrete Sine Transform (MDST)

memory_efficient

Memory-efficient FFT operations

ndim_fft

High-performance multidimensional FFT with cache-oblivious tiling.

ndim_optimized

Optimized N-dimensional FFT operations

nufft

Non-Uniform Fast Fourier Transform module

optimized_fft

High-Performance FFT Optimizations

oxifft_backend

OxiFFT-based FFT backend for high performance

oxifft_plan_cache

OxiFFT Plan Cache for performance optimization

padding

Automatic padding strategies for optimal FFT performance

performance_profiler

FFT Performance Profiling Module

plan_cache

FFT Plan Caching Module

plan_serialization

FFT Plan Serialization

planning

FFT Planning Module

planning_adaptive

Adaptive FFT Planning

planning_parallel

Parallel FFT Planning

quantum

Quantum-inspired Fourier Transform algorithms.

ramanujan

Ramanujan Periodic Transform (RPT).

real_planner

Real FFT planner with trait object support

rfft

Real-valued Fast Fourier Transform (RFFT) module

scattering

Wavelet Scattering Transform

shor

Shor’s Algorithm Building Blocks.

signal_processing

Signal Processing and Filtering Integration

simd_fft

Minimal SIMD-accelerated FFT operations stub

simd_rfft

SIMD-accelerated Real-valued Fast Fourier Transform (RFFT) operations

sparse_fft

Sparse Fast Fourier Transform Implementation

sparse_fft_batch

Batch processing for sparse FFT algorithms

sparse_fft_cuda_kernels

GPU kernel stub for sparse FFT algorithms

sparse_fft_cuda_kernels_frequency_pruning

Stub implementations for all GPU kernel modules

sparse_fft_cuda_kernels_iterative

Stub implementations for all GPU kernel modules

sparse_fft_cuda_kernels_spectral_flatness

Stub implementations for all GPU kernel modules

sparse_fft_gpu

GPU-accelerated Sparse Fast Fourier Transform

sparse_fft_gpu_cuda

GPU-accelerated sparse FFT implementation using scirs2-core abstractions

sparse_fft_gpu_kernels

GPU kernel implementations for sparse FFT algorithms

sparse_fft_gpu_memory

Memory management for GPU-accelerated sparse FFT

sparse_fft_multi_gpu

Multi-GPU Sparse FFT Implementation

sparse_fft_specialized_hardware

Specialized Hardware Support for Sparse FFT

spectrogram

Spectrogram module for time-frequency analysis

stft_enhanced

Enhanced Short-Time Fourier Transform (STFT) module

strided_fft

Advanced Strided FFT Operations

time_frequency

Advanced Time-Frequency Analysis Tools

waterfall

Waterfall plot module for time-frequency analysis visualization

wigner_ville

Wigner-Ville Distribution (WVD) and Pseudo-WVD (PWVD).

window

Window functions for signal processing

window_extended

Extended window functions and analysis tools

worker_pool

Worker Pool Management for FFT Parallelization

Functions

fft_bounds

Returns the minimum and maximum values for each FFT dimension.

hilbert

stft

Performs a Short-Time Fourier Transform (STFT).