mod root;
use root::{brentq, fminbound};
use solow_distributions::{chi2_ppf, chi2_sf};
#[derive(Clone, Debug)]
pub struct DescStat {
endog: Vec<f64>,
nobs: usize,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TestResult {
pub stat: f64,
pub pvalue: f64,
}
impl DescStat {
pub fn new(endog: &[f64]) -> Self {
assert!(endog.len() >= 2, "need at least two observations");
DescStat {
endog: endog.to_vec(),
nobs: endog.len(),
}
}
pub fn nobs(&self) -> usize {
self.nobs
}
fn min(&self) -> f64 {
self.endog.iter().cloned().fold(f64::INFINITY, f64::min)
}
fn max(&self) -> f64 {
self.endog.iter().cloned().fold(f64::NEG_INFINITY, f64::max)
}
pub fn test_mean(&self, mu0: f64) -> TestResult {
let n = self.nobs as f64;
let endog = &self.endog;
let eta_min = (1.0 - 1.0 / n) / (mu0 - self.max());
let eta_max = (1.0 - 1.0 / n) / (mu0 - self.min());
let find_eta = |eta: f64| -> f64 {
endog
.iter()
.map(|&xi| (xi - mu0) / (1.0 + eta * (xi - mu0)))
.sum()
};
let eta_star = brentq(find_eta, eta_min, eta_max);
let llr: f64 = endog
.iter()
.map(|&xi| {
let w = (1.0 / n) / (1.0 + eta_star * (xi - mu0));
(n * w).ln()
})
.sum::<f64>()
* -2.0;
TestResult {
stat: llr,
pvalue: chi2_sf(llr, 1.0),
}
}
pub fn ci_mean(&self, sig: f64) -> (f64, f64) {
self.ci_mean_opts(sig, 1e-8, -1e10, 1e10)
}
pub fn ci_mean_opts(
&self,
sig: f64,
epsilon: f64,
gamma_low: f64,
gamma_high: f64,
) -> (f64, f64) {
let endog = &self.endog;
let n = self.nobs as f64;
let r0 = chi2_ppf(1.0 - sig, 1.0);
let find_gamma = |gamma: f64| -> f64 {
let denom: f64 = endog.iter().map(|&xi| 1.0 / (xi - gamma)).sum();
let llr: f64 = endog
.iter()
.map(|&xi| {
let w = (1.0 / (xi - gamma)) / denom;
(n * w).ln()
})
.sum();
-2.0 * llr - r0
};
let gamma_star_l = brentq(find_gamma, gamma_low, self.min() - epsilon);
let gamma_star_u = brentq(find_gamma, self.max() + epsilon, gamma_high);
let mu_at = |gamma: f64| -> f64 {
let denom: f64 = endog.iter().map(|&xi| 1.0 / (xi - gamma)).sum();
endog
.iter()
.map(|&xi| ((1.0 / (xi - gamma)) / denom) * xi)
.sum()
};
(mu_at(gamma_star_l), mu_at(gamma_star_u))
}
pub fn test_var(&self, sig2_0: f64) -> TestResult {
let mu_min = self.min();
let mu_max = self.max();
let mut opt_var = |nuisance_mu: f64| self.opt_var(nuisance_mu, sig2_0);
let (_xf, llr) = fminbound(&mut opt_var, mu_min, mu_max);
TestResult {
stat: llr,
pvalue: chi2_sf(llr, 1.0),
}
}
fn opt_var(&self, nuisance_mu: f64, sig2_0: f64) -> f64 {
let n = self.nobs as f64;
let est: Vec<[f64; 2]> = self
.endog
.iter()
.map(|&x| {
let m = x - nuisance_mu;
[m, m * m - sig2_0]
})
.collect();
let eta = modif_newton(&est, self.nobs);
let llr: f64 = est
.iter()
.map(|e| {
let denom = 1.0 + eta[0] * e[0] + eta[1] * e[1];
let w = (1.0 / n) / denom;
(n * w).ln()
})
.sum();
-2.0 * llr
}
}
fn modif_newton(est: &[[f64; 2]], nobs: usize) -> [f64; 2] {
let n = nobs as f64;
let weights = 1.0 / n; let sum_w = 1.0; let inv_n = 1.0 / n;
let start = inv_n;
let mut params = [start, start];
let mut oldparams = [f64::INFINITY, f64::INFINITY];
let tol = 1e-8;
let ridge = 1e-10;
let maxiter = 50;
let mut iters = 0;
while iters < maxiter
&& ((params[0] - oldparams[0]).abs() > tol || (params[1] - oldparams[1]).abs() > tol)
{
let (grad, hess) = grad_hess(est, ¶ms, weights, sum_w, n);
let h = [
[-hess[0][0] + ridge, -hess[0][1]],
[-hess[1][0], -hess[1][1] + ridge],
];
let s = [-grad[0], -grad[1]];
let det = h[0][0] * h[1][1] - h[0][1] * h[1][0];
let step = [
(h[1][1] * s[0] - h[0][1] * s[1]) / det,
(-h[1][0] * s[0] + h[0][0] * s[1]) / det,
];
oldparams = params;
params = [oldparams[0] - step[0], oldparams[1] - step[1]];
iters += 1;
}
params
}
fn grad_hess(
est: &[[f64; 2]],
eta: &[f64; 2],
weights: f64,
sum_w: f64,
nobs: f64,
) -> ([f64; 2], [[f64; 2]; 2]) {
let mut grad = [0.0_f64; 2];
let mut hess = [[0.0_f64; 2]; 2];
let thr = 1.0 / nobs;
for e in est {
let ds = sum_w + eta[0] * e[0] + eta[1] * e[1];
let dsp = if ds < thr {
nobs * (2.0 - nobs * ds)
} else {
1.0 / ds
};
let gfac = weights * dsp;
grad[0] += gfac * e[0];
grad[1] += gfac * e[1];
let dspp = if ds < thr {
-nobs * nobs
} else {
-1.0 / (ds * ds)
};
let hfac = weights * dspp;
hess[0][0] += hfac * e[0] * e[0];
hess[0][1] += hfac * e[0] * e[1];
hess[1][0] += hfac * e[1] * e[0];
hess[1][1] += hfac * e[1] * e[1];
}
(grad, hess)
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_abs_diff_eq;
fn ramp() -> Vec<f64> {
(1..=10).map(|i| i as f64).collect()
}
#[test]
fn test_mean_at_sample_mean_is_zero() {
let d = DescStat::new(&ramp());
let r = d.test_mean(5.5);
assert_abs_diff_eq!(r.stat, 0.0, epsilon = 1e-9);
assert_abs_diff_eq!(r.pvalue, 1.0, epsilon = 1e-9);
}
#[test]
fn test_mean_is_symmetric_about_mean() {
let d = DescStat::new(&ramp());
let a = d.test_mean(5.0);
let b = d.test_mean(6.0);
assert_abs_diff_eq!(a.stat, b.stat, epsilon = 1e-9);
}
#[test]
fn ci_mean_brackets_sample_mean() {
let d = DescStat::new(&ramp());
let (lo, hi) = d.ci_mean(0.05);
assert!(lo < 5.5 && 5.5 < hi, "CI [{lo}, {hi}] must contain 5.5");
let crit = chi2_ppf(0.95, 1.0);
assert_abs_diff_eq!(d.test_mean(lo).stat, crit, epsilon = 1e-6);
assert_abs_diff_eq!(d.test_mean(hi).stat, crit, epsilon = 1e-6);
}
#[test]
fn test_var_at_sample_variance_is_zero() {
let d = DescStat::new(&ramp());
let r = d.test_var(8.25);
assert_abs_diff_eq!(r.stat, 0.0, epsilon = 1e-7);
}
#[test]
fn pvalue_matches_chi2_sf() {
let d = DescStat::new(&ramp());
let r = d.test_mean(4.0);
assert_abs_diff_eq!(r.pvalue, chi2_sf(r.stat, 1.0), epsilon = 1e-12);
}
}