so_models/

robust.rs

//! Robust statistical methods for StatOxide
//!
//! This module implements robust regression and estimation methods that are
//! less sensitive to outliers and violations of classical assumptions.
//!
//! # Methods Implemented
//!
//! 1. **M-estimators**: Huber, Tukey's biweight, Hampel, Andrews
//! 2. **S-estimators**: High breakdown point estimators
//! 3. **MM-estimators**: Combine high breakdown and high efficiency
//! 4. **LTS/LMS**: Least Trimmed Squares / Least Median of Squares
//! 5. **Robust covariance estimation**: Minimum Covariance Determinant (MCD)
//!

#![allow(non_snake_case)] // Allow mathematical notation (X, W, etc.)

use ndarray::{Array1, Array2};
use serde::{Deserialize, Serialize};
use statrs::distribution::{ContinuousCDF, Normal};

use so_core::error::{Error, Result};
use so_linalg::{inv, solve};
use so_stats::median;

/// Loss functions for M-estimation
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum LossFunction {
    /// Huber loss: quadratic near zero, linear in tails
    Huber { k: f64 },
    /// Tukey's biweight: redescending, completely rejects outliers
    Tukey { c: f64 },
    /// Hampel loss: piecewise linear with flat sections
    Hampel { a: f64, b: f64, c: f64 },
    /// Andrew's sine wave
    Andrews { c: f64 },
    /// Least squares (non-robust baseline)
    LeastSquares,
}

impl LossFunction {
    /// Compute weight for a standardized residual
    fn weight(&self, r: f64) -> f64 {
        match self {
            LossFunction::Huber { k } => {
                if r.abs() <= *k {
                    1.0
                } else {
                    k / r.abs()
                }
            }
            LossFunction::Tukey { c } => {
                if r.abs() <= *c {
                    let t = r / c;
                    (1.0 - t * t).powi(2)
                } else {
                    0.0
                }
            }
            LossFunction::Hampel { a, b, c } => {
                let abs_r = r.abs();
                if abs_r <= *a {
                    1.0
                } else if abs_r <= *b {
                    a / abs_r
                } else if abs_r <= *c {
                    a * (c - abs_r) / ((c - b) * abs_r)
                } else {
                    0.0
                }
            }
            LossFunction::Andrews { c } => {
                if r.abs() <= *c * std::f64::consts::PI {
                    (c * r.sin() / r).max(0.0)
                } else {
                    0.0
                }
            }
            LossFunction::LeastSquares => 1.0,
        }
    }

    /// Compute psi function (derivative of loss)
    fn psi(&self, r: f64) -> f64 {
        match self {
            LossFunction::Huber { k } => {
                if r.abs() <= *k {
                    r
                } else {
                    k * r.signum()
                }
            }
            LossFunction::Tukey { c } => {
                if r.abs() <= *c {
                    let t = r / c;
                    r * (1.0 - t * t).powi(2)
                } else {
                    0.0
                }
            }
            LossFunction::Hampel { a, b, c } => {
                let abs_r = r.abs();
                if abs_r <= *a {
                    r
                } else if abs_r <= *b {
                    a * r.signum()
                } else if abs_r <= *c {
                    a * (c - abs_r) / (c - b) * r.signum()
                } else {
                    0.0
                }
            }
            LossFunction::Andrews { c } => {
                if r.abs() <= *c * std::f64::consts::PI {
                    c * r.sin()
                } else {
                    0.0
                }
            }
            LossFunction::LeastSquares => r,
        }
    }
}

/// Robust regression results
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RobustRegressionResults {
    /// Robust coefficients
    pub coefficients: Array1<f64>,
    /// Standard errors (robust)
    pub standard_errors: Array1<f64>,
    /// Robust scale estimate (MAD or similar)
    pub scale: f64,
    /// Number of iterations
    pub iterations: usize,
    /// Final weights (can be used to identify outliers)
    pub weights: Array1<f64>,
    /// Breakdown point achieved
    pub breakdown_point: f64,
    /// Efficiency relative to OLS
    pub efficiency: f64,
}

/// M-estimator for robust regression
#[derive(Clone)]
pub struct MEstimator {
    loss: LossFunction,
    max_iter: usize,
    tol: f64,
    scale_est: ScaleEstimator,
    tuning: TuningParameters,
}

/// Scale estimation methods
#[derive(Debug, Clone, Copy)]
pub enum ScaleEstimator {
    /// Median Absolute Deviation (robust)
    MAD,
    /// Interquartile Range / 1.349
    IQR,
    /// S-estimator scale
    SEstimate,
    /// Fixed scale
    Fixed(f64),
}

