use serde_json::Value;
use solow_summary::{HeaderStats, RegressionSummary};
use std::fs;
fn load() -> Value {
let p = concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../tests/fixtures/summary.json"
);
let s = fs::read_to_string(p).expect("fixture present (run tools/reference/gen_summary.py)");
serde_json::from_str(&s).unwrap()
}
fn vec1(v: &Value) -> Vec<f64> {
v.as_array()
.unwrap()
.iter()
.map(|x| x.as_f64().unwrap())
.collect()
}
fn conf_int(v: &Value) -> Vec<(f64, f64)> {
v.as_array()
.unwrap()
.iter()
.map(|row| {
let r = row.as_array().unwrap();
(r[0].as_f64().unwrap(), r[1].as_f64().unwrap())
})
.collect()
}
fn close_displayed(got: f64, want: f64) -> bool {
(got - want).abs() / (1.0 + want.abs()) <= 1e-3
}
fn coef_row<'a>(rendered: &'a str, name: &str) -> Vec<&'a str> {
for line in rendered.lines() {
let toks: Vec<&str> = line.split_whitespace().collect();
if toks.len() == 7 && toks[0] == name {
return toks;
}
}
panic!("could not find coefficient row for {name:?} in:\n{rendered}");
}
fn build(case: &Value) -> RegressionSummary {
let names: Vec<String> = case["exog_names"]
.as_array()
.unwrap()
.iter()
.map(|s| s.as_str().unwrap().to_string())
.collect();
let params = vec1(&case["params"]);
let bse = vec1(&case["bse"]);
let tvalues = vec1(&case["tvalues"]);
let pvalues = vec1(&case["pvalues"]);
let ci = conf_int(&case["conf_int"]);
let header = HeaderStats {
model: Some(case["model"].as_str().unwrap().to_string()),
nobs: Some(case["nobs"].as_f64().unwrap()),
df_model: Some(case["df_model"].as_f64().unwrap()),
df_resid: Some(case["df_resid"].as_f64().unwrap()),
rsquared: Some(case["rsquared"].as_f64().unwrap()),
rsquared_adj: Some(case["rsquared_adj"].as_f64().unwrap()),
fvalue: Some(case["fvalue"].as_f64().unwrap()),
f_pvalue: Some(case["f_pvalue"].as_f64().unwrap()),
llf: Some(case["llf"].as_f64().unwrap()),
aic: Some(case["aic"].as_f64().unwrap()),
bic: Some(case["bic"].as_f64().unwrap()),
..HeaderStats::new()
};
RegressionSummary::new(&names, ¶ms, &bse, &tvalues, &pvalues, &ci, header)
}
#[test]
fn coefficient_cells_match_reference() {
let fx = load();
for case in fx["cases"].as_array().unwrap() {
let name = case["name"].as_str().unwrap();
let summary = build(case);
let rendered = summary.to_string();
let exog: Vec<String> = case["exog_names"]
.as_array()
.unwrap()
.iter()
.map(|s| s.as_str().unwrap().to_string())
.collect();
let params = vec1(&case["params"]);
let bse = vec1(&case["bse"]);
let tvalues = vec1(&case["tvalues"]);
let pvalues = vec1(&case["pvalues"]);
let ci = conf_int(&case["conf_int"]);
for (i, pname) in exog.iter().enumerate() {
assert!(
rendered.contains(pname),
"{name}: missing param name {pname}"
);
let toks = coef_row(&rendered, pname);
let coef: f64 = toks[1].parse().unwrap();
let std_err: f64 = toks[2].parse().unwrap();
let stat: f64 = toks[3].parse().unwrap();
let pval: f64 = toks[4].parse().unwrap();
let ci_lo: f64 = toks[5].parse().unwrap();
let ci_hi: f64 = toks[6].parse().unwrap();
assert!(
close_displayed(coef, params[i]),
"{name}.{pname}: coef cell {coef} vs {}",
params[i]
);
assert!(
close_displayed(std_err, bse[i]),
"{name}.{pname}: std err cell {std_err} vs {}",
bse[i]
);
assert!(
close_displayed(stat, tvalues[i]),
"{name}.{pname}: t cell {stat} vs {}",
tvalues[i]
);
let want_p_disp = format!("{:.3}", pvalues[i]).parse::<f64>().unwrap();
assert!(
(pval - want_p_disp).abs() <= 1e-9,
"{name}.{pname}: p cell {pval} vs displayed {want_p_disp}"
);
assert!(
close_displayed(ci_lo, ci[i].0),
"{name}.{pname}: CI lo {ci_lo} vs {}",
ci[i].0
);
assert!(
close_displayed(ci_hi, ci[i].1),
"{name}.{pname}: CI hi {ci_hi} vs {}",
ci[i].1
);
}
}
}
#[test]
fn header_stats_formatted_correctly() {
let fx = load();
for case in fx["cases"].as_array().unwrap() {
let name = case["name"].as_str().unwrap();
let summary = build(case);
let rendered = summary.to_string();
let rsq = case["rsquared"].as_f64().unwrap();
let rsq_disp = format!("{rsq:.3}");
assert!(
rendered.contains("R-squared:"),
"{name}: missing R-squared label"
);
assert!(
rendered.contains(&rsq_disp),
"{name}: R-squared value {rsq_disp} not in:\n{rendered}"
);
for (label, key) in [("AIC:", "aic"), ("BIC:", "bic")] {
let want = case[key].as_f64().unwrap();
let line = rendered
.lines()
.find(|l| l.trim_start().starts_with(label))
.unwrap_or_else(|| panic!("{name}: no {label} line"));
let cell = line.split_whitespace().last().unwrap();
let got: f64 = cell.parse().unwrap();
assert!(
close_displayed(got, want),
"{name}: {label} cell {got} vs {want}"
);
}
let model = case["model"].as_str().unwrap();
assert!(
rendered.contains(model),
"{name}: model name {model} missing"
);
}
}