Add functions to support interleaved complex num

.github/workflows/rust.yml

@@ -63,6 +63,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: test
+          args: --all-features
 
   coverage:
     runs-on: ubuntu-latest

Cargo.toml

@@ -13,6 +13,12 @@ exclude = ["assets", "scripts", "benches"]
 [dependencies]
 num-traits = "0.2.18"
 multiversion = "0.7"
+num-complex = { version = "0.4.6", features = ["bytemuck"], optional = true }
+bytemuck = { version = "1.16.0", optional = true }
+
+[features]
+default = []
+complex-nums = ["dep:num-complex", "dep:bytemuck"]
 
 [dev-dependencies]
 criterion = "0.5.1"
@@ -33,3 +39,5 @@ panic = "abort"
 inherits = "release"
 debug = true
 
+[package.metadata.docs.rs]
+all-features = true

benches/README.md

@@ -4,35 +4,26 @@
 
 ### Setup Environment
 
-1. Install [FFTW3](http://www.fftw.org/download.html)[^1]
+1. Clone the `PhastFT` git repository [^2].
 
-   It may be possible to install `fftw3` using a package manager.
-
-   ##### debian
-   ```bash
-   sudo apt install libfftw3-dev
-   ```
-
-2. Clone the `PhastFT` git repository [^2].
-
-3. Create virtual env
+2. Create virtual env
 
 ```bash
 cd ~/PhastFT/benches && python3 -m venv .env && source .env/bin/activate
 ```
 
-4. Install python dependencies[^1]
+3. Install python dependencies[^1]
 
 ```bash
 pip install -r requirements.txt
 cd ~/PhastFT/pyphastft
 pip install .
 ```
 
-5. Run the `FFTW3` vs. `RustFFT` vs. `PhastFT` benchmark for all inputs of size `2^n`, where `n \in [4, 30].`
+5. Run the `FFTW3-RB` vs. `RustFFT` vs. `PhastFT` benchmarks`
 
 ```bash
-./benchmark.sh 4 29
+python run_benches.py
 ```
 
 6. Plot the results
@@ -101,13 +92,6 @@ On linux, open access to performance monitoring, and observability operations fo
 echo -1 | sudo tee /proc/sys/kernel/perf_event_paranoid
 ```
 
-Add debug to `Cargo.toml` under `profile.release`:
-
-```bash
-[profile.release]
-debug = true
-```
-
 Finally, run:
 
 ```bash

benches/bench.rs

@@ -13,7 +13,7 @@ use utilities::rustfft::num_complex::Complex;
 use utilities::rustfft::FftPlanner;
 
 const LENGTHS: &[usize] = &[
-    6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+    6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
 ];
 
 fn generate_numbers<T: Float>(n: usize) -> (Vec<T>, Vec<T>)
@@ -69,7 +69,7 @@ fn benchmark_forward_f32(c: &mut Criterion) {
         let planner = Planner32::new(len, Direction::Forward);
         let (mut reals, mut imags) = generate_numbers(len);
 
-        group.bench_with_input(BenchmarkId::new(id, len), &len, |b, &len| {
+        group.bench_with_input(BenchmarkId::new(id, len), &len, |b, &_len| {
             b.iter(|| {
                 fft_32_with_opts_and_plan(
                     black_box(&mut reals),
@@ -85,7 +85,7 @@ fn benchmark_forward_f32(c: &mut Criterion) {
         let fft = planner.plan_fft_forward(len);
         let mut signal = generate_complex_numbers(len);
 
-        group.bench_with_input(BenchmarkId::new(id, len), &len, |b, &len| {
+        group.bench_with_input(BenchmarkId::new(id, len), &len, |b, &_len| {
             b.iter(|| fft.process(black_box(&mut signal)));
         });
     }
@@ -103,31 +103,49 @@ fn benchmark_inverse_f32(c: &mut Criterion) {
         c.bench_function(&id, |b| {
             let (mut reals, mut imags) = generate_numbers(len);
             b.iter(|| {
-                black_box(fft_32_with_opts_and_plan(
-                    &mut reals, &mut imags, &options, &planner,
-                ));
+                fft_32_with_opts_and_plan(
+                    black_box(&mut reals),
+                    black_box(&mut imags),
+                    black_box(&options),
+                    black_box(&planner),
+                );
             });
         });
     }
 }
 
 fn benchmark_forward_f64(c: &mut Criterion) {
-    let options = Options::default();
+    let mut group = c.benchmark_group("Forward f64");
 
     for n in LENGTHS.iter() {
         let len = 1 << n;
-        let id = format!("FFT Forward f64 {} elements", len);
+        let id = "PhastFT FFT Forward";
+        let options = Options::guess_options(len);
         let planner = Planner64::new(len, Direction::Forward);
+        let (mut reals, mut imags) = generate_numbers(len);
+        group.throughput(Throughput::Elements(len as u64));
 
-        c.bench_function(&id, |b| {
-            let (mut reals, mut imags) = generate_numbers(len);
+        group.bench_with_input(BenchmarkId::new(id, len), &len, |b, &_len| {
             b.iter(|| {
-                black_box(fft_64_with_opts_and_plan(
-                    &mut reals, &mut imags, &options, &planner,
-                ));
+                fft_64_with_opts_and_plan(
+                    black_box(&mut reals),
+                    black_box(&mut imags),
+                    black_box(&options),
+                    black_box(&planner),
+                );
             });
         });
+
+        let id = "RustFFT FFT Forward";
+        let mut planner = FftPlanner::<f64>::new();
+        let fft = planner.plan_fft_forward(len);
+        let mut signal = generate_complex_numbers(len);
+
+        group.bench_with_input(BenchmarkId::new(id, len), &len, |b, &_len| {
+            b.iter(|| fft.process(black_box(&mut signal)));
+        });
     }
+    group.finish();
 }
 
 fn benchmark_inverse_f64(c: &mut Criterion) {
@@ -141,9 +159,12 @@ fn benchmark_inverse_f64(c: &mut Criterion) {
         c.bench_function(&id, |b| {
             let (mut reals, mut imags) = generate_numbers(len);
             b.iter(|| {
-                black_box(fft_64_with_opts_and_plan(
-                    &mut reals, &mut imags, &options, &planner,
-                ));
+                fft_64_with_opts_and_plan(
+                    black_box(&mut reals),
+                    black_box(&mut imags),
+                    black_box(&options),
+                    black_box(&planner),
+                );
             });
         });
     }