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);
}
}
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() };
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
);
}
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());
}
}