use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_distributions::{norm_pdf, norm_ppf};
use solow_linalg::pinv;
#[derive(Clone, Debug)]
pub struct QuantReg {
endog: Array1<f64>,
exog: Array2<f64>,
k_constant: usize,
}
impl QuantReg {
pub fn new(endog: Array1<f64>, exog: Array2<f64>) -> Result<Self> {
if endog.len() != exog.nrows() {
return Err(Error::Shape("endog length != exog rows".into()));
}
if exog.nrows() == 0 {
return Err(Error::Value("empty design matrix".into()));
}
let k_constant = detect_k_constant(&exog);
Ok(QuantReg {
endog,
exog,
k_constant,
})
}
pub fn fit(&self, q: f64) -> Result<QuantRegResults> {
self.fit_with(q, 1e-9, 5000)
}
pub fn fit_with(&self, q: f64, p_tol: f64, max_iter: usize) -> Result<QuantRegResults> {
if q <= 0.0 || q >= 1.0 {
return Err(Error::Value("q must be strictly between 0 and 1".into()));
}
let (n, p) = self.exog.dim();
let nobs = n as f64;
let mut beta = Array1::<f64>::ones(p);
let mut xstar = self.exog.clone();
let mut diff = 10.0_f64;
let mut n_iter = 0usize;
while n_iter < max_iter && diff > p_tol {
n_iter += 1;
let beta0 = beta.clone();
let xtx = xstar.t().dot(&self.exog);
let xty = xstar.t().dot(&self.endog);
let (xtx_pinv, _) = pinv(&xtx)?;
beta = xtx_pinv.dot(&xty);
let fitted = self.exog.dot(&beta);
let mut resid = &self.endog - &fitted;
for r in resid.iter_mut() {
if r.abs() < 1e-6 {
*r = if *r >= 0.0 { 1e-6 } else { -1e-6 };
}
let w = if *r < 0.0 { q * *r } else { (1.0 - q) * *r };
*r = w.abs();
}
let mut new_xstar = self.exog.clone();
for i in 0..n {
let inv = 1.0 / resid[i];
for j in 0..p {
new_xstar[[i, j]] *= inv;
}
}
xstar = new_xstar;
diff = (&beta - &beta0)
.iter()
.fold(0.0_f64, |m, &v| m.max(v.abs()));
}
let e = &self.endog - &self.exog.dot(&beta);
let hs = hall_sheather(nobs, q, 0.05);
let iqre = percentile(&e, 75.0) - percentile(&e, 25.0);
let std_endog = std(&self.endog);
let h = std_endog.min(iqre / 1.34) * (norm_ppf(q + hs) - norm_ppf(q - hs));
let mut fhat0 = 0.0;
for &ei in e.iter() {
fhat0 += epanechnikov(ei / h);
}
fhat0 /= nobs * h;
let sparsity = 1.0 / fhat0;
let xtx = self.exog.t().dot(&self.exog);
let (xtxi, _) = pinv(&xtx)?;
let mut xtdx = Array2::<f64>::zeros((p, p));
for i in 0..n {
let d = if e[i] > 0.0 {
(q / fhat0).powi(2)
} else {
((1.0 - q) / fhat0).powi(2)
};
let row = self.exog.row(i);
for a in 0..p {
let ra = row[a] * d;
for b in 0..p {
xtdx[[a, b]] += ra * row[b];
}
}
}
let vcov = xtxi.dot(&xtdx).dot(&xtxi);
let mut bse = Array1::<f64>::zeros(p);
for j in 0..p {
bse[j] = vcov[[j, j]].sqrt();
}
let rank = matrix_rank(&self.exog);
let k_constant = self.k_constant;
Ok(QuantRegResults {
params: beta,
bse,
vcov,
q,
sparsity,
bandwidth: h,
iterations: n_iter,
resid: e,
nobs,
rank,
k_constant,
df_model: rank as f64 - k_constant as f64,
df_resid: nobs - rank as f64,
})
}
pub fn nobs(&self) -> usize {
self.endog.len()
}
}
#[derive(Clone, Debug)]
pub struct QuantRegResults {
pub params: Array1<f64>,
pub bse: Array1<f64>,
pub vcov: Array2<f64>,
pub q: f64,
pub sparsity: f64,
pub bandwidth: f64,
pub iterations: usize,
pub resid: Array1<f64>,
pub nobs: f64,
pub rank: usize,
pub k_constant: usize,
pub df_model: f64,
pub df_resid: f64,
}
fn epanechnikov(u: f64) -> f64 {
if u.abs() <= 1.0 {
0.75 * (1.0 - u * u)
} else {
0.0
}
}
fn hall_sheather(n: f64, q: f64, alpha: f64) -> f64 {
let z = norm_ppf(q);
let num = 1.5 * norm_pdf(z).powi(2);
let den = 2.0 * z * z + 1.0;
n.powf(-1.0 / 3.0) * norm_ppf(1.0 - alpha / 2.0).powf(2.0 / 3.0) * (num / den).powf(1.0 / 3.0)
}
fn std(v: &Array1<f64>) -> f64 {
let n = v.len() as f64;
let mean = v.sum() / n;
let var = v.iter().map(|&x| (x - mean) * (x - mean)).sum::<f64>() / n;
var.sqrt()
}
fn percentile(v: &Array1<f64>, per: f64) -> f64 {
let mut s: Vec<f64> = v.to_vec();
s.sort_by(|a, b| a.total_cmp(b));
let n = s.len();
if n == 1 {
return s[0];
}
let idx = per / 100.0 * (n as f64 - 1.0);
let lo = idx.floor() as usize;
let frac = idx - lo as f64;
if lo + 1 >= n {
s[n - 1]
} else {
s[lo] + (s[lo + 1] - s[lo]) * frac
}
}
fn detect_k_constant(exog: &Array2<f64>) -> usize {
let (_, k) = exog.dim();
for j in 0..k {
let col = exog.column(j);
let Some(&first) = col.iter().next() else {
continue;
};
if first != 0.0 && col.iter().all(|&v| v == first) {
return 1;
}
}
0
}
fn matrix_rank(x: &Array2<f64>) -> usize {
solow_linalg::matrix_rank(x).unwrap_or_else(|_| x.ncols())
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
#[test]
fn median_regression_is_robust_to_an_outlier() {
let x = array![
[1.0, 0.0],
[1.0, 1.0],
[1.0, 2.0],
[1.0, 3.0],
[1.0, 4.0],
[1.0, 5.0]
];
let mut y = array![1.0, 3.0, 5.0, 7.0, 9.0, 11.0];
y[2] = 100.0; let res = QuantReg::new(y, x).unwrap().fit(0.5).unwrap();
assert!(
(res.params[0] - 1.0).abs() < 1e-6,
"intercept {}",
res.params[0]
);
assert!(
(res.params[1] - 2.0).abs() < 1e-6,
"slope {}",
res.params[1]
);
}
#[test]
fn median_regression_bse_well_defined_on_noisy_data() {
let x = array![
[1.0, -1.0],
[1.0, -0.5],
[1.0, 0.0],
[1.0, 0.5],
[1.0, 1.0],
[1.0, 1.5],
[1.0, 2.0],
[1.0, 2.5]
];
let y = array![0.9, 1.2, 2.1, 2.0, 3.3, 3.1, 4.4, 4.0];
let res = QuantReg::new(y, x).unwrap().fit(0.5).unwrap();
assert!(
res.bse.iter().all(|&b| b.is_finite() && b >= 0.0),
"bse {:?}",
res.bse
);
assert!(res.sparsity.is_finite() && res.sparsity > 0.0);
}
#[test]
fn percentile_matches_linear_interpolation() {
let v = array![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0];
assert!((percentile(&v, 75.0) - 5.5).abs() < 1e-12);
assert!((percentile(&v, 25.0) - 2.5).abs() < 1e-12);
assert!((percentile(&v, 50.0) - 4.0).abs() < 1e-12);
}
#[test]
fn rejects_out_of_range_quantile() {
let x = array![[1.0, 0.0], [1.0, 1.0]];
let y = array![0.0, 1.0];
let m = QuantReg::new(y, x).unwrap();
assert!(m.fit(0.0).is_err());
assert!(m.fit(1.0).is_err());
}
}