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 es_pilot(x: &[f64], y: &[f64], range: f64, n: usize, vy: f64) -> EsPilot {
let mut k = 4usize;
let (rk, inv_gk) = loop {
let rk = vander(x, k);
let g = rk.transpose() * &rk;
match g.cholesky() {
Some(_) => break (rk.clone(), qr_xx_inv(&rk)),
None if k > 2 => k -= 1,
None => break (rk.clone(), 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 pl = es_pilot(&xl, &yl, range_l, n, vy_l);
let pr = es_pilot(&xr, &yr, range_r, n, vy_r);
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 j_l = nbins_l
.unwrap_or_else(|| (scale_l * pick(&pl)).ceil() as usize)
.max(1);
let j_r = nbins_r
.unwrap_or_else(|| (scale_r * pick(&pr)).ceil() as usize)
.max(1);
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,
}
}