sklears-gaussian-process 0.2.0

//! Spatial Gaussian Processes and Kriging Methods
//!
//! This module implements Gaussian Process methods for spatial data analysis,
//! including various kriging methods, spatial correlation modeling, and
//! geostatistical applications.
//!
//! # Mathematical Background
//!
//! Spatial GPs extend standard GP regression to handle spatial data with:
//! 1. **Distance-based kernels**: Kernels that depend on spatial distance
//! 2. **Anisotropic correlation**: Different correlation in different directions
//! 3. **Kriging methods**: Simple, ordinary, universal, and co-kriging
//! 4. **Variogram modeling**: Semi-variogram estimation and fitting
//! 5. **Spatial interpolation**: Optimal spatial prediction with uncertainty
//!
//! # Examples
//!
//! ```rust,no_run
//! use sklears_gaussian_process::spatial::{SpatialGaussianProcessRegressor, SpatialKernel, KrigingType};
//! use sklears_core::traits::{Fit, Predict};
//! use scirs2_core::ndarray::array;
//!
//! // Create spatial GP for ordinary kriging
//! let spatial_gp = SpatialGaussianProcessRegressor::builder()
//!     .spatial_kernel(SpatialKernel::spherical(1.0, 10.0))
//!     .kriging_type(KrigingType::Ordinary)
//!     .build();
//!
//! // Spatial coordinates (x, y)
//! let coords = array![[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]];
//! let values = array![1.0, 2.0, 1.5, 2.5];
//!
//! let trained_model = spatial_gp.fit(&coords, &values).expect("fit should succeed with valid spatial data");
//! let predictions = trained_model.predict(&array![[0.5, 0.5]]).expect("predict should succeed on trained model");
//! ```

use crate::kernels::Kernel;
use crate::utils;
use scirs2_core::ndarray::{s, Array1, Array2, ArrayView1, Axis};
// SciRS2 Policy
use sklears_core::error::{Result as SklResult, SklearsError};
use sklears_core::traits::{Estimator, Fit, Predict};
use std::f64::consts::PI;

/// State marker for untrained spatial GP
#[derive(Debug, Clone)]
pub struct Untrained;

/// State marker for trained spatial GP
#[derive(Debug, Clone)]
pub struct Trained {
    pub spatial_kernel: SpatialKernel,
    pub kriging_type: KrigingType,
    pub training_data: (Array2<f64>, Array1<f64>),
    pub alpha: Array1<f64>,
    pub cholesky: Array2<f64>,
    pub log_likelihood: f64,
    pub variogram: Option<Variogram>,
    pub anisotropy_matrix: Option<Array2<f64>>,
}

/// Types of kriging methods
#[derive(Debug, Clone, Copy)]
pub enum KrigingType {
    /// Simple kriging (known mean)
    Simple { mean: f64 },
    /// Ordinary kriging (unknown constant mean)
    Ordinary,
    /// Universal kriging (trend model)
    Universal,
    /// Co-kriging (multiple variables)
    CoKriging,
}

/// Spatial kernel types for geostatistical modeling
#[derive(Debug, Clone)]
pub enum SpatialKernel {
    /// Spherical model: commonly used in geostatistics
    Spherical {
        sill: f64,   // Maximum variance
        range: f64,  // Correlation range
        nugget: f64, // Nugget effect (short-range noise)
    },
    /// Exponential model: smooth spatial correlation
    Exponential { sill: f64, range: f64, nugget: f64 },
    /// Gaussian model: very smooth spatial correlation
    Gaussian { sill: f64, range: f64, nugget: f64 },
    /// Matérn model: flexible smoothness parameter
    Matern {
        sill: f64,
        range: f64,
        nugget: f64,
        nu: f64, // Smoothness parameter
    },
    /// Power model: unbounded variance
    Power {
        scale: f64,
        exponent: f64, // Should be < 2 for valid covariance
    },
    /// Linear model: linear increase with distance
    Linear { slope: f64, nugget: f64 },
    /// Hole effect model: oscillatory correlation
    HoleEffect {
        sill: f64,
        range: f64,
        nugget: f64,
        damping: f64,
    },
    /// Anisotropic kernel with directional correlation
    Anisotropic {
        base_kernel: Box<SpatialKernel>,
        anisotropy_matrix: Array2<f64>,
    },
}

impl SpatialKernel {
    /// Create a spherical spatial kernel
    pub fn spherical(sill: f64, range: f64) -> Self {
        Self::Spherical {
            sill,
            range,
            nugget: 0.0,
        }
    }

    /// Create a spherical kernel with nugget effect
    pub fn spherical_with_nugget(sill: f64, range: f64, nugget: f64) -> Self {
        Self::Spherical {
            sill,
            range,
            nugget,
        }
    }

    /// Create an exponential spatial kernel
    pub fn exponential(sill: f64, range: f64) -> Self {
        Self::Exponential {
            sill,
            range,
            nugget: 0.0,
        }
    }

    /// Create a Gaussian spatial kernel
    pub fn gaussian(sill: f64, range: f64) -> Self {
        Self::Gaussian {
            sill,
            range,
            nugget: 0.0,
        }
    }

    /// Create a Matérn spatial kernel
    pub fn matern(sill: f64, range: f64, nu: f64) -> Self {
        Self::Matern {
            sill,
            range,
            nugget: 0.0,
            nu,
        }
    }

    /// Create an anisotropic kernel
    pub fn anisotropic(base_kernel: SpatialKernel, anisotropy_matrix: Array2<f64>) -> Self {
        Self::Anisotropic {
            base_kernel: Box::new(base_kernel),
            anisotropy_matrix,
        }
    }

    /// Compute spatial distance between two points
    fn compute_distance(&self, x1: &[f64], x2: &[f64]) -> f64 {
        match self {
            Self::Anisotropic {
                anisotropy_matrix, ..
            } => {
                // Transform coordinates and compute Mahalanobis distance
                let diff: Array1<f64> =
                    Array1::from_vec(x1.iter().zip(x2.iter()).map(|(a, b)| a - b).collect());
                let transformed = anisotropy_matrix.dot(&diff);
                transformed.iter().map(|x| x.powi(2)).sum::<f64>().sqrt()
            }
            _ => {
                // Standard Euclidean distance
                x1.iter()
                    .zip(x2.iter())
                    .map(|(a, b)| (a - b).powi(2))
                    .sum::<f64>()
                    .sqrt()
            }
        }
    }

