use crate::bw::{assemble_from_vfit, compute_vfit, VFit};
use crate::{Kernel, Vce};
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Bws {
pub h_l: f64,
pub h_r: f64,
pub b_l: f64,
pub b_r: f64,
}
fn c_c(kernel: Kernel) -> f64 {
match kernel {
Kernel::Epanechnikov => 2.34,
Kernel::Uniform => 1.843,
Kernel::Triangular => 2.576,
}
}
fn sd(x: &[f64]) -> f64 {
let n = x.len() as f64;
let mean = x.iter().sum::<f64>() / n;
(x.iter().map(|&v| (v - mean) * (v - mean)).sum::<f64>() / (n - 1.0)).sqrt()
}
fn quantile_type2(sorted: &[f64], p: f64) -> f64 {
let n = sorted.len();
let np = n as f64 * p;
let j = np.floor() as usize; let g = np - j as f64;
if g > 0.0 {
sorted[j.min(n - 1)] } else {
let lo = j.max(1) - 1; let hi = j.min(n - 1); 0.5 * (sorted[lo] + sorted[hi])
}
}
pub(crate) fn perf_comp(x: &[f64], t: &[f64], c: f64) -> bool {
let constant = |on_left: bool| -> bool {
let mut first: Option<f64> = None;
(0..t.len())
.filter(|&i| (x[i] < c) == on_left)
.all(|i| *first.get_or_insert(t[i]) == t[i])
};
constant(true) || constant(false)
}
fn r_min(a: f64, b: f64) -> f64 {
if a.is_nan() || b.is_nan() {
f64::NAN
} else {
a.min(b)
}
}
fn r_max(a: f64, b: f64) -> f64 {
if a.is_nan() || b.is_nan() {
f64::NAN
} else {
a.max(b)
}
}
fn median3(a: f64, b: f64, c: f64) -> f64 {
if a.is_nan() || b.is_nan() || c.is_nan() {
return f64::NAN;
}
let mut v = [a, b, c];
v.sort_by(|x, y| x.total_cmp(y));
v[1]
}
#[allow(clippy::too_many_arguments)]
pub fn rdbwselect(
y: &[f64],
x: &[f64],
t: Option<&[f64]>,
z: Option<&[f64]>,
dz: usize,
c: f64,
p: usize,
q: usize,
deriv: usize,
kernel: Kernel,
vce: Vce,
nnmatch: usize,
covs_drop_coll: bool,
scaleregul: f64,
bwselect: &str,
cluster: Option<&[f64]>,
weights: Option<&[f64]>,
masspoints: &str,
stdvars: bool,
bwrestrict: bool,
bwcheck: Option<usize>,
) -> Bws {
let n = y.len();
let t = t.filter(|tt| !perf_comp(x, tt, c));
let (x_sd, y_sd) = if stdvars { (sd(x), sd(y)) } else { (1.0, 1.0) };
let xv: Vec<f64> = x.iter().map(|v| v / x_sd).collect();
let yv: Vec<f64> = y.iter().map(|v| v / y_sd).collect();
let x = xv.as_slice();
let y = yv.as_slice();
let c = c / x_sd;
let mut xs = x.to_vec();
xs.sort_by(|a, b| a.total_cmp(b));
let x_iq = quantile_type2(&xs, 0.75) - quantile_type2(&xs, 0.25);
let bwp = sd(x).min(x_iq / 1.349);
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..n {
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 cll_opt = cluster.map(|_| cll.as_slice());
let clr_opt = cluster.map(|_| clr.as_slice());
let fwl_opt = weights.map(|_| fwl.as_slice());
let fwr_opt = weights.map(|_| fwr.as_slice());
let n_unique = |v: &[f64]| -> usize {
let mut s = v.to_vec();
s.sort_by(|a, b| a.total_cmp(b));
s.dedup();
s.len()
};
let g_l = cluster.map(|_| n_unique(&cll));
let g_r = cluster.map(|_| n_unique(&clr));
let range_l = (c - xs[0]).abs();
let range_r = (c - xs[n - 1]).abs();
let nl = xl.len();
let nr = xr.len();
let mp_on = masspoints == "check" || masspoints == "adjust";
let (m_l, m_r) = if mp_on || bwcheck.is_some() {
(n_unique(&xl), n_unique(&xr))
} else {
(nl, nr)
};
let m = m_l + m_r;
let mut bwcheck_eff = bwcheck;
if mp_on {
let mass_l = 1.0 - m_l as f64 / nl as f64;
let mass_r = 1.0 - m_r as f64 / nr as f64;
if (mass_l >= 0.2 || mass_r >= 0.2) && masspoints == "adjust" && bwcheck.is_none() {
bwcheck_eff = Some(10);
}
}
let pilot_pow = if masspoints == "adjust" {
m as f64
} else {
n as f64
};
let mut c_bw = c_c(kernel) * bwp * pilot_pow.powf(-1.0 / 5.0);
let bw_max_l = range_l;
let bw_max_r = range_r;
let bw_max = bw_max_l.max(bw_max_r);
if bwrestrict {
c_bw = r_min(c_bw, bw_max);
}
let (bw_min_l, bw_min_r) = match bwcheck_eff {
Some(bc) => {
let mut ul = xl.clone();
ul.sort_by(|a, b| a.total_cmp(b));
ul.dedup();
let mut ur = xr.clone();
ur.sort_by(|a, b| a.total_cmp(b));
ur.dedup();
let bcl = bc.min(m_l);
let bcr = bc.min(m_r);
let lhs = (ul[ul.len() - bcl] - c).abs(); let rhs = (ur[bcr - 1] - c).abs();
(lhs, rhs)
}
None => (0.0, 0.0),
};
if bwcheck_eff.is_some() {
c_bw = r_max(r_max(c_bw, bw_min_l), bw_min_r);
}
let restrict = |v: f64, bmax: f64| if bwrestrict { r_min(v, bmax) } else { v };
let floor_side = |v: f64, bmin: f64| {
if bwcheck_eff.is_some() {
r_max(v, bmin)
} else {
v
}
};
let floor_comb = |v: f64| {
if bwcheck_eff.is_some() {
r_max(r_max(v, bw_min_l), bw_min_r)
} else {
v
}
};
let mk_vfit = |yy: &[f64], xx: &[f64], tt, zz, cc, ww, o, nu| {
compute_vfit(
yy,
xx,
tt,
zz,
dz,
c,
o,
nu,
c_bw,
vce,
nnmatch,
covs_drop_coll,
kernel,
cc,
ww,
)
};
let vd_l = mk_vfit(&yl, &xl, tl_opt, zl_opt, cll_opt, fwl_opt, q + 1, q + 1);
let vb_l = mk_vfit(&yl, &xl, tl_opt, zl_opt, cll_opt, fwl_opt, q, p + 1);
let vh_l = mk_vfit(&yl, &xl, tl_opt, zl_opt, cll_opt, fwl_opt, p, deriv);
let vd_r = mk_vfit(&yr, &xr, tr_opt, zr_opt, clr_opt, fwr_opt, q + 1, q + 1);
let vb_r = mk_vfit(&yr, &xr, tr_opt, zr_opt, clr_opt, fwr_opt, q, p + 1);
let vh_r = mk_vfit(&yr, &xr, tr_opt, zr_opt, clr_opt, fwr_opt, p, deriv);
let asm = |vf: &VFit, yy: &[f64], xx: &[f64], tt, zz, cc, ww, o, nu, o_b, h_b, scale| {
assemble_from_vfit(
vf, yy, xx, tt, zz, dz, c, o, nu, o_b, c_bw, h_b, scale, vce, nnmatch, kernel, cc, ww,
)
};
let cdl = asm(
&vd_l,
&yl,
&xl,
tl_opt,
zl_opt,
cll_opt,
fwl_opt,
q + 1,
q + 1,
q + 2,
range_l,
0.0,
);
let cdr = asm(
&vd_r,
&yr,
&xr,
tr_opt,
zr_opt,
clr_opt,
fwr_opt,
q + 1,
q + 1,
q + 2,
range_r,
0.0,
);
let rate_d = cdl.rate;
let d_bw_l = (cdl.v / cdl.b.powi(2)).powf(rate_d);
let d_bw_r = (cdr.v / cdr.b.powi(2)).powf(rate_d);
let d_bw_s = ((cdl.v + cdr.v) / (cdr.b + cdl.b).powi(2)).powf(rate_d);
let d_bw_d = ((cdl.v + cdr.v) / (cdr.b - cdl.b).powi(2)).powf(rate_d);
let d_bw_l = floor_side(restrict(d_bw_l, bw_max_l), bw_min_l);
let d_bw_r = floor_side(restrict(d_bw_r, bw_max_r), bw_min_r);
let d_bw_s = floor_comb(restrict(d_bw_s, bw_max));
let d_bw_d = floor_comb(restrict(d_bw_d, bw_max));
let reg_two =
|cv: f64, cb: f64, cr: f64, rate: f64| (cv / (cb.powi(2) + scaleregul * cr)).powf(rate);
let reg_comb = |vl: f64, vr: f64, b_combined: f64, rl: f64, rr: f64, rate: f64| {
((vl + vr) / (b_combined.powi(2) + scaleregul * (rl + rr))).powf(rate)
};
let cbl = asm(
&vb_l,
&yl,
&xl,
tl_opt,
zl_opt,
cll_opt,
fwl_opt,
q,
p + 1,
q + 1,
d_bw_l,
scaleregul,
);
let cbr = asm(
&vb_r,
&yr,
&xr,
tr_opt,
zr_opt,
clr_opt,
fwr_opt,
q,
p + 1,
q + 1,
d_bw_r,
scaleregul,
);
let rate_b = cbl.rate;
let b_bw_l = restrict(reg_two(cbl.v, cbl.b, cbl.r, rate_b), bw_max_l);
let b_bw_r = restrict(reg_two(cbr.v, cbr.b, cbr.r, rate_b), bw_max_r);
let chl = asm(
&vh_l, &yl, &xl, tl_opt, zl_opt, cll_opt, fwl_opt, p, deriv, q, b_bw_l, scaleregul,
);
let chr = asm(
&vh_r, &yr, &xr, tr_opt, zr_opt, clr_opt, fwr_opt, p, deriv, q, b_bw_r, scaleregul,
);
let rate_h = chl.rate;
let h_bw_l = restrict(reg_two(chl.v, chl.b, chl.r, rate_h), bw_max_l);
let h_bw_r = restrict(reg_two(chr.v, chr.b, chr.r, rate_h), bw_max_r);
let cbl_s = asm(
&vb_l,
&yl,
&xl,
tl_opt,
zl_opt,
cll_opt,
fwl_opt,
q,
p + 1,
q + 1,
d_bw_s,
scaleregul,
);
let cbr_s = asm(
&vb_r,
&yr,
&xr,
tr_opt,
zr_opt,
clr_opt,
fwr_opt,
q,
p + 1,
q + 1,
d_bw_s,
scaleregul,
);
let b_bw_s = restrict(
reg_comb(
cbl_s.v,
cbr_s.v,
cbr_s.b + cbl_s.b,
cbl_s.r,
cbr_s.r,
rate_b,
),
bw_max,
);
let chl_s = asm(
&vh_l, &yl, &xl, tl_opt, zl_opt, cll_opt, fwl_opt, p, deriv, q, b_bw_s, scaleregul,
);
let chr_s = asm(
&vh_r, &yr, &xr, tr_opt, zr_opt, clr_opt, fwr_opt, p, deriv, q, b_bw_s, scaleregul,
);
let h_bw_s = restrict(
reg_comb(
chl_s.v,
chr_s.v,
chr_s.b + chl_s.b,
chl_s.r,
chr_s.r,
rate_h,
),
bw_max,
);
let cbl_d = asm(
&vb_l,
&yl,
&xl,
tl_opt,
zl_opt,
cll_opt,
fwl_opt,
q,
p + 1,
q + 1,
d_bw_d,
scaleregul,
);
let cbr_d = asm(
&vb_r,
&yr,
&xr,
tr_opt,
zr_opt,
clr_opt,
fwr_opt,
q,
p + 1,
q + 1,
d_bw_d,
scaleregul,
);
let b_bw_d = restrict(
reg_comb(
cbl_d.v,
cbr_d.v,
cbr_d.b - cbl_d.b,
cbl_d.r,
cbr_d.r,
rate_b,
),
bw_max,
);
let chl_d = asm(
&vh_l, &yl, &xl, tl_opt, zl_opt, cll_opt, fwl_opt, p, deriv, q, b_bw_d, scaleregul,
);
let chr_d = asm(
&vh_r, &yr, &xr, tr_opt, zr_opt, clr_opt, fwr_opt, p, deriv, q, b_bw_d, scaleregul,
);
let h_bw_d = restrict(
reg_comb(
chl_d.v,
chr_d.v,
chr_d.b - chl_d.b,
chl_d.r,
chr_d.r,
rate_h,
),
bw_max,
);
let (h_rd, b_rd) = (h_bw_d, b_bw_d);
let (h_sum, b_sum) = (h_bw_s, b_bw_s);
let h_c1 = r_min(h_rd, h_sum);
let b_c1 = r_min(b_rd, b_sum);
let h_c2_l = median3(h_rd, h_sum, h_bw_l);
let h_c2_r = median3(h_rd, h_sum, h_bw_r);
let b_c2_l = median3(b_rd, b_sum, b_bw_l);
let b_c2_r = median3(b_rd, b_sum, b_bw_r);
let pf = p as f64;
let cer_base = match (g_l, g_r) {
(Some(gl), Some(gr)) => (gl + gr) as f64,
_ => n as f64,
};
let cer_h = cer_base.powf(-(pf / ((3.0 + pf) * (3.0 + 2.0 * pf))));
let cer_b = 1.0;
let common = |h: f64, b: f64| Bws {
h_l: h,
h_r: h,
b_l: b,
b_r: b,
};
let bws = match bwselect {
"mserd" | "" => common(h_rd, b_rd),
"msesum" => common(h_sum, b_sum),
"msetwo" => Bws {
h_l: h_bw_l,
h_r: h_bw_r,
b_l: b_bw_l,
b_r: b_bw_r,
},
"msecomb1" => common(h_c1, b_c1),
"msecomb2" => Bws {
h_l: h_c2_l,
h_r: h_c2_r,
b_l: b_c2_l,
b_r: b_c2_r,
},
"cerrd" => common(h_rd * cer_h, b_rd * cer_b),
"cersum" => common(h_sum * cer_h, b_sum * cer_b),
"certwo" => Bws {
h_l: h_bw_l * cer_h,
h_r: h_bw_r * cer_h,
b_l: b_bw_l * cer_b,
b_r: b_bw_r * cer_b,
},
"cercomb1" => common(h_c1 * cer_h, b_c1 * cer_b),
"cercomb2" => Bws {
h_l: h_c2_l * cer_h,
h_r: h_c2_r * cer_h,
b_l: b_c2_l * cer_b,
b_r: b_c2_r * cer_b,
},
other => panic!("unknown bwselect {other}"),
};
Bws {
h_l: bws.h_l * x_sd,
h_r: bws.h_r * x_sd,
b_l: bws.b_l * x_sd,
b_r: bws.b_r * x_sd,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn quantile_type2_even_n_averages() {
let s = [1.0, 2.0, 3.0, 4.0];
assert_eq!(quantile_type2(&s, 0.5), 2.5);
}
#[test]
fn median3_picks_middle() {
assert_eq!(median3(3.0, 1.0, 2.0), 2.0);
assert!(median3(3.0, f64::NAN, 2.0).is_nan());
}
#[test]
fn clamps_propagate_nan_like_r() {
assert!(r_min(f64::NAN, 1.0).is_nan());
assert!(r_max(1.0, f64::NAN).is_nan());
assert_eq!(r_min(2.0, 1.0), 1.0);
assert_eq!(r_max(2.0, 1.0), 2.0);
}
#[test]
fn perf_comp_detects_constant_side_exactly() {
let x = [-0.5, -0.25, 0.25, 0.5];
assert!(perf_comp(&x, &[0.1, 0.1, 0.0, 1.0], 0.0));
assert!(perf_comp(&x, &[0.0, 1.0, 0.3, 0.3], 0.0));
assert!(!perf_comp(&x, &[0.0, 1.0, 0.0, 1.0], 0.0));
}
}