/// Tuning parameters for robust estimators
#[derive(Debug, Clone, Copy)]
pub struct TuningParameters {
    /// Initial breakdown point for S-estimators
    pub breakdown_point: f64,
    /// Efficiency target for MM-estimators
    pub efficiency: f64,
    /// Numerical stability parameter
    pub delta: f64,
}

impl Default for TuningParameters {
    fn default() -> Self {
        Self {
            breakdown_point: 0.5,
            efficiency: 0.95,
            delta: 1e-8,
        }
    }
}

impl MEstimator {
    /// Create a new M-estimator with Huber loss (k=1.345 gives 95% efficiency)
    pub fn huber(k: f64) -> Self {
        Self {
            loss: LossFunction::Huber { k },
            max_iter: 50,
            tol: 1e-6,
            scale_est: ScaleEstimator::MAD,
            tuning: TuningParameters::default(),
        }
    }

    /// Create a new M-estimator with Tukey's biweight (c=4.685 gives 95% efficiency)
    pub fn tukey(c: f64) -> Self {
        Self {
            loss: LossFunction::Tukey { c },
            max_iter: 50,
            tol: 1e-6,
            scale_est: ScaleEstimator::MAD,
            tuning: TuningParameters::default(),
        }
    }

    /// Set maximum iterations
    pub fn max_iterations(mut self, max_iter: usize) -> Self {
        self.max_iter = max_iter;
        self
    }

    /// Set convergence tolerance
    pub fn tolerance(mut self, tol: f64) -> Self {
        self.tol = tol;
        self
    }

    /// Set scale estimation method
    pub fn scale_estimator(mut self, scale_est: ScaleEstimator) -> Self {
        self.scale_est = scale_est;
        self
    }

    /// Set tuning parameters
    pub fn tuning(mut self, tuning: TuningParameters) -> Self {
        self.tuning = tuning;
        self
    }

    /// Fit robust regression using Iteratively Reweighted Least Squares (IRLS)
    pub fn fit(&self, X: &Array2<f64>, y: &Array1<f64>) -> Result<RobustRegressionResults> {
        let n = X.nrows();
        let p = X.ncols();

        if n <= p {
            return Err(Error::DataError(
                "Need more observations than predictors for robust regression".to_string(),
            ));
        }

        // Initial OLS estimate
        let mut beta = self.initial_estimate(X, y)?;

        // Initial scale estimate
        let mut scale = self.initial_scale(X, y, &beta)?;

        // Iteratively reweighted least squares
        let mut iter = 0;
        let mut converged = false;
        let mut weights = Array1::ones(n);

        while !converged && iter < self.max_iter {
            iter += 1;

            // Store previous coefficients
            let beta_prev = beta.clone();

            // Compute standardized residuals
            let residuals = y - X.dot(&beta);
            let scaled_residuals = &residuals / scale;

            // Compute weights based on loss function
            for i in 0..n {
                weights[i] = self.loss.weight(scaled_residuals[i]);
            }

            // Solve weighted least squares
            let W_sqrt = weights.mapv(|w| w.sqrt());
            let X_weighted = X * W_sqrt.clone().insert_axis(ndarray::Axis(1));
            let y_weighted = y * &W_sqrt;

            beta = solve(
                &X_weighted.t().dot(&X_weighted),
                &X_weighted.t().dot(&y_weighted),
            )
            .map_err(|e| Error::LinearAlgebraError(format!("WLS solve failed: {}", e)))?;

            // Update scale estimate if needed
            if matches!(self.scale_est, ScaleEstimator::MAD | ScaleEstimator::IQR) {
                scale = self.update_scale(&residuals, &weights);
            }

            // Check convergence
            let beta_diff = (&beta - &beta_prev).mapv(|x| x.abs());
            let max_diff = beta_diff.iter().fold(0.0, |a, &b| f64::max(a, b));
            converged = max_diff < self.tol;
        }

        // Compute robust standard errors
        let standard_errors = self.compute_standard_errors(X, y, &beta, scale, &weights)?;

        // Compute efficiency and breakdown point
        let efficiency = self.compute_efficiency();
        let breakdown_point = self.breakdown_point();

        Ok(RobustRegressionResults {
            coefficients: beta,
            standard_errors,
            scale,
            iterations: iter,
            weights,
            breakdown_point,
            efficiency,
        })
    }

    /// Initial estimate (usually LTS or LMS for high breakdown)
    fn initial_estimate(&self, X: &Array2<f64>, y: &Array1<f64>) -> Result<Array1<f64>> {
        // For simplicity, use LTS with default coverage
        let lts = LeastTrimmedSquares::default();
        lts.fit(X, y).map(|results| results.coefficients)
    }