    /// Compute the covariance for a given distance
    pub fn compute_covariance(&self, distance: f64) -> f64 {
        match self {
            Self::Spherical {
                sill,
                range,
                nugget,
            } => {
                if distance == 0.0 {
                    sill + nugget
                } else if distance <= *range {
                    let h_r = distance / range;
                    sill * (1.0 - 1.5 * h_r + 0.5 * h_r.powi(3))
                        + if distance == 0.0 { *nugget } else { 0.0 }
                } else {
                    if distance == 0.0 {
                        *nugget
                    } else {
                        0.0
                    }
                }
            }
            Self::Exponential {
                sill,
                range,
                nugget,
            } => {
                if distance == 0.0 {
                    sill + nugget
                } else {
                    sill * (-3.0 * distance / range).exp()
                }
            }
            Self::Gaussian {
                sill,
                range,
                nugget,
            } => {
                if distance == 0.0 {
                    sill + nugget
                } else {
                    sill * (-3.0 * (distance / range).powi(2)).exp()
                }
            }
            Self::Matern {
                sill,
                range,
                nugget,
                nu,
            } => {
                if distance == 0.0 {
                    return sill + nugget;
                }

                let h = distance / range;
                match nu {
                    0.5 => sill * (-h).exp(),
                    1.5 => sill * (1.0 + h * 3.0_f64.sqrt()) * (-h * 3.0_f64.sqrt()).exp(),
                    2.5 => {
                        sill * (1.0 + h * 5.0_f64.sqrt() + 5.0 * h.powi(2) / 3.0)
                            * (-h * 5.0_f64.sqrt()).exp()
                    }
                    _ => {
                        // General Matérn (simplified approximation)
                        sill * (1.0 + h).exp() * (-h).exp()
                    }
                }
            }
            Self::Power { scale, exponent } => {
                if distance == 0.0 {
                    0.0
                } else {
                    scale * distance.powf(*exponent)
                }
            }
            Self::Linear { slope, nugget } => {
                if distance == 0.0 {
                    *nugget
                } else {
                    slope * distance
                }
            }
            Self::HoleEffect {
                sill,
                range,
                nugget,
                damping,
            } => {
                if distance == 0.0 {
                    sill + nugget
                } else {
                    let h_r = distance / range;
                    sill * (1.0 - h_r) * (-damping * h_r).exp().max(0.0)
                }
            }
            Self::Anisotropic { base_kernel, .. } => {
                // Distance is already transformed, use base kernel
                base_kernel.compute_covariance(distance)
            }
        }
    }

    /// Compute the semi-variogram for a given distance
    pub fn compute_variogram(&self, distance: f64) -> f64 {
        match self {
            Self::Spherical {
                sill,
                range,
                nugget,
            } => {
                if distance == 0.0 {
                    0.0
                } else if distance <= *range {
                    let h_r = distance / range;
                    nugget + sill * (1.5 * h_r - 0.5 * h_r.powi(3))
                } else {
                    nugget + sill
                }
            }
            Self::Exponential {
                sill,
                range,
                nugget,
            } => {
                if distance == 0.0 {
                    0.0
                } else {
                    nugget + sill * (1.0 - (-3.0 * distance / range).exp())
                }
            }
            Self::Gaussian {
                sill,
                range,
                nugget,
            } => {
                if distance == 0.0 {
                    0.0
                } else {
                    nugget + sill * (1.0 - (-3.0 * (distance / range).powi(2)).exp())
                }
            }
            _ => {
                // For other kernels, use the relation: γ(h) = C(0) - C(h)
                let c0 = self.compute_covariance(0.0);
                let ch = self.compute_covariance(distance);
                (c0 - ch).max(0.0)
            }
        }
    }

    /// Get the effective range of the kernel
    pub fn effective_range(&self) -> f64 {
        match self {
            Self::Spherical { range, .. }
            | Self::Exponential { range, .. }
            | Self::Gaussian { range, .. }
            | Self::Matern { range, .. }
            | Self::HoleEffect { range, .. } => *range,
            Self::Power { .. } => f64::INFINITY,
            Self::Linear { .. } => f64::INFINITY,
            Self::Anisotropic { base_kernel, .. } => base_kernel.effective_range(),
        }
    }

    /// Get the sill (maximum variance) of the kernel
    pub fn sill(&self) -> f64 {
        match self {
            Self::Spherical { sill, .. }
            | Self::Exponential { sill, .. }
            | Self::Gaussian { sill, .. }
            | Self::Matern { sill, .. }
            | Self::HoleEffect { sill, .. } => *sill,
            Self::Power { scale, .. } => *scale,
            Self::Linear { slope, .. } => *slope,
            Self::Anisotropic { base_kernel, .. } => base_kernel.sill(),
        }
    }

    /// Get the nugget effect
    pub fn nugget(&self) -> f64 {
        match self {
            Self::Spherical { nugget, .. }
            | Self::Exponential { nugget, .. }
            | Self::Gaussian { nugget, .. }
            | Self::Matern { nugget, .. }
            | Self::HoleEffect { nugget, .. }
            | Self::Linear { nugget, .. } => *nugget,
            Self::Power { .. } => 0.0,
            Self::Anisotropic { base_kernel, .. } => base_kernel.nugget(),
        }
    }
}

#[allow(non_snake_case)]
impl Kernel for SpatialKernel {
    fn compute_kernel_matrix(
        &self,
        x1: &Array2<f64>,
        x2: Option<&Array2<f64>>,
    ) -> SklResult<Array2<f64>> {
        let x2 = x2.unwrap_or(x1);
        let n1 = x1.nrows();
        let n2 = x2.nrows();

        if x1.ncols() < 2 || x2.ncols() < 2 {
            return Err(SklearsError::InvalidInput(
                "Spatial kernels require at least 2D coordinates".to_string(),
            ));
        }

        let mut K = Array2::zeros((n1, n2));

        for i in 0..n1 {
            for j in 0..n2 {
                let x1_coords = x1.row(i).to_vec();
                let x2_coords = x2.row(j).to_vec();
                let distance = self.compute_distance(&x1_coords, &x2_coords);
                K[[i, j]] = self.compute_covariance(distance);
            }
        }

        Ok(K)
    }

    fn clone_box(&self) -> Box<dyn Kernel> {
        Box::new(self.clone())
    }

    fn kernel(&self, x1: &ArrayView1<f64>, x2: &ArrayView1<f64>) -> f64 {
        if x1.len() < 2 || x2.len() < 2 {
            return 0.0; // Invalid spatial coordinates
        }
        let distance = self.compute_distance(&x1.to_vec(), &x2.to_vec());
        self.compute_covariance(distance)
    }

