pub struct Windows {
pub spans: Vec<f64>,
pub samples: Vec<(f64, u32)>,
pub total: u64,
started: Option<f64>,
sums: Vec<u64>,
heads: Vec<usize>,
base: usize,
}
impl Windows {
pub fn new(spans: &[f64]) -> Windows {
Windows {
spans: spans.to_vec(),
samples: Vec::new(),
total: 0,
started: None,
sums: vec![0; spans.len()],
heads: vec![0; spans.len()],
base: 0,
}
}
pub fn add(&mut self, when: f64, counts: u32) {
if self.started.is_none() {
self.started = Some(when);
}
self.samples.push((when, counts));
self.total += counts as u64;
for i in 0..self.spans.len() {
self.sums[i] += counts as u64;
let cutoff = when - self.spans[i];
let mut head = self.heads[i];
while head - self.base < self.samples.len() {
let (t, c) = self.samples[head - self.base];
if t > cutoff {
break;
}
self.sums[i] -= c as u64;
head += 1;
}
self.heads[i] = head;
}
let keep = self.heads.iter().copied().min().unwrap_or(0).saturating_sub(1);
if keep > self.base {
self.samples.drain(..keep - self.base);
self.base = keep;
}
}
pub fn first_index(&self) -> usize {
self.base
}
pub fn elapsed(&self) -> f64 {
match (self.started, self.samples.last()) {
(Some(s), Some(&(t, _))) => t - s,
_ => 0.0,
}
}
pub fn average(&self, span: f64) -> Option<f64> {
if self.samples.is_empty() || self.elapsed() < span {
return None;
}
let i = self.spans.iter().position(|&s| s == span)?;
Some(self.sums[i] as f64 * 60.0 / span)
}
}
pub const LEVEL_RAISED: f64 = 100.0;
pub const LEVEL_HIGH: f64 = 300.0;
#[derive(PartialEq, Clone, Copy)]
pub enum Level {
Calm,
Raised,
High,
}
pub fn level(cpm: f64) -> Level {
if cpm >= LEVEL_HIGH {
Level::High
} else if cpm >= LEVEL_RAISED {
Level::Raised
} else {
Level::Calm
}
}
pub const BAND_ATTENUATED: f64 = 3.0;
pub const BAND_NOMINAL: f64 = 30.0;
pub const BAND_ADVISORY: f64 = 120.0;
pub const BAND_WARNING: f64 = 240.0;
pub const BAND_DEADLY: f64 = 600.0;
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]
pub enum Band {
Attenuated,
Nominal,
Advisory,
Warning,
Deadly,
}
pub fn band(cpm: f64) -> Band {
if cpm >= BAND_DEADLY {
Band::Deadly
} else if cpm >= BAND_WARNING {
Band::Warning
} else if cpm >= BAND_ADVISORY {
Band::Advisory
} else if cpm >= BAND_NOMINAL {
Band::Nominal
} else {
Band::Attenuated
}
}
impl Band {
pub fn name(self) -> &'static str {
match self {
Band::Attenuated => "attenuated",
Band::Nominal => "nominal",
Band::Advisory => "advisory",
Band::Warning => "warning",
Band::Deadly => "deadly",
}
}
pub fn floor(self) -> f64 {
match self {
Band::Attenuated => 0.0,
Band::Nominal => BAND_NOMINAL,
Band::Advisory => BAND_ADVISORY,
Band::Warning => BAND_WARNING,
Band::Deadly => BAND_DEADLY,
}
}
pub fn all() -> [Band; 5] {
[Band::Attenuated, Band::Nominal, Band::Advisory, Band::Warning, Band::Deadly]
}
}
#[derive(Clone, Copy)]
struct C {
re: f64,
im: f64,
}
impl C {
fn mul(self, o: C) -> C {
C {
re: self.re * o.re - self.im * o.im,
im: self.re * o.im + self.im * o.re,
}
}
fn add(self, o: C) -> C {
C { re: self.re + o.re, im: self.im + o.im }
}
fn sub(self, o: C) -> C {
C { re: self.re - o.re, im: self.im - o.im }
}
fn norm(self) -> f64 {
self.re * self.re + self.im * self.im
}
}
fn fft(values: &[f64]) -> Vec<C> {
let n = values.len();
assert!(n > 0 && n & (n - 1) == 0, "fft needs a power-of-two length");
let mut a: Vec<C> = values.iter().map(|&v| C { re: v, im: 0.0 }).collect();
let mut j = 0usize;
for i in 1..n {
let mut bit = n >> 1;
while j & bit != 0 {
j ^= bit;
bit >>= 1;
}
j |= bit;
if i < j {
a.swap(i, j);
}
}
let mut size = 2usize;
while size <= n {
let ang = -2.0 * std::f64::consts::PI / size as f64;
let step = C { re: ang.cos(), im: ang.sin() };
let half = size / 2;
let mut start = 0usize;
while start < n {
let mut w = C { re: 1.0, im: 0.0 };
for k in start..start + half {
let u = a[k];
let v = a[k + half].mul(w);
a[k] = u.add(v);
a[k + half] = u.sub(v);
w = w.mul(step);
}
start += size;
}
size <<= 1;
}
a
}
pub struct Spectrum {
pub window: usize,
pub bins: usize,
buf: Vec<f64>,
power: Vec<f64>,
pub runs: u32,
taper: Vec<f64>,
}
impl Spectrum {
pub fn new(window: usize) -> Spectrum {
let taper = (0..window)
.map(|i| {
0.5 - 0.5
* (2.0 * std::f64::consts::PI * i as f64 / (window - 1) as f64).cos()
})
.collect();
Spectrum {
window,
bins: window / 2,
buf: Vec::with_capacity(window),
power: vec![0.0; window / 2],
runs: 0,
taper,
}
}
pub fn add(&mut self, counts: u32) -> bool {
self.buf.push(counts as f64);
if self.buf.len() < self.window {
return false;
}
let mean = self.buf.iter().sum::<f64>() / self.window as f64;
let shaped: Vec<f64> = self
.buf
.iter()
.zip(&self.taper)
.map(|(v, t)| (v - mean) * t)
.collect();
let spec = fft(&shaped);
for i in 0..self.bins {
self.power[i] += spec[i].norm();
}
self.runs += 1;
self.buf.drain(..self.window / 2);
true
}
pub fn wait(&self) -> usize {
if self.runs > 0 { 0 } else { self.window - self.buf.len() }
}
pub fn relative(&self) -> Vec<f64> {
if self.runs == 0 {
return Vec::new();
}
let avg: Vec<f64> = self.power[1..].iter().map(|p| p / self.runs as f64).collect();
let mean = avg.iter().sum::<f64>() / avg.len() as f64;
if mean <= 0.0 {
return vec![0.0; avg.len()];
}
avg.into_iter().map(|p| p / mean).collect()
}
fn independent(&self) -> f64 {
if self.runs > 1 { self.runs as f64 * 9.0 / 11.0 } else { self.runs as f64 }
}
pub fn sigma(&self, rel: f64) -> f64 {
let n = self.independent();
if n < 1.0 { 0.0 } else { (rel - 1.0) * n.sqrt() }
}
pub fn chance_max(&self) -> f64 {
let n = self.independent();
if n < 1.0 || self.bins < 2 {
return f64::INFINITY;
}
let x = ((self.bins - 1) as f64).ln() / n;
1.0 + (2.0 * x).sqrt() + 2.0 * x / 3.0
}
pub fn period(&self, index: usize) -> f64 {
self.window as f64 / (index + 1) as f64
}
pub fn loudest(&self) -> (f64, usize) {
let rel = self.relative();
if rel.is_empty() {
return (0.0, 0);
}
let mut best = (rel[0], 0usize);
for (i, &v) in rel.iter().enumerate() {
if v > best.0 {
best = (v, i);
}
}
best
}
}
pub struct Ladder {
pub rungs: Vec<Spectrum>,
}
impl Ladder {
pub fn new() -> Ladder {
Ladder { rungs: vec![Spectrum::new(128), Spectrum::new(256), Spectrum::new(512)] }
}
pub fn add(&mut self, counts: u32) {
for r in self.rungs.iter_mut() {
r.add(counts);
}
}
pub fn best(&self) -> &Spectrum {
for r in self.rungs.iter().rev() {
if r.runs >= 2 {
return r;
}
}
for r in self.rungs.iter().rev() {
if r.runs > 0 {
return r;
}
}
self.rungs.iter().min_by_key(|r| r.wait()).unwrap()
}
}
pub fn spectrum_columns(rel: &[f64], width: usize) -> Vec<f64> {
if rel.is_empty() || width == 0 {
return Vec::new();
}
let n = rel.len();
(0..width)
.map(|c| {
let lo = c * n / width;
let hi = ((c + 1) * n / width).max(lo + 1).min(n);
rel[lo..hi].iter().cloned().fold(0.0f64, f64::max)
})
.collect()
}
pub const SPARK: [char; 9] = [' ', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
pub fn bar_rows(values: &[f64], width: usize, height: usize) -> Vec<Vec<char>> {
let tail: Vec<f64> = values.iter().rev().take(width).rev().cloned().collect();
if tail.is_empty() {
return vec![Vec::new(); height];
}
let peak = tail.iter().cloned().fold(0.0f64, f64::max).max(1.0);
(0..height)
.map(|r| {
let floor = ((height - 1 - r) * 8) as f64;
tail.iter()
.map(|&c| {
let units = (c * height as f64 * 8.0 / peak).round();
SPARK[(units - floor).clamp(0.0, 8.0) as usize]
})
.collect()
})
.collect()
}
#[derive(Clone, Debug, PartialEq)]
pub struct Tier {
pub columns: usize,
pub seconds: f64,
pub values: Vec<Option<f64>>,
}
pub const TIERS: usize = 4;
pub const INTERLEAVE_SECONDS: usize = 4;
pub fn tiers(samples: &[u32], first: usize, width: usize, span: usize) -> Vec<Tier> {
let v: Vec<f64> = samples.iter().map(|&c| c as f64).collect();
tiers_with(&v, first, width, span, TIERS, 1.0)
}
pub fn tiers_with(
samples: &[f64],
first: usize,
width: usize,
span: usize,
count: usize,
unit: f64,
) -> Vec<Tier> {
if count == 0 || width == 0 {
return Vec::new();
}
let q = width / count;
let fine_cols = width - q * (count - 1);
let reach = |k: usize| -> usize {
let mut u = 1usize;
let mut total = fine_cols;
for _ in 1..count {
u *= k;
total += q * u;
}
total
};
let mut k = 2usize;
while reach(k) < span && k < 60 {
k += 1;
}
let n = (first + samples.len()) as i64;
let first = first as i64;
let at = |a: i64| -> Option<f64> {
(a >= first && a < n).then(|| samples[(a - first) as usize])
};
let mean = |lo: i64, hi: i64| -> Option<f64> {
let (lo, hi) = (lo.max(first), hi.min(n));
(hi > lo).then(|| {
(lo..hi).map(|a| at(a).unwrap_or(0.0)).sum::<f64>() / (hi - lo) as f64
})
};
let fine: Vec<Option<f64>> = (0..fine_cols as i64)
.map(|j| at(n - fine_cols as i64 + j))
.collect();
let mut out = vec![Tier { columns: fine_cols, seconds: unit, values: fine }];
let mut b = n - fine_cols as i64;
let mut step = 1i64;
for _ in 1..count {
step *= k as i64;
let c = q as i64;
let top = (b - 1).div_euclid(step);
let values: Vec<Option<f64>> = (0..c)
.map(|j| {
let g = top - c + 1 + j;
mean(g * step, (g * step + step).min(b))
})
.collect();
b = (top - c + 1) * step;
out.push(Tier { columns: q, seconds: step as f64 * unit, values });
}
out.reverse();
out
}
pub fn tiers_interleaved(
samples: &[f64],
first: usize,
width: usize,
tubes: usize,
) -> Vec<Tier> {
let tubes = tubes.max(1);
if width == 0 {
return Vec::new();
}
let fine_cols = (INTERLEAVE_SECONDS * tubes)
.clamp(1, width.saturating_sub(TIERS).max(1));
let rest = width - fine_cols;
let q = rest / TIERS;
let extra = rest - q * TIERS;
let n = (first + samples.len()) as i64;
let base = first as i64;
let at = |a: i64| -> Option<f64> {
(a >= base && a < n).then(|| samples[(a - base) as usize])
};
let mean = |lo: i64, hi: i64| -> Option<f64> {
let (lo, hi) = (lo.max(base), hi.min(n));
(hi > lo).then(|| {
(lo..hi).map(|a| at(a).unwrap_or(0.0)).sum::<f64>() / (hi - lo) as f64
})
};
let unit = 1.0 / tubes as f64;
let fine: Vec<Option<f64>> = (0..fine_cols as i64)
.map(|j| at(n - fine_cols as i64 + j))
.collect();
let mut out = vec![Tier { columns: fine_cols, seconds: unit, values: fine }];
let mut step = tubes as i64;
let mut b = n - fine_cols as i64;
for t in 0..TIERS {
let c = (q + if t == 0 { extra } else { 0 }) as i64;
let top = (b - 1).div_euclid(step);
let values: Vec<Option<f64>> = (0..c)
.map(|j| {
let g = top - c + 1 + j;
mean(g * step, (g * step + step).min(b))
})
.collect();
b = (top - c + 1) * step;
out.push(Tier {
columns: c as usize,
seconds: step as f64 / tubes as f64,
values,
});
step *= 2;
}
out.reverse();
out
}
pub fn bar_seconds(seconds: f64) -> String {
if (seconds - seconds.round()).abs() < 1e-9 {
return format!("{}", seconds.round() as i64);
}
if seconds > 0.0 && seconds < 1.0 {
for d in 2..=64i64 {
let n = seconds * d as f64;
if (n - n.round()).abs() < 1e-6 && n.round() >= 1.0 {
return format!("{}/{}", n.round() as i64, d);
}
}
}
format!("{:.1}", seconds)
}
pub fn interleave_quality(gap: f64, tubes: usize) -> f64 {
let ideal = 1.0 / tubes.max(2) as f64;
if gap <= 0.0 {
return 0.0;
}
ideal.min(gap) / ideal.max(gap)
}
pub fn tiers_for(counters: usize) -> usize {
TIERS + if counters > 1 { 1 } else { 0 }
}
pub fn span_words(seconds: f64) -> String {
let s = seconds.round().max(0.0) as usize;
match s {
s if s < 120 => format!("{}s", s),
s if s < 3600 => format!("{}m", s / 60),
s if s % 3600 == 0 => format!("{}h", s / 3600),
s => format!("{}h {}m", s / 3600, (s % 3600) / 60),
}
}
pub fn bar_rows_to(values: &[Option<f64>], height: usize, peak: f64) -> Vec<Vec<char>> {
let peak = peak.max(1.0);
(0..height)
.map(|r| {
let floor = ((height - 1 - r) * 8) as f64;
values
.iter()
.map(|v| match v {
Some(c) => {
let units = (c * height as f64 * 8.0 / peak).round();
SPARK[(units - floor).clamp(0.0, 8.0) as usize]
}
None => ' ',
})
.collect()
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn fill(w: &mut Windows, counts: &[u32]) {
for (i, &c) in counts.iter().enumerate() {
w.add(i as f64, c);
}
}
#[test]
fn a_window_says_nothing_until_it_is_full() {
let mut w = Windows::new(&[3.0, 30.0]);
fill(&mut w, &[1, 1, 1]);
assert_eq!(w.average(3.0), None, "three samples span two seconds");
w.add(3.0, 1);
assert_eq!(w.average(3.0), Some(60.0));
assert_eq!(w.average(30.0), None);
}
#[test]
fn cpm_is_the_windows_counts_scaled_to_a_minute() {
let mut w = Windows::new(&[10.0]);
fill(&mut w, &[2; 11]);
assert_eq!(w.average(10.0), Some(120.0));
}
#[test]
fn a_span_nobody_asked_for_has_no_answer() {
let mut w = Windows::new(&[3.0]);
fill(&mut w, &[1; 40]);
assert_eq!(w.average(300.0), None);
}
#[test]
fn the_sample_list_does_not_grow_without_bound() {
let mut w = Windows::new(&[3.0, 30.0]);
fill(&mut w, &[1; 600]);
assert!(w.samples.len() < 40, "kept {} samples", w.samples.len());
assert_eq!(w.total, 600);
}
#[test]
fn a_reading_is_named_rather_than_compared() {
assert_eq!(band(0.0), Band::Attenuated);
assert_eq!(band(2.9), Band::Attenuated);
assert_eq!(band(29.9), Band::Attenuated, "under 30 is not yet nominal");
assert_eq!(band(30.0), Band::Nominal);
assert_eq!(band(119.9), Band::Nominal);
assert_eq!(band(120.0), Band::Advisory);
assert_eq!(band(239.9), Band::Advisory);
assert_eq!(band(240.0), Band::Warning);
assert_eq!(band(599.9), Band::Warning);
assert_eq!(band(600.0), Band::Deadly);
assert_eq!(band(65535.0), Band::Deadly, "the counter's ceiling is still deadly");
}
#[test]
fn the_bands_order_themselves() {
let mut all = Band::all();
all.reverse();
all.sort();
assert_eq!(all, Band::all());
assert!(Band::Deadly > Band::Nominal);
assert_eq!(Band::all().iter().copied().max().unwrap(), Band::Deadly);
}
#[test]
fn the_bands_are_where_the_constants_say() {
assert!(level(0.0) == Level::Calm);
assert!(level(LEVEL_RAISED - 0.1) == Level::Calm);
assert!(level(LEVEL_RAISED) == Level::Raised);
assert!(level(LEVEL_HIGH - 0.1) == Level::Raised);
assert!(level(LEVEL_HIGH) == Level::High);
}
#[test]
fn a_chart_is_as_tall_as_it_was_asked_for_and_as_wide_as_it_has_data() {
let rows = bar_rows(&[1.0, 2.0, 3.0, 4.0], 4, 5);
assert_eq!(rows.len(), 5);
for r in &rows {
assert_eq!(r.len(), 4);
}
assert_eq!(rows[0][3], '█');
assert_eq!(rows[0][0], ' ');
assert_eq!(rows[4][3], '█');
}
#[test]
fn a_chart_of_nothing_is_blank_rather_than_full() {
let rows = bar_rows(&[0.0; 6], 6, 3);
assert_eq!(rows.len(), 3);
assert!(rows.iter().all(|r| r.iter().all(|&c| c == ' ')));
}
#[test]
fn a_chart_shows_the_most_recent_samples_when_there_are_too_many() {
let values: Vec<f64> = (0..100).map(|i| i as f64).collect();
let rows = bar_rows(&values, 10, 1);
assert_eq!(rows[0].len(), 10);
assert_eq!(*rows[0].last().unwrap(), '█');
}
#[test]
fn the_spectrum_answers_nothing_until_it_has_a_window() {
let mut s = Spectrum::new(16);
assert_eq!(s.wait(), 16);
for i in 0..15 {
assert!(!s.add(i % 3), "fired before the window was full");
}
assert_eq!(s.wait(), 1);
assert!(s.add(1), "the sixteenth sample completes the window");
assert_eq!(s.wait(), 0);
assert_eq!(s.relative().len(), s.bins - 1);
}
#[test]
fn windows_half_overlap_so_two_averages_come_out_of_each_windows_data() {
let mut s = Spectrum::new(8);
let mut fired = 0;
for i in 0..24 {
if s.add((i % 5) as u32) {
fired += 1;
}
}
assert_eq!(fired, 5);
assert_eq!(s.runs, 5);
}
#[test]
fn a_constant_input_has_no_spectrum_at_all() {
let mut s = Spectrum::new(32);
for _ in 0..64 {
s.add(7);
}
let rel = s.relative();
assert!(!rel.is_empty());
assert!(rel.iter().all(|v| v.is_finite()), "{:?}", rel);
}
#[test]
fn a_periodic_input_puts_a_peak_where_its_period_is() {
let mut s = Spectrum::new(64);
for i in 0..512 {
let phase = 2.0 * std::f64::consts::PI * i as f64 / 8.0;
s.add((10.0 + 8.0 * phase.sin()).round() as u32);
}
let (top, where_) = s.loudest();
assert!(top > 5.0, "a period-8 signal should stand out, got {}", top);
let period = s.period(where_);
assert!(
(period - 8.0).abs() < 0.5,
"peak at {}s, expected 8s",
period
);
}
#[test]
fn poisson_arrivals_do_not_produce_a_peak_worth_reporting() {
let mut s = Spectrum::new(64);
let mut seed = 0x2545f491u32;
for _ in 0..2048 {
let mut k = 0u32;
let mut p = 1.0f64;
let target = (-2.0f64).exp();
loop {
seed ^= seed << 13;
seed ^= seed >> 17;
seed ^= seed << 5;
p *= (seed as f64) / (u32::MAX as f64);
if p <= target {
break;
}
k += 1;
}
s.add(k);
}
let (top, _) = s.loudest();
assert!(
top < s.chance_max() * 1.25,
"background read as periodic: peak {:.2}x against chance {:.2}x",
top,
s.chance_max()
);
}
#[test]
fn a_flat_source_is_not_called_periodic_however_long_it_is_watched() {
let mut seed = 0x2545f491u32;
let mut next = move || {
seed ^= seed << 13;
seed ^= seed >> 17;
seed ^= seed << 5;
seed
};
let mut draw = || {
let u = (next() >> 8) as f64 / (1u32 << 24) as f64;
if u < 0.55 { 0 } else if u < 0.85 { 1 } else if u < 0.96 { 2 }
else if u < 0.99 { 3 } else { 5 }
};
for &(secs, want_runs) in &[(1800usize, 6u32), (3600, 13), (7200, 27)] {
let mut fired = 0;
let trials = 20;
for _ in 0..trials {
let mut s = Spectrum::new(512);
for _ in 0..secs {
s.add(draw());
}
assert_eq!(s.runs, want_runs, "{} seconds", secs);
let (top, _) = s.loudest();
if top >= s.chance_max() * 1.25 {
fired += 1;
}
}
assert!(
fired <= 1,
"{} seconds of a provably flat source read as periodic {} \
times in {} (chance_max {:.2}x)",
secs, fired, trials, Spectrum::new(512).chance_max()
);
}
}
#[test]
fn the_tallest_bin_by_luck_keeps_its_square_root_term() {
let mut two = Spectrum::new(256);
for i in 0..384 {
two.add((i % 3) as u32);
}
assert_eq!(two.runs, 2);
assert!((two.chance_max() - 5.41).abs() < 0.02,
"two windows: {:.2}x", two.chance_max());
let mut many = Spectrum::new(512);
for i in 0..7424 {
many.add((i % 3) as u32);
}
assert_eq!(many.runs, 28);
assert!((many.chance_max() - 1.86).abs() < 0.02,
"twenty-eight windows: {:.2}x", many.chance_max());
assert!(many.chance_max() < two.chance_max(),
"more averaging must lower the bar, not raise it");
}
#[test]
fn columns_take_the_loudest_bin_they_cover() {
let rel = vec![1.0, 1.0, 9.0, 1.0, 1.0, 1.0, 1.0, 1.0];
let cols = spectrum_columns(&rel, 4);
assert_eq!(cols.len(), 4);
assert_eq!(cols[1], 9.0);
assert_eq!(cols[0], 1.0);
}
#[test]
fn columns_survive_being_asked_for_more_than_there_are_bins() {
let cols = spectrum_columns(&[1.0, 2.0], 8);
assert_eq!(cols.len(), 8);
assert!(cols.iter().all(|v| *v == 1.0 || *v == 2.0));
assert!(spectrum_columns(&[], 8).is_empty());
assert!(spectrum_columns(&[1.0], 0).is_empty());
}
#[test]
fn the_ladder_prefers_the_window_that_has_actually_run() {
let mut l = Ladder::new();
for i in 0..200 {
l.add((i % 4) as u32);
}
assert!(l.best().runs > 0, "nothing has answered after 200 samples");
}
#[test]
fn the_strip_reaches_back_the_spectrum_window() {
let t = tiers(&[], 0, 159, 512);
assert_eq!(t.len(), TIERS);
assert_eq!(t.iter().map(|x| x.columns).collect::<Vec<_>>(), vec![39, 39, 39, 42]);
assert_eq!(t.iter().map(|x| x.seconds).collect::<Vec<_>>(), vec![8.0, 4.0, 2.0, 1.0]);
let reach: f64 = t.iter().map(|x| x.columns as f64 * x.seconds).sum();
assert!(reach >= 512.0, "{}", reach);
}
#[test]
fn a_sub_second_bar_is_labelled_as_the_fraction_it_is() {
assert_eq!(bar_seconds(8.0), "8");
assert_eq!(bar_seconds(1.0), "1");
assert_eq!(bar_seconds(0.5), "1/2");
assert_eq!(bar_seconds(1.0 / 9.0), "1/9");
assert_eq!(bar_seconds(1.0 / 3.0), "1/3");
assert_eq!(bar_seconds(2.0 / 9.0), "2/9");
assert_eq!(bar_seconds(4.0 / 9.0), "4/9");
assert_eq!(bar_seconds(8.0 / 9.0), "8/9");
assert_eq!(bar_seconds(16.0 / 9.0), "1.8");
assert_eq!(bar_seconds(128.0 / 9.0), "14.2");
}
#[test]
fn exactly_one_tier_is_added_for_the_interleave() {
assert_eq!(tiers_for(1), TIERS, "one tube is the strip as it was");
assert_eq!(tiers_for(2), TIERS + 1);
assert_eq!(tiers_for(9), TIERS + 1, "nine tubes is still one interleave");
assert_eq!(tiers_for(0), TIERS, "no tubes is not fewer than one");
}
#[test]
fn nine_tubes_give_whole_seconds_and_one_interleave_tier() {
let n = 9usize;
let samples: Vec<f64> = (0..8000).map(|i| (i % 5) as f64).collect();
let t = tiers_interleaved(&samples, 0, 240, n);
assert_eq!(t.len(), TIERS + 1, "five tiers, not eight");
let seconds: Vec<String> = t.iter().map(|x| bar_seconds(x.seconds)).collect();
assert_eq!(seconds, vec!["8", "4", "2", "1", "1/9"]);
for pair in t[..TIERS].windows(2) {
assert!((pair[0].seconds / pair[1].seconds - 2.0).abs() < 1e-9);
}
assert!((t[TIERS - 1].seconds - 1.0).abs() < 1e-9);
assert!((t[TIERS].seconds - 1.0 / 9.0).abs() < 1e-9);
}
#[test]
fn two_tubes_are_the_same_shape_as_nine() {
let samples: Vec<f64> = (0..4000).map(|i| (i % 3) as f64).collect();
let t = tiers_interleaved(&samples, 0, 240, 2);
let seconds: Vec<String> = t.iter().map(|x| bar_seconds(x.seconds)).collect();
assert_eq!(seconds, vec!["8", "4", "2", "1", "1/2"]);
}
#[test]
fn the_interleave_is_judged_against_what_this_many_tubes_could_manage() {
let pc = |g, n| (100.0 * interleave_quality(g, n)).round() as i64;
assert_eq!(pc(0.5, 2), 100, "a pair half a second apart is perfect");
assert_eq!(pc(1.0 / 9.0, 9), 100, "and so is nine a ninth apart");
assert_eq!(pc(0.0, 2), 0);
assert!(pc(0.5, 9) < 100);
assert_eq!(pc(0.25, 2), 50);
assert_eq!(pc(1.0, 2), 50, "and it is symmetric either side");
assert_eq!(pc(0.24, 9), 46);
for n in [2usize, 3, 9] {
for g in [0.0, 0.01, 0.11, 0.5, 1.0, 7.5] {
let q = interleave_quality(g, n);
assert!((0.0..=1.0).contains(&q), "{} tubes at {}s: {}", n, g, q);
}
}
}
#[test]
fn the_interleave_tier_shows_four_seconds_however_many_tubes() {
for n in [2usize, 3, 4, 9] {
let samples: Vec<f64> = (0..8000).map(|i| (i % 5) as f64).collect();
let t = tiers_interleaved(&samples, 0, 240, n);
let fine = t.last().expect("a strip has an interleave tier");
assert_eq!(fine.columns, INTERLEAVE_SECONDS * n,
"{} tubes: {} bars", n, fine.columns);
assert!((fine.columns as f64 * fine.seconds - INTERLEAVE_SECONDS as f64).abs()
< 1e-9);
}
}
#[test]
fn the_width_the_interleave_gave_back_went_to_the_other_tiers() {
for n in [2usize, 3, 9] {
for width in [80usize, 160, 240] {
let t = tiers_interleaved(&[], 0, width, n);
let total: usize = t.iter().map(|x| x.columns).sum();
assert_eq!(total, width, "{} tubes at {} columns", n, width);
}
}
let t = tiers_interleaved(&[], 0, 240, 2);
let aggregated: f64 = t[..TIERS].iter().map(|x| x.columns as f64 * x.seconds).sum();
assert!(aggregated > 720.0, "only {}s", aggregated);
}
#[test]
fn the_interleaved_strip_still_reaches_back_minutes() {
let t = tiers_interleaved(&(0..8000).map(|_| 1.0).collect::<Vec<f64>>(), 0, 240, 9);
let reach: f64 = t.iter().map(|x| x.columns as f64 * x.seconds).sum();
assert!(reach > 600.0, "only {}s", reach);
}
#[test]
fn every_tier_leftwards_is_one_more_doubling() {
let t = tiers(&[], 0, 160, 512);
for w in t.windows(2) {
let (left, right) = (&w[0], &w[1]);
assert_eq!(left.seconds, right.seconds * 2.0,
"a bar left is not two bars right");
assert_eq!(left.columns as f64 * left.seconds, right.columns as f64 * right.seconds * 2.0,
"a tier left does not take twice as long to fill");
}
}
#[test]
fn a_bar_is_the_mean_of_exactly_its_seconds() {
let s: Vec<u32> = (0..200).collect();
let t = tiers(&s, 0, 20, 30);
let (oldest, far, near, fine) = (&t[0], &t[1], &t[2], &t[3]);
assert_eq!(
(oldest.columns, far.columns, near.columns, fine.columns),
(5, 5, 5, 5)
);
assert_eq!(fine.values[4], Some(199.0));
assert_eq!(fine.values[0], Some(195.0));
assert_eq!(near.seconds, 2.0);
assert_eq!(near.values[4], Some(194.0));
assert_eq!(near.values[3], Some(192.5));
assert_eq!(far.seconds, 4.0);
assert_eq!(far.values[4], Some(184.5));
assert_eq!(far.values[3], Some(181.5));
assert_eq!(oldest.seconds, 8.0);
assert_eq!(oldest.values[4], Some(163.5));
assert_eq!(oldest.values[3], Some(155.5));
}
#[test]
fn a_bar_does_not_change_as_the_strip_scrolls_under_it() {
let s: Vec<u32> = (0..400).map(|i| (i * 7919 % 13) as u32).collect();
let before = tiers(&s[..300], 0, 40, 80);
let after = tiers(&s[..302], 0, 40, 80);
let k = before[2].seconds as usize;
assert_eq!(k, 2);
let b = &before[2].values;
let a = &after[2].values;
assert_eq!(&a[..a.len() - 2], &b[1..b.len() - 1]);
}
#[test]
fn early_on_the_old_tiers_are_empty_not_zero() {
let t = tiers(&[3, 4, 5], 0, 40, 512);
for coarse in &t[..TIERS - 1] {
assert!(coarse.values.iter().all(|v| v.is_none()));
}
assert_eq!(t[TIERS - 1].values.iter().filter(|v| v.is_some()).count(), 3);
}
}