Simplex Splines on the Powell-Sabin 12-split
SSplines is a Python library for the evaluation of simplex splines over the Powell-Sabin 12-split of a triangle. The library provides efficient evaluation using the matrix recurrence relation for S-spline basis functions for constant, linear, and quadratic simplex splines as developed by Cohen, Lyche and Riesenfeld. The SSplines library was developed as part of the thesis: Simplex Splines on the Powell-Sabin 12-Split.
- SplineFunction objects: Callable spline functions over a single triangle
- SplineSpace objects: Facilitate instantiation of multiple functions in the same spline space
- Evaluation and differentiation: Support for constant, linear, and quadratic simplex splines with convenient shortcuts for gradient, divergence, and Laplacian operators
- Hermite basis conversion: Conversion between quadratic S-spline basis and quadratic Hermite nodal basis for finite element methods
- Triangle sampling: Methods for sampling triangles for evaluation and visualization
- Numerical integration: Basic subdomain integration methods over the Powell-Sabin 12-split for finite element computations
- Polynomial pieces: Methods for returning polynomial restrictions of splines to each of the twelve sub-triangles
- Symbolic computation: Integration with SymPy for exact symbolic calculations
pip install SSplines# Install uv first (if not already installed)
curl -LsSf https://astral.sh/uv/install.sh | sh
# Install SSplines
uv pip install SSplines
# For development with testing and visualization
uv pip install "SSplines[dev]"git clone https://github.com/qTipTip/SSplines
cd SSplines
uv pip install -e ".[dev]"import numpy as np
from SSplines import SplineSpace, SplineFunction
# Define a triangle
triangle = np.array([
[0, 0],
[1, 0],
[0, 1]
])
# Create a quadratic spline space
space = SplineSpace(triangle, degree=2)
# Get the dimension of the space
print(f"Spline space dimension: {space.dimension}") # 12 for quadratic
# Create a spline function with random coefficients
coefficients = np.random.rand(space.dimension)
spline_func = space.function(coefficients)
# Evaluate the spline at points
points = np.array([
[0.3, 0.3],
[0.1, 0.2],
[0.5, 0.1]
])
values = spline_func(points)
print(f"Spline values: {values}")# Get all basis functions
basis_functions = space.basis()
# Evaluate the first basis function
first_basis = basis_functions[0]
value_at_point = first_basis([0.3, 0.3])
# Compute derivatives
gradient = first_basis.grad([0.3, 0.3])
laplacian = first_basis.lapl([0.3, 0.3])# For quadratic splines, you can use Hermite basis
hermite_basis = space.hermite_basis()
# Each Hermite basis function corresponds to nodal values or derivatives
h0 = hermite_basis[0] # Value at first vertex
h1 = hermite_basis[1] # x-derivative at first vertex
h2 = hermite_basis[2] # y-derivative at first vertexfrom SSplines.symbolic import polynomial_basis_quadratic
# Get symbolic polynomial representations
symbolic_basis = polynomial_basis_quadratic(triangle)
# Each entry contains the polynomial pieces over the 12 sub-triangles
print(f"Number of polynomial pieces: {len(symbolic_basis[0])}") # 12-
Core dependencies:
numpy≥ 1.24.0: Numerical computationssympy≥ 1.10: Symbolic mathematics
-
Development dependencies:
pytest≥ 7.0.1: Testing frameworkpytest-cov: Test coveragematplotlib≥ 3.5.1: Plotting and visualization
# Clone the repository
git clone https://github.com/qTipTip/SSplines
cd SSplines
# Install in development mode with all dependencies
uv pip install -e ".[dev]"# Run all tests
uv run pytest
# Run with coverage
uv run pytest --cov SSplines/
# Run specific test file
uv run pytest tests/test_spline_function.py -vSSplines/
├── __init__.py # Main module exports
├── constants.py # Mathematical constants and lookup tables
├── helper_functions.py # Core computational functions
├── simplex_spline.py # SimplexSpline class
├── spline_function.py # SplineFunction class
├── spline_space.py # SplineSpace class
├── symbolic.py # Symbolic computation utilities
└── dicts.py # Lookup dictionaries for sub-triangles
The library implements S-splines on the Powell-Sabin 12-split, which divides a triangle into 12 sub-triangles by:
- Adding a point at the centroid
- Adding midpoints on each edge
- Connecting these points to create 12 sub-triangles
The S-splines are defined using a matrix recurrence relation that allows efficient evaluation without explicit polynomial representation. This approach is particularly useful for:
- Finite element methods
- Computer-aided geometric design
- Approximation theory
- Scientific computing applications requiring smooth basis functions
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
This project is licensed under the MIT License - see the LICENSE file for details.
If you use SSplines in your research, please cite the original theoretical work and the software implementation:
Original S-splines theory:
@article{cohen2013splines,
title={S-splines},
author={Cohen, Elaine and Lyche, Tom and Riesenfeld, Richard},
journal={Mathematics of Computation},
volume={82},
number={283},
pages={1577--1596},
year={2013},
doi={10.1090/S0025-5718-2013-02664-6}
}SSplines software and implementation:
@mastersthesis{stangeby2018ssplines,
title={Simplex Splines on the Powell-Sabin 12-Split},
author={Stangeby, Ivar Haugal{\o}kken},
school={University of Oslo},
year={2018},
url={http://hdl.handle.net/10852/64070},
urn={URN:NBN:no-66606}
}Software repository:
@software{stangeby2024ssplines,
title={SSplines: Simplex Splines on the Powell-Sabin 12-split},
author={Stangeby, Ivar},
year={2024},
doi={10.5281/zenodo.15742326},
url={https://github.com/qTipTip/SSplines}
}Ivar Stangeby - [email protected]