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