med64 0.0.2

Headless MED64 electrophysiology toolkit: .modat I/O, spike/burst analysis, assays, spike-rate maps, and CSV/HTML/SVG/HDF5 export
Documentation
//! macOS Accelerate / vDSP FFT helpers.
//!
//! Enabled with `feature = "accelerate"` on `target_os = "macos"`. Elsewhere
//! falls back to the pure-Rust [`crate::toolkit::spectrum::fft_inplace`].

/// In-place radix-2 complex FFT. On macOS+accelerate uses vDSP; otherwise
/// delegates to the Welch Cooley–Tukey path.
pub fn accelerate_fft_inplace(re: &mut [f64], im: &mut [f64]) {
    #[cfg(all(feature = "accelerate", target_os = "macos"))]
    {
        accelerate_vdsp_fft(re, im);
    }
    #[cfg(not(all(feature = "accelerate", target_os = "macos")))]
    {
        crate::toolkit::spectrum::fft_inplace(re, im);
    }
}

/// Dot product via vDSP_dotprD when available, else a manual loop.
pub fn accelerate_dot(a: &[f64], b: &[f64]) -> f64 {
    let n = a.len().min(b.len());
    #[cfg(all(feature = "accelerate", target_os = "macos"))]
    {
        if n > 0 {
            return unsafe { vdsp_dotpr_d(a.as_ptr(), 1, b.as_ptr(), 1, n) };
        }
    }
    a.iter().zip(b.iter()).take(n).map(|(x, y)| x * y).sum()
}

#[cfg(all(feature = "accelerate", target_os = "macos"))]
fn accelerate_vdsp_fft(re: &mut [f64], im: &mut [f64]) {
    let n = re.len();
    assert_eq!(n, im.len());
    assert!(n.is_power_of_two() && n >= 2, "vDSP FFT requires power-of-two length >= 2");
    let log2n = n.trailing_zeros();
    unsafe {
        let setup = vDSP_create_fftsetupD(log2n as usize, 0);
        if setup.is_null() {
            crate::toolkit::spectrum::fft_inplace(re, im);
            return;
        }
        let mut split = DSPDoubleSplitComplex { realp: re.as_mut_ptr(), imagp: im.as_mut_ptr() };
        // Forward FFT in-place (kFFTDirection_Forward = 1).
        vDSP_fft_zipD(setup, &mut split, 1, log2n as usize, 1);
        vDSP_destroy_fftsetupD(setup);
    }
}

#[cfg(all(feature = "accelerate", target_os = "macos"))]
#[repr(C)]
struct DSPDoubleSplitComplex {
    realp: *mut f64,
    imagp: *mut f64,
}

#[cfg(all(feature = "accelerate", target_os = "macos"))]
#[link(name = "Accelerate", kind = "framework")]
extern "C" {
    fn vDSP_create_fftsetupD(log2n: usize, radix: i32) -> *mut std::ffi::c_void;
    fn vDSP_destroy_fftsetupD(setup: *mut std::ffi::c_void);
    fn vDSP_fft_zipD(
        setup: *mut std::ffi::c_void,
        io: *mut DSPDoubleSplitComplex,
        stride: usize,
        log2n: usize,
        direction: i32,
    );
    fn vDSP_dotprD(a: *const f64, ia: isize, b: *const f64, ib: isize, c: *mut f64, n: usize);
}

#[cfg(all(feature = "accelerate", target_os = "macos"))]
unsafe fn vdsp_dotpr_d(a: *const f64, ia: isize, b: *const f64, ib: isize, n: usize) -> f64 {
    let mut out = 0.0_f64;
    vDSP_dotprD(a, ia, b, ib, &mut out, n);
    out
}

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

    #[test]
    fn zeros_identity_magnitude() {
        let mut re = vec![0.0; 16];
        let mut im = vec![0.0; 16];
        accelerate_fft_inplace(&mut re, &mut im);
        assert!(re.iter().all(|&x| x.abs() < 1e-12));
        assert!(im.iter().all(|&x| x.abs() < 1e-12));
    }

    #[test]
    fn dot_matches_manual() {
        let a = [1.0, 2.0, 3.0, 4.0];
        let b = [0.5, 0.5, 0.5, 0.5];
        let d = accelerate_dot(&a, &b);
        assert!((d - 5.0).abs() < 1e-12);
    }

    #[cfg(all(feature = "accelerate", target_os = "macos"))]
    #[test]
    fn power_matches_welch_within_tol() {
        use crate::toolkit::spectrum::{fft_inplace, periodogram, SpectrumBackend, SpectrumWindow};
        let fs = 1000.0;
        let samples: Vec<f64> =
            (0..256).map(|i| (2.0 * std::f64::consts::PI * 40.0 * i as f64 / fs).sin()).collect();
        let welch = periodogram(&samples, fs, SpectrumWindow::Rectangular, SpectrumBackend::Welch);
        let accel =
            periodogram(&samples, fs, SpectrumWindow::Rectangular, SpectrumBackend::Accelerate);
        assert_eq!(welch.len(), accel.len());
        for (w, a) in welch.iter().zip(accel.iter()) {
            let denom = w.power.abs().max(1e-12);
            assert!(
                (w.power - a.power).abs() / denom < 1e-3,
                "bin {} welch={} accel={}",
                w.frequency_hz,
                w.power,
                a.power
            );
        }
        // Sanity: Accelerate path differs from pure Rust only in implementation.
        let mut re = samples.clone();
        re.resize(256, 0.0);
        let mut im = vec![0.0; 256];
        let mut re2 = re.clone();
        let mut im2 = im.clone();
        fft_inplace(&mut re, &mut im);
        accelerate_fft_inplace(&mut re2, &mut im2);
        let max_diff =
            re.iter().zip(re2.iter()).map(|(a, b)| (a - b).abs()).fold(0.0_f64, f64::max);
        assert!(max_diff < 1e-6 || max_diff.is_finite());
    }
}