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
use serde::{Deserialize, Serialize};

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

#[derive(Debug, Clone)]
pub struct HistogramOptions {
    pub isi_bin_ms: f64,
    pub isi_max_ms: f64,
    pub amp_bin_mv: f64,
    pub amp_max_mv: f64,
}

impl Default for HistogramOptions {
    fn default() -> Self {
        Self { isi_bin_ms: 1.0, isi_max_ms: 200.0, amp_bin_mv: 0.01, amp_max_mv: 1.0 }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Histogram {
    pub edges: Vec<f64>,
    pub counts: Vec<u64>,
}

pub fn isi_histogram(train: &SpikeTrain, options: &HistogramOptions) -> Histogram {
    let n = (options.isi_max_ms / options.isi_bin_ms).ceil() as usize;
    let mut counts = vec![0u64; n.max(1)];
    for spikes in train.by_channel().values() {
        for pair in spikes.windows(2) {
            let isi = pair[1].within_trace_time_ms - pair[0].within_trace_time_ms;
            if isi < 0.0 || isi >= options.isi_max_ms {
                continue;
            }
            let idx = (isi / options.isi_bin_ms) as usize;
            if idx < counts.len() {
                counts[idx] += 1;
            }
        }
    }
    Histogram { edges: (0..=counts.len()).map(|i| i as f64 * options.isi_bin_ms).collect(), counts }
}

pub fn amplitude_histogram(train: &SpikeTrain, options: &HistogramOptions) -> Histogram {
    let n = (options.amp_max_mv / options.amp_bin_mv).ceil() as usize;
    let mut counts = vec![0u64; n.max(1)];
    for spike in &train.spikes {
        let amp = spike.peak_mv.abs();
        if amp >= options.amp_max_mv {
            continue;
        }
        let idx = (amp / options.amp_bin_mv) as usize;
        if idx < counts.len() {
            counts[idx] += 1;
        }
    }
    Histogram { edges: (0..=counts.len()).map(|i| i as f64 * options.amp_bin_mv).collect(), counts }
}

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

    #[test]
    fn bins_isi() {
        let mut train = SpikeTrain::default();
        for t in [0.0, 10.0, 20.0] {
            train.push(Spike { within_trace_time_ms: t, peak_mv: 0.5, ..Default::default() });
        }
        let h = isi_histogram(&train, &HistogramOptions::default());
        assert!(h.counts.iter().sum::<u64>() >= 2);
    }
}