pub struct Windows {
pub spans: Vec<f64>,
pub samples: Vec<(f64, u32)>,
pub total: u64,
started: Option<f64>,
sums: Vec<u64>,
held: 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()],
held: 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;
self.held[i] += 1;
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;
self.held[i] -= 1;
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 fn behind(&self, span: f64) -> Option<(u64, u64)> {
if self.samples.is_empty() || self.elapsed() < span {
return None;
}
let i = self.spans.iter().position(|&s| s == span)?;
Some((self.sums[i], self.held[i]))
}
pub fn mean(&self, span: f64) -> Option<f64> {
let (counts, seconds) = self.behind(span)?;
(seconds > 0).then(|| counts as f64 * 60.0 / seconds as f64)
}
pub fn sigma(&self, span: f64) -> Option<f64> {
let (counts, _) = self.behind(span)?;
let cpm = self.mean(span)?;
(counts > 0).then(|| cpm / (counts as f64).sqrt())
}
}
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
}
fn powers(values: &[f64]) -> Vec<f64> {
let n = values.len();
if n < 4 {
return Vec::new();
}
if n & (n - 1) == 0 {
return fft(values)[1..n / 2].iter().map(|c| c.norm()).collect();
}
let turn: Vec<(f64, f64)> = (0..n)
.map(|j| (2.0 * std::f64::consts::PI * j as f64 / n as f64).sin_cos())
.collect();
(1..n / 2)
.map(|k| {
let (mut re, mut im) = (0.0f64, 0.0f64);
let mut at = 0usize;
for v in values {
let (sin, cos) = turn[at];
re += v * cos;
im -= v * sin;
at += k;
if at >= n {
at -= n;
}
}
re * re + im * im
})
.collect()
}
pub fn gain(value: f64, top: f64) -> f64 {
if !(value > 0.0) || !(top > 0.0) {
return 0.0;
}
(value.ln_1p() / top.ln_1p()).clamp(0.0, 1.0)
}
pub fn chance_max_of(bins: usize, n: f64) -> f64 {
if n < 1.0 || bins < 2 {
return f64::INFINITY;
}
let x = ((bins - 1) as f64).ln() / n;
1.0 + (2.0 * x).sqrt() + 2.0 * x / 3.0
}
fn hann(n: usize) -> Vec<f64> {
(0..n)
.map(|i| 0.5 - 0.5 * (2.0 * std::f64::consts::PI * i as f64 / (n - 1) as f64).cos())
.collect()
}
pub struct Waterfall {
pub window: usize,
pub hop: usize,
pub depth: usize,
pub made: u64,
buf: std::collections::VecDeque<f64>,
since: usize,
taper: Vec<f64>,
rows: std::collections::VecDeque<Vec<f32>>,
over: usize,
long: std::collections::VecDeque<f64>,
long_sum: f64,
long_steps: f64,
}
impl Waterfall {
pub fn new(window: usize, hop: usize, depth: usize) -> Waterfall {
Waterfall {
window,
hop: hop.max(1),
depth: depth.max(1),
made: 0,
buf: std::collections::VecDeque::with_capacity(window + 1),
since: 0,
taper: hann(window),
rows: std::collections::VecDeque::with_capacity(depth + 1),
over: 0,
long: std::collections::VecDeque::new(),
long_sum: 0.0,
long_steps: 0.0,
}
}
pub fn leveled(window: usize, hop: usize, depth: usize, over: usize) -> Waterfall {
let mut w = Waterfall::new(window, hop, depth);
w.over = over.max(window);
w
}
pub fn level(&self) -> Option<f64> {
(self.over > 0 && !self.long.is_empty())
.then(|| self.long_sum / self.long.len() as f64)
}
pub fn scatter(&self) -> Option<f64> {
let pairs = self.long.len().saturating_sub(1) as f64;
(self.over > 0 && pairs > 0.0).then(|| self.long_steps / (2.0 * pairs))
}
pub fn add(&mut self, counts: u32) -> bool {
self.buf.push_back(counts as f64);
if self.buf.len() > self.window {
self.buf.pop_front();
}
if self.over > 0 {
let c = counts as f64;
if let Some(last) = self.long.back() {
self.long_steps += (c - last) * (c - last);
}
self.long.push_back(c);
self.long_sum += c;
if self.long.len() > self.over {
let gone = self.long.pop_front().unwrap_or(0.0);
self.long_sum -= gone;
if let Some(next) = self.long.front() {
self.long_steps -= (next - gone) * (next - gone);
}
}
}
self.since += 1;
if self.buf.len() < self.window || self.since < self.hop {
return false;
}
self.since = 0;
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 power = powers(&shaped);
let level = match self.scatter() {
Some(variance) => variance * self.taper.iter().map(|t| t * t).sum::<f64>(),
None => power.iter().sum::<f64>() / power.len().max(1) as f64,
};
let row = power
.iter()
.map(|p| if level > 0.0 { (p / level) as f32 } else { 0.0 })
.collect();
self.rows.push_front(row);
self.rows.truncate(self.depth);
self.made += 1;
true
}
pub fn rows(&self) -> Vec<Vec<f32>> {
self.rows.iter().cloned().collect()
}
pub fn age(&self) -> usize {
self.since
}
pub fn wait(&self) -> usize {
if self.made > 0 { 0 } else { self.window - self.buf.len() }
}
pub fn period(&self, index: usize) -> f64 {
self.window as f64 / (index + 1) as f64
}
pub fn chance_max(&self) -> f64 {
chance_max_of(self.window / 2, 1.0)
}
pub fn chance_rows(&self) -> usize {
(self.window / (2 * self.hop)).max(1)
}
}
pub fn scatter_of(seconds: &[f64]) -> f64 {
let pairs = seconds.len().saturating_sub(1);
if pairs == 0 {
return 0.0;
}
seconds.windows(2).map(|p| (p[1] - p[0]).powi(2)).sum::<f64>() / (2.0 * pairs as f64)
}
struct Reach {
window: usize,
bins: Vec<usize>,
taper: Vec<f64>,
energy: f64,
turn: Vec<(f64, f64)>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct TrailRow {
pub level: f32,
pub bins: Vec<(f32, f32)>,
}
impl TrailRow {
pub fn peaks(&self, floor: f32) -> Vec<usize> {
let p = |i: usize| self.bins[i].1;
(0..self.bins.len())
.filter(|&i| {
p(i) > floor
&& (i == 0 || p(i) > p(i - 1))
&& (i + 1 == self.bins.len() || p(i) >= p(i + 1))
})
.collect()
}
}
pub struct Trail {
reaches: Vec<Reach>,
pub hop: usize,
pub depth: usize,
over: usize,
seconds: std::collections::VecDeque<f64>,
keep: usize,
pub total: u64,
kept: std::collections::VecDeque<(u64, TrailRow)>,
}
impl Trail {
pub fn new(windows: &[usize], hop: usize, depth: usize, over: usize) -> Trail {
let mut lengths: Vec<usize> = windows.iter().copied().filter(|w| *w >= 4).collect();
lengths.sort_unstable();
lengths.dedup();
let mut before = 0usize;
let reaches: Vec<Reach> = lengths
.iter()
.map(|&window| {
let bins: Vec<usize> = (1..window / 2)
.filter(|k| before == 0 || window > before * k)
.collect();
before = window;
let taper = hann(window);
Reach {
window,
bins,
energy: taper.iter().map(|t| t * t).sum(),
taper,
turn: (0..window)
.map(|j| (2.0 * std::f64::consts::PI * j as f64 / window as f64).sin_cos())
.collect(),
}
})
.collect();
let (hop, depth) = (hop.max(1), depth.max(1));
let longest = lengths.last().copied().unwrap_or(0);
Trail {
reaches,
hop,
depth,
over: over.max(1),
seconds: std::collections::VecDeque::new(),
keep: longest.max(over) + depth * hop,
total: 0,
kept: std::collections::VecDeque::new(),
}
}
pub fn add(&mut self, counts: u32) {
self.seconds.push_back(counts as f64);
if self.seconds.len() > self.keep {
self.seconds.pop_front();
}
self.total += 1;
}
pub fn newest(&self) -> Option<u64> {
let first = self.reaches.first()?.window as u64;
let end = self.total / self.hop as u64 * self.hop as u64;
(end >= first).then_some(end)
}
pub fn age(&self) -> usize {
match self.newest() {
Some(end) => (self.total - end) as usize,
None => 0,
}
}
pub fn bins(&self) -> usize {
self.reaches.iter().map(|r| r.bins.len()).sum()
}
pub fn chance_max(&self) -> f64 {
chance_max_of(self.bins() + 1, 1.0)
}
pub fn rows(&mut self) -> Vec<TrailRow> {
let Some(newest) = self.newest() else { return Vec::new() };
let first = self.reaches[0].window as u64;
let ends: Vec<u64> = (0..self.depth as u64)
.map(|k| newest.saturating_sub(k * self.hop as u64))
.take_while(|end| *end >= first)
.collect();
self.kept.retain(|(end, _)| ends.contains(end));
for end in &ends {
if !self.kept.iter().any(|(e, _)| e == end) {
let row = self.row(*end);
self.kept.push_back((*end, row));
}
}
self.kept.make_contiguous().sort_by(|a, b| b.0.cmp(&a.0));
self.kept.iter().map(|(_, row)| row.clone()).collect()
}
fn row(&mut self, end: u64) -> TrailRow {
let oldest = self.total - self.seconds.len() as u64;
let seconds = self.seconds.make_contiguous();
let upto = (end - oldest.min(end)) as usize;
if end < oldest || upto > seconds.len() {
return TrailRow { level: 0.0, bins: Vec::new() };
}
let long = &seconds[upto.saturating_sub(self.over)..upto];
let n = long.len().max(1) as f64;
let rate = long.iter().sum::<f64>() / n;
let variance = scatter_of(long);
let mut row = Vec::new();
let mut level = 0.0f32;
for reach in self.reaches.iter().rev() {
if upto < reach.window {
continue;
}
let x = &seconds[upto - reach.window..upto];
let mean = x.iter().sum::<f64>() / reach.window as f64;
level = if rate > 0.0 { (mean / rate) as f32 } else { 0.0 };
let shaped: Vec<f64> = x.iter().zip(&reach.taper).map(|(v, t)| (v - mean) * t).collect();
let level = variance * reach.energy;
for &k in &reach.bins {
let (mut re, mut im) = (0.0f64, 0.0f64);
let mut at = 0usize;
for v in &shaped {
let (sin, cos) = reach.turn[at];
re += v * cos;
im -= v * sin;
at += k;
if at >= reach.window {
at -= reach.window;
}
}
let power = if level > 0.0 { (re * re + im * im) / level } else { 0.0 };
row.push(((reach.window as f64 / k as f64) as f32, power as f32));
}
}
TrailRow { level, bins: row }
}
}
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 = hann(window);
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 {
chance_max_of(self.bins, self.independent())
}
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 = 11;
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
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Arrival {
pub who: usize,
pub when: f64,
pub counts: u32,
}
#[derive(Clone, Debug, PartialEq, Default)]
pub struct Strip {
pub tiers: Vec<Tier>,
pub sources: Vec<Option<u8>>,
pub live: usize,
}
pub const QUIET_AFTER: f64 = 2.5;
pub fn tiers_arrivals(arrivals: &[Arrival], live: &[bool], width: usize) -> Strip {
if width == 0 || arrivals.is_empty() {
return Strip::default();
}
let newest = arrivals.iter().map(|a| a.when).fold(f64::MIN, f64::max);
let answering = |who: usize| live.get(who).copied().unwrap_or(false);
let n = live.iter().filter(|l| **l).count();
let last = newest.floor() as i64;
let first = arrivals.iter().map(|a| a.when).fold(f64::MAX, f64::min).floor() as i64;
let span = (last - first + 1).max(1) as usize;
let mut sum = vec![0u64; span];
let mut held = vec![0u32; span];
for a in arrivals {
let k = (a.when.floor() as i64 - first) as usize;
sum[k] += a.counts as u64;
held[k] += 1;
}
let mean = |lo: i64, hi: i64| -> Option<f64> {
let (lo, hi) = (lo.max(first), hi.min(last + 1));
if hi <= lo {
return None;
}
let (mut c, mut s) = (0u64, 0u64);
for t in lo..hi {
c += sum[(t - first) as usize];
s += held[(t - first) as usize] as u64;
}
(s > 0).then(|| c as f64 / s as f64)
};
let mut tiers = Vec::new();
let mut sources = Vec::new();
let mut rest = width;
let mut b = last + 1;
if n > 1 {
let cols = (INTERLEAVE_SECONDS * n).clamp(1, width.saturating_sub(TIERS).max(1));
let since = newest - INTERLEAVE_SECONDS as f64;
let mut fresh: Vec<&Arrival> = arrivals
.iter()
.filter(|a| answering(a.who) && a.when > since)
.collect();
fresh.sort_by(|x, y| x.when.partial_cmp(&y.when).unwrap_or(std::cmp::Ordering::Equal));
let fresh: Vec<&Arrival> = fresh.into_iter().rev().take(cols).rev().collect();
let pad = cols - fresh.len();
let mut values: Vec<Option<f64>> = vec![None; pad];
sources = vec![None; pad];
for a in fresh {
values.push(Some(a.counts as f64));
sources.push(Some(a.who.min(255) as u8));
}
tiers.push(Tier { columns: cols, seconds: 1.0 / n as f64, values });
rest = width - cols;
b = last + 1 - INTERLEAVE_SECONDS as i64;
}
let q = rest / TIERS;
let extra = rest - q * TIERS;
let mut step = 1i64;
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;
tiers.push(Tier { columns: c as usize, seconds: step as f64, values });
step *= 2;
}
tiers.reverse();
Strip { tiers, sources, live: n }
}
pub const TREND_SIDE: usize = 4;
pub fn trend(tiers: &[Tier]) -> Vec<Vec<Option<f64>>> {
trend_over(tiers, TREND_SIDE)
}
pub fn trend_over(tiers: &[Tier], side: usize) -> Vec<Vec<Option<f64>>> {
let run: Vec<(Option<f64>, f64)> = tiers
.iter()
.filter(|t| t.seconds >= 1.0)
.flat_map(|t| t.values.iter().map(move |v| (*v, t.seconds)))
.collect();
let mut at = 0usize;
tiers
.iter()
.map(|t| {
if t.seconds < 1.0 {
return vec![None; t.values.len()];
}
let line = (at..at + t.values.len())
.map(|i| {
run[i].0?;
let lo = i.saturating_sub(side);
let hi = (i + side + 1).min(run.len());
let (mut counts, mut seconds) = (0.0f64, 0.0f64);
for (v, s) in &run[lo..hi] {
if let Some(v) = v {
counts += v * s;
seconds += s;
}
}
(seconds > 0.0).then(|| counts / seconds)
})
.collect();
at += t.values.len();
line
})
.collect()
}
#[derive(Clone, Debug, PartialEq)]
pub struct TierTrend {
pub seconds: f64,
pub reach: f64,
pub newest: Option<f64>,
pub mean: Option<f64>,
pub high: Option<f64>,
pub low: Option<f64>,
}
pub fn trend_by_tier(tiers: &[Tier]) -> Vec<TierTrend> {
let line = trend(tiers);
tiers
.iter()
.zip(&line)
.filter(|(t, _)| t.seconds >= 1.0)
.map(|(t, line)| {
let some: Vec<f64> = line.iter().flatten().copied().collect();
TierTrend {
seconds: t.seconds,
reach: t.columns as f64 * t.seconds,
newest: some.last().copied(),
mean: (!some.is_empty()).then(|| some.iter().sum::<f64>() / some.len() as f64),
high: some.iter().copied().reduce(f64::max),
low: some.iter().copied().reduce(f64::min),
}
})
.collect()
}
pub fn bar_spans(tiers: &[Tier], end: i64) -> Vec<Vec<(i64, i64)>> {
let mut out: Vec<Vec<(i64, i64)>> = vec![Vec::new(); tiers.len()];
let unit = tiers
.iter()
.map(|t| t.seconds)
.filter(|s| *s >= 1.0)
.fold(f64::MAX, f64::min);
let mut b = end;
for (k, t) in tiers.iter().enumerate().rev() {
if t.seconds < 1.0 {
continue;
}
let c = t.values.len() as i64;
if (t.seconds - unit).abs() < 1e-9 {
out[k] = (0..c).map(|j| (b - c + j, b - c + j + 1)).collect();
b -= c;
continue;
}
let step = (t.seconds / unit).round() as i64;
let top = (b - 1).div_euclid(step);
out[k] = (0..c)
.map(|j| {
let g = top - c + 1 + j;
(g * step, (g * step + step).min(b))
})
.collect();
b = (top - c + 1) * step;
}
out
}
pub fn answering(heard: &[Option<f64>], gone: &[bool], now: f64) -> Vec<bool> {
heard
.iter()
.enumerate()
.map(|(k, h)| {
!gone.get(k).copied().unwrap_or(false)
&& h.map(|t| now - t <= QUIET_AFTER).unwrap_or(false)
})
.collect()
}
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![14; 10].into_iter().chain([19]).collect::<Vec<_>>());
assert_eq!(
t.iter().map(|x| x.seconds).collect::<Vec<_>>(),
(0..11).rev().map(|k| (1u32 << k) as f64).collect::<Vec<_>>()
);
let reach: f64 = t.iter().map(|x| x.columns as f64 * x.seconds).sum();
assert_eq!(reach, 28663.0);
}
#[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, "one tier for the interleave, not four");
let seconds: Vec<String> = t.iter().map(|x| bar_seconds(x.seconds)).collect();
assert_eq!(seconds, vec!["1024", "512", "256", "128", "64", "32", "16", "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!["1024", "512", "256", "128", "64", "32", "16", "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, 165, 512);
assert_eq!(t.len(), TIERS);
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, 55, 30);
assert!(t.iter().all(|x| x.columns == 5));
let (oldest, far, near, fine) = (&t[7], &t[8], &t[9], &t[10]);
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));
assert_eq!(t[6].seconds, 16.0);
assert_eq!(t[6].values[4], Some(119.5));
assert_eq!(t[6].values[3], Some(103.5));
assert_eq!(t[5].seconds, 32.0);
assert_eq!(t[5].values[4], Some(39.5));
assert_eq!(t[5].values[3], Some(15.5));
assert_eq!(t[5].values[2], None);
for k in 0..5 {
assert_eq!(t[k].seconds, (1024 >> k) as f64);
assert!(t[k].values.iter().all(|v| v.is_none()), "tier {} has something", k);
}
}
#[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 near = TIERS - 2;
let k = before[near].seconds as usize;
assert_eq!(k, 2);
let b = &before[near].values;
let a = &after[near].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);
}
fn room(seconds: std::ops::Range<i64>, tubes: &[usize]) -> Vec<Arrival> {
let mut v = Vec::new();
for t in seconds {
for &k in tubes {
v.push(Arrival { who: k, when: t as f64 + 0.5 * k as f64, counts: 2 });
}
}
v
}
#[test]
fn a_tube_that_stops_is_out_of_the_mean_and_the_room_is_what_it_was() {
let mut w = Windows::new(&[30.0]);
for a in room(0..60, &[0, 1]) {
w.add(a.when, a.counts);
}
assert_eq!(w.mean(30.0), Some(120.0));
assert_eq!(w.average(30.0).map(|v| v / 2.0), Some(120.0));
for a in room(60..100, &[0]) {
w.add(a.when, a.counts);
}
assert_eq!(w.mean(30.0), Some(120.0));
assert_eq!(w.average(30.0).map(|v| v / 2.0), Some(60.0));
assert_eq!(w.behind(30.0), Some((60, 30)));
let one = w.sigma(30.0).unwrap();
for a in room(100..140, &[0, 1]) {
w.add(a.when, a.counts);
}
assert_eq!(w.mean(30.0), Some(120.0));
assert_eq!(w.behind(30.0), Some((120, 60)));
let two = w.sigma(30.0).unwrap();
assert!((one / two - 2f64.sqrt()).abs() < 1e-9, "{one} {two}");
}
#[test]
fn a_window_a_tube_was_in_for_half_of_is_divided_by_what_was_measured() {
let mut w = Windows::new(&[30.0]);
for a in room(0..45, &[0, 1]) {
w.add(a.when, a.counts);
}
for a in room(45..60, &[0]) {
w.add(a.when, a.counts);
}
assert_eq!(w.behind(30.0), Some((92, 46)));
assert_eq!(w.mean(30.0), Some(120.0));
}
#[test]
fn a_reader_that_missed_seconds_does_not_lower_the_room() {
let mut w = Windows::new(&[30.0]);
for a in room(0..90, &[0, 1]) {
if a.who == 1 && (a.when.floor() as i64) % 3 == 0 {
continue;
}
w.add(a.when, a.counts);
}
assert_eq!(w.mean(30.0), Some(120.0));
}
#[test]
fn the_strip_is_cut_by_the_clock() {
let both = room(1000..1100, &[0, 1]);
let s = tiers_arrivals(&both, &[true, true], 108);
assert_eq!(s.live, 2);
assert_eq!(s.tiers.len(), TIERS + 1);
let fine = s.tiers.last().unwrap();
assert_eq!((fine.columns, fine.seconds), (INTERLEAVE_SECONDS * 2, 0.5));
assert!(fine.values.iter().all(|v| *v == Some(2.0)));
let turns: Vec<u8> = s.sources.iter().flatten().copied().collect();
assert_eq!(turns, [0, 1, 0, 1, 0, 1, 0, 1]);
let second = &s.tiers[TIERS - 1];
assert_eq!(second.seconds, 1.0);
assert!(second.values.iter().all(|v| *v == Some(2.0)));
}
#[test]
fn a_tube_that_stops_leaves_the_interleave_and_the_seconds_stay_seconds() {
let mut a = room(1000..1060, &[0, 1]);
a.extend(room(1060..1100, &[0]));
let s = tiers_arrivals(&a, &[true, false], 275);
assert_eq!((s.live, s.tiers.len()), (1, TIERS));
assert!(s.sources.is_empty());
let second = s.tiers.last().unwrap();
assert_eq!((second.seconds, second.columns), (1.0, 25));
assert!(second.values.iter().all(|v| *v == Some(2.0)));
assert!(s.tiers[TIERS - 2].values.iter().all(|v| *v == Some(2.0)));
}
#[test]
fn a_tube_that_comes_back_is_in_the_interleave_with_its_first_sample() {
let mut a = room(1000..1060, &[0, 1]);
a.extend(room(1060..1098, &[0]));
a.extend(room(1098..1100, &[0, 1]));
let s = tiers_arrivals(&a, &[true, true], 108);
assert_eq!((s.live, s.tiers.len()), (2, TIERS + 1));
let turns: Vec<u8> = s.sources.iter().flatten().copied().collect();
assert_eq!(turns, [0, 0, 0, 1, 0, 1]);
assert_eq!(s.tiers.last().unwrap().values.iter().filter(|v| v.is_none()).count(), 2);
}
#[test]
fn a_second_nothing_measured_is_empty_and_not_nought() {
let mut a = room(1000..1010, &[0]);
a.extend(room(1020..1030, &[0]));
let s = tiers_arrivals(&a, &[true], 330);
let second = s.tiers.last().unwrap();
let shown: Vec<Option<f64>> = second.values.iter().rev().take(30).rev().cloned().collect();
assert_eq!(shown.iter().filter(|v| v.is_none()).count(), 10);
assert_eq!(shown.iter().filter(|v| **v == Some(2.0)).count(), 20);
}
fn scramble(n: usize, seed: u64) -> Vec<u32> {
let mut x = seed;
(0..n)
.map(|_| {
x = x.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
((x >> 33) % 4) as u32
})
.collect()
}
#[test]
fn a_period_is_a_ridge_in_the_same_bin_of_every_row() {
let swell = [3u32, 4, 3, 2, 1, 0, 1, 2];
let mut w = Waterfall::new(256, 8, 48);
for (t, c) in scramble(1024, 7).into_iter().enumerate() {
w.add(c + swell[t % 8]);
}
assert_eq!(w.made, 1 + (1024 - 256) / 8);
let rows = w.rows();
assert_eq!(rows.len(), 48);
assert_eq!(w.period(31), 8.0);
let luck = w.chance_max() as f32;
assert!((7.2..7.5).contains(&luck), "{}", luck);
for (k, row) in rows.iter().enumerate() {
assert_eq!(row.len(), 127);
let loudest = (0..row.len()).max_by(|a, b| row[*a].total_cmp(&row[*b])).unwrap();
assert_eq!(loudest, 31, "row {} is loudest somewhere else", k);
assert!(row[31] > luck, "row {} reads {} there", k, row[31]);
}
}
#[test]
fn noise_makes_spikes_and_no_ridge() {
let mut w = Waterfall::new(256, 8, 48);
for c in scramble(1024, 11) {
w.add(c);
}
let rows = w.rows();
let luck = w.chance_max() as f32;
for row in &rows {
let mean = row.iter().sum::<f32>() / row.len() as f32;
assert!((mean - 1.0).abs() < 1e-4, "{}", mean);
}
for bin in 0..127 {
let over = rows.iter().filter(|r| r[bin] > luck).count();
assert!(over < 12, "bin {} is over the line in {} rows of 48", bin, over);
}
}
#[test]
fn luck_draws_short_ridges_and_no_long_ones() {
let mut w = Waterfall::new(256, 8, 48);
let luck = w.chance_max() as f32;
let mut run = [0usize; 127];
let (mut longest, mut ridges) = (0usize, 0usize);
for c in scramble(40_000, 3) {
if !w.add(c) {
continue;
}
let rows = w.rows();
for (bin, v) in rows[0].iter().enumerate() {
if *v > luck {
run[bin] += 1;
longest = longest.max(run[bin]);
} else {
ridges += (run[bin] > 0) as usize;
run[bin] = 0;
}
}
}
assert!(ridges > 20, "only {} in eleven hours", ridges);
assert!(longest > 1, "no spike outlived its row");
assert_eq!(w.chance_rows(), 16);
assert!(longest <= w.chance_rows(), "luck ran {} rows", longest);
}
#[test]
fn the_waterfall_has_nothing_until_it_has_a_window() {
let mut w = Waterfall::new(256, 8, 48);
assert_eq!(w.wait(), 256);
for _ in 0..255 {
assert!(!w.add(1));
}
assert_eq!((w.wait(), w.rows().len()), (1, 0));
assert!(w.add(1));
assert_eq!((w.wait(), w.age(), w.made), (0, 0, 1));
assert!(w.rows()[0].iter().all(|v| *v == 0.0));
for k in 1..8 {
assert!(!w.add(1));
assert_eq!(w.age(), k);
}
assert!(w.add(1));
assert_eq!(w.rows().len(), 2);
}
#[test]
fn the_trend_is_a_bar_and_its_neighbours() {
let some = |v: &[f64]| v.iter().map(|x| Some(*x)).collect::<Vec<_>>();
let t = vec![
Tier { columns: 3, seconds: 2.0, values: some(&[1.0, 4.0, 1.0]) },
Tier { columns: 3, seconds: 1.0, values: some(&[4.0, 0.0, 6.0]) },
Tier { columns: 2, seconds: 0.5, values: some(&[9.0, 9.0]) },
];
let line = trend_over(&t, 1);
assert_eq!(line.iter().map(|l| l.len()).collect::<Vec<_>>(), [3, 3, 2]);
assert_eq!(line[0][0], Some(2.5));
assert_eq!(line[0][1], Some(2.0));
assert_eq!(line[0][2], Some(14.0 / 5.0));
assert_eq!(line[1][0], Some(1.5));
assert_eq!(line[1][1], Some(10.0 / 3.0));
assert_eq!(line[1][2], Some(3.0));
assert_eq!(line[2], [None, None]);
}
#[test]
fn the_trend_is_empty_where_nothing_was_measured() {
let t = vec![Tier {
columns: 5,
seconds: 1.0,
values: vec![None, Some(3.0), None, Some(1.0), Some(5.0)],
}];
assert_eq!(trend_over(&t, 1)[0], [None, Some(3.0), None, Some(3.0), Some(3.0)]);
assert!(trend(&[]).is_empty());
}
#[test]
fn a_height_is_a_logarithm_against_the_loudest_in_view() {
assert_eq!(gain(0.0, 40.0), 0.0);
assert_eq!(gain(40.0, 40.0), 1.0);
assert_eq!(gain(400.0, 40.0), 1.0);
assert_eq!(gain(-1.0, 40.0), 0.0);
assert_eq!(gain(1.0, 0.0), 0.0);
assert_eq!(gain(f64::NAN, 40.0), 0.0);
assert!((gain(1.0, 40.0) - 0.1867).abs() < 1e-3);
assert!((gain(7.5, 40.0) - 0.5763).abs() < 1e-3);
let mut last = 0.0;
for k in 1..=400 {
let g = gain(k as f64 / 10.0, 40.0);
assert!(g > last, "{} is not taller than the one before", k);
last = g;
}
let step = |v: f64| gain(2.0 * v, 1000.0) - gain(v, 1000.0);
assert!((step(50.0) - step(200.0)).abs() < 0.002);
}
#[test]
fn the_trend_is_of_nine_bars() {
let mut values = vec![Some(0.0); 21];
values[10] = Some(9.0);
let line = &trend(&[Tier { columns: 21, seconds: 1.0, values }])[0];
assert_eq!(TREND_SIDE, 4);
for (i, v) in line.iter().enumerate() {
let near = (6..=14).contains(&i);
assert_eq!(*v, Some(if near { 1.0 } else { 0.0 }), "bar {}", i);
}
let mut values = vec![Some(0.0); 21];
values[0] = Some(9.0);
let line = &trend(&[Tier { columns: 21, seconds: 1.0, values }])[0];
assert_eq!(line[0], Some(9.0 / 5.0));
assert_eq!(line[4], Some(1.0));
assert_eq!(line[5], Some(0.0));
}
#[test]
fn the_trend_is_summed_up_by_tier() {
let some = |v: &[f64]| v.iter().map(|x| Some(*x)).collect::<Vec<_>>();
let t = vec![
Tier { columns: 4, seconds: 2.0, values: vec![None, None, Some(1.0), Some(3.0)] },
Tier { columns: 4, seconds: 1.0, values: some(&[2.0, 2.0, 4.0, 0.0]) },
Tier { columns: 2, seconds: 0.5, values: some(&[9.0, 9.0]) },
];
let by = trend_by_tier(&t);
assert_eq!(by.len(), 2);
assert_eq!((by[0].seconds, by[0].reach), (2.0, 8.0));
assert_eq!((by[1].seconds, by[1].reach), (1.0, 4.0));
assert!((by[1].newest.unwrap() - 14.0 / 6.0).abs() < 1e-9);
assert!(by[1].high.unwrap() > by[1].low.unwrap());
assert!(by[1].mean.unwrap() > by[1].low.unwrap() && by[1].mean.unwrap() < by[1].high.unwrap());
let empty = trend_by_tier(&[Tier { columns: 3, seconds: 4.0, values: vec![None; 3] }]);
assert_eq!((empty[0].newest, empty[0].mean, empty[0].high), (None, None, None));
}
#[test]
fn a_bar_is_said_to_be_when_it_is() {
let both: Vec<Arrival> = (1000..1400)
.flat_map(|t| {
[0usize, 1].map(|who| Arrival { who, when: t as f64 + 0.25 * who as f64, counts: t as u32 })
})
.collect();
let s = tiers_arrivals(&both, &[true, true], 128);
let end = 1400 - INTERLEAVE_SECONDS as i64;
let spans = bar_spans(&s.tiers, end);
assert_eq!(spans.len(), s.tiers.len());
assert!(spans.last().unwrap().is_empty(), "the interleave has no spans");
let mut bars = 0;
for (tier, at) in s.tiers.iter().zip(&spans).filter(|(t, _)| t.seconds >= 1.0) {
assert_eq!(tier.values.len(), at.len());
for (v, (from, to)) in tier.values.iter().zip(at) {
let Some(v) = v else { continue };
assert!(to > from && (to - from) as f64 <= tier.seconds);
let from = (*from).max(1000);
let mean = (from..*to).map(|t| t as f64).sum::<f64>() / (to - from) as f64;
assert_eq!(*v, mean, "{}s bar said to be {}..{}", tier.seconds, from, to);
bars += 1;
}
}
assert!(bars > 50, "only {} bars were checked", bars);
assert_eq!(spans[TIERS - 1].last(), Some(&(end - 1, end)));
let one: Vec<u32> = (0..300).collect();
let t = tiers(&one, 0, 60, 60);
for (tier, at) in t.iter().zip(bar_spans(&t, 300)) {
for (v, (from, to)) in tier.values.iter().zip(at) {
let Some(v) = v else { continue };
let mean = (from..to).map(|t| t as f64).sum::<f64>() / (to - from) as f64;
assert_eq!(*v, mean);
}
}
}
fn by_chance(n: usize, rate: f64, seed: u64) -> Vec<u32> {
let mut x = seed;
let mut unit = move || {
x = x.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
((x >> 11) as f64 + 0.5) / (1u64 << 53) as f64
};
let limit = (-rate).exp();
(0..n)
.map(|_| {
let (mut k, mut p) = (0u32, unit());
while p > limit {
k += 1;
p *= unit();
}
k
})
.collect()
}
#[test]
fn a_row_is_held_against_the_long_average() {
let mut counts = by_chance(3000, 0.9, 21);
counts.extend(by_chance(300, 1.8, 22));
let mean = |row: &[f32]| row.iter().sum::<f32>() / row.len() as f32;
let (mut own, mut long) = (Waterfall::new(300, 10, 48), Waterfall::leveled(300, 10, 48, 3000));
assert_eq!((own.level(), long.level()), (None, None));
let mut before = Vec::new();
for (t, c) in counts.iter().enumerate() {
own.add(*c);
if long.add(*c) && t < 3000 {
before.push(mean(&long.rows()[0]));
}
}
let usual = before.iter().sum::<f32>() / before.len() as f32;
assert!((usual - 1.0).abs() < 0.05, "flat read {}", usual);
assert!(before.iter().all(|m| (0.6..1.5).contains(m)), "{:?}", before);
let level = long.level().unwrap();
assert!((0.9..1.1).contains(&level), "the long average is {}", level);
let raised = mean(&long.rows()[0]);
assert!((1.6..2.2).contains(&raised), "the raised row reads {}", raised);
assert!((mean(&own.rows()[0]) - 1.0).abs() < 1e-4);
assert_eq!(Waterfall::leveled(300, 10, 48, 60).over, 300);
}
#[test]
fn a_row_reaches_as_far_as_its_longest_window() {
let mut t = Trail::new(&[4096, 300, 512], 10, 48, 3000);
assert_eq!(t.bins(), 149 + 1 + 7);
assert_eq!((t.newest(), t.rows().len()), (None, 0));
let counts: Vec<u32> = by_chance(6000, 0.9, 31)
.into_iter()
.enumerate()
.map(|(i, c)| c + if i % 1024 < 512 { 1 } else { 0 })
.collect();
for c in &counts[..299] {
t.add(*c);
}
assert_eq!(t.newest(), None);
t.add(counts[299]);
assert_eq!((t.newest(), t.age()), (Some(300), 0));
let early = t.rows();
assert_eq!((early.len(), early[0].bins.len()), (1, 149));
assert_eq!(early[0].bins[0].0, 300.0);
assert_eq!(early[0].level, 1.0);
for c in &counts[300..] {
t.add(*c);
}
assert_eq!((t.newest(), t.age()), (Some(6000), 0));
let rows = t.rows();
assert_eq!(rows.len(), 48);
for row in &rows {
assert!((0.5..1.6).contains(&row.level), "the row stands at {}", row.level);
let peaks = row.peaks(t.chance_max() as f32);
assert!(peaks.iter().any(|i| row.bins[*i].0 == 1024.0), "the swell is not a peak");
let row = &row.bins;
assert_eq!(row.len(), 157);
assert_eq!(row[0].0, 4096.0);
assert!(row.windows(2).all(|p| p[0].0 > p[1].0), "the periods are not in order");
assert!((row[156].0 - 300.0 / 149.0).abs() < 1e-4);
let far = &row[..7];
let loudest = far.iter().max_by(|a, b| a.1.total_cmp(&b.1)).unwrap();
assert_eq!(loudest.0, 1024.0);
assert!(loudest.1 as f64 > t.chance_max(), "it reads {}", loudest.1);
}
let mut often = Trail::new(&[4096, 300, 512], 10, 48, 3000);
for (i, c) in counts.iter().enumerate() {
often.add(*c);
if i % 10 == 9 {
often.rows();
}
}
assert_eq!(often.rows(), rows);
often.add(1);
often.add(1);
assert_eq!((often.newest(), often.age()), (Some(6000), 2));
assert_eq!(often.rows(), rows);
}
#[test]
fn a_row_stands_as_high_as_the_room_counted() {
let mut counts = by_chance(3000, 0.9, 51);
counts.extend(by_chance(300, 27.0, 52));
let mut t = Trail::new(&[300], 10, 48, 3000);
for c in &counts[..3000] {
t.add(*c);
}
let before = t.rows();
assert!(before.iter().all(|r| (0.8..1.2).contains(&r.level)));
for c in &counts[3000..] {
t.add(*c);
}
let after = t.rows();
assert!((7.0..8.4).contains(&after[0].level), "it stands at {}", after[0].level);
assert!((0.8..1.2).contains(&after[30].level), "{}", after[30].level);
let mean = after[0].bins.iter().map(|b| b.1).sum::<f32>() / 149.0;
assert!((6.0..10.0).contains(&mean), "its bins average {}", mean);
}
#[test]
fn a_clumped_tube_reads_flat_and_a_burst_reads_high() {
let single = by_chance(4000, 0.9, 61);
let clumped: Vec<u32> = by_chance(4000, 0.45, 62).into_iter().map(|c| 2 * c).collect();
let mean = |row: &[(f32, f32)]| row.iter().map(|b| b.1).sum::<f32>() / row.len() as f32;
let mut reads = Vec::new();
for counts in [&single, &clumped] {
let mut t = Trail::new(&[512], 16, 48, 3000);
for c in counts {
t.add(*c);
}
let rows = t.rows();
let flat = rows.iter().map(|r| mean(&r.bins)).sum::<f32>() / rows.len() as f32;
assert!((flat - 1.0).abs() < 0.2, "reads {}", flat);
assert!(rows.iter().all(|r| (0.7..1.4).contains(&r.level)));
reads.push(flat);
}
assert!((reads[0] - reads[1]).abs() < 0.25, "{:?}", reads);
let mut counts = by_chance(3000, 0.9, 63);
counts.extend(by_chance(900, 0.15, 64).into_iter().map(|c| 6 * c));
let mut t = Trail::new(&[512], 16, 48, 3000);
for c in &counts {
t.add(*c);
}
let newest = mean(&t.rows()[0].bins);
assert!(newest > 1.8, "the burst reads {}", newest);
let flat: Vec<f64> = by_chance(3000, 0.9, 65).into_iter().map(f64::from).collect();
assert!((scatter_of(&flat) - 0.9).abs() < 0.1, "{}", scatter_of(&flat));
let mut stepped = flat.clone();
stepped.iter_mut().skip(2700).for_each(|x| *x += 100.0);
assert!(scatter_of(&stepped) < 3.0, "{}", scatter_of(&stepped));
assert_eq!(scatter_of(&[]), 0.0);
assert_eq!(scatter_of(&[4.0]), 0.0);
}
#[test]
fn a_peak_stands_over_its_neighbours_and_over_the_floor() {
let row = |powers: &[f32]| TrailRow {
level: 1.0,
bins: powers.iter().enumerate().map(|(i, p)| (100.0 - i as f32, *p)).collect(),
};
assert_eq!(row(&[1.0, 9.0, 2.0, 8.5, 8.0, 1.0, 3.0]).peaks(7.5), [1, 3]);
assert_eq!(row(&[1.0, 5.0, 1.0]).peaks(7.5), Vec::<usize>::new());
assert_eq!(row(&[9.0, 1.0, 1.0, 8.0]).peaks(7.5), [0, 3]);
assert_eq!(row(&[1.0, 8.0, 8.0, 1.0]).peaks(7.5), [1]);
assert_eq!(row(&[]).peaks(7.5), Vec::<usize>::new());
}
#[test]
fn a_height_adjusts_itself_to_what_is_loudest() {
assert_eq!(gain(2000.0, 2000.0), 1.0);
assert!((gain(1.0, 2000.0) - 0.0912).abs() < 1e-3);
assert!((gain(7.59, 2000.0) - 0.2829).abs() < 1e-3);
assert!(1.0 / 2000.0 * 100.0 < 0.06);
assert!((gain(1.0, 7.59) - 0.3224).abs() < 1e-3);
}
#[test]
fn the_short_end_of_a_row_is_the_waterfalls_row() {
let counts = by_chance(3600, 0.9, 41);
let mut fall = Waterfall::leveled(300, 10, 48, 3000);
let mut trail = Trail::new(&[300], 10, 48, 3000);
for c in &counts {
fall.add(*c);
trail.add(*c);
}
let (a, b) = (fall.rows(), trail.rows());
assert_eq!(a.len(), b.len());
for (x, y) in a.iter().zip(&b) {
assert_eq!(x.len(), y.bins.len());
for (k, (p, (period, q))) in x.iter().zip(&y.bins).enumerate() {
assert_eq!(*period, (300.0 / (k + 1) as f64) as f32);
assert!((p - q).abs() <= 1e-4 * p.max(1.0), "{} and {}", p, q);
}
}
}
#[test]
fn a_window_of_any_length_is_transformed() {
let x: Vec<f64> = scramble(256, 5).into_iter().map(|c| c as f64 - 1.5).collect();
let by_fft = powers(&x);
let by_sum: Vec<f64> = (1..128)
.map(|k| {
let (mut re, mut im) = (0.0f64, 0.0f64);
for (i, v) in x.iter().enumerate() {
let a = 2.0 * std::f64::consts::PI * (k * i) as f64 / 256.0;
re += v * a.cos();
im -= v * a.sin();
}
re * re + im * im
})
.collect();
assert_eq!(by_fft.len(), 127);
for (a, b) in by_fft.iter().zip(&by_sum) {
assert!((a - b).abs() <= 1e-6 * a.max(1.0), "{} and {}", a, b);
}
let swell = [3u32, 4, 4, 3, 2, 1, 0, 0, 1, 2];
let mut w = Waterfall::new(300, 10, 48);
for (t, c) in scramble(1200, 7).into_iter().enumerate() {
w.add(c + swell[t % 10]);
}
assert_eq!(w.made, 1 + (1200 - 300) / 10);
assert_eq!((w.period(29), w.chance_rows()), (10.0, 15));
let luck = w.chance_max() as f32;
assert!((7.4..7.6).contains(&luck), "{}", luck);
for (k, row) in w.rows().iter().enumerate() {
assert_eq!(row.len(), 149);
let loudest = (0..row.len()).max_by(|a, b| row[*a].total_cmp(&row[*b])).unwrap();
assert_eq!(loudest, 29, "row {} is loudest somewhere else", k);
assert!(row[29] > luck);
let mean = row.iter().sum::<f32>() / row.len() as f32;
assert!((mean - 1.0).abs() < 1e-4);
}
}
#[test]
fn a_tube_is_answering_until_it_is_quiet_or_gone() {
let heard = [Some(100.0), Some(96.0), None, Some(100.0)];
let gone = [false, false, false, true];
assert_eq!(answering(&heard, &gone, 100.5), [true, false, false, false]);
}
}