use std::fs;
use std::path::PathBuf;
use rdrobust_core::{rdplot, Kernel};
use serde::Deserialize;
#[derive(Deserialize)]
struct Expected {
j_l: usize,
j_r: usize,
coef_l: Vec<f64>,
coef_r: Vec<f64>,
mean_x_l: Vec<f64>,
mean_y_l: Vec<f64>,
mean_x_r: Vec<f64>,
mean_y_r: Vec<f64>,
}
#[derive(Deserialize)]
struct Fixture {
id: String,
x: Vec<f64>,
y: Vec<f64>,
c: f64,
p: usize,
kernel: String,
binselect: String,
scale_l: f64,
scale_r: f64,
nbins_l: Option<usize>,
nbins_r: Option<usize>,
expected: Expected,
}
#[derive(Deserialize)]
struct FixtureBundle {
schema_version: u32,
oracle: OracleMetadata,
cases: Vec<serde_json::Value>,
}
#[derive(Deserialize)]
struct OracleMetadata {
package: String,
version: String,
}
fn parse_kernel(s: &str) -> Kernel {
match s {
"uni" => Kernel::Uniform,
"tri" => Kernel::Triangular,
"epa" => Kernel::Epanechnikov,
other => panic!("unknown kernel {other}"),
}
}
fn close(a: f64, b: f64) -> bool {
(a - b).abs() <= 1e-8 * a.abs().max(b.abs()).max(1.0)
}
fn sort_by_x(mean_x: &[f64], mean_y: &[f64]) -> (Vec<f64>, Vec<f64>) {
assert_eq!(mean_x.len(), mean_y.len());
let mut pairs: Vec<(f64, f64)> = mean_x.iter().copied().zip(mean_y.iter().copied()).collect();
pairs.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
let sx: Vec<f64> = pairs.iter().map(|p| p.0).collect();
let sy: Vec<f64> = pairs.iter().map(|p| p.1).collect();
(sx, sy)
}
#[test]
fn rdplot_matches_r() {
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../fixtures/plotting.json");
let bundle: FixtureBundle = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
assert_eq!(bundle.schema_version, 1);
assert_eq!(bundle.oracle.package, "rdrobust");
assert_eq!(bundle.oracle.version, "1.3.0");
let mut n = 0usize;
for case in bundle
.cases
.into_iter()
.filter(|case| case["kind"] == "rdplot")
{
let f: Fixture = serde_json::from_value(case).unwrap();
let out = rdplot(
&f.y,
&f.x,
f.c,
f.p,
parse_kernel(&f.kernel),
&f.binselect,
f.scale_l,
f.scale_r,
f.nbins_l,
f.nbins_r,
None,
);
assert_eq!(
out.j_l, f.expected.j_l,
"{} j_l: Rust {} vs R {}",
f.id, out.j_l, f.expected.j_l
);
assert_eq!(
out.j_r, f.expected.j_r,
"{} j_r: Rust {} vs R {}",
f.id, out.j_r, f.expected.j_r
);
let p1 = f.p + 1;
assert_eq!(
out.coef_l.len(),
p1,
"{} coef_l length: {} vs expected {}",
f.id,
out.coef_l.len(),
p1
);
assert_eq!(
out.coef_r.len(),
p1,
"{} coef_r length: {} vs expected {}",
f.id,
out.coef_r.len(),
p1
);
for i in 0..p1 {
assert!(
close(out.coef_l[i], f.expected.coef_l[i]),
"{} coef_l[{}]: Rust {:.10e} vs R {:.10e}",
f.id,
i,
out.coef_l[i],
f.expected.coef_l[i]
);
assert!(
close(out.coef_r[i], f.expected.coef_r[i]),
"{} coef_r[{}]: Rust {:.10e} vs R {:.10e}",
f.id,
i,
out.coef_r[i],
f.expected.coef_r[i]
);
}
assert_eq!(
out.mean_x_l.len(),
f.expected.mean_x_l.len(),
"{} n_bins_l: Rust {} vs R {}",
f.id,
out.mean_x_l.len(),
f.expected.mean_x_l.len()
);
assert_eq!(
out.mean_x_r.len(),
f.expected.mean_x_r.len(),
"{} n_bins_r: Rust {} vs R {}",
f.id,
out.mean_x_r.len(),
f.expected.mean_x_r.len()
);
let (rust_mx_l, rust_my_l) = sort_by_x(&out.mean_x_l, &out.mean_y_l);
let (rust_mx_r, rust_my_r) = sort_by_x(&out.mean_x_r, &out.mean_y_r);
for i in 0..rust_mx_l.len() {
assert!(
close(rust_mx_l[i], f.expected.mean_x_l[i]),
"{} mean_x_l[{}]: Rust {:.10e} vs R {:.10e}",
f.id,
i,
rust_mx_l[i],
f.expected.mean_x_l[i]
);
assert!(
close(rust_my_l[i], f.expected.mean_y_l[i]),
"{} mean_y_l[{}]: Rust {:.10e} vs R {:.10e}",
f.id,
i,
rust_my_l[i],
f.expected.mean_y_l[i]
);
}
for i in 0..rust_mx_r.len() {
assert!(
close(rust_mx_r[i], f.expected.mean_x_r[i]),
"{} mean_x_r[{}]: Rust {:.10e} vs R {:.10e}",
f.id,
i,
rust_mx_r[i],
f.expected.mean_x_r[i]
);
assert!(
close(rust_my_r[i], f.expected.mean_y_r[i]),
"{} mean_y_r[{}]: Rust {:.10e} vs R {:.10e}",
f.id,
i,
rust_my_r[i],
f.expected.mean_y_r[i]
);
}
n += 1;
}
assert!(n >= 8, "expected >= 8 rdplot fixtures, found {n}");
eprintln!("rdplot parity: {n} fixtures matched R to 1e-8");
}