splinefit 0.4.1

B-spline curve and surface fitting — pure-Rust Dierckx engine with ergonomic API
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

# splinefit

B-spline curve fitting for Python, powered by a native Rust engine. Fit smoothing, interpolating, or cardinal cubic splines to data and evaluate, integrate, or find roots -- with the same numerical accuracy as SciPy's FITPACK, at native speed.

Built from a pure-Rust translation of Paul Dierckx' classic [FITPACK](http://www.netlib.org/dierckx/) library (the same Fortran engine behind SciPy's `splrep`/`splev`).

## Installation

```sh
pip install splinefit
```

Requires Python >= 3.9 and NumPy.

## Quick start

```python
import numpy as np
from splinefit import CubicSpline

# Sample data: sin(x) on [0, 2pi]
x = np.linspace(0, 2 * np.pi, 50)
y = np.sin(x)

# Fit a smoothing spline (rms = 0.05)
spline = CubicSpline.smoothing(x, y, rms=0.05)
print(spline)  # CubicSpline(num_knots=11, domain=[0.000000, 6.283185])

# Evaluate at 200 points
x_new = np.linspace(0, 2 * np.pi, 200)
y_fit = spline.evaluate(x_new)
```

## API

### Constructors

All constructors take NumPy arrays (or array-like inputs) for `x` and `y`. `x` must be strictly increasing with at least 4 points.

#### `CubicSpline.smoothing(x, y, rms)`

Fit a smoothing spline. `rms` is the target root-mean-square residual in the same units as `y`. Smaller values produce more knots and a tighter fit.

```python
spline = CubicSpline.smoothing(x, y, rms=0.05)
```

#### `CubicSpline.interpolating(x, y)`

Fit an interpolating spline that passes exactly through every data point.

```python
spline = CubicSpline.interpolating(x, y)
```

#### `CubicSpline.cardinal(x, y, dt)`

Fit a spline on a fixed equidistant knot grid with spacing `dt`.

```python
spline = CubicSpline.cardinal(x, y, dt=0.5)
```

### Methods

#### `spline.evaluate(x) -> numpy.ndarray`

Evaluate the spline at each point in `x`.

```python
y_fit = spline.evaluate(np.array([0.5, 1.0, 1.5]))
```

#### `spline.integral(a, b) -> float`

Compute the definite integral of the spline over `[a, b]`.

```python
area = spline.integral(0, np.pi)  # integral of sin(x) from 0 to pi ~ 2.0
```

#### `spline.roots() -> numpy.ndarray`

Find all interior zeros of the spline, returned in ascending order. Zeros at the domain boundaries may not be included.

```python
zeros = spline.roots()  # e.g. array([3.14159...])
```

#### `spline.knots() -> numpy.ndarray`

Return the knot vector.

#### `spline.coefficients() -> numpy.ndarray`

Return the B-spline coefficients.

#### `spline.num_knots -> int`

Number of knots (property).

### String representation

```python
>>> spline
CubicSpline(num_knots=11, domain=[0.000000, 6.283185])
```

## Comparison with SciPy

`splinefit` uses the same FITPACK algorithms as SciPy but compiled as a native Rust extension rather than wrapping Fortran via `f2py`. The API is simpler:

| splinefit | SciPy equivalent |
|---|---|
| `CubicSpline.smoothing(x, y, rms)` | `splrep(x, y, s=m*rms**2)` |
| `CubicSpline.interpolating(x, y)` | `splrep(x, y, s=0)` |
| `spline.evaluate(x)` | `splev(x, tck)` |
| `spline.integral(a, b)` | `splint(a, b, tck)` |
| `spline.roots()` | `sproot(tck)` |

## How it works

This package is compiled from the Rust crate [`splinefit`](https://crates.io/crates/splinefit) using [PyO3](https://pyo3.rs) and [maturin](https://www.maturin.rs). It runs the same numerical algorithms as SciPy's FITPACK, translated line-by-line from Paul Dierckx' original Fortran into Rust.

## License

Apache-2.0 OR MIT