scirs2-fft 0.4.2

Fast Fourier Transform module for SciRS2 (scirs2-fft)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! Example demonstrating the FFT backend system
//!
//! This example shows how to use and switch between different FFT backends.

// use scirs2_core::Complex64;  // Unused import
use scirs2_fft::{fft, get_backend_info, get_backend_name, ifft, list_backends, BackendContext};

#[allow(dead_code)]
fn main() {
    println!("FFT Backend System Example");
    println!("=========================");
    println!();

    // List available backends
    let backends = list_backends();
    println!("Available backends:");
    for backend_name in &backends {
        if let Some(info) = get_backend_info(backend_name) {
            println!("  {}", info);
        }
    }
    println!();

    // Show current backend
    println!("Current backend: {}", get_backend_name());
    println!();

    // Create test signal
    let signal: Vec<f64> = (0..16).map(|i| i as f64).collect();
    println!("Test signal: {:?}", signal);

    // Use default backend
    println!("\nUsing default backend ({}):", get_backend_name());
    let spectrum = fft(&signal, None).expect("Operation failed");
    println!("  FFT result (first 4 values): {:?}", &spectrum[0..4]);

    // Verify inverse FFT
    let recovered = ifft(&spectrum, None).expect("Operation failed");
    println!(
        "  IFFT recovery successful: {}",
        signal
            .iter()
            .zip(recovered.iter())
            .all(|(a, b)| (a - b.re).abs() < 1e-10 && b.im.abs() < 1e-10)
    );

    // Demonstrate backend context (for future use when we have multiple backends)
    println!("\nUsing backend context:");
    {
        let _ctx = BackendContext::new("rustfft").expect("Operation failed");
        println!("  Inside context: backend = {}", get_backend_name());
        let _ = fft(&signal, None).expect("Operation failed");
    }
    println!("  Outside context: backend = {}", get_backend_name());

    // Test backend info
    println!("\nBackend capabilities:");
    if let Some(backend_manager) = Some(scirs2_fft::get_backend_manager()) {
        let backend = backend_manager.get_backend();
        let features = vec![
            "1d_fft",
            "2d_fft",
            "nd_fft",
            "cached_plans",
            "gpu_acceleration",
        ];

        for feature in features {
            println!(
                "  Supports {}: {}",
                feature,
                backend.supports_feature(feature)
            );
        }
    }

    // Demonstrate array-like object handling (conceptual)
    println!("\nArray interoperability:");

    // Convert from various array types
    let vec_input = vec![1.0, 2.0, 3.0, 4.0];
    let ndarray_input = scirs2_core::ndarray::Array1::from(vec![1.0, 2.0, 3.0, 4.0]);

    // All should work with the same interface
    let result1 = fft(&vec_input, None).expect("Operation failed");
    let result2 =
        fft(ndarray_input.as_slice().expect("Operation failed"), None).expect("Operation failed");

    println!("  Vec input FFT: success");
    println!("  ndarray input FFT: success");
    println!(
        "  Results match: {}",
        result1
            .iter()
            .zip(result2.iter())
            .all(|(a, b)| (a.re - b.re).abs() < 1e-10 && (a.im - b.im).abs() < 1e-10)
    );

    // Future features demonstration (commented out as they're not implemented yet)
    /*
    // Switch to OxiFFT backend (Pure Rust, high-performance)
    set_backend("oxifft").ok();

    // Use GPU backend if available
    if backends.contains(&"cuda_fft".to_string()) {
        set_backend("cuda_fft").ok();
        println!("\nUsing GPU backend:");
        let gpu_result = fft(&signal, None).expect("Operation failed");
        println!("  GPU FFT completed");
    }
    */
}