    /// Initial scale estimate
    fn initial_scale(&self, X: &Array2<f64>, y: &Array1<f64>, beta: &Array1<f64>) -> Result<f64> {
        match self.scale_est {
            ScaleEstimator::MAD => {
                let residuals = y - X.dot(beta);
                Ok(self.mad(&residuals))
            }
            ScaleEstimator::IQR => {
                let residuals = y - X.dot(beta);
                Ok(self.iqr_scale(&residuals))
            }
            ScaleEstimator::SEstimate => {
                // Use S-estimator for initial scale
                let s_est = SEstimator::default();
                s_est.fit(X, y).map(|results| results.scale)
            }
            ScaleEstimator::Fixed(scale) => Ok(scale),
        }
    }

    /// Update scale estimate based on residuals and weights
    fn update_scale(&self, residuals: &Array1<f64>, weights: &Array1<f64>) -> f64 {
        // Weighted scale estimate
        let _n = residuals.len();
        let sum_weights: f64 = weights.iter().sum();
        let weighted_sse: f64 = residuals
            .iter()
            .zip(weights.iter())
            .map(|(&r, &w)| r * r * w)
            .sum();

        (weighted_sse / sum_weights).sqrt()
    }

    /// Compute Median Absolute Deviation
    fn mad(&self, data: &Array1<f64>) -> f64 {
        let med = median(data).unwrap_or(0.0);
        let abs_dev: Array1<f64> = data.mapv(|x| (x - med).abs());
        let mad = median(&abs_dev).unwrap_or(0.0);
        mad / 0.6745 // Convert to consistent estimator for normal distribution
    }

    /// Compute IQR-based scale estimate
    fn iqr_scale(&self, data: &Array1<f64>) -> f64 {
        use so_stats::quantile;
        let q1 = quantile(data, 0.25).unwrap_or(0.0);
        let q3 = quantile(data, 0.75).unwrap_or(0.0);
        (q3 - q1) / 1.349 // Convert to consistent estimator for normal distribution
    }

    /// Compute robust standard errors
    fn compute_standard_errors(
        &self,
        X: &Array2<f64>,
        y: &Array1<f64>,
        beta: &Array1<f64>,
        scale: f64,
        weights: &Array1<f64>,
    ) -> Result<Array1<f64>> {
        let n = X.nrows();
        let p = X.ncols();

        // Compute weighted X'X inverse
        let W_sqrt = weights.mapv(|w| w.sqrt());
        let X_weighted = X * W_sqrt.clone().insert_axis(ndarray::Axis(1));
        let XtWX = X_weighted.t().dot(&X_weighted);

        let XtWX_inv = inv(&XtWX)
            .map_err(|e| Error::LinearAlgebraError(format!("Failed to invert X'WX: {}", e)))?;

        // Compute leverage-adjusted residuals
        let residuals = y - X.dot(beta);
        let scaled_residuals = &residuals / scale;

        // Compute empirical influence function
        let mut influence = Array1::<f64>::zeros(p);
        for i in 0..n {
            let psi = self.loss.psi(scaled_residuals[i]);
            let xi = X.row(i);
            influence = influence + xi.mapv(|x| x * psi);
        }

        // Compute sandwich variance estimator
        let mut sandwich = Array2::zeros((p, p));
        for i in 0..n {
            let psi = self.loss.psi(scaled_residuals[i]);
            let xi = X.row(i);
            let outer = xi.t().dot(&xi).to_owned() * psi * psi;
            sandwich += outer;
        }

        let cov = XtWX_inv.dot(&sandwich.dot(&XtWX_inv)) * scale * scale / n as f64;
        let se = cov.diag().mapv(|x| x.sqrt());

        Ok(se)
    }

    /// Compute asymptotic efficiency
    fn compute_efficiency(&self) -> f64 {
        // Asymptotic efficiency relative to OLS under normality
        match self.loss {
            LossFunction::Huber { k } => {
                let normal = Normal::new(0.0, 1.0).unwrap();
                let eff = 1.0 / (1.0 + 2.0 * (1.0 - normal.cdf(k)) / k.powi(2));
                eff.min(1.0)
            }
            LossFunction::Tukey { c } => {
                // Approximation for Tukey's efficiency
                let _c2 = c * c;

                if c >= 4.0 { 0.95 } else { 0.85 }
            }
            _ => 0.85, // Conservative estimate for other loss functions
        }
    }

    /// Estimate breakdown point
    fn breakdown_point(&self) -> f64 {
        match self.loss {
            LossFunction::Huber { .. } => 0.0, // M-estimators have 0 breakdown
            LossFunction::Tukey { .. } => 0.5, // Redescending M-estimators can have high breakdown
            LossFunction::Hampel { .. } => 0.5,
            LossFunction::Andrews { .. } => 0.5,
            LossFunction::LeastSquares => 0.0,
        }
    }
}

/// Least Trimmed Squares estimator (high breakdown)
pub struct LeastTrimmedSquares {
    coverage: f64,
}