    fn get_params(&self) -> Vec<f64> {
        match self {
            Self::Spherical {
                range,
                sill,
                nugget,
            } => vec![*range, *sill, *nugget],
            Self::Exponential {
                range,
                sill,
                nugget,
            } => vec![*range, *sill, *nugget],
            Self::Gaussian {
                range,
                sill,
                nugget,
            } => vec![*range, *sill, *nugget],
            Self::Matern {
                range,
                sill,
                nugget,
                nu,
            } => vec![*range, *sill, *nugget, *nu],
            Self::Linear { slope, nugget } => vec![*slope, *nugget],
            Self::Power { scale, exponent } => vec![*scale, *exponent],
            Self::HoleEffect {
                range,
                sill,
                nugget,
                damping,
            } => vec![*range, *sill, *nugget, *damping],
            Self::Anisotropic {
                base_kernel,
                anisotropy_matrix,
            } => {
                let mut params = base_kernel.get_params();
                // Add anisotropy matrix elements (flattened)
                for row in anisotropy_matrix.rows() {
                    for &val in row {
                        params.push(val);
                    }
                }
                params
            }
        }
    }

    fn set_params(&mut self, params: &[f64]) -> SklResult<()> {
        match self {
            Self::Spherical {
                range,
                sill,
                nugget,
            } => {
                if params.len() != 3 {
                    return Err(SklearsError::InvalidInput(
                        "Spherical kernel requires 3 parameters".to_string(),
                    ));
                }
                *range = params[0];
                *sill = params[1];
                *nugget = params[2];
            }
            Self::Exponential {
                range,
                sill,
                nugget,
            } => {
                if params.len() != 3 {
                    return Err(SklearsError::InvalidInput(
                        "Exponential kernel requires 3 parameters".to_string(),
                    ));
                }
                *range = params[0];
                *sill = params[1];
                *nugget = params[2];
            }
            Self::Gaussian {
                range,
                sill,
                nugget,
            } => {
                if params.len() != 3 {
                    return Err(SklearsError::InvalidInput(
                        "Gaussian kernel requires 3 parameters".to_string(),
                    ));
                }
                *range = params[0];
                *sill = params[1];
                *nugget = params[2];
            }
            Self::Matern {
                range,
                sill,
                nugget,
                nu,
            } => {
                if params.len() != 4 {
                    return Err(SklearsError::InvalidInput(
                        "Matern kernel requires 4 parameters".to_string(),
                    ));
                }
                *range = params[0];
                *sill = params[1];
                *nugget = params[2];
                *nu = params[3];
            }
            Self::Linear { slope, nugget } => {
                if params.len() != 2 {
                    return Err(SklearsError::InvalidInput(
                        "Linear kernel requires 2 parameters".to_string(),
                    ));
                }
                *slope = params[0];
                *nugget = params[1];
            }
            Self::Power { scale, exponent } => {
                if params.len() != 2 {
                    return Err(SklearsError::InvalidInput(
                        "Power kernel requires 2 parameters".to_string(),
                    ));
                }
                *scale = params[0];
                *exponent = params[1];
            }
            Self::HoleEffect {
                range,
                sill,
                nugget,
                damping,
            } => {
                if params.len() != 4 {
                    return Err(SklearsError::InvalidInput(
                        "HoleEffect kernel requires 4 parameters".to_string(),
                    ));
                }
                *range = params[0];
                *sill = params[1];
                *nugget = params[2];
                *damping = params[3];
            }
            Self::Anisotropic {
                base_kernel,
                anisotropy_matrix,
            } => {
                let base_params_len = base_kernel.get_params().len();
                if params.len() < base_params_len {
                    return Err(SklearsError::InvalidInput(
                        "Not enough parameters for anisotropic kernel".to_string(),
                    ));
                }

                // Set base kernel parameters
                base_kernel.set_params(&params[..base_params_len])?;

                // Set anisotropy matrix
                let matrix_size = anisotropy_matrix.nrows() * anisotropy_matrix.ncols();
                if params.len() != base_params_len + matrix_size {
                    return Err(SklearsError::InvalidInput(
                        "Incorrect number of parameters for anisotropy matrix".to_string(),
                    ));
                }

                let matrix_params = &params[base_params_len..];
                let ncols = anisotropy_matrix.ncols();
                for (i, mut row) in anisotropy_matrix.rows_mut().into_iter().enumerate() {
                    for (j, val) in row.iter_mut().enumerate() {
                        *val = matrix_params[i * ncols + j];
                    }
                }
            }
        }
        Ok(())
    }
}

/// Empirical variogram computation and modeling
#[derive(Debug, Clone)]
pub struct Variogram {
    pub distances: Array1<f64>,
    pub semivariances: Array1<f64>,
    pub n_pairs: Array1<usize>,
    pub fitted_model: Option<SpatialKernel>,
}

impl Variogram {
    /// Compute empirical variogram from spatial data
    pub fn compute_empirical(
        coords: &Array2<f64>,
        values: &Array1<f64>,
        n_bins: usize,
    ) -> SklResult<Self> {
        let n_points = coords.nrows();
        if coords.nrows() != values.len() {
            return Err(SklearsError::DimensionMismatch {
                expected: coords.nrows(),
                actual: values.len(),
            });
        }

        // Compute all pairwise distances and semivariances
        let mut all_distances = Vec::new();
        let mut all_semivariances = Vec::new();

        for i in 0..n_points {
            for j in i + 1..n_points {
                let dist = coords
                    .row(i)
                    .iter()
                    .zip(coords.row(j).iter())
                    .map(|(a, b)| (a - b).powi(2))
                    .sum::<f64>()
                    .sqrt();

                let semivar = 0.5 * (values[i] - values[j]).powi(2);

                all_distances.push(dist);
                all_semivariances.push(semivar);
            }
        }

        if all_distances.is_empty() {
            return Err(SklearsError::InvalidInput(
                "Not enough data points for variogram".to_string(),
            ));
        }

        // Create distance bins
        let max_dist = all_distances.iter().fold(0.0f64, |a, &b| a.max(b));
        let min_dist = all_distances.iter().fold(f64::INFINITY, |a, &b| a.min(b));
        let bin_width = (max_dist - min_dist) / n_bins as f64;

        let mut bin_distances: Array1<f64> = Array1::zeros(n_bins);
        let mut bin_semivariances: Array1<f64> = Array1::zeros(n_bins);
        let mut bin_counts: Array1<f64> = Array1::zeros(n_bins);

        // Assign pairs to bins
        for (dist, semivar) in all_distances.iter().zip(all_semivariances.iter()) {
            let bin_idx = ((*dist - min_dist) / bin_width).floor() as usize;
            let bin_idx = bin_idx.min(n_bins - 1);

            bin_distances[bin_idx] += dist;
            bin_semivariances[bin_idx] += semivar;
            bin_counts[bin_idx] += 1.0;
        }

        // Compute bin averages
        let mut distances = Vec::new();
        let mut semivariances = Vec::new();
        let mut n_pairs = Vec::new();

        for i in 0..n_bins {
            if bin_counts[i] > 0.0 {
                distances.push(bin_distances[i] / bin_counts[i] as f64);
                semivariances.push(bin_semivariances[i] / bin_counts[i] as f64);
                n_pairs.push(bin_counts[i] as usize);
            }
        }

        Ok(Self {
            distances: Array1::from_vec(distances),
            semivariances: Array1::from_vec(semivariances),
            n_pairs: Array1::from_vec(n_pairs),
            fitted_model: None,
        })
    }

