easyfft

A Rust library crate providing an [FFT] API for arrays and slices. This crate wraps the [rustfft] and [realfft] crates that does the heavy lifting behind the scenes.

Advantages

• If it compiles, your code won't panic™ in this library[^panic], unless you enable the fallible[^fallible] feature
• No [Result] return type for you to worry about, you simply cannot get an [Error]
• Ergonomic API

Current limitations

• The const-realfft feature requires the nightly compiler because it depends on the [genericconstexprs] feature
• There are no methods for in-place mutation for complex -> real or real -> complex transforms.

Example

The nightly dependent features are commented out. ```rust // NOTE: Only required for real arrays // #![allow(incompletefeatures)] // #![feature(genericconst_exprs)]

// use easyfft::constsize::realfft::*; use easyfft::constsize::; use easyfft::dyn_size::realfft::; use easyfft::dyn_size::; use easyfft::;

// Complex arrays let complexarray = [Complex::new(1.0, 0.0); 100]; let complexarraydft = complexarray.fft(); let complexarraydftidft = complexarraydft.ifft();

// Real to complex arrays let realarray = [1.0; 100]; let _realarraydft = realarray.fft();

// // Real arrays // let realarray = [1.0; 100]; // let realarraydft = realarray.realfft(); // let _realarraydftidft = realarraydft.real_ifft();

// Complex slices let complexslice: &[] = &[Complex::new(1.0, 0.0); 100]; let complexslicedft = complexslice.fft(); let _complexslicedftidft = complexslicedft.ifft();

// Real to complex slices let realslice: &[] = &[1.0; 100]; let realslicedft = realslice.fft();

// Real slices let realslice: &[] = &[1.0; 100]; let realslicedft = realslice.realfft(); let realslicedftidft = realslicedft.real_ifft();

// In-place mutation on complex -> complex transforms let mut complexslice = [Complex::new(1.0, 0.0); 100]; complexslice.fftmut(); complexslice.ifftmut(); let mut complexarray = [Complex::new(1.0, 0.0); 100]; complexarray.fftmut(); complexarray.ifftmut(); ```

Footnotes

There could be bugs in this crate or it's dependencies that may cause a panic, but in theory all the runtime panics have been moved to compile time errors.

panic. This is because the rust language does not have the ability to encode properties of the length of slices in the type system. This might become possible in the future if the rust team manages to extend const generics to fully fledged [dependent types]. For now, we're limited to using arrays where we can ensure these properties. You can opt into these panic-able operations via the fallible feature flag. This brings slices up to feature parity with arrays, but you opt out of the "won't panic™" guarantee of this crate. I do recommend you take a step back and consider if you REALLY need to work with slices instead of arrays. Many applications can get away with knowing the size of their signal at compile time.