pub struct Trace {
chains: Vec<Vec<Vec<f64>>>,
n_divergences: usize,
}
impl Trace {
pub(crate) fn new(chains: Vec<Vec<Vec<f64>>>, n_divergences: usize) -> Self {
Self {
chains,
n_divergences,
}
}
#[must_use]
pub fn n_chains(&self) -> usize {
self.chains.len()
}
#[must_use]
pub fn n_draws(&self) -> usize {
self.chains.iter().map(Vec::len).sum()
}
#[must_use]
pub fn dim(&self) -> usize {
self.chains
.first()
.and_then(|c| c.first())
.map_or(0, Vec::len)
}
#[must_use]
pub fn chains(&self) -> &[Vec<Vec<f64>>] {
&self.chains
}
#[must_use]
pub fn combined_samples(&self) -> Vec<Vec<f64>> {
self.chains.iter().flatten().cloned().collect()
}
#[must_use]
pub fn n_divergences(&self) -> usize {
self.n_divergences
}
#[must_use]
pub fn divergence_rate(&self) -> f64 {
let total = self.n_draws();
if total == 0 {
0.0
} else {
self.n_divergences as f64 / total as f64
}
}
#[must_use]
pub fn mean(&self, param: usize) -> f64 {
let (s, n) = self
.chains
.iter()
.flatten()
.fold((0.0_f64, 0usize), |(s, n), draw| (s + draw[param], n + 1));
if n == 0 { 0.0 } else { s / n as f64 }
}
#[must_use]
pub fn std(&self, param: usize) -> f64 {
let mean = self.mean(param);
let (acc, n) = self
.chains
.iter()
.flatten()
.fold((0.0_f64, 0usize), |(acc, n), draw| {
let d = draw[param] - mean;
(acc + d * d, n + 1)
});
if n <= 1 {
0.0
} else {
(acc / (n - 1) as f64).sqrt()
}
}
#[must_use]
pub fn ess(&self, param: usize) -> f64 {
self.chains
.iter()
.map(|chain| geyer_ess(¶m_column(chain, param)))
.sum()
}
#[must_use]
pub fn rhat(&self, param: usize) -> f64 {
if self.chains.len() < 2 {
return f64::NAN;
}
split_rhat(&self.chains, param)
}
}
fn param_column(chain: &[Vec<f64>], param: usize) -> Vec<f64> {
chain.iter().map(|draw| draw[param]).collect()
}
fn geyer_ess(x: &[f64]) -> f64 {
let n = x.len();
if n < 2 {
return n as f64;
}
let mean = x.iter().sum::<f64>() / n as f64;
let var = x.iter().map(|v| (v - mean).powi(2)).sum::<f64>() / n as f64;
if var == 0.0 {
return n as f64;
}
let mut p = vec![1.0_f64];
let mut t = 1usize;
loop {
let r2 = autocovariance(x, mean, var, 2 * t);
let r1 = autocovariance(x, mean, var, 2 * t + 1);
let pt = r2 + r1;
if pt <= 0.0 || 2 * t + 1 >= n {
break;
}
p.push(pt);
t += 1;
}
for i in (1..p.len()).rev() {
if p[i] > p[i - 1] {
p[i] = p[i - 1];
}
}
let tau = (-1.0 + 2.0 * p.iter().sum::<f64>()).max(1.0);
n as f64 / tau
}
fn autocovariance(x: &[f64], mean: f64, var: f64, lag: usize) -> f64 {
let n = x.len();
if lag >= n {
return 0.0;
}
let mut s = 0.0;
for i in 0..(n - lag) {
s += (x[i] - mean) * (x[i + lag] - mean);
}
s / (n as f64 * var)
}
fn split_rhat(chains: &[Vec<Vec<f64>>], param: usize) -> f64 {
let mut split: Vec<Vec<f64>> = Vec::new();
for c in chains {
let n = c.len();
let h = n / 2;
if h == 0 {
continue;
}
split.push(c[..h].iter().map(|d| d[param]).collect());
split.push(c[h..].iter().map(|d| d[param]).collect());
}
let m = split.len() as f64;
let n = split[0].len() as f64;
let chain_means: Vec<f64> = split.iter().map(|s| s.iter().sum::<f64>() / n).collect();
let grand = chain_means.iter().sum::<f64>() / m;
let b = n / (m - 1.0)
* chain_means
.iter()
.map(|cm| (cm - grand).powi(2))
.sum::<f64>();
let mut w = 0.0;
for (s, cm) in split.iter().zip(&chain_means) {
let v = s.iter().map(|v| (v - cm).powi(2)).sum::<f64>() / (n - 1.0);
w += v;
}
w /= m;
if w == 0.0 {
return 1.0;
}
let var_hat = (n - 1.0) / n * w + b / n;
(var_hat / w).sqrt()
}