    /// Fit a spatial kernel model to the empirical variogram
    pub fn fit_model(&mut self, model_type: &str) -> SklResult<()> {
        if self.distances.is_empty() {
            return Err(SklearsError::InvalidInput(
                "No variogram data to fit".to_string(),
            ));
        }

        // Simple parameter estimation (could be improved with non-linear optimization)
        let max_semivar = self.semivariances.iter().fold(0.0f64, |a, &b| a.max(b));
        let max_dist = self.distances.iter().fold(0.0f64, |a, &b| a.max(b));

        // Estimate nugget as the y-intercept
        let nugget = if self.distances[0] > 0.0 {
            0.0
        } else {
            self.semivariances[0]
        };

        // Estimate sill as maximum semivariance
        let sill = max_semivar - nugget;

        // Estimate range as distance where semivariance reaches ~95% of sill
        let target_semivar = nugget + 0.95 * sill;
        let mut range = max_dist;
        for i in 0..self.distances.len() {
            if self.semivariances[i] >= target_semivar {
                range = self.distances[i];
                break;
            }
        }

        let fitted_model = match model_type {
            "spherical" => SpatialKernel::Spherical {
                sill,
                range,
                nugget,
            },
            "exponential" => SpatialKernel::Exponential {
                sill,
                range,
                nugget,
            },
            "gaussian" => SpatialKernel::Gaussian {
                sill,
                range,
                nugget,
            },
            "matern15" => SpatialKernel::Matern {
                sill,
                range,
                nugget,
                nu: 1.5,
            },
            _ => {
                return Err(SklearsError::InvalidInput(format!(
                    "Unknown model type: {}",
                    model_type
                )))
            }
        };

        self.fitted_model = Some(fitted_model);
        Ok(())
    }

    /// Compute goodness of fit for the fitted model
    pub fn goodness_of_fit(&self) -> SklResult<f64> {
        let model = self
            .fitted_model
            .as_ref()
            .ok_or_else(|| SklearsError::InvalidInput("No model fitted".to_string()))?;

        let mut ss_res = 0.0;
        let mut ss_tot = 0.0;
        let mean_semivar = self.semivariances.mean().unwrap_or(0.0);

        for i in 0..self.distances.len() {
            let predicted = model.compute_variogram(self.distances[i]);
            let observed = self.semivariances[i];

            ss_res += (observed - predicted).powi(2);
            ss_tot += (observed - mean_semivar).powi(2);
        }

        let r_squared = 1.0 - (ss_res / ss_tot.max(1e-12));
        Ok(r_squared)
    }
}

/// Spatial Gaussian Process Regressor
#[derive(Debug, Clone)]
pub struct SpatialGaussianProcessRegressor<S = Untrained> {
    spatial_kernel: Option<SpatialKernel>,
    kriging_type: KrigingType,
    estimate_variogram: bool,
    variogram_bins: usize,
    anisotropy_matrix: Option<Array2<f64>>,
    alpha: f64,
    _state: S,
}

/// Configuration for spatial GP
#[derive(Debug, Clone)]
pub struct SpatialGPConfig {
    pub kriging_type: KrigingType,
    pub estimate_variogram: bool,
    pub variogram_bins: usize,
    pub regularization: f64,
}

impl Default for SpatialGPConfig {
    fn default() -> Self {
        Self {
            kriging_type: KrigingType::Ordinary,
            estimate_variogram: false,
            variogram_bins: 20,
            regularization: 1e-6,
        }
    }
}

impl Default for SpatialGaussianProcessRegressor<Untrained> {
    fn default() -> Self {
        Self::new()
    }
}

impl SpatialGaussianProcessRegressor<Untrained> {
    /// Create a new spatial GP regressor
    pub fn new() -> Self {
        Self {
            spatial_kernel: None,
            kriging_type: KrigingType::Ordinary,
            estimate_variogram: false,
            variogram_bins: 20,
            anisotropy_matrix: None,
            alpha: 1e-6,
            _state: Untrained,
        }
    }

    /// Create a builder for spatial GP
    pub fn builder() -> SpatialGPBuilder {
        SpatialGPBuilder::new()
    }

    /// Set the spatial kernel
    pub fn spatial_kernel(mut self, kernel: SpatialKernel) -> Self {
        self.spatial_kernel = Some(kernel);
        self
    }

    /// Set the kriging type
    pub fn kriging_type(mut self, kriging_type: KrigingType) -> Self {
        self.kriging_type = kriging_type;
        self
    }

    /// Enable automatic variogram estimation
    pub fn estimate_variogram(mut self, estimate: bool) -> Self {
        self.estimate_variogram = estimate;
        self
    }

    /// Set anisotropy matrix for directional correlation
    pub fn anisotropy_matrix(mut self, matrix: Array2<f64>) -> Self {
        self.anisotropy_matrix = Some(matrix);
        self
    }

    /// Set regularization parameter
    pub fn alpha(mut self, alpha: f64) -> Self {
        self.alpha = alpha;
        self
    }
}

/// Builder for spatial GP regressor
#[derive(Debug, Clone)]
pub struct SpatialGPBuilder {
    kernel: Option<SpatialKernel>,
    kriging_type: KrigingType,
    estimate_variogram: bool,
    variogram_bins: usize,
    anisotropy_matrix: Option<Array2<f64>>,
    alpha: f64,
}

