solvr 0.2.0

Advanced computing library for real-world problem solving - optimization, differential equations, interpolation, statistics, and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Rect bivariate spline trait — tensor-product B-spline on rectangular grid.
use crate::DType;

use crate::interpolate::error::InterpolateResult;
use crate::interpolate::traits::bspline::BSplineBoundary;
use numr::runtime::Runtime;
use numr::tensor::Tensor;

/// A fitted tensor-product bivariate B-spline on a rectangular grid.
///
/// Represents `S(x,y) = Σᵢ Σⱼ cᵢⱼ Bᵢ(x) Bⱼ(y)` where Bᵢ, Bⱼ are 1D B-spline
/// basis functions along x and y axes respectively.
#[derive(Debug, Clone)]
pub struct BivariateSpline<R: Runtime<DType = DType>> {
    /// Knot vector for x-axis, shape `[n_knots_x]`.
    pub knots_x: Tensor<R>,
    /// Knot vector for y-axis, shape `[n_knots_y]`.
    pub knots_y: Tensor<R>,
    /// Coefficient matrix, shape `[n_coeffs_x, n_coeffs_y]`.
    pub coefficients: Tensor<R>,
    /// Polynomial degree along x-axis.
    pub degree_x: usize,
    /// Polynomial degree along y-axis.
    pub degree_y: usize,
}

/// Algorithms for tensor-product B-spline interpolation on rectangular grids.
///
/// Given a regular grid of (x, y) values and corresponding z values,
/// fits a smooth bivariate B-spline surface. Supports evaluation,
/// partial derivatives, and integration over rectangular domains.
pub trait RectBivariateSplineAlgorithms<R: Runtime<DType = DType>> {
    /// Fit a tensor-product B-spline to data on a rectangular grid.
    ///
    /// # Arguments
    /// * `x` - 1D tensor of x coordinates, shape `[nx]`, strictly increasing
    /// * `y` - 1D tensor of y coordinates, shape `[ny]`, strictly increasing
    /// * `z` - 2D tensor of values, shape `[nx, ny]`
    /// * `degree_x` - Polynomial degree along x (typically 3)
    /// * `degree_y` - Polynomial degree along y (typically 3)
    /// * `boundary` - Boundary condition for knot vector construction
    #[allow(clippy::too_many_arguments)]
    fn rect_bivariate_spline_fit(
        &self,
        x: &Tensor<R>,
        y: &Tensor<R>,
        z: &Tensor<R>,
        degree_x: usize,
        degree_y: usize,
        boundary: &BSplineBoundary,
    ) -> InterpolateResult<BivariateSpline<R>>;

    /// Evaluate a bivariate spline at query points.
    ///
    /// # Arguments
    /// * `spline` - The fitted bivariate spline
    /// * `xi` - 1D tensor of x query coordinates, shape `[m]`
    /// * `yi` - 1D tensor of y query coordinates, shape `[m]`
    ///
    /// # Returns
    /// 1D tensor of interpolated values, shape `[m]`
    fn rect_bivariate_spline_evaluate(
        &self,
        spline: &BivariateSpline<R>,
        xi: &Tensor<R>,
        yi: &Tensor<R>,
    ) -> InterpolateResult<Tensor<R>>;

    /// Evaluate a bivariate spline on a grid of query points.
    ///
    /// # Arguments
    /// * `spline` - The fitted bivariate spline
    /// * `xi` - 1D tensor of x grid coordinates, shape `[mx]`
    /// * `yi` - 1D tensor of y grid coordinates, shape `[my]`
    ///
    /// # Returns
    /// 2D tensor of interpolated values, shape `[mx, my]`
    fn rect_bivariate_spline_evaluate_grid(
        &self,
        spline: &BivariateSpline<R>,
        xi: &Tensor<R>,
        yi: &Tensor<R>,
    ) -> InterpolateResult<Tensor<R>>;

    /// Evaluate partial derivative of a bivariate spline at query points.
    ///
    /// # Arguments
    /// * `spline` - The fitted bivariate spline
    /// * `xi` - 1D tensor of x query coordinates, shape `[m]`
    /// * `yi` - 1D tensor of y query coordinates, shape `[m]`
    /// * `dx` - Derivative order in x direction
    /// * `dy` - Derivative order in y direction
    fn rect_bivariate_spline_partial_derivative(
        &self,
        spline: &BivariateSpline<R>,
        xi: &Tensor<R>,
        yi: &Tensor<R>,
        dx: usize,
        dy: usize,
    ) -> InterpolateResult<Tensor<R>>;

    /// Integrate the bivariate spline over a rectangular domain [xa, xb] × [ya, yb].
    fn rect_bivariate_spline_integrate(
        &self,
        spline: &BivariateSpline<R>,
        xa: f64,
        xb: f64,
        ya: f64,
        yb: f64,
    ) -> InterpolateResult<Tensor<R>>;
}