use nalgebra::{DMatrix, DVector};
use crate::bwselect::rdbwselect;
use crate::kernel::eff_weight;
use crate::linalg::{qr_xx_inv, vander};
use crate::stats::{pnorm, qnorm};
use crate::vce;
use crate::{Kernel, Vce};
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RdRobust {
pub coef: [f64; 3],
pub se: [f64; 3],
pub z: [f64; 3],
pub pv: [f64; 3],
pub ci: [[f64; 2]; 3],
pub bws: [[f64; 2]; 2],
}
struct SideFit {
r_p: DMatrix<f64>, r_q: DMatrix<f64>, inv_g_p: DMatrix<f64>,
inv_g_q: DMatrix<f64>,
rp_wh: DMatrix<f64>, rp_swh: DMatrix<f64>, rq_wb: DMatrix<f64>, rq_swb: DMatrix<f64>, w_b: Vec<f64>, q_q: DMatrix<f64>, d: DMatrix<f64>, beta_p: DMatrix<f64>, beta_q: DMatrix<f64>, beta_bc: DMatrix<f64>, zwz_p: Option<DMatrix<f64>>, zwy_p: Option<DMatrix<f64>>,
ex: Vec<f64>,
ec: Vec<f64>, en: usize,
edups: Vec<usize>,
edupsid: Vec<usize>,
}
#[allow(clippy::too_many_arguments)]
fn fit_side(
y: &[f64],
x: &[f64],
t: Option<&[f64]>,
z: Option<&[f64]>,
cl: Option<&[f64]>,
wt: Option<&[f64]>,
dz: usize,
c: f64,
p: usize,
q: usize,
h: f64,
b: f64,
kernel: Kernel,
vce_kind: Vce,
) -> SideFit {
let w_h_full = eff_weight(x, c, h, kernel, wt);
let w_b_full = eff_weight(x, c, b, kernel, wt);
let ind: Vec<usize> = if h > b {
(0..x.len()).filter(|&i| w_h_full[i] > 0.0).collect()
} else {
(0..x.len()).filter(|&i| w_b_full[i] > 0.0).collect()
};
let en = ind.len();
let ex: Vec<f64> = ind.iter().map(|&i| x[i]).collect();
let ec: Vec<f64> = cl.map_or(Vec::new(), |c| ind.iter().map(|&i| c[i]).collect());
let w_h: Vec<f64> = ind.iter().map(|&i| w_h_full[i]).collect();
let w_b: Vec<f64> = ind.iter().map(|&i| w_b_full[i]).collect();
let (edups, edupsid) = match vce_kind {
Vce::NearestNeighbor => {
let (du, ds) = vce::compute_dups_dupsid(x); (
ind.iter().map(|&i| du[i]).collect(),
ind.iter().map(|&i| ds[i]).collect(),
)
}
_ => (Vec::new(), Vec::new()),
};
let u: Vec<f64> = ex.iter().map(|&xi| xi - c).collect();
let r_q = vander(&u, q);
let r_p = r_q.columns(0, p + 1).into_owned();
let row_scale = |m: &DMatrix<f64>, w: &[f64]| {
let mut out = m.clone();
for i in 0..en {
for j in 0..m.ncols() {
out[(i, j)] *= w[i];
}
}
out
};
let sqrt_w = |w: &[f64]| w.iter().map(|v| v.sqrt()).collect::<Vec<_>>();
let rp_swh = row_scale(&r_p, &sqrt_w(&w_h));
let rq_swb = row_scale(&r_q, &sqrt_w(&w_b));
let inv_g_p = qr_xx_inv(&rp_swh);
let inv_g_q = qr_xx_inv(&rq_swb);
let rp_wh = row_scale(&r_p, &w_h);
let rq_wb = row_scale(&r_q, &w_b);
let u_pow = DVector::from_iterator(en, u.iter().map(|&uu| (uu / h).powi((p + 1) as i32)));
let l_vec = rp_wh.transpose() * &u_pow; let rq_ig = &r_q * &inv_g_q; let hp1 = h.powi((p + 1) as i32);
let mut q_q = rp_wh.clone();
for k in 0..en {
let vcorr = w_b[k] * rq_ig[(k, p + 1)];
for i in 0..=p {
q_q[(k, i)] -= hp1 * vcorr * l_vec[i];
}
}
let dt = t.is_some() as usize;
let mut d = DMatrix::zeros(en, 1 + dt + dz);
for (r, &i) in ind.iter().enumerate() {
d[(r, 0)] = y[i];
}
if let Some(tt) = t {
for (r, &i) in ind.iter().enumerate() {
d[(r, 1)] = tt[i];
}
}
if let Some(zz) = z {
for (r, &i) in ind.iter().enumerate() {
for j in 0..dz {
d[(r, 1 + dt + j)] = zz[i * dz + j];
}
}
}
let beta_p = &inv_g_p * (rp_wh.transpose() * &d);
let beta_q = &inv_g_q * (rq_wb.transpose() * &d);
let beta_bc = &inv_g_p * (q_q.transpose() * &d);
let (zwz_p, zwy_p) = if dz > 0 {
let (zwz, zwy) = vce::partialling(&rp_wh, &inv_g_p, &d, &w_h, dt, dz);
(Some(zwz), Some(zwy))
} else {
(None, None)
};
SideFit {
r_p,
r_q,
inv_g_p,
inv_g_q,
rp_wh,
rp_swh,
rq_wb,
rq_swb,
w_b,
q_q,
d,
beta_p,
beta_q,
beta_bc,
zwz_p,
zwy_p,
ex,
ec,
en,
edups,
edupsid,
}
}
#[derive(Debug, Clone, Copy)]
pub struct RdRobustOptions {
pub c: f64,
pub p: usize,
pub q: usize,
pub deriv: usize,
pub kernel: Kernel,
pub vce: Vce,
pub nnmatch: usize,
pub covs_drop_coll: bool,
pub scaleregul: f64,
pub scalepar: f64,
pub level: f64,
pub bwselect: &'static str,
pub masspoints: &'static str,
pub stdvars: bool,
pub bwrestrict: bool,
pub bwcheck: Option<usize>,
pub rho: Option<f64>,
pub sharpbw: bool,
pub h: Option<(f64, f64)>,
pub b: Option<(f64, f64)>,
}
impl Default for RdRobustOptions {
fn default() -> Self {
Self {
c: 0.0,
p: 1,
q: 2,
deriv: 0,
kernel: Kernel::Triangular,
vce: Vce::NearestNeighbor,
nnmatch: 3,
covs_drop_coll: false,
scaleregul: 1.0,
scalepar: 1.0,
level: 95.0,
bwselect: "mserd",
masspoints: "adjust",
stdvars: true,
bwrestrict: true,
bwcheck: None,
rho: None,
sharpbw: false,
h: None,
b: None,
}
}
}
#[allow(clippy::too_many_arguments)]
pub fn rdrobust_with(
y: &[f64],
x: &[f64],
fuzzy: Option<&[f64]>,
covs: Option<&[f64]>,
dz: usize,
cluster: Option<&[f64]>,
weights: Option<&[f64]>,
opts: &RdRobustOptions,
) -> RdRobust {
rdrobust(
y,
x,
fuzzy,
covs,
dz,
opts.c,
opts.p,
opts.q,
opts.deriv,
opts.kernel,
opts.vce,
opts.nnmatch,
opts.covs_drop_coll,
opts.scaleregul,
opts.scalepar,
opts.level,
opts.bwselect,
cluster,
weights,
opts.masspoints,
opts.stdvars,
opts.bwrestrict,
opts.bwcheck,
opts.rho,
opts.sharpbw,
opts.h,
opts.b,
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RdError {
TooFewObs,
LengthMismatch {
name: &'static str,
len: usize,
expected: usize,
},
NonFinite {
name: &'static str,
},
OneSidedCutoff,
InvalidOrder,
InvalidNnmatch,
InvalidLevel,
NonPositiveBandwidth {
name: &'static str,
},
NonNegativeWeightRequired,
EmptyCovariates,
DegenerateFuzzy,
}
impl std::fmt::Display for RdError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
RdError::TooFewObs => {
write!(f, "y and x must have at least two observations")
}
RdError::LengthMismatch {
name,
len,
expected,
} => write!(f, "{name} has length {len}, expected {expected}"),
RdError::NonFinite { name } => write!(f, "{name} must be finite"),
RdError::OneSidedCutoff => {
write!(f, "c must lie strictly inside the range of x")
}
RdError::InvalidOrder => write!(f, "q must be > p and deriv must be <= p"),
RdError::InvalidNnmatch => write!(f, "nnmatch must be >= 1"),
RdError::InvalidLevel => write!(f, "level must be in (0, 100)"),
RdError::NonPositiveBandwidth { name } => write!(f, "{name} must be positive"),
RdError::NonNegativeWeightRequired => write!(f, "weights must be non-negative"),
RdError::EmptyCovariates => write!(f, "covs must have at least one column"),
RdError::DegenerateFuzzy => write!(
f,
"fuzzy has no variation and no jump at the cutoff; the fuzzy estimator is not identified"
),
}
}
}
impl std::error::Error for RdError {}
#[allow(clippy::too_many_arguments)]
fn validate_rdrobust_inputs(
y: &[f64],
x: &[f64],
fuzzy: Option<&[f64]>,
covs: Option<&[f64]>,
dz: usize,
cluster: Option<&[f64]>,
weights: Option<&[f64]>,
opts: &RdRobustOptions,
) -> Result<(), RdError> {
let n = y.len();
if n < 2 {
return Err(RdError::TooFewObs);
}
let ensure_len = |name: &'static str, len: usize| -> Result<(), RdError> {
if len == n {
Ok(())
} else {
Err(RdError::LengthMismatch {
name,
len,
expected: n,
})
}
};
let ensure_finite = |name: &'static str, values: &[f64]| -> Result<(), RdError> {
if values.iter().all(|v| v.is_finite()) {
Ok(())
} else {
Err(RdError::NonFinite { name })
}
};
ensure_len("x", x.len())?;
ensure_finite("y", y)?;
ensure_finite("x", x)?;
if let Some(values) = fuzzy {
ensure_len("fuzzy", values.len())?;
ensure_finite("fuzzy", values)?;
}
if let Some(values) = cluster {
ensure_len("cluster", values.len())?;
ensure_finite("cluster", values)?;
}
if let Some(values) = weights {
ensure_len("weights", values.len())?;
ensure_finite("weights", values)?;
if values.iter().any(|&v| v < 0.0) {
return Err(RdError::NonNegativeWeightRequired);
}
}
if let Some(values) = covs {
if dz == 0 {
return Err(RdError::EmptyCovariates);
}
if values.len() != n * dz {
return Err(RdError::LengthMismatch {
name: "covs",
len: values.len() / dz,
expected: n,
});
}
ensure_finite("covs", values)?;
}
if opts.q <= opts.p || opts.deriv > opts.p {
return Err(RdError::InvalidOrder);
}
if opts.nnmatch == 0 {
return Err(RdError::InvalidNnmatch);
}
if !(0.0..100.0).contains(&opts.level) {
return Err(RdError::InvalidLevel);
}
if let Some(r) = opts.rho {
if r <= 0.0 {
return Err(RdError::NonPositiveBandwidth { name: "rho" });
}
}
if let Some((hl, hr)) = opts.h {
if hl <= 0.0 || hr <= 0.0 {
return Err(RdError::NonPositiveBandwidth { name: "h" });
}
}
if let Some((bl, br)) = opts.b {
if bl <= 0.0 || br <= 0.0 {
return Err(RdError::NonPositiveBandwidth { name: "b" });
}
}
let x_min = x.iter().cloned().fold(f64::INFINITY, f64::min);
let x_max = x.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
if !(opts.c > x_min && opts.c < x_max) {
return Err(RdError::OneSidedCutoff);
}
if let Some(tt) = fuzzy {
let side = |on_left: bool| -> Vec<f64> {
(0..n)
.filter(|&i| (x[i] < opts.c) == on_left)
.map(|i| tt[i])
.collect()
};
let (tl, tr) = (side(true), side(false));
let constant = |v: &[f64]| v.iter().all(|&u| u == v[0]);
if constant(&tl) && constant(&tr) && (tl[0] - tr[0]).abs() < f64::EPSILON.sqrt() {
return Err(RdError::DegenerateFuzzy);
}
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub fn try_rdrobust_with(
y: &[f64],
x: &[f64],
fuzzy: Option<&[f64]>,
covs: Option<&[f64]>,
dz: usize,
cluster: Option<&[f64]>,
weights: Option<&[f64]>,
opts: &RdRobustOptions,
) -> Result<RdRobust, RdError> {
validate_rdrobust_inputs(y, x, fuzzy, covs, dz, cluster, weights, opts)?;
Ok(rdrobust_with(y, x, fuzzy, covs, dz, cluster, weights, opts))
}
#[allow(clippy::too_many_arguments)]
pub fn rdrobust(
y: &[f64],
x: &[f64],
t: Option<&[f64]>,
z: Option<&[f64]>,
dz: usize,
c: f64,
p: usize,
q: usize,
deriv: usize,
kernel: Kernel,
vce_kind: Vce,
nnmatch: usize,
covs_drop_coll: bool,
scaleregul: f64,
scalepar: f64,
level: f64,
bwselect: &str,
cluster: Option<&[f64]>,
weights: Option<&[f64]>,
masspoints: &str,
stdvars: bool,
bwrestrict: bool,
bwcheck: Option<usize>,
rho: Option<f64>,
sharpbw: bool,
h: Option<(f64, f64)>,
b: Option<(f64, f64)>,
) -> RdRobust {
let perf_comp = t.is_some_and(|tt| crate::bwselect::perf_comp(x, tt, c));
let bw_t = if perf_comp || sharpbw { None } else { t };
let h = if y.len() < 20 {
let x_min = x.iter().cloned().fold(f64::INFINITY, f64::min);
let x_max = x.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let full = (c - x_min).abs().max((x_max - c).abs());
Some((full, full))
} else {
h
};
let (rho, b) = if y.len() < 20 { (None, None) } else { (rho, b) };
let (h_l, h_r, b_l, b_r) = match h {
Some((hl, hr)) => {
let (bl, br) = match (rho, b) {
(Some(r), _) => (hl / r, hr / r), (None, Some((bl, br))) => (bl, br), (None, None) => (hl, hr), };
(hl, hr, bl, br)
}
None => {
let bw = rdbwselect(
y,
x,
bw_t,
z,
dz,
c,
p,
q,
deriv,
kernel,
vce_kind,
nnmatch,
covs_drop_coll,
scaleregul,
bwselect,
cluster,
weights,
masspoints,
stdvars,
bwrestrict,
bwcheck,
);
match rho {
Some(r) => (bw.h_l, bw.h_r, bw.h_l / r, bw.h_r / r),
None => (bw.h_l, bw.h_r, bw.b_l, bw.b_r),
}
}
};
if [h_l, h_r, b_l, b_r].iter().any(|v| v.is_nan()) {
return RdRobust {
coef: [f64::NAN; 3],
se: [f64::NAN; 3],
z: [f64::NAN; 3],
pv: [f64::NAN; 3],
ci: [[f64::NAN; 2]; 3],
bws: [[h_l, h_r], [b_l, b_r]],
};
}
let (mut yl, mut xl, mut tl, mut zl, mut cll, mut fwl) = (
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
);
let (mut yr, mut xr, mut tr, mut zr, mut clr, mut fwr) = (
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
);
for i in 0..y.len() {
if x[i] < c {
yl.push(y[i]);
xl.push(x[i]);
if let Some(tt) = t {
tl.push(tt[i]);
}
if let Some(zz) = z {
zl.extend_from_slice(&zz[i * dz..i * dz + dz]);
}
if let Some(cc) = cluster {
cll.push(cc[i]);
}
if let Some(ww) = weights {
fwl.push(ww[i]);
}
} else {
yr.push(y[i]);
xr.push(x[i]);
if let Some(tt) = t {
tr.push(tt[i]);
}
if let Some(zz) = z {
zr.extend_from_slice(&zz[i * dz..i * dz + dz]);
}
if let Some(cc) = cluster {
clr.push(cc[i]);
}
if let Some(ww) = weights {
fwr.push(ww[i]);
}
}
}
let tl_opt = t.map(|_| tl.as_slice());
let tr_opt = t.map(|_| tr.as_slice());
let zl_opt = z.map(|_| zl.as_slice());
let zr_opt = z.map(|_| zr.as_slice());
let fwl_opt = weights.map(|_| fwl.as_slice());
let fwr_opt = weights.map(|_| fwr.as_slice());
let cll_opt = cluster.map(|_| cll.as_slice());
let clr_opt = cluster.map(|_| clr.as_slice());
let fl = fit_side(
&yl, &xl, tl_opt, zl_opt, cll_opt, fwl_opt, dz, c, p, q, h_l, b_l, kernel, vce_kind,
);
let fr = fit_side(
&yr, &xr, tr_opt, zr_opt, clr_opt, fwr_opt, dz, c, p, q, h_r, b_r, kernel, vce_kind,
);
let fac = vce::factorial(deriv);
let beta_p_diff = &fr.beta_p - &fl.beta_p;
let beta_bc_diff = &fr.beta_bc - &fl.beta_bc;
let fuzzy = t.is_some();
let covs = dz > 0;
let (tau_cl, tau_bc, s_y): (f64, f64, DVector<f64>) = match (fuzzy, covs) {
(false, false) => (
scalepar * fac * beta_p_diff[(deriv, 0)],
scalepar * fac * beta_bc_diff[(deriv, 0)],
DVector::from_element(1, 1.0),
),
(true, false) => {
let tau_y_cl = scalepar * fac * beta_p_diff[(deriv, 0)];
let tau_t_cl = fac * beta_p_diff[(deriv, 1)];
let tau_y_bc = scalepar * fac * beta_bc_diff[(deriv, 0)];
let tau_t_bc = fac * beta_bc_diff[(deriv, 1)];
let tcl = tau_y_cl / tau_t_cl;
let s = DVector::from_vec(vec![1.0 / tau_t_cl, -(tau_y_cl / (tau_t_cl * tau_t_cl))]);
let b_f = DVector::from_vec(vec![tau_y_cl - tau_y_bc, tau_t_cl - tau_t_bc]);
let tbc = tcl - s.dot(&b_f);
(tcl, tbc, s)
}
(false, true) => {
let zwz = fl.zwz_p.as_ref().unwrap() + fr.zwz_p.as_ref().unwrap();
let zwy = fl.zwy_p.as_ref().unwrap() + fr.zwy_p.as_ref().unwrap();
let gamma = vce::gamma_from(&zwz, &zwy, covs_drop_coll); let mut s = DVector::zeros(1 + dz);
s[0] = 1.0;
for j in 0..dz {
s[1 + j] = -gamma[(j, 0)];
}
let dot = |bd: &DMatrix<f64>| (0..s.len()).map(|k| s[k] * bd[(deriv, k)]).sum::<f64>();
(
scalepar * dot(&beta_p_diff),
scalepar * dot(&beta_bc_diff),
s,
)
}
(true, true) => {
let zwz = fl.zwz_p.as_ref().unwrap() + fr.zwz_p.as_ref().unwrap();
let zwy = fl.zwy_p.as_ref().unwrap() + fr.zwy_p.as_ref().unwrap();
let gamma = vce::gamma_from(&zwz, &zwy, covs_drop_coll); let cz = 2; let dot = |bd: &DMatrix<f64>, yt: usize, gcol: usize| -> f64 {
bd[(deriv, yt)]
+ (0..dz)
.map(|j| -gamma[(j, gcol)] * bd[(deriv, cz + j)])
.sum::<f64>()
};
let tau_y_cl = scalepar * fac * dot(&beta_p_diff, 0, 0);
let tau_t_cl = fac * dot(&beta_p_diff, 1, 1);
let tau_y_bc = scalepar * fac * dot(&beta_bc_diff, 0, 0);
let tau_t_bc = fac * dot(&beta_bc_diff, 1, 1);
let tcl = tau_y_cl / tau_t_cl;
let s_delta =
DVector::from_vec(vec![1.0 / tau_t_cl, -(tau_y_cl / (tau_t_cl * tau_t_cl))]);
let b_f = DVector::from_vec(vec![tau_y_cl - tau_y_bc, tau_t_cl - tau_t_bc]);
let tbc = tcl - s_delta.dot(&b_f);
let mut s = DVector::zeros(2 + dz);
s[0] = 1.0 / tau_t_cl;
s[1] = -(tau_y_cl / (tau_t_cl * tau_t_cl));
for j in 0..dz {
s[2 + j] = -(1.0 / tau_t_cl) * gamma[(j, 0)]
+ (tau_y_cl / (tau_t_cl * tau_t_cl)) * gamma[(j, 1)];
}
(tcl, tbc, s)
}
};
let has_cluster = cluster.is_some();
let kind = vce::cluster_kind(vce_kind);
let crv2 = kind == vce::ClusterKind::Crv2;
let hb_match = h_l == b_l && h_r == b_r;
let side_v = |f: &SideFit| -> (DMatrix<f64>, DMatrix<f64>) {
let res_h = vce::residuals(
&f.ex,
&f.r_p,
&f.inv_g_p,
&f.rp_wh,
&f.beta_p,
&f.d,
f.en,
vce_kind,
&f.edups,
&f.edupsid,
nnmatch,
has_cluster,
);
let res_b = if matches!(vce_kind, Vce::NearestNeighbor) && !has_cluster {
res_h.clone()
} else {
vce::residuals(
&f.ex,
&f.r_q,
&f.inv_g_q,
&f.rq_wb,
&f.beta_q,
&f.d,
f.en,
vce_kind,
&f.edups,
&f.edupsid,
nnmatch,
has_cluster,
)
};
if !has_cluster {
let v_cl = vce::v_matrix(&f.inv_g_p, &f.rp_wh, &res_h, &s_y);
let v_rb = vce::v_matrix(&f.inv_g_p, &f.q_q, &res_b, &s_y);
return (v_cl, v_rb);
}
let groups = vce::cluster_idx(&f.ec);
let v_cl = vce::v_cluster(
&f.inv_g_p,
&f.rp_wh,
&res_h,
&s_y,
&groups,
kind,
Some(&f.rp_swh),
None,
);
let v_rb = if hb_match {
match kind {
vce::ClusterKind::Cr1 => vce::v_cluster(
&f.inv_g_q, &f.rq_wb, &res_b, &s_y, &groups, kind, None, None,
),
_ => vce::v_cluster(
&f.inv_g_q,
&f.rq_wb,
&res_b,
&s_y,
&groups,
kind,
Some(&f.rq_swb),
None,
),
}
} else {
match kind {
vce::ClusterKind::Cr1 => vce::v_cluster(
&f.inv_g_p,
&f.q_q,
&res_b,
&s_y,
&groups,
kind,
None,
Some(q + 1),
),
_ => {
let m = vce::vce_meat_qq_cluster(
&f.q_q, &f.r_q, &f.w_b, &f.inv_g_q, &res_b, &groups, crv2, &s_y,
);
&f.inv_g_p * (m * &f.inv_g_p)
}
}
};
(v_cl, v_rb)
};
let (v_cl_l, v_rb_l) = side_v(&fl);
let (v_cl_r, v_rb_r) = side_v(&fr);
let scale2 = scalepar * scalepar * fac * fac;
let v_tau_cl = scale2 * (v_cl_l[(deriv, deriv)] + v_cl_r[(deriv, deriv)]);
let v_tau_rb = scale2 * (v_rb_l[(deriv, deriv)] + v_rb_r[(deriv, deriv)]);
let se_cl = v_tau_cl.sqrt();
let se_rb = v_tau_rb.sqrt();
let coef = [tau_cl, tau_bc, tau_bc];
let se = [se_cl, se_cl, se_rb];
let quant = -qnorm((1.0 - level / 100.0) / 2.0);
let mut z = [0.0; 3];
let mut pv = [0.0; 3];
let mut ci = [[0.0; 2]; 3];
for i in 0..3 {
z[i] = coef[i] / se[i];
pv[i] = 2.0 * pnorm(-z[i].abs());
ci[i] = [coef[i] - quant * se[i], coef[i] + quant * se[i]];
}
RdRobust {
coef,
se,
z,
pv,
ci,
bws: [[h_l, h_r], [b_l, b_r]],
}
}
#[cfg(test)]
mod tests {
use super::*;
fn dgp(n: usize) -> (Vec<f64>, Vec<f64>) {
let x: Vec<f64> = (0..n)
.map(|i| -1.0 + 2.0 * (i as f64 + 0.5) / n as f64)
.collect();
let y: Vec<f64> = x
.iter()
.enumerate()
.map(|(i, &xi)| 0.5 * xi + if xi >= 0.0 { 2.0 } else { 0.0 } + 0.3 * (i as f64).sin())
.collect();
(x, y)
}
#[test]
fn cutoff_must_be_strictly_inside_support() {
let (x, y) = dgp(200);
let at = |c: f64| {
try_rdrobust_with(
&y,
&x,
None,
None,
0,
None,
None,
&RdRobustOptions {
c,
..Default::default()
},
)
};
assert_eq!(at(x[x.len() - 1]).map(|_| ()), Err(RdError::OneSidedCutoff));
assert_eq!(at(x[0]).map(|_| ()), Err(RdError::OneSidedCutoff));
assert_eq!(at(2.0).map(|_| ()), Err(RdError::OneSidedCutoff));
assert!(at(0.0).is_ok());
assert!(at(x[1]).is_ok());
}
#[test]
fn cutoff_at_max_x_does_not_panic_in_raw_path() {
let (x, y) = dgp(200);
let c = x[x.len() - 1];
let out = rdrobust_with(
&y,
&x,
None,
None,
0,
None,
None,
&RdRobustOptions {
c,
..Default::default()
},
);
assert!(out.coef.iter().chain(out.se.iter()).all(|v| v.is_nan()));
assert!(out.bws[0][0].is_nan());
}
#[test]
fn ragged_covariates_rejected() {
let (x, y) = dgp(100);
let z = vec![0.0; 2 * 100 - 1];
let err = try_rdrobust_with(
&y,
&x,
None,
Some(&z),
2,
None,
None,
&RdRobustOptions::default(),
);
assert!(matches!(
err,
Err(RdError::LengthMismatch { name: "covs", .. })
));
}
#[test]
fn degenerate_fuzzy_rejected_but_one_sided_compliance_allowed() {
let (x, y) = dgp(200);
let flat = vec![0.5; 200];
let err = try_rdrobust_with(
&y,
&x,
Some(&flat),
None,
0,
None,
None,
&RdRobustOptions::default(),
);
assert_eq!(err.map(|_| ()), Err(RdError::DegenerateFuzzy));
let step: Vec<f64> = x
.iter()
.map(|&v| if v >= 0.0 { 1.0 } else { 0.0 })
.collect();
let out = try_rdrobust_with(
&y,
&x,
Some(&step),
None,
0,
None,
None,
&RdRobustOptions::default(),
)
.unwrap();
let sharp = rdrobust_with(
&y,
&x,
None,
None,
0,
None,
None,
&RdRobustOptions::default(),
);
assert!((out.coef[0] - sharp.coef[0]).abs() < 1e-12);
assert_eq!(out.bws, sharp.bws);
}
#[test]
fn fewer_than_twenty_obs_use_full_support() {
let x: Vec<f64> = (0..12).map(|i| -0.8 + 2.0 * i as f64 / 11.0).collect();
let y: Vec<f64> = x
.iter()
.map(|&v| 0.3 * v + if v >= 0.0 { 1.0 } else { 0.0 })
.collect();
let full = (x[11] - 0.0).abs().max((0.0 - x[0]).abs());
for opts in [
RdRobustOptions::default(),
RdRobustOptions {
h: Some((0.1, 0.1)),
..Default::default()
},
RdRobustOptions {
h: Some((0.1, 0.1)),
rho: Some(0.5),
..Default::default()
},
] {
let out = rdrobust_with(&y, &x, None, None, 0, None, None, &opts);
assert_eq!(out.bws, [[full, full], [full, full]]);
assert!(out.coef[0].is_finite() && out.se[2].is_finite());
}
let (x20, y20) = dgp(20);
let out = rdrobust_with(
&y20,
&x20,
None,
None,
0,
None,
None,
&RdRobustOptions::default(),
);
assert!(out.bws[0][0] < 1.0);
}
}