impl Default for SpatialGPBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl SpatialGPBuilder {
    pub fn new() -> Self {
        Self {
            kernel: None,
            kriging_type: KrigingType::Ordinary,
            estimate_variogram: false,
            variogram_bins: 20,
            anisotropy_matrix: None,
            alpha: 1e-6,
        }
    }

    pub fn spatial_kernel(mut self, kernel: SpatialKernel) -> Self {
        self.kernel = Some(kernel);
        self
    }

    pub fn kriging_type(mut self, kriging_type: KrigingType) -> Self {
        self.kriging_type = kriging_type;
        self
    }

    pub fn estimate_variogram(mut self, estimate: bool) -> Self {
        self.estimate_variogram = estimate;
        self
    }

    pub fn variogram_bins(mut self, bins: usize) -> Self {
        self.variogram_bins = bins;
        self
    }

    pub fn anisotropy_matrix(mut self, matrix: Array2<f64>) -> Self {
        self.anisotropy_matrix = Some(matrix);
        self
    }

    pub fn alpha(mut self, alpha: f64) -> Self {
        self.alpha = alpha;
        self
    }

    pub fn build(self) -> SpatialGaussianProcessRegressor<Untrained> {
        SpatialGaussianProcessRegressor {
            spatial_kernel: self.kernel,
            kriging_type: self.kriging_type,
            estimate_variogram: self.estimate_variogram,
            variogram_bins: self.variogram_bins,
            anisotropy_matrix: self.anisotropy_matrix.clone(),
            alpha: self.alpha,
            _state: Untrained,
        }
    }
}

impl Estimator for SpatialGaussianProcessRegressor<Untrained> {
    type Config = SpatialGPConfig;
    type Error = SklearsError;
    type Float = f64;

    fn config(&self) -> &Self::Config {
        static DEFAULT_CONFIG: SpatialGPConfig = SpatialGPConfig {
            kriging_type: KrigingType::Ordinary,
            estimate_variogram: false,
            variogram_bins: 20,
            regularization: 1e-6,
        };
        &DEFAULT_CONFIG
    }
}

impl Estimator for SpatialGaussianProcessRegressor<Trained> {
    type Config = SpatialGPConfig;
    type Error = SklearsError;
    type Float = f64;

    fn config(&self) -> &Self::Config {
        static DEFAULT_CONFIG: SpatialGPConfig = SpatialGPConfig {
            kriging_type: KrigingType::Ordinary,
            estimate_variogram: false,
            variogram_bins: 20,
            regularization: 1e-6,
        };
        &DEFAULT_CONFIG
    }
}

#[allow(non_snake_case)]
impl Fit<Array2<f64>, Array1<f64>> for SpatialGaussianProcessRegressor<Untrained> {
    type Fitted = SpatialGaussianProcessRegressor<Trained>;

    fn fit(self, X: &Array2<f64>, y: &Array1<f64>) -> SklResult<Self::Fitted> {
        if X.nrows() != y.len() {
            return Err(SklearsError::DimensionMismatch {
                expected: X.nrows(),
                actual: y.len(),
            });
        }

        if X.ncols() < 2 {
            return Err(SklearsError::InvalidInput(
                "Spatial GP requires at least 2D coordinates".to_string(),
            ));
        }

        let X_owned = X.to_owned();
        let y_owned = y.to_owned();

        // Estimate variogram if requested
        let variogram = if self.estimate_variogram {
            Some(Variogram::compute_empirical(
                &X_owned,
                &y_owned,
                self.variogram_bins,
            )?)
        } else {
            None
        };

        // Get spatial kernel
        let mut spatial_kernel = self.spatial_kernel.clone().ok_or_else(|| {
            SklearsError::InvalidInput("Spatial kernel must be specified".to_string())
        })?;

        // Apply anisotropy if specified
        if let Some(anisotropy_matrix) = &self.anisotropy_matrix {
            spatial_kernel = SpatialKernel::anisotropic(spatial_kernel, anisotropy_matrix.clone());
        }

        // Compute kernel matrix
        let K = spatial_kernel.compute_kernel_matrix(&X_owned, None)?;

        // Handle different kriging types
        let (y_for_gp, augmented_matrix) = match self.kriging_type {
            KrigingType::Simple { mean } => {
                // Subtract known mean
                let y_centered = &y_owned - mean;
                (y_centered, K.clone())
            }
            KrigingType::Ordinary => {
                // Add constraint for constant mean
                let n = K.nrows();
                let mut augmented = Array2::zeros((n + 1, n + 1));

                // Copy kernel matrix
                for i in 0..n {
                    for j in 0..n {
                        augmented[[i, j]] = K[[i, j]];
                    }
                }

                // Add constraint equations
                for i in 0..n {
                    augmented[[i, n]] = 1.0;
                    augmented[[n, i]] = 1.0;
                }

                (y_owned.clone(), augmented)
            }
            KrigingType::Universal => {
                // For universal kriging, we would add trend terms
                // Simplified implementation: treat as ordinary kriging for now
                let n = K.nrows();
                let mut augmented = Array2::zeros((n + 1, n + 1));

                for i in 0..n {
                    for j in 0..n {
                        augmented[[i, j]] = K[[i, j]];
                    }
                }

                for i in 0..n {
                    augmented[[i, n]] = 1.0;
                    augmented[[n, i]] = 1.0;
                }

                (y_owned.clone(), augmented)
            }
            KrigingType::CoKriging => {
                // Co-kriging would handle multiple variables
                // For now, treat as ordinary kriging
                let n = K.nrows();
                let mut augmented = Array2::zeros((n + 1, n + 1));

                for i in 0..n {
                    for j in 0..n {
                        augmented[[i, j]] = K[[i, j]];
                    }
                }

                for i in 0..n {
                    augmented[[i, n]] = 1.0;
                    augmented[[n, i]] = 1.0;
                }

                (y_owned.clone(), augmented)
            }
        };

        // Regularize the covariance (kernel) block of the system. The kernel
        // block `K` is symmetric positive semi-definite; `alpha` (the user
        // nugget/observation noise) lifts the smallest eigenvalue and makes it
        // positive definite so that a Cholesky factorization is well defined.
        let n_train = K.nrows();
        let mut k_block_reg = K.clone();
        for i in 0..n_train {
            k_block_reg[[i, i]] += self.alpha;
        }

        // Cholesky factor of the (regularized) kernel block only. This factor
        // is symmetric-positive-definite by construction (adaptive jitter is
        // applied internally if `alpha` alone is insufficient) and is reused
        // downstream for the kriging *variance*, which is a Gaussian-process
        // posterior variance defined purely by the covariance block.
        let chol_block = utils::robust_cholesky(&k_block_reg)?;

        // Solve for the kriging weights. The numerical character of the system
        // differs fundamentally between simple and ordinary/universal kriging.
        let alpha = match self.kriging_type {
            KrigingType::Simple { .. } => {
                // Simple kriging: weights solve the SPD system `K w = y_c`,
                // handled directly and stably by the Cholesky factor above.
                utils::triangular_solve(&chol_block, &y_for_gp)?
            }
            _ => {
                // Ordinary / universal / co-kriging augment `K` with an
                // unbiasedness (Lagrange) constraint, producing a SYMMETRIC
                // INDEFINITE saddle-point (KKT) system:
                //
                //     [ K   1 ] [ w ]   [ y ]
                //     [ 1^T 0 ] [ λ ] = [ 0 ]
                //
                // Such a system can never be Cholesky-factored (it always has a
                // negative eigenvalue), so we regularize the SPD kernel block
                // with the same nugget used above and solve the full system with
                // a general LU-based solver, which correctly handles indefinite
                // matrices. This is the principled fix for the instability:
                // Cholesky is used only where it is mathematically valid.
                let mut a = augmented_matrix.clone();
                for i in 0..n_train {
                    a[[i, i]] += self.alpha;
                }

                let mut rhs = Array1::zeros(n_train + 1);
                for i in 0..n_train {
                    rhs[i] = y_for_gp[i];
                }
                // The trailing entry (Lagrange multiplier row) is the
                // unbiasedness condition sum(w) = 1, hence rhs = 0 there.

                scirs2_linalg::solve(&a.view(), &rhs.view(), None).map_err(|e| {
                    SklearsError::NumericalError(format!(
                        "Failed to solve ordinary/universal kriging system: {e}"
                    ))
                })?
            }
        };

        // Log marginal likelihood is defined for the Gaussian-process model on
        // the covariance block (the unbiasedness constraint is not part of the
        // likelihood). Use the SPD kernel block and the matching weight vector.
        let weights_block = alpha.slice(s![0..n_train]).to_owned();
        let log_det = chol_block.diag().iter().map(|x| x.ln()).sum::<f64>() * 2.0;
        let data_fit = y_for_gp.dot(&weights_block);
        let log_likelihood = -0.5 * (data_fit + log_det + n_train as f64 * (2.0 * PI).ln());

        let chol_decomp = chol_block;

        Ok(SpatialGaussianProcessRegressor {
            spatial_kernel: self.spatial_kernel,
            kriging_type: self.kriging_type,
            estimate_variogram: self.estimate_variogram,
            variogram_bins: self.variogram_bins,
            anisotropy_matrix: self.anisotropy_matrix.clone(),
            alpha: self.alpha,
            _state: Trained {
                spatial_kernel,
                kriging_type: self.kriging_type,
                training_data: (X_owned, y_owned),
                alpha,
                cholesky: chol_decomp,
                log_likelihood,
                variogram,
                anisotropy_matrix: self.anisotropy_matrix.clone(),
            },
        })
    }
}

