oxifft 0.2.0

Pure Rust implementation of FFTW - the Fastest Fourier Transform in the West
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

//! No-op solver for size-1 transforms.
//!
//! A size-1 DFT is trivial: the output equals the input.
//! This solver handles this base case efficiently.

use crate::kernel::{Complex, Float};

/// No-op solver for trivial (size-1) transforms.
///
/// For a size-1 DFT, X\[0\] = x\[0\] (just copy the single element).
/// This is the base case for recursive FFT algorithms.
pub struct NopSolver<T: Float> {
    _marker: core::marker::PhantomData<T>,
}

impl<T: Float> Default for NopSolver<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Float> NopSolver<T> {
    /// Create a new no-op solver.
    #[must_use]
    pub fn new() -> Self {
        Self {
            _marker: core::marker::PhantomData,
        }
    }

    /// Solver name.
    #[must_use]
    pub fn name(&self) -> &'static str {
        "dft-nop"
    }

    /// Check if this solver can handle the given size.
    #[must_use]
    pub fn applicable(n: usize) -> bool {
        n <= 1
    }

    /// Execute the no-op transform.
    ///
    /// For size 0: does nothing
    /// For size 1: copies input\[0\] to output\[0\]
    #[inline]
    pub fn execute(&self, input: &[Complex<T>], output: &mut [Complex<T>]) {
        match input.len() {
            0 => {}
            1 => output[0] = input[0],
            _ => panic!("NopSolver only handles size 0 or 1"),
        }
    }

    /// Execute in-place (no-op for size 0 or 1).
    #[inline]
    pub fn execute_inplace(&self, _data: &mut [Complex<T>]) {
        // Nothing to do - data is already in place
    }

    /// Execute on raw pointers.
    ///
    /// # Safety
    /// - For n=1: both pointers must be valid
    /// - Pointers may be equal (in-place)
    #[inline]
    pub unsafe fn execute_ptr(&self, input: *const Complex<T>, output: *mut Complex<T>, n: usize) {
        if n == 1 && input != output as *const _ {
            unsafe { *output = *input };
        }
    }
}

/// Convenience function for size-1 DFT.
#[inline]
pub fn dft_nop<T: Float>(input: &[Complex<T>], output: &mut [Complex<T>]) {
    NopSolver::new().execute(input, output);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_nop_size_0() {
        let input: [Complex<f64>; 0] = [];
        let mut output: [Complex<f64>; 0] = [];

        NopSolver::new().execute(&input, &mut output);
        // No assertion needed - just shouldn't panic
    }

    #[test]
    fn test_nop_size_1() {
        let input = [Complex::new(3.0_f64, 4.0)];
        let mut output = [Complex::zero()];

        NopSolver::new().execute(&input, &mut output);

        assert!((output[0].re - 3.0).abs() < 1e-10);
        assert!((output[0].im - 4.0).abs() < 1e-10);
    }

    #[test]
    fn test_applicable() {
        assert!(NopSolver::<f64>::applicable(0));
        assert!(NopSolver::<f64>::applicable(1));
        assert!(!NopSolver::<f64>::applicable(2));
        assert!(!NopSolver::<f64>::applicable(100));
    }
}