use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
#[derive(Debug, Clone)]
pub struct CombinedEstimate {
pub params: Array1<f64>,
pub cov_within: Array2<f64>,
pub cov_between: Array2<f64>,
pub cov_total: Array2<f64>,
pub bse: Array1<f64>,
pub relative_increase: Array1<f64>,
pub fmi: Array1<f64>,
pub df: Array1<f64>,
pub m: usize,
}
impl CombinedEstimate {
pub fn tvalues(&self) -> Array1<f64> {
&self.params / &self.bse
}
pub fn pvalues(&self) -> Array1<f64> {
let t = self.tvalues();
Array1::from_iter(
t.iter()
.zip(self.df.iter())
.map(|(&tv, &df)| 2.0 * solow_distributions::t_sf(tv.abs(), df)),
)
}
pub fn conf_int(&self, alpha: f64) -> Array2<f64> {
let p = self.params.len();
let mut out = Array2::<f64>::zeros((p, 2));
for i in 0..p {
let q = solow_distributions::t_ppf(1.0 - alpha / 2.0, self.df[i]);
out[[i, 0]] = self.params[i] - q * self.bse[i];
out[[i, 1]] = self.params[i] + q * self.bse[i];
}
out
}
}
pub fn combine(
params_list: &[Array1<f64>],
cov_list: &[Array2<f64>],
dfcom: f64,
) -> Result<CombinedEstimate> {
let m = params_list.len();
if m < 2 {
return Err(Error::Value(
"combining requires at least two imputations".into(),
));
}
if cov_list.len() != m {
return Err(Error::Shape(format!(
"params_list has {m} entries but cov_list has {}",
cov_list.len()
)));
}
let p = params_list[0].len();
if p == 0 {
return Err(Error::Value("parameter vectors are empty".into()));
}
for (k, par) in params_list.iter().enumerate() {
if par.len() != p {
return Err(Error::Shape(format!(
"params_list[{k}] has length {} (expected {p})",
par.len()
)));
}
}
for (k, cov) in cov_list.iter().enumerate() {
if cov.dim() != (p, p) {
return Err(Error::Shape(format!(
"cov_list[{k}] has shape {:?} (expected {p}x{p})",
cov.dim()
)));
}
}
let mf = m as f64;
let mut params = Array1::<f64>::zeros(p);
for par in params_list {
params += par;
}
params /= mf;
let mut cov_within = Array2::<f64>::zeros((p, p));
for cov in cov_list {
cov_within += cov;
}
cov_within /= mf;
let mut cov_between = Array2::<f64>::zeros((p, p));
for par in params_list {
let d = par - ¶ms;
for i in 0..p {
for j in 0..p {
cov_between[[i, j]] += d[i] * d[j];
}
}
}
cov_between /= mf - 1.0;
let f = 1.0 + 1.0 / mf;
let cov_total = &cov_within + &(f * &cov_between);
let mut bse = Array1::<f64>::zeros(p);
let mut relative_increase = Array1::<f64>::zeros(p);
let mut fmi = Array1::<f64>::zeros(p);
let mut df = Array1::<f64>::zeros(p);
let dfm = mf - 1.0;
for i in 0..p {
let ubar = cov_within[[i, i]];
let b = cov_between[[i, i]];
let t = cov_total[[i, i]];
bse[i] = t.sqrt();
relative_increase[i] = f * b / ubar;
let lambda = f * b / t;
fmi[i] = lambda;
df[i] = barnard_rubin_df(m, lambda, dfm, dfcom);
}
Ok(CombinedEstimate {
params,
cov_within,
cov_between,
cov_total,
bse,
relative_increase,
fmi,
df,
m,
})
}
fn barnard_rubin_df(_m: usize, lambda: f64, dfm: f64, dfcom: f64) -> f64 {
if lambda <= 0.0 {
return if dfcom.is_finite() {
dfcom
} else {
f64::INFINITY
};
}
let nu_old = dfm / (lambda * lambda);
if !dfcom.is_finite() {
return nu_old;
}
let nu_obs = (dfcom + 1.0) / (dfcom + 3.0) * dfcom * (1.0 - lambda);
nu_old * nu_obs / (nu_old + nu_obs)
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
#[test]
fn pooled_estimate_is_the_mean() {
let p1 = array![1.0, 3.0];
let p2 = array![3.0, 5.0];
let c1 = array![[0.1, 0.0], [0.0, 0.2]];
let c2 = array![[0.3, 0.0], [0.0, 0.4]];
let res = combine(&[p1, p2], &[c1, c2], f64::INFINITY).unwrap();
assert!((res.params[0] - 2.0).abs() < 1e-12);
assert!((res.params[1] - 4.0).abs() < 1e-12);
assert!((res.cov_within[[0, 0]] - 0.2).abs() < 1e-12);
assert!((res.cov_within[[1, 1]] - 0.3).abs() < 1e-12);
}
#[test]
fn identical_imputations_give_zero_between_and_full_df() {
let p = array![1.0, -2.0];
let c = array![[0.05, 0.01], [0.01, 0.08]];
let res = combine(
&[p.clone(), p.clone(), p.clone()],
&[c.clone(), c.clone(), c.clone()],
50.0,
)
.unwrap();
for i in 0..2 {
for j in 0..2 {
assert!((res.cov_between[[i, j]]).abs() < 1e-12);
assert!((res.cov_total[[i, j]] - c[[i, j]]).abs() < 1e-12);
}
assert!(res.fmi[i].abs() < 1e-12);
assert!((res.df[i] - 50.0).abs() < 1e-9);
}
}
#[test]
fn infinite_dfcom_recovers_rubin_1987_df() {
let p1 = array![1.0];
let p2 = array![1.4];
let p3 = array![0.7];
let c = array![[0.02]];
let res = combine(
&[p1, p2, p3],
&[c.clone(), c.clone(), c.clone()],
f64::INFINITY,
)
.unwrap();
let m = 3.0;
let f = 1.0 + 1.0 / m;
let lambda = res.fmi[0];
let expected = (m - 1.0) / (lambda * lambda);
assert!((res.df[0] - expected).abs() < 1e-9);
let r = res.relative_increase[0];
assert!((lambda - r / (1.0 + r)).abs() < 1e-12);
let _ = f;
}
#[test]
fn rejects_single_imputation_and_mismatched_shapes() {
let p = array![1.0];
let c = array![[0.1]];
assert!(combine(std::slice::from_ref(&p), std::slice::from_ref(&c), 10.0).is_err());
let p2 = array![1.0, 2.0];
assert!(combine(&[p, p2], &[c.clone(), c], 10.0).is_err());
}
}