#[allow(non_snake_case)]
impl SpatialGaussianProcessRegressor<Trained> {
    /// Access the trained state
    pub fn trained_state(&self) -> &Trained {
        &self._state
    }

    /// Get the empirical variogram if computed
    pub fn variogram(&self) -> Option<&Variogram> {
        self._state.variogram.as_ref()
    }

    /// Predict with uncertainty (kriging variance)
    pub fn predict_with_variance(&self, X: &Array2<f64>) -> SklResult<(Array1<f64>, Array1<f64>)> {
        let n_test = X.nrows();
        let n_train = self._state.training_data.0.nrows();

        // Compute cross-covariance matrix
        let K_star = self
            ._state
            .spatial_kernel
            .compute_kernel_matrix(&self._state.training_data.0, Some(X))?;

        // Handle different kriging types for prediction
        let (predictions, variances) = match self._state.kriging_type {
            KrigingType::Simple { mean } => {
                // Simple kriging predictions
                let pred = K_star.t().dot(&self._state.alpha.slice(s![0..n_train])) + mean;

                // Compute prediction variance
                let K_star_star = self._state.spatial_kernel.compute_kernel_matrix(X, None)?;
                let cholesky_slice = self
                    ._state
                    .cholesky
                    .slice(s![0..n_train, 0..n_train])
                    .to_owned();
                let v = utils::triangular_solve_matrix(&cholesky_slice, &K_star)?;
                let pred_var =
                    K_star_star.diag().to_owned() - &v.map(|x| x.powi(2)).sum_axis(Axis(0));

                (pred, pred_var)
            }
            _ => {
                // Ordinary/Universal kriging
                let mut extended_k_star = Array2::zeros((n_train + 1, n_test));

                // Copy cross-covariances
                for i in 0..n_train {
                    for j in 0..n_test {
                        extended_k_star[[i, j]] = K_star[[i, j]];
                    }
                }

                // Add constraint (unitary condition)
                for j in 0..n_test {
                    extended_k_star[[n_train, j]] = 1.0;
                }

                let pred = extended_k_star.t().dot(&self._state.alpha);

                // Compute prediction variance (simplified)
                let K_star_star = self._state.spatial_kernel.compute_kernel_matrix(X, None)?;
                let cholesky_slice = self
                    ._state
                    .cholesky
                    .slice(s![0..n_train, 0..n_train])
                    .to_owned();
                let v = utils::triangular_solve_matrix(&cholesky_slice, &K_star)?;
                let pred_var =
                    K_star_star.diag().to_owned() - &v.map(|x| x.powi(2)).sum_axis(Axis(0));

                (pred, pred_var.map(|x| x.max(0.0)))
            }
        };

        Ok((predictions, variances.map(|x| x.sqrt())))
    }

    /// Compute spatial correlation structure
    pub fn correlation_structure(
        &self,
        max_distance: f64,
        n_points: usize,
    ) -> (Array1<f64>, Array1<f64>) {
        let distances = Array1::linspace(0.0, max_distance, n_points);
        let correlations = distances.map(|&d| self._state.spatial_kernel.compute_covariance(d));
        (distances, correlations)
    }

