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
//! Poincaré ISI return maps .

use serde::{Deserialize, Serialize};

use crate::analysis::spike::SpikeTrain;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoincarePoint {
    pub isi_n_ms: f64,
    pub isi_n1_ms: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoincareReport {
    pub points: Vec<PoincarePoint>,
    pub sd1: f64,
    pub sd2: f64,
    pub mean_isi_ms: f64,
}

/// Consecutive inter-spike-interval return map with SD1/SD2 descriptors.
pub fn poincare_isi(train: &SpikeTrain) -> PoincareReport {
    let mut isis = Vec::new();
    for spikes in train.by_channel().values() {
        for w in spikes.windows(2) {
            let isi = w[1].within_trace_time_ms - w[0].within_trace_time_ms;
            if isi > 0.0 {
                isis.push(isi);
            }
        }
    }
    let points: Vec<_> =
        isis.windows(2).map(|w| PoincarePoint { isi_n_ms: w[0], isi_n1_ms: w[1] }).collect();
    let mean = if isis.is_empty() { 0.0 } else { isis.iter().sum::<f64>() / isis.len() as f64 };
    let (sd1, sd2) = sd1_sd2(&points);
    PoincareReport { points, sd1, sd2, mean_isi_ms: mean }
}

fn sd1_sd2(points: &[PoincarePoint]) -> (f64, f64) {
    if points.is_empty() {
        return (0.0, 0.0);
    }
    let diffs: Vec<f64> = points.iter().map(|p| p.isi_n1_ms - p.isi_n_ms).collect();
    let sums: Vec<f64> = points.iter().map(|p| p.isi_n1_ms + p.isi_n_ms).collect();
    let var = |xs: &[f64]| {
        let m = xs.iter().sum::<f64>() / xs.len() as f64;
        xs.iter().map(|x| (x - m).powi(2)).sum::<f64>() / xs.len() as f64
    };
    ((var(&diffs) / 2.0).sqrt(), (var(&sums) / 2.0).sqrt())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::analysis::spike::{Spike, SpikeTrain};

    #[test]
    fn builds_return_map() {
        let mut train = SpikeTrain::default();
        for t in [0.0, 100.0, 210.0, 300.0] {
            train.push(Spike { within_trace_time_ms: t, ..Default::default() });
        }
        let report = poincare_isi(&train);
        assert_eq!(report.points.len(), 2);
        assert!(report.mean_isi_ms > 0.0);
    }
}