rdrobust-core 0.1.0

Pure-Rust numerical core for robust local-polynomial regression-discontinuity estimation (rdrobust).
Documentation
//! End-to-end parity test: the ported `rdplot` (ES binselect family) vs R.
//! Cases come from `fixtures/plotting.json` and are regenerated by `tools/parity.py`.
//!
//! Bin-comparison convention: fixtures store per-bin mean_x / mean_y sorted by
//! mean_x ascending on each side (as produced by R `vars_bins` which is already
//! x-ascending). We replicate that order from the Rust output by sorting the
//! Rust `mean_x_l`/`mean_x_r` (and correspondingly `mean_y`) vectors by mean_x.
//! This sidesteps any absolute bin-id convention mismatch between R's negative
//! left-side ids and the Rust port's id scheme — what matters is that the same
//! number of non-empty bins exist and the sorted (mean_x, mean_y) pairs agree.

use std::fs;
use std::path::PathBuf;

use rdrobust_core::{rdplot, Kernel};
use serde::Deserialize;

/// The expected outputs stored in the fixture JSON.
#[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>,
}

/// Top-level fixture structure.
#[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,
    /// None if not set (null in JSON).
    nbins_l: Option<usize>,
    /// None if not set (null in JSON).
    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,
}

/// Parse a kernel string to the Kernel enum.
fn parse_kernel(s: &str) -> Kernel {
    match s {
        "uni" => Kernel::Uniform,
        "tri" => Kernel::Triangular,
        "epa" => Kernel::Epanechnikov,
        other => panic!("unknown kernel {other}"),
    }
}

/// Relative-absolute close: |a - b| <= tol * max(|a|, |b|, 1).
/// Mirrors the helper in rdrobust_parity.rs.
fn close(a: f64, b: f64) -> bool {
    (a - b).abs() <= 1e-8 * a.abs().max(b.abs()).max(1.0)
}

/// Sort (mean_x, mean_y) pairs together by mean_x ascending.
/// Returns (sorted_mean_x, sorted_mean_y).
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,
        );

        // ---------------------------------------------------------------
        // 1. Discrete gate: j_l and j_r must be EXACT (integer equality).
        //    A wrong bin count rewrites every per-bin mean.
        // ---------------------------------------------------------------
        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
        );

        // ---------------------------------------------------------------
        // 2. Global polynomial coefficients ~1e-8 (length p+1 per side).
        // ---------------------------------------------------------------
        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]
            );
        }

        // ---------------------------------------------------------------
        // 3. Per-bin means: compare sorted by mean_x ascending.
        //    Fixtures already store R's output sorted by mean_x ascending.
        //    We sort the Rust output the same way so bin-id convention
        //    differences (R negative left ids vs Rust's scheme) don't matter.
        //    Gate: same number of non-empty bins, then (mean_x, mean_y) ~1e-8.
        // ---------------------------------------------------------------
        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);

        // left side mean_x and mean_y
        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]
            );
        }

        // right side mean_x and mean_y
        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");
}