    /// Detect spatial outliers using leave-one-out kriging cross-validation.
    ///
    /// A kriging model interpolates its training data exactly, so *in-sample*
    /// residuals are identically zero and carry no information about outliers.
    /// The standard geostatistical diagnostic is therefore the **leave-one-out
    /// (LOO) cross-validated, studentized residual**: each observation is
    /// removed, predicted from the remaining points, and the prediction error
    /// is standardized by the kriging standard deviation at that location:
    ///
    /// ```text
    /// z_i = (y_i - yhat_{-i}) / sigma_{-i}
    /// ```
    ///
    /// Spatially anomalous observations are those whose value disagrees with
    /// what their neighbours predict, yielding a large |z_i|. Points are
    /// flagged when |z_i| exceeds `threshold` (a number of standard deviations).
    pub fn detect_spatial_outliers(&self, threshold: f64) -> SklResult<Vec<usize>> {
        let coords = &self._state.training_data.0;
        let targets = &self._state.training_data.1;
        let n = coords.nrows();
        let n_features = coords.ncols();

        let mut outliers = Vec::new();

        for i in 0..n {
            // Build the leave-one-out training set (all points except `i`).
            let mut train_coords = Vec::with_capacity((n - 1) * n_features);
            let mut train_values = Vec::with_capacity(n - 1);
            for j in 0..n {
                if j != i {
                    train_coords.extend(coords.row(j).iter().copied());
                    train_values.push(targets[j]);
                }
            }

            let train_coords_array = Array2::from_shape_vec((n - 1, n_features), train_coords)
                .map_err(|_| {
                    SklearsError::InvalidInput(
                        "Failed to build leave-one-out coordinates".to_string(),
                    )
                })?;
            let train_values_array = Array1::from_vec(train_values);

            let reduced_gp = SpatialGaussianProcessRegressor::builder()
                .spatial_kernel(self._state.spatial_kernel.clone())
                .kriging_type(self._state.kriging_type)
                .alpha(self.alpha)
                .build();

            let fitted = reduced_gp.fit(&train_coords_array, &train_values_array)?;

            let test_coords = coords.slice(s![i..i + 1, ..]).to_owned();
            let (prediction, std_dev) = fitted.predict_with_variance(&test_coords)?;

            let residual = targets[i] - prediction[0];
            // Standardize by the kriging standard deviation. Guard against a
            // degenerate (zero) predictive std with a trace-proportional floor
            // derived from the data scale so the z-score stays finite.
            let sigma = std_dev[0];
            let sigma = if sigma.is_finite() && sigma > 1e-12 {
                sigma
            } else {
                let scale = targets.std(0.0);
                (scale * 1e-6).max(1e-12)
            };

            let z_score = residual / sigma;
            if z_score.is_finite() && z_score.abs() > threshold {
                outliers.push(i);
            }
        }

        Ok(outliers)
    }

    /// Cross-validation for spatial data (leave-one-out)
    pub fn spatial_cross_validation(&self) -> SklResult<f64> {
        let n = self._state.training_data.0.nrows();
        let mut errors = Vec::new();

        for i in 0..n {
            // Create training data excluding point i
            let mut train_coords = Vec::new();
            let mut train_values = Vec::new();

            for j in 0..n {
                if j != i {
                    train_coords.push(self._state.training_data.0.row(j).to_vec());
                    train_values.push(self._state.training_data.1[j]);
                }
            }

            // Convert back to arrays
            let train_coords_array = Array2::from_shape_vec(
                (n - 1, self._state.training_data.0.ncols()),
                train_coords.into_iter().flatten().collect(),
            )
            .map_err(|_| {
                SklearsError::InvalidInput("Failed to create training coordinates".to_string())
            })?;

            let train_values_array = Array1::from_vec(train_values);

            // Fit model on reduced data
            let reduced_gp = SpatialGaussianProcessRegressor::builder()
                .spatial_kernel(self._state.spatial_kernel.clone())
                .kriging_type(self._state.kriging_type)
                .alpha(self.alpha)
                .build();

            if let Ok(fitted) = reduced_gp.fit(&train_coords_array, &train_values_array) {
                // Predict for the left-out point
                let test_coords = self._state.training_data.0.slice(s![i..i + 1, ..]);
                if let Ok(pred) = fitted.predict(&test_coords.to_owned()) {
                    let error = (pred[0] - self._state.training_data.1[i]).powi(2);
                    errors.push(error);
                }
            }
        }

        if errors.is_empty() {
            return Err(SklearsError::InvalidInput(
                "Cross-validation failed".to_string(),
            ));
        }

        let mse = errors.iter().sum::<f64>() / errors.len() as f64;
        Ok(mse.sqrt()) // Return RMSE
    }
}

#[allow(non_snake_case)]
impl Predict<Array2<f64>, Array1<f64>> for SpatialGaussianProcessRegressor<Trained> {
    fn predict(&self, X: &Array2<f64>) -> SklResult<Array1<f64>> {
        let (predictions, _) = self.predict_with_variance(X)?;
        Ok(predictions)
    }
}

#[allow(non_snake_case)]
#[cfg(test)]
mod tests {
    use super::*;
    use approx::assert_abs_diff_eq;
    use scirs2_core::ndarray::array;

    #[test]
    fn test_spatial_kernel_spherical() {
        let kernel = SpatialKernel::spherical(1.0, 10.0);

        // Test at distance 0
        assert_abs_diff_eq!(kernel.compute_covariance(0.0), 1.0, epsilon = 1e-10);

        // Test within range
        let cov_5 = kernel.compute_covariance(5.0);
        assert!(cov_5 > 0.0 && cov_5 < 1.0);

        // Test beyond range
        let cov_15 = kernel.compute_covariance(15.0);
        assert_abs_diff_eq!(cov_15, 0.0, epsilon = 1e-10);
    }

    #[test]
    fn test_spatial_kernel_exponential() {
        let kernel = SpatialKernel::exponential(1.0, 5.0);

        // Test exponential decay
        let cov_0 = kernel.compute_covariance(0.0);
        let cov_5 = kernel.compute_covariance(5.0);
        let cov_10 = kernel.compute_covariance(10.0);

        assert_abs_diff_eq!(cov_0, 1.0, epsilon = 1e-10);
        assert!(cov_5 > cov_10);
        assert!(cov_10 > 0.0);
    }

    #[test]
    fn test_variogram_computation() {
        let coords = array![[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]];
        let values = array![1.0, 2.0, 1.5, 2.5];

        let variogram =
            Variogram::compute_empirical(&coords, &values, 5).expect("operation should succeed");

        assert!(!variogram.distances.is_empty());
        assert_eq!(variogram.distances.len(), variogram.semivariances.len());
        assert_eq!(variogram.distances.len(), variogram.n_pairs.len());
    }

