use nalgebra::{DMatrix, DVector};
use crate::kernel::eff_weight;
use crate::linalg::{qr_xx_inv, vander};
use crate::Kernel;
#[derive(Debug, Clone)]
pub struct RdPlot {
pub j_l: usize,
pub j_r: usize,
pub coef_l: Vec<f64>,
pub coef_r: Vec<f64>,
pub bin_l: Vec<i64>,
pub bin_r: Vec<i64>,
pub mean_x_l: Vec<f64>,
pub mean_y_l: Vec<f64>,
pub mean_x_r: Vec<f64>,
pub mean_y_r: Vec<f64>,
}
fn row_scale(m: &DMatrix<f64>, w: &[f64]) -> DMatrix<f64> {
let mut out = m.clone();
for i in 0..m.nrows() {
for j in 0..m.ncols() {
out[(i, j)] *= w[i];
}
}
out
}
fn var_y(y: &[f64]) -> f64 {
let n = y.len() as f64;
let mean = y.iter().sum::<f64>() / n;
y.iter().map(|&v| (v - mean) * (v - mean)).sum::<f64>() / (n - 1.0)
}
fn poly_fit(
x: &[f64],
y: &[f64],
c: f64,
p: usize,
h: f64,
kernel: Kernel,
wt: Option<&[f64]>,
) -> Vec<f64> {
let w = eff_weight(x, c, h, kernel, wt);
let u: Vec<f64> = x.iter().map(|&xi| xi - c).collect();
let r_p = vander(&u, p);
let wsqrt: Vec<f64> = w.iter().map(|v| v.sqrt()).collect();
let inv_g = qr_xx_inv(&row_scale(&r_p, &wsqrt));
let rw = row_scale(&r_p, &w);
let yv = DVector::from_column_slice(y);
let gamma = &inv_g * (rw.transpose() * &yv);
gamma.iter().copied().collect()
}
struct EsPilot {
hat_dw: f64, chk_dw: f64, hat_mv: f64, chk_mv: f64, }
fn dvander(x: &[f64], k: usize) -> DMatrix<f64> {
let n = x.len();
let mut d = DMatrix::zeros(n, k + 1);
for i in 0..n {
for j in 1..=k {
d[(i, j)] = j as f64 * x[i].powi((j - 1) as i32);
}
}
d
}
fn pilot_order(xl: &[f64], xr: &[f64]) -> usize {
let finite_gram = |x: &[f64], k: usize| {
let r = vander(x, k);
(r.transpose() * &r).iter().all(|v| v.is_finite())
};
let mut k = 4usize;
while k > 2 && !(finite_gram(xl, k) && finite_gram(xr, k)) {
k -= 1;
}
k
}
fn es_pilot(x: &[f64], y: &[f64], range: f64, n: usize, vy: f64, k: usize) -> EsPilot {
let rk = vander(x, k);
let inv_gk = qr_xx_inv(&rk);
let yv = DVector::from_column_slice(y);
let y2: Vec<f64> = y.iter().map(|&v| v * v).collect();
let y2v = DVector::from_column_slice(&y2);
let gamma_k1 = &inv_gk * (rk.transpose() * &yv);
let gamma_k2 = &inv_gk * (rk.transpose() * &y2v);
let drk = dvander(x, k);
let mu1_hat = &drk * &gamma_k1;
let mut order: Vec<usize> = (0..x.len()).collect();
order.sort_by(|&a, &b| x[a].total_cmp(&x[b]));
let xs: Vec<f64> = order.iter().map(|&i| x[i]).collect();
let ys: Vec<f64> = order.iter().map(|&i| y[i]).collect();
let m = xs.len();
let dxi: Vec<f64> = (1..m).map(|i| xs[i] - xs[i - 1]).collect();
let dyi: Vec<f64> = (1..m).map(|i| ys[i] - ys[i - 1]).collect();
let x_bar: Vec<f64> = (1..m).map(|i| 0.5 * (xs[i] + xs[i - 1])).collect();
let rk_bar = vander(&x_bar, k);
let mu0_i = &rk_bar * &gamma_k1;
let mu2_i = &rk_bar * &gamma_k2;
let sigma2_bar: Vec<f64> = (0..x_bar.len())
.map(|i| {
let s = mu2_i[i] - mu0_i[i] * mu0_i[i];
if s < 0.0 {
vy
} else {
s
}
})
.collect();
let nf = n as f64;
let sum_mu1_sq: f64 = mu1_hat.iter().map(|v| v * v).sum();
let b_es = (range * range / (12.0 * nf)) * sum_mu1_sq;
let v_hat = (0.5 / range)
* dxi
.iter()
.zip(&dyi)
.map(|(&dx, &dy)| dx * dy * dy)
.sum::<f64>();
let v_chk = (1.0 / range)
* dxi
.iter()
.zip(&sigma2_bar)
.map(|(&dx, &s)| dx * s)
.sum::<f64>();
let j_fun = |b: f64, v: f64| (((2.0 * b) / v) * nf).powf(1.0 / 3.0).ceil();
let nlogn = nf / (nf.ln() * nf.ln());
EsPilot {
hat_dw: j_fun(b_es, v_hat),
chk_dw: j_fun(b_es, v_chk),
hat_mv: ((vy / v_hat) * nlogn).ceil(),
chk_mv: ((vy / v_chk) * nlogn).ceil(),
}
}
fn find_interval(v: f64, knots: &[f64]) -> usize {
let j = knots.len() - 1;
if v < knots[0] {
return 0;
}
if v >= knots[j] {
return j;
}
knots.iter().filter(|&&k| k <= v).count()
}
fn bin_means(x: &[f64], y: &[f64], bins: &[i64]) -> (Vec<i64>, Vec<f64>, Vec<f64>) {
use std::collections::BTreeMap;
let mut acc: BTreeMap<i64, (f64, f64, usize)> = BTreeMap::new();
for k in 0..bins.len() {
let e = acc.entry(bins[k]).or_insert((0.0, 0.0, 0));
e.0 += x[k];
e.1 += y[k];
e.2 += 1;
}
let mut ids = Vec::with_capacity(acc.len());
let mut mx = Vec::with_capacity(acc.len());
let mut my = Vec::with_capacity(acc.len());
for (&id, &(sx, sy, cnt)) in &acc {
ids.push(id);
mx.push(sx / cnt as f64);
my.push(sy / cnt as f64);
}
(ids, mx, my)
}
#[allow(clippy::too_many_arguments)]
pub fn rdplot(
y: &[f64],
x: &[f64],
c: f64,
p: usize,
kernel: Kernel,
binselect: &str,
scale_l: f64,
scale_r: f64,
nbins_l: Option<usize>,
nbins_r: Option<usize>,
wt: Option<&[f64]>,
) -> RdPlot {
let x_min = x.iter().cloned().fold(f64::INFINITY, f64::min);
let x_max = x.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
let range_l = c - x_min;
let range_r = x_max - c;
let (mut xl, mut yl, mut wl, mut xr, mut yr, mut wr) = (
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
Vec::new(),
);
for i in 0..x.len() {
if x[i] < c {
xl.push(x[i]);
yl.push(y[i]);
if let Some(ww) = wt {
wl.push(ww[i]);
}
} else {
xr.push(x[i]);
yr.push(y[i]);
if let Some(ww) = wt {
wr.push(ww[i]);
}
}
}
let wl_opt = wt.map(|_| wl.as_slice());
let wr_opt = wt.map(|_| wr.as_slice());
let n = x.len();
let coef_l = poly_fit(&xl, &yl, c, p, range_l, kernel, wl_opt);
let coef_r = poly_fit(&xr, &yr, c, p, range_r, kernel, wr_opt);
let vy_l = var_y(&yl);
let vy_r = var_y(&yr);
let k = pilot_order(&xl, &xr);
let pl = es_pilot(&xl, &yl, range_l, n, vy_l, k);
let pr = es_pilot(&xr, &yr, range_r, n, vy_r, k);
let pick = |pe: &EsPilot| -> f64 {
match binselect {
"es" => pe.hat_dw,
"espr" => pe.chk_dw,
"esmv" | "" => pe.hat_mv,
"esmvpr" => pe.chk_mv,
other => unimplemented!("binselect {other} not yet ported (ES family only)"),
}
};
let bins = |nbins: Option<usize>, scale: f64, j: f64, vy: f64| -> usize {
if vy == 0.0 {
return 1;
}
let j = nbins.map_or(scale * j, |nb| nb as f64);
assert!(
j.is_finite(),
"rdplot: bin selector diverged (zero spacings variance with non-zero bias on one side)"
);
(j.ceil() as usize).max(1)
};
let j_l = bins(nbins_l, scale_l, pick(&pl), vy_l);
let j_r = bins(nbins_r, scale_r, pick(&pr), vy_r);
let jump_l = range_l / j_l as f64;
let jump_r = range_r / j_r as f64;
let knots_l: Vec<f64> = (0..=j_l).map(|i| x_min + i as f64 * jump_l).collect();
let knots_r: Vec<f64> = (0..=j_r).map(|i| c + i as f64 * jump_r).collect();
let bins_l: Vec<i64> = xl
.iter()
.map(|&v| find_interval(v, &knots_l) as i64 - j_l as i64 - 1)
.collect();
let bins_r: Vec<i64> = xr
.iter()
.map(|&v| find_interval(v, &knots_r) as i64)
.collect();
let (bin_l, mean_x_l, mean_y_l) = bin_means(&xl, &yl, &bins_l);
let (bin_r, mean_x_r, mean_y_r) = bin_means(&xr, &yr, &bins_r);
RdPlot {
j_l,
j_r,
coef_l,
coef_r,
bin_l,
bin_r,
mean_x_l,
mean_y_l,
mean_x_r,
mean_y_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 pilot_order_stays_at_four_when_gram_is_finite_but_ill_conditioned() {
let (x, _) = dgp(400);
let xo: Vec<f64> = x.iter().map(|v| v + 1.0e5).collect();
let (xl, xr): (Vec<f64>, Vec<f64>) = xo.iter().partition(|&&v| v < 1.0e5);
assert_eq!(pilot_order(&xl, &xr), 4);
let huge: Vec<f64> = x.iter().map(|v| v * 1.0e40).collect();
let (hl, hr): (Vec<f64>, Vec<f64>) = huge.iter().partition(|&&v| v < 0.0);
assert!(pilot_order(&hl, &hr) < 4);
}
#[test]
fn constant_outcome_side_gets_one_bin() {
let (x, _) = dgp(300);
let y: Vec<f64> = x
.iter()
.map(|&xi| if xi >= 0.0 { 1.0 + xi } else { 0.0 })
.collect();
for sel in ["es", "espr", "esmv", "esmvpr"] {
let out = rdplot(
&y,
&x,
0.0,
4,
Kernel::Uniform,
sel,
1.0,
1.0,
None,
None,
None,
);
assert_eq!(out.j_l, 1, "{sel}");
assert!(out.j_r >= 1);
assert_eq!(out.mean_y_l, vec![0.0]);
}
let out = rdplot(
&y,
&x,
0.0,
4,
Kernel::Uniform,
"esmv",
1.0,
1.0,
Some(7),
Some(7),
None,
);
assert_eq!((out.j_l, out.j_r), (1, 7));
}
}