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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Example demonstrating FFT context managers
//!
//! This example shows how to use context managers to temporarily change FFT settings.

use scirs2_fft::{
    fft, fft_context, get_backend_name, get_global_cache, get_workers, with_backend,
    with_fft_settings, with_workers, without_cache,
};
use std::time::Instant;

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

    // Create test signal
    let signal: Vec<f64> = (0..1024).map(|i| (i as f64).sin()).collect();

    // Show default settings
    println!("Default settings:");
    println!("  Backend: {}", get_backend_name());
    println!("  Workers: {}", get_workers());
    println!("  Cache enabled: {}", get_global_cache().is_enabled());
    println!();

    // Test 1: Temporarily disable cache
    println!("Test 1: Without cache");
    let _result1 = without_cache(|| {
        println!(
            "  Cache enabled inside context: {}",
            get_global_cache().is_enabled()
        );

        let start = Instant::now();
        let spectrum = fft(&signal, None).expect("Operation failed");
        let duration1 = start.elapsed();

        let start = Instant::now();
        let _ = fft(&signal, None).expect("Operation failed");
        let duration2 = start.elapsed();

        println!("  First FFT: {duration1:?}");
        println!("  Second FFT: {duration2:?} (no caching)");

        spectrum
    })
    .expect("Operation failed");

    println!(
        "  Cache enabled after context: {}",
        get_global_cache().is_enabled()
    );
    println!();

    // Test 2: With specific backend (same as default in this case)
    println!("Test 2: With specific backend");
    let _result2 = with_backend("rustfft", || {
        println!("  Backend inside context: {}", get_backend_name());
        fft(&signal, None).expect("Operation failed")
    })
    .expect("Operation failed");
    println!("  Backend after context: {}", get_backend_name());
    println!();

    // Test 3: With specific number of workers
    println!("Test 3: With specific workers");
    let _result3 = with_workers(2, || {
        // Note: Due to current implementation limitations, this doesn't actually
        // change the worker count, but demonstrates the API
        println!("  Would use 2 workers if fully implemented");
        fft(&signal, None)
    })
    .expect("Operation failed");
    println!();

    // Test 4: Combined settings using builder
    println!("Test 4: Combined settings");
    let _result4 = with_fft_settings(
        fft_context()
            .backend("rustfft")
            .workers(4)
            .cache_enabled(false),
        || {
            println!("  Backend: {}", get_backend_name());
            println!("  Cache enabled: {}", get_global_cache().is_enabled());

            let start = Instant::now();
            let spectrum = fft(&signal, None).expect("Operation failed");
            let duration = start.elapsed();

            println!("  FFT duration: {duration:?}");

            spectrum
        },
    )
    .expect("Operation failed");

    println!("  Settings restored after context");
    println!("  Backend: {}", get_backend_name());
    println!("  Cache enabled: {}", get_global_cache().is_enabled());
    println!();

    // Test 5: Nested contexts
    println!("Test 5: Nested contexts");
    with_backend("rustfft", || {
        println!("  Outer context - Backend: {}", get_backend_name());

        without_cache(|| {
            println!("  Inner context - Backend: {}", get_backend_name());
            println!(
                "  Inner context - Cache: {}",
                get_global_cache().is_enabled()
            );
        })
        .expect("Operation failed");

        println!(
            "  Back to outer context - Cache: {}",
            get_global_cache().is_enabled()
        );
    })
    .expect("Operation failed");

    println!();

    // Test 6: Verify FFT functionality within contexts
    println!("Test 6: FFT functionality check");
    let original_spectrum = fft(&signal, None).expect("Operation failed");

    let context_spectrum =
        without_cache(|| fft(&signal, None).expect("Operation failed")).expect("Operation failed");

    // Check if results are the same
    let results_match = original_spectrum
        .iter()
        .zip(context_spectrum.iter())
        .all(|(a, b)| (a.re - b.re).abs() < 1e-10 && (a.im - b.im).abs() < 1e-10);

    println!("  Results match: {results_match}");

    // Show cache statistics
    let stats = get_global_cache().get_stats();
    println!("\nCache statistics:");
    println!("{stats}");
}