    #[test]
    fn test_spatial_gp_ordinary_kriging() {
        let coords = array![[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]];
        let values = array![1.0, 2.0, 1.5, 2.5];

        let spatial_gp = SpatialGaussianProcessRegressor::builder()
            .spatial_kernel(SpatialKernel::spherical(1.0, 2.0))
            .kriging_type(KrigingType::Ordinary)
            .build();

        let trained = spatial_gp
            .fit(&coords, &values)
            .expect("model fitting should succeed");
        let predictions = trained.predict(&coords).expect("prediction should succeed");

        assert_eq!(predictions.len(), coords.nrows());
    }

    #[test]
    fn test_spatial_gp_simple_kriging() {
        let coords = array![[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]];
        let values = array![1.0, 2.0, 1.5, 2.5];

        let spatial_gp = SpatialGaussianProcessRegressor::builder()
            .spatial_kernel(SpatialKernel::exponential(1.0, 2.0))
            .kriging_type(KrigingType::Simple { mean: 1.75 })
            .build();

        let trained = spatial_gp
            .fit(&coords, &values)
            .expect("model fitting should succeed");
        let predictions = trained.predict(&coords).expect("prediction should succeed");

        assert_eq!(predictions.len(), coords.nrows());
    }

    #[test]
    fn test_spatial_gp_with_variance() {
        let coords = array![[0.0, 0.0], [2.0, 0.0], [0.0, 2.0], [2.0, 2.0]];
        let values = array![1.0, 3.0, 2.0, 4.0];

        let spatial_gp = SpatialGaussianProcessRegressor::builder()
            .spatial_kernel(SpatialKernel::gaussian(2.0, 1.0))
            .kriging_type(KrigingType::Ordinary)
            .build();

        let trained = spatial_gp
            .fit(&coords, &values)
            .expect("model fitting should succeed");

        let test_coords = array![[1.0, 1.0]]; // Center point
        let (predictions, variances) = trained
            .predict_with_variance(&test_coords)
            .expect("operation should succeed");

        assert_eq!(predictions.len(), 1);
        assert_eq!(variances.len(), 1);
        assert!(variances[0] >= 0.0);
    }

    #[test]
    fn test_spatial_kernel_with_nugget() {
        let kernel = SpatialKernel::spherical_with_nugget(1.0, 5.0, 0.1);

        // At distance 0, should include nugget
        assert_abs_diff_eq!(kernel.compute_covariance(0.0), 1.1, epsilon = 1e-10);

        // At non-zero distance, no nugget contribution
        let cov_1 = kernel.compute_covariance(1.0);
        assert!(cov_1 > 0.0 && cov_1 < 1.0);
    }

    #[test]
    fn test_anisotropic_kernel() {
        let base_kernel = SpatialKernel::exponential(1.0, 2.0);
        let anisotropy_matrix = array![[2.0, 0.0], [0.0, 1.0]]; // Stretch in x-direction

        let aniso_kernel = SpatialKernel::anisotropic(base_kernel, anisotropy_matrix);

        let coords = array![[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]];
        let K = aniso_kernel
            .compute_kernel_matrix(&coords, None)
            .expect("operation should succeed");

        assert_eq!(K.shape(), &[3, 3]);
        assert_abs_diff_eq!(
            K[[0, 0]],
            aniso_kernel.compute_covariance(0.0),
            epsilon = 1e-10
        );
    }

    #[test]
    fn test_variogram_model_fitting() {
        let coords = array![[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0], [4.0, 0.0]];
        let values = array![1.0, 1.2, 1.8, 2.1, 2.5];

        let mut variogram =
            Variogram::compute_empirical(&coords, &values, 4).expect("operation should succeed");
        variogram
            .fit_model("spherical")
            .expect("operation should succeed");

        assert!(variogram.fitted_model.is_some());

        let goodness = variogram
            .goodness_of_fit()
            .expect("operation should succeed");
        assert!((0.0..=1.0).contains(&goodness));
    }

    #[test]
    fn test_spatial_outlier_detection() {
        let coords = array![[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]];
        let values = array![1.0, 2.0, 3.0, 10.0]; // Last value is outlier

        let spatial_gp = SpatialGaussianProcessRegressor::builder()
            .spatial_kernel(SpatialKernel::exponential(1.0, 2.0))
            .kriging_type(KrigingType::Ordinary)
            .build();

        let trained = spatial_gp
            .fit(&coords, &values)
            .expect("model fitting should succeed");
        let outliers = trained
            .detect_spatial_outliers(2.0)
            .expect("operation should succeed");

        // Should detect the outlier (index 3)
        assert!(!outliers.is_empty());
    }

    #[test]
    fn test_spatial_cross_validation() {
        let coords = array![[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [0.5, 0.5]];
        let values = array![1.0, 2.0, 1.5, 2.5, 1.8];

        let spatial_gp = SpatialGaussianProcessRegressor::builder()
            .spatial_kernel(SpatialKernel::spherical(1.0, 2.0))
            .kriging_type(KrigingType::Ordinary)
            .build();

        let trained = spatial_gp
            .fit(&coords, &values)
            .expect("model fitting should succeed");
        let cv_error = trained
            .spatial_cross_validation()
            .expect("operation should succeed");

        assert!(cv_error >= 0.0);
    }

    #[test]
    fn test_matern_kernel() {
        let kernel = SpatialKernel::matern(1.0, 2.0, 1.5);

        // Test at distance 0
        assert_abs_diff_eq!(kernel.compute_covariance(0.0), 1.0, epsilon = 1e-10);

        // Test decay properties
        let cov_1 = kernel.compute_covariance(1.0);
        let cov_2 = kernel.compute_covariance(2.0);
        assert!(cov_1 > cov_2);
        assert!(cov_2 > 0.0);
    }

    #[test]
    fn test_correlation_structure() {
        let coords = array![[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]];
        let values = array![1.0, 2.0, 1.5];

        let spatial_gp = SpatialGaussianProcessRegressor::builder()
            .spatial_kernel(SpatialKernel::exponential(1.0, 2.0))
            .kriging_type(KrigingType::Ordinary)
            .build();

        let trained = spatial_gp
            .fit(&coords, &values)
            .expect("model fitting should succeed");
        let (distances, correlations) = trained.correlation_structure(5.0, 10);

        assert_eq!(distances.len(), 10);
        assert_eq!(correlations.len(), 10);
        assert_abs_diff_eq!(correlations[0], 1.0, epsilon = 1e-10); // At distance 0
    }
}