pub const MAX_SPIKE_HISTORY: usize = 64;
const _: () = assert!(MAX_SPIKE_HISTORY.is_power_of_two());
#[derive(Clone)]
pub struct SpikeRecorder {
buf: [u32; MAX_SPIKE_HISTORY],
head: usize,
len: usize,
}
impl SpikeRecorder {
#[must_use]
pub const fn new() -> Self {
Self {
buf: [0; MAX_SPIKE_HISTORY],
head: 0,
len: 0,
}
}
pub fn record(&mut self, t_us: u32) {
debug_assert!(self.head < MAX_SPIKE_HISTORY);
if self.len < MAX_SPIKE_HISTORY {
self.buf[(self.head + self.len) & (MAX_SPIKE_HISTORY - 1)] = t_us;
self.len += 1;
} else {
self.buf[self.head & (MAX_SPIKE_HISTORY - 1)] = t_us;
self.head = (self.head + 1) % MAX_SPIKE_HISTORY;
}
}
#[must_use]
pub fn len(&self) -> usize {
self.len
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len == 0
}
pub fn iter(&self) -> impl Iterator<Item = u32> + '_ {
(0..self.len).map(move |i| self.buf[(self.head + i) % MAX_SPIKE_HISTORY])
}
pub fn clear(&mut self) {
self.head = 0;
self.len = 0;
}
}
impl Default for SpikeRecorder {
fn default() -> Self {
Self::new()
}
}
impl core::fmt::Debug for SpikeRecorder {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_list().entries(self.iter()).finish()
}
}
#[cfg(test)]
#[allow(clippy::cast_possible_truncation)] impl SpikeRecorder {
pub(crate) fn get(&self, i: usize) -> u32 {
assert!(
i < self.len,
"SpikeRecorder index {i} out of range {}",
self.len
);
self.buf[(self.head + i) % MAX_SPIKE_HISTORY]
}
pub(crate) fn firing_rate_mhz(&self, now_us: u32, window_us: u32) -> u32 {
if self.is_empty() || window_us == 0 {
return 0;
}
let window_start = now_us.saturating_sub(window_us);
let count = self.iter().filter(|&t| t >= window_start).count() as u32;
count
.saturating_mul(1_000_000_000)
.checked_div(window_us)
.unwrap_or(0)
}
pub(crate) fn isi_stats_us(&self) -> Option<(u32, u32)> {
if self.len() < 2 {
return None;
}
let n = self.len();
let mut intervals_sum: u128 = 0;
let mut intervals_sqsum: u128 = 0;
let mut count: u128 = 0;
for i in 1..n {
let prev = self.get(i - 1);
let curr = self.get(i);
if curr >= prev {
let d = u128::from(curr - prev);
intervals_sum += d;
intervals_sqsum += d * d;
count += 1;
}
}
if count == 0 {
return None;
}
let mean = intervals_sum / count;
let mean_sq = mean * mean;
let sq_mean = intervals_sqsum / count;
let variance = u64::try_from(sq_mean.saturating_sub(mean_sq))
.expect("variance of u32 intervals is below 2^64");
let std = isqrt_u64(variance);
Some((mean as u32, std as u32))
}
}
#[cfg(test)]
fn isqrt_u64(n: u64) -> u64 {
if n == 0 {
return 0;
}
let mut x = n;
let mut y = x.div_ceil(2);
while y < x {
x = y;
y = u64::midpoint(x, n / x);
}
x
}
#[cfg(test)]
mod tests {
use super::*;
use crate::lif_neuron::{LIFNeuron, NeuronType, VoltageResolution};
use proptest::prelude::*;
struct HeaplessOracle {
history: heapless::Vec<u32, MAX_SPIKE_HISTORY>,
}
#[allow(clippy::cast_possible_truncation)]
impl HeaplessOracle {
fn new() -> Self {
Self {
history: heapless::Vec::new(),
}
}
fn push(&mut self, t: u32) {
if self.history.is_full() {
self.history.remove(0);
}
let _ = self.history.push(t);
}
fn firing_rate_mhz(&self, last_update_time_us: u32, window_us: u32) -> u32 {
if self.history.is_empty() || window_us == 0 {
return 0;
}
let window_start = last_update_time_us.saturating_sub(window_us);
let count = self.history.iter().filter(|&&t| t >= window_start).count() as u32;
count
.saturating_mul(1_000_000_000)
.checked_div(window_us)
.unwrap_or(0)
}
fn isi_stats_us(&self) -> Option<(u32, u32)> {
if self.history.len() < 2 {
return None;
}
let n = self.history.len();
let mut intervals_sum: u128 = 0;
let mut intervals_sqsum: u128 = 0;
let mut count: u128 = 0;
for i in 1..n {
let prev = self.history[i - 1];
let curr = self.history[i];
if curr >= prev {
let d = u128::from(curr - prev);
intervals_sum += d;
intervals_sqsum += d * d;
count += 1;
}
}
if count == 0 {
return None;
}
let mean = intervals_sum / count;
let mean_sq = mean * mean;
let sq_mean = intervals_sqsum / count;
let variance = u64::try_from(sq_mean.saturating_sub(mean_sq))
.expect("variance of u32 intervals is below 2^64");
let std = isqrt_u64(variance);
Some((mean as u32, std as u32))
}
}
proptest! {
#[test]
fn prop_ring_matches_the_heapless_oracle(
times in proptest::collection::vec(any::<u32>(), 0..300),
last_update_time_us in any::<u32>(),
window_us in any::<u32>(),
) {
let mut rec = SpikeRecorder::new();
let mut oracle = HeaplessOracle::new();
for &t in × {
rec.record(t);
oracle.push(t);
}
let ring: std::vec::Vec<u32> = rec.iter().collect();
let vec: std::vec::Vec<u32> = oracle.history.iter().copied().collect();
prop_assert_eq!(ring, vec, "iteration order and contents");
prop_assert_eq!(rec.len(), oracle.history.len());
prop_assert_eq!(
rec.firing_rate_mhz(last_update_time_us, window_us),
oracle.firing_rate_mhz(last_update_time_us, window_us)
);
prop_assert_eq!(rec.isi_stats_us(), oracle.isi_stats_us());
}
#[test]
fn prop_ring_keeps_the_newest_in_order(
times in proptest::collection::vec(any::<u32>(), 0..300),
) {
let mut ring = SpikeRecorder::new();
for &t in × {
ring.record(t);
}
let live = times.len().min(MAX_SPIKE_HISTORY);
prop_assert_eq!(ring.len(), live);
prop_assert_eq!(ring.is_empty(), live == 0);
let expected = ×[times.len() - live..];
let got: std::vec::Vec<u32> = ring.iter().collect();
prop_assert_eq!(got.as_slice(), expected);
for (i, &t) in expected.iter().enumerate() {
prop_assert_eq!(ring.get(i), t);
}
ring.clear();
prop_assert!(ring.is_empty());
prop_assert_eq!(ring.iter().count(), 0);
ring.record(7);
prop_assert_eq!(ring.len(), 1);
prop_assert_eq!(ring.get(0), 7);
}
#[test]
fn prop_history_never_exceeds_capacity(id in 0u16..=10) {
let mut n = LIFNeuron::new(id, NeuronType::Excitatory, VoltageResolution::Millivolt);
let mut rec = SpikeRecorder::new();
n.threshold = -100;
for i in 0..1000_u32 {
let t = i * 1000;
if n.integrate_and_fire(1000, 1000, t) {
rec.record(t);
}
}
prop_assert!(rec.len() <= MAX_SPIKE_HISTORY);
}
}
#[test]
fn isi_stats_none_with_fewer_than_two_spikes() {
let rec = SpikeRecorder::new();
assert!(rec.isi_stats_us().is_none());
}
#[test]
fn isi_stats_computed_with_two_spikes() {
let mut rec = SpikeRecorder::new();
rec.record(1_000);
rec.record(2_000); let (mean, std) = rec.isi_stats_us().expect("two spikes → Some");
assert_eq!(mean, 1000);
assert_eq!(std, 0);
}
#[test]
fn isi_stats_survive_three_maximal_intervals() {
let times = [0, u32::MAX, 0, u32::MAX, 0, u32::MAX];
let mut rec = SpikeRecorder::new();
let mut oracle = HeaplessOracle::new();
for &t in × {
rec.record(t);
oracle.push(t);
}
assert_eq!(rec.isi_stats_us(), Some((u32::MAX, 0)));
assert_eq!(oracle.isi_stats_us(), Some((u32::MAX, 0)));
}
#[test]
fn ring_debug_shows_live_entries_only() {
let mut ring = SpikeRecorder::new();
assert_eq!(std::format!("{ring:?}"), "[]");
ring.record(1);
ring.record(2);
assert_eq!(std::format!("{ring:?}"), "[1, 2]");
let mut ring = SpikeRecorder::new();
for t in 0..70_u32 {
ring.record(t);
}
let shown = std::format!("{ring:?}");
assert!(shown.starts_with("[6, 7, 8,"), "{shown}");
assert!(shown.ends_with(" 69]"), "{shown}");
assert_eq!(ring.iter().count(), MAX_SPIKE_HISTORY);
}
#[test]
#[should_panic(expected = "SpikeRecorder index 2 out of range 2")]
fn ring_get_past_len_panics_like_a_slice() {
let mut ring = SpikeRecorder::new();
ring.record(10);
ring.record(20);
let _ = ring.get(2);
}
}