Struct LocalPolynomialRegression 

pub struct LocalPolynomialRegression<F>
where
    F: Float + FromPrimitive + Debug,
{ /* private fields */ }

Local Polynomial Regression model

This model fits a polynomial of specified degree locally around each prediction point using weighted least squares. The weights depend on the distance between the prediction point and the data points.

The implementation includes:

• Multiple weight function options
• Polynomial basis options (constant, linear, quadratic)
• Standard error estimates
• Optional confidence intervals
• Local R² and effective degrees of freedom
• Support for robust standard errors

Examples

use scirs2_core::ndarray::{Array1, Array2, Axis};
use scirs2_interpolate::local::polynomial::{
    LocalPolynomialRegression, LocalPolynomialConfig
};
use scirs2_interpolate::local::mls::{WeightFunction, PolynomialBasis};

// Create some 1D data with noise
let x = Array1::<f64>::linspace(0.0, 10.0, 50);
let mut y = Array1::<f64>::zeros(50);
for (i, x_val) in x.iter().enumerate() {
    // y = sin(x) + some noise
    y[i] = x_val.sin() + 0.1 * 0.3;
}

// Create a 2D array of points
let points = x.clone().insert_axis(Axis(1));

// Configure and create the local polynomial regression model
let config = LocalPolynomialConfig::<f64> {
    bandwidth: 1.0,
    weight_fn: WeightFunction::Gaussian,
    basis: PolynomialBasis::Quadratic,
    confidence_level: Some(0.95),
    ..LocalPolynomialConfig::default()
};

let loess = LocalPolynomialRegression::with_config(
    points,
    y,
    config
).unwrap();

// Predict at a new point
let query = Array1::from_vec(vec![5.0]);
let result = loess.fit_at_point(&query.view()).unwrap();

// Access the fitted value
println!("Fitted value: {}", result.value);

// Access confidence interval
if let Some((lower, upper)) = result.confidence_interval {
    println!("95% CI: ({}, {})", lower, upper);
}

Implementations

impl<F> LocalPolynomialRegression<F>

where F: Float + FromPrimitive + Debug,

pub fn response_sd(&self) -> F

Get the precomputed standard deviation of the response

impl<F> LocalPolynomialRegression<F>

where F: Float + FromPrimitive + Debug + 'static,

pub fn new( points: Array2<F>, values: Array1<F>, bandwidth: F, ) -> InterpolateResult<Self>

Create a new LocalPolynomialRegression with default configuration

Arguments

• points - Point coordinates with shape (n_points, n_dims)
• values - Values at each point with shape (n_points,)
• bandwidth - Bandwidth parameter controlling locality (larger = smoother)

Returns

A new LocalPolynomialRegression model

pub fn with_config( points: Array2<F>, values: Array1<F>, config: LocalPolynomialConfig<F>, ) -> InterpolateResult<Self>

Create a new LocalPolynomialRegression with custom configuration

Arguments

• points - Point coordinates with shape (n_points, n_dims)
• values - Values at each point with shape (n_points,)
• config - Configuration for the regression

Returns

A new LocalPolynomialRegression model

pub fn fit_at_point( &self, x: &ArrayView1<'_, F>, ) -> InterpolateResult<RegressionResult<F>>

Fit the local polynomial regression at a given point

Arguments

• x - Query point with shape (n_dims,)

Returns

Regression result at the query point

pub fn fit_multiple( &self, points: &ArrayView2<'_, F>, ) -> InterpolateResult<Array1<F>>

Fit the local polynomial regression at multiple points

Arguments

• points - Query points with shape (n_points, n_dims)

Returns

Array of fitted values at the query points

pub fn config(&self) -> &LocalPolynomialConfig<F>

Get the configuration used by this local polynomial regression

pub fn points(&self) -> &Array2<F>

Get the points used by this local polynomial regression

pub fn values(&self) -> &Array1<F>

Get the values used by this local polynomial regression

pub fn select_bandwidth(&self, bandwidths: &[F]) -> InterpolateResult<F>

Compute the optimal bandwidth using leave-one-out cross-validation

Arguments

• bandwidths - Array of bandwidths to evaluate

Returns

The bandwidth that minimizes prediction error in cross-validation

Trait Implementations

impl<F> Clone for LocalPolynomialRegression<F>

where F: Float + FromPrimitive + Debug + Clone,

fn clone(&self) -> LocalPolynomialRegression<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F> Debug for LocalPolynomialRegression<F>

where F: Float + FromPrimitive + Debug + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.