Cubic spline approximation (smoothing) algorithm written in Rust.

csaps is a crate for univariate, multivariate and n-dimensional grid data approximation using cubic smoothing splines. The package can be useful in practical engineering tasks for data approximation and smoothing.

Usage

Univariate data auto-smoothing

use ndarray::{array, Array1};
use csaps::CubicSmoothingSpline;


fn main() {
    let x = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
    let y = vec![2.3, 3.5, 3.3, 1.2, 4.5, 6.2, 5.6, 7.2, 1.5];
    
    let spline = CubicSmoothingSpline::new(&x, &y)
        .make()
        .unwrap();
    
    let xi = Array1::linspace(1., 9., 30);
    let yi = spline.evaluate(&xi).unwrap();
    
    println!("{}", xi);
    println!("{}", yi);
}

Multivariate data smoothing with weights and specified smoothing parameter

use ndarray::{array, Array1};
use csaps::CubicSmoothingSpline;


fn main() {
    let x = array![1., 2., 3., 4.];
    let y = array![[1., 2., 3., 4.], 
                   [5., 6., 7., 8.]];
    let w = array![1., 0.7, 0.5, 1.];
    
    let spline = CubicSmoothingSpline::new(&x, &y)
        .with_weights(&w)
        .with_smooth(0.8)
        .make()
        .unwrap();
    
    let xi = Array1::linspace(1., 4., 10);
    let yi = spline.evaluate(&xi).unwrap();
    
    println!("{}", xi);
    println!("{}", yi);
}

2-d grid (surface) data smoothing

use ndarray::array;
use csaps::GridCubicSmoothingSpline;


fn main() {
    let x0 = array![1.0, 2.0, 3.0, 4.0];
    let x1 = array![1.0, 2.0, 3.0, 4.0];
    let x = vec![x0.view(), x1.view()];
    
    let y = array![
        [0.5, 1.2, 3.4, 2.5],
        [1.5, 2.2, 4.4, 3.5],
        [2.5, 3.2, 5.4, 4.5],
        [3.5, 4.2, 6.4, 5.5],
    ];
    
    let yi = GridCubicSmoothingSpline::new(&x, &y)
     .with_smooth_fill(0.5)
     .make().unwrap()
     .evaluate(&x).unwrap();
    
    println!("xi: {:?}", xi);
    println!("yi: {}", yi);
}

Performance 问题

Currently, the performance of computation of smoothing splines might be very low for a large data.

The algorithm of sparse matrices mutliplication in sprs crate is not optimized for large diagonal matrices which causes a poor performance of computation of smoothing splines. See issue for details.

Algorithms and implementations

The crate implementation is based on ndarray and sprs crates and has been inspired by Fortran routine SMOOTH from PGS (originally written by Carl de Boor).

The implementation of the algorithm in other languages:

• Python NumPy/SciPy based implementation
• C++11 Eigen based implementation

References

• C. de Boor, A Practical Guide to Splines, Springer-Verlag, 1978.

License

MIT