impl Default for LeastTrimmedSquares {
    fn default() -> Self {
        Self { coverage: 0.5 }
    }
}

impl LeastTrimmedSquares {
    /// Create LTS with specified coverage
    pub fn new(coverage: f64) -> Self {
        Self { coverage }
    }

    /// Fit LTS regression
    pub fn fit(&self, X: &Array2<f64>, y: &Array1<f64>) -> Result<RobustRegressionResults> {
        let n = X.nrows();
        let p = X.ncols();

        if n <= p {
            return Err(Error::DataError(
                "Need more observations than predictors for LTS".to_string(),
            ));
        }

        let h = (n as f64 * self.coverage).ceil() as usize;

        // Simplified LTS: use random subsets (in practice, use fast algorithms)
        let n_subsets = 500.min(n);
        let mut best_sse = f64::INFINITY;
        let mut best_beta = Array1::zeros(p);

        let mut rng = rand::rng();

        for _ in 0..n_subsets {
            // Random subset of size p+1
            let subset_indices = rand::seq::index::sample(&mut rng, n, p + 1).into_vec();
            let X_subset = X.select(ndarray::Axis(0), &subset_indices);
            let y_subset = y.select(ndarray::Axis(0), &subset_indices);

            // Fit on subset
            if let Ok(beta) = solve(&X_subset.t().dot(&X_subset), &X_subset.t().dot(&y_subset)) {
                let residuals = y - X.dot(&beta);
                let mut squared_residuals: Vec<(f64, usize)> = residuals
                    .iter()
                    .enumerate()
                    .map(|(i, &r)| (r * r, i))
                    .collect();

                squared_residuals.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());

                let sse: f64 = squared_residuals[..h].iter().map(|(r2, _)| r2).sum();

                if sse < best_sse {
                    best_sse = sse;
                    best_beta = beta;
                }
            }
        }

        // Refit on best h points
        let residuals = y - X.dot(&best_beta);
        let mut squared_residuals: Vec<(f64, usize)> = residuals
            .iter()
            .enumerate()
            .map(|(i, &r)| (r * r, i))
            .collect();

        squared_residuals.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());

        let best_indices: Vec<usize> = squared_residuals[..h].iter().map(|(_, i)| *i).collect();
        let X_best = X.select(ndarray::Axis(0), &best_indices);
        let y_best = y.select(ndarray::Axis(0), &best_indices);

        let final_beta = solve(&X_best.t().dot(&X_best), &X_best.t().dot(&y_best))
            .map_err(|e| Error::LinearAlgebraError(format!("LTS final fit failed: {}", e)))?;

        // Compute scale from trimmed residuals
        let scale = (best_sse / h as f64).sqrt();

        // Create weight vector (1 for inliers, 0 for outliers)
        let mut weights = Array1::zeros(n);
        for &idx in &best_indices {
            weights[idx] = 1.0;
        }

        Ok(RobustRegressionResults {
            coefficients: final_beta,
            standard_errors: Array1::zeros(p), // Simplified
            scale,
            iterations: n_subsets,
            weights,
            breakdown_point: 1.0 - self.coverage,
            efficiency: 0.7, // LTS has lower efficiency
        })
    }
}

/// S-estimator (high breakdown point)
#[allow(dead_code)]
pub struct SEstimator {
    breakdown_point: f64,
    max_iter: usize,
    tol: f64,
}

impl Default for SEstimator {
    fn default() -> Self {
        Self {
            breakdown_point: 0.5,
            max_iter: 100,
            tol: 1e-6,
        }
    }
}

impl SEstimator {
    /// Fit S-estimator (simplified implementation)
    pub fn fit(&self, X: &Array2<f64>, y: &Array1<f64>) -> Result<RobustRegressionResults> {
        // Simplified: use LTS as starting point
        let lts = LeastTrimmedSquares::new(self.breakdown_point);
        lts.fit(X, y)
    }
}

/// MM-estimator (combines high breakdown and high efficiency)
pub struct MMEstimator {
    s_estimator: SEstimator,
    m_estimator: MEstimator,
}

impl MMEstimator {
    /// Create new MM-estimator
    pub fn new() -> Self {
        Self {
            s_estimator: SEstimator::default(),
            m_estimator: MEstimator::tukey(4.685),
        }
    }

    /// Fit MM-estimator
    pub fn fit(&self, X: &Array2<f64>, y: &Array1<f64>) -> Result<RobustRegressionResults> {
        // Step 1: S-estimator for high breakdown
        let s_results = self.s_estimator.fit(X, y)?;

        // Step 2: M-estimation with fixed scale from S-estimator
        let m_estimator = self
            .m_estimator
            .clone()
            .scale_estimator(ScaleEstimator::Fixed(s_results.scale));

        m_estimator.fit(X, y)
    }
}