pub const WGSL_BSPLINE_F64: &str = include_str!("bspline_f64.wgsl");
use std::f64::consts::PI;
#[must_use]
pub fn bspline(order: usize, x: f64) -> f64 {
if order == 0 {
return 0.0;
}
if order == 1 {
return if (0.0..1.0).contains(&x) { 1.0 } else { 0.0 };
}
let order_f = order as f64;
if x <= 0.0 || x >= order_f {
return 0.0;
}
let p = order;
let pm1 = (p - 1) as i32;
let mut factorial = 1.0;
for i in 2..=pm1 {
factorial *= i as f64;
}
let mut sum = 0.0;
for k in 0..=p {
let xmk = x - k as f64;
if xmk > 0.0 {
let sign = if k % 2 == 0 { 1.0 } else { -1.0 };
let binom = binomial(p, k) as f64;
sum = (sign * binom).mul_add(xmk.powi(pm1), sum);
}
}
sum / factorial
}
fn binomial(n: usize, k: usize) -> usize {
if k > n {
return 0;
}
if k == 0 || k == n {
return 1;
}
let k = k.min(n - k); let mut result = 1;
for i in 0..k {
result = result * (n - i) / (i + 1);
}
result
}
#[must_use]
pub fn bspline_deriv(order: usize, x: f64) -> f64 {
if order <= 1 {
return 0.0;
}
bspline(order - 1, x) - bspline(order - 1, x - 1.0)
}
#[derive(Clone, Debug)]
pub struct BsplineCoeffs {
pub order: usize,
pub base_idx: [i32; 3],
pub coeffs: [Vec<f64>; 3],
pub derivs: [Vec<f64>; 3],
}
impl BsplineCoeffs {
#[must_use]
pub fn compute(order: usize, pos: [f64; 3], mesh_dims: [usize; 3], box_dims: [f64; 3]) -> Self {
let mut coeffs = [
Vec::with_capacity(order),
Vec::with_capacity(order),
Vec::with_capacity(order),
];
let mut derivs = [
Vec::with_capacity(order),
Vec::with_capacity(order),
Vec::with_capacity(order),
];
let mut base_idx = [0i32; 3];
let p = order;
for d in 0..3 {
let u = pos[d] / box_dims[d] * mesh_dims[d] as f64;
base_idx[d] = u.floor() as i32 - p as i32 + 1;
for k in 0..p {
let node_pos = (base_idx[d] + k as i32) as f64;
let arg = u - node_pos;
coeffs[d].push(bspline(p, arg));
derivs[d].push(bspline_deriv(p, arg));
}
}
Self {
order,
base_idx,
coeffs,
derivs,
}
}
#[must_use]
pub fn mesh_index(&self, ix: usize, iy: usize, iz: usize, mesh_dims: [usize; 3]) -> [usize; 3] {
[
((self.base_idx[0] + ix as i32).rem_euclid(mesh_dims[0] as i32)) as usize,
((self.base_idx[1] + iy as i32).rem_euclid(mesh_dims[1] as i32)) as usize,
((self.base_idx[2] + iz as i32).rem_euclid(mesh_dims[2] as i32)) as usize,
]
}
#[must_use]
pub fn weight(&self, ix: usize, iy: usize, iz: usize) -> f64 {
self.coeffs[0][ix] * self.coeffs[1][iy] * self.coeffs[2][iz]
}
#[must_use]
pub fn gradient_weights(&self, ix: usize, iy: usize, iz: usize) -> [f64; 3] {
[
self.derivs[0][ix] * self.coeffs[1][iy] * self.coeffs[2][iz],
self.coeffs[0][ix] * self.derivs[1][iy] * self.coeffs[2][iz],
self.coeffs[0][ix] * self.coeffs[1][iy] * self.derivs[2][iz],
]
}
#[must_use]
pub fn weight_sum(&self) -> f64 {
let mut sum = 0.0;
for ix in 0..self.order {
for iy in 0..self.order {
for iz in 0..self.order {
sum += self.weight(ix, iy, iz);
}
}
}
sum
}
#[must_use]
pub fn weight_sum_1d(&self) -> [f64; 3] {
[
self.coeffs[0].iter().sum(),
self.coeffs[1].iter().sum(),
self.coeffs[2].iter().sum(),
]
}
}
#[must_use]
pub fn influence_function(
kx: f64,
ky: f64,
kz: f64,
order: usize,
box_dims: [f64; 3],
mesh_dims: [usize; 3],
) -> f64 {
let k_sq = kz.mul_add(kz, kx.mul_add(kx, ky * ky));
if k_sq < 1e-14 {
return 0.0;
}
let hx = box_dims[0] / mesh_dims[0] as f64;
let hy = box_dims[1] / mesh_dims[1] as f64;
let hz = box_dims[2] / mesh_dims[2] as f64;
let bx = bspline_ft_squared(kx * hx / (2.0 * PI), order);
let by = bspline_ft_squared(ky * hy / (2.0 * PI), order);
let bz = bspline_ft_squared(kz * hz / (2.0 * PI), order);
let denominator = bx * by * bz;
if denominator < 1e-14 {
return 0.0;
}
4.0 * PI / k_sq / denominator
}
fn bspline_ft_squared(xi: f64, order: usize) -> f64 {
if xi.abs() < 1e-10 {
return 1.0;
}
let sinc = (PI * xi).sin() / (PI * xi);
sinc.powi(2 * order as i32)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_bspline_order_1() {
assert!((bspline(1, 0.5) - 1.0).abs() < 1e-10);
assert!(bspline(1, -0.1).abs() < 1e-10);
assert!(bspline(1, 1.1).abs() < 1e-10);
}
#[test]
fn test_bspline_order_2() {
assert!((bspline(2, 1.0) - 1.0).abs() < 1e-10); assert!(bspline(2, 0.0).abs() < 1e-10);
assert!(bspline(2, 2.0).abs() < 1e-10);
assert!((bspline(2, 0.5) - 0.5).abs() < 1e-10);
assert!((bspline(2, 1.5) - 0.5).abs() < 1e-10);
}
#[test]
fn test_bspline_order_4() {
let mid = 2.0;
let v1 = bspline(4, mid - 0.5);
let v2 = bspline(4, mid + 0.5);
assert!((v1 - v2).abs() < 1e-10);
assert!(bspline(4, mid) > bspline(4, mid + 0.5));
}
#[test]
fn test_bspline_partition_of_unity() {
for order in 2..=6 {
let x = 2.37; let mut sum = 0.0;
for n in -5..15 {
sum += bspline(order, x - n as f64);
}
assert!(
(sum - 1.0).abs() < 1e-10,
"Partition of unity failed for order {order}: sum = {sum}"
);
}
}
#[test]
fn test_bspline_coeffs_sum_to_one() {
for order in 2..=6 {
for i in 0..10 {
let pos = [
(i as f64).mul_add(0.73, 0.1),
(i as f64).mul_add(0.91, 0.2),
(i as f64).mul_add(0.67, 0.3),
];
let mesh_dims = [16, 16, 16];
let box_dims = [10.0, 10.0, 10.0];
let coeffs = BsplineCoeffs::compute(order, pos, mesh_dims, box_dims);
let sums = coeffs.weight_sum_1d();
for (d, s) in sums.iter().enumerate() {
assert!(
(s - 1.0).abs() < 1e-10,
"Order {order} dim {d} at {pos:?}: 1D sum = {s} (expected 1)"
);
}
}
}
}
#[test]
fn test_bspline_coeffs_3d_sum() {
let pos = [5.0, 5.0, 5.0];
let mesh_dims = [16, 16, 16];
let box_dims = [10.0, 10.0, 10.0];
for order in 2..=6 {
let coeffs = BsplineCoeffs::compute(order, pos, mesh_dims, box_dims);
let sum = coeffs.weight_sum();
assert!(
(sum - 1.0).abs() < 1e-10,
"Order {order}: 3D sum = {sum} (expected 1)"
);
}
}
#[test]
fn test_influence_function() {
let order = 4;
let box_dims = [10.0, 10.0, 10.0];
let mesh_dims = [16, 16, 16];
assert!(influence_function(0.0, 0.0, 0.0, order, box_dims, mesh_dims).abs() < 1e-10);
let g = influence_function(1.0, 0.0, 0.0, order, box_dims, mesh_dims);
assert!(g > 0.0);
let g1 = influence_function(1.0, 0.0, 0.0, order, box_dims, mesh_dims);
let g2 = influence_function(2.0, 0.0, 0.0, order, box_dims, mesh_dims);
assert!(g2 < g1);
}
}