use eunomia::FloatElement;
use leto::{Array2, Array3, ArrayView2, ArrayView3};
#[must_use]
pub fn bilinear_index_space<T>(field: ArrayView2<T>, ix: T, iy: T) -> T
where
T: FloatElement + Copy,
{
let [nx, ny] = field.shape();
let (i, dxf) = axis_index_and_frac::<T>(ix, nx);
let (j, dyf) = axis_index_and_frac::<T>(iy, ny);
let i1 = if nx <= 1 { i } else { i + 1 };
let j1 = if ny <= 1 { j } else { j + 1 };
let c00 = field[[i, j]];
let c10 = field[[i1, j]];
let c01 = field[[i, j1]];
let c11 = field[[i1, j1]];
let row0 = lerp(c00, c10, dxf);
let row1 = lerp(c01, c11, dxf);
lerp(row0, row1, dyf)
}
#[must_use]
#[inline]
pub fn bilinear<T>(field: &Array2<T>, ix: T, iy: T) -> T
where
T: FloatElement + Copy,
{
bilinear_index_space(field.view(), ix, iy)
}
#[must_use]
pub fn trilinear_index_space<T>(field: ArrayView3<T>, ix: T, iy: T, iz: T) -> T
where
T: FloatElement + Copy,
{
let [nx, ny, nz] = field.shape();
let (i, dxf) = axis_index_and_frac::<T>(ix, nx);
let (j, dyf) = axis_index_and_frac::<T>(iy, ny);
let (k, dzf) = axis_index_and_frac::<T>(iz, nz);
let i1 = if nx <= 1 { i } else { i + 1 };
let j1 = if ny <= 1 { j } else { j + 1 };
let k1 = if nz <= 1 { k } else { k + 1 };
let c000 = field[[i, j, k]];
let c100 = field[[i1, j, k]];
let c010 = field[[i, j1, k]];
let c110 = field[[i1, j1, k]];
let c001 = field[[i, j, k1]];
let c101 = field[[i1, j, k1]];
let c011 = field[[i, j1, k1]];
let c111 = field[[i1, j1, k1]];
let c00 = lerp(c000, c100, dxf);
let c10 = lerp(c010, c110, dxf);
let c01 = lerp(c001, c101, dxf);
let c11 = lerp(c011, c111, dxf);
let c0 = lerp(c00, c10, dyf);
let c1 = lerp(c01, c11, dyf);
lerp(c0, c1, dzf)
}
#[must_use]
#[inline]
pub fn trilinear<T>(field: &Array3<T>, ix: T, iy: T, iz: T) -> T
where
T: FloatElement + Copy,
{
trilinear_index_space(field.view(), ix, iy, iz)
}
#[inline]
fn axis_index_and_frac<T: FloatElement + Copy>(v: T, n: usize) -> (usize, T) {
if n <= 1 {
return (0, T::ZERO);
}
let max_idx = n - 2; let clamped = v.max_scalar(T::ZERO).min_scalar(T::from_count(n - 1));
let fl = clamped.floor();
let idx = (fl.to_f64() as usize).min(max_idx);
let frac = (clamped - T::from_count(idx))
.max_scalar(T::ZERO)
.min_scalar(T::ONE);
(idx, frac)
}
#[inline]
fn lerp<T: FloatElement + Copy>(a: T, b: T, t: T) -> T {
a * (T::ONE - t) + b * t
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bilinear_exact_at_corners() {
let mut f = Array2::<f64>::zeros([2, 2]);
f[[0, 0]] = 1.0;
f[[1, 0]] = 2.0;
f[[0, 1]] = 3.0;
f[[1, 1]] = 4.0;
assert!((bilinear_index_space(f.view(), 0.0, 0.0) - 1.0).abs() < 1e-14);
assert!((bilinear_index_space(f.view(), 1.0, 0.0) - 2.0).abs() < 1e-14);
assert!((bilinear_index_space(f.view(), 0.0, 1.0) - 3.0).abs() < 1e-14);
assert!((bilinear_index_space(f.view(), 1.0, 1.0) - 4.0).abs() < 1e-14);
}
#[test]
fn bilinear_mid_quad_is_average() {
let mut f = Array2::<f64>::zeros([2, 2]);
f[[0, 0]] = 1.0;
f[[1, 0]] = 2.0;
f[[0, 1]] = 3.0;
f[[1, 1]] = 4.0;
assert!((bilinear_index_space(f.view(), 0.5, 0.5) - 2.5).abs() < 1e-14);
}
#[test]
fn bilinear_degenerate_y_axis() {
let mut f = Array2::<f64>::zeros([4, 1]);
for i in 0..4 {
f[[i, 0]] = i as f64;
}
assert!((bilinear_index_space(f.view(), 1.5, 0.0) - 1.5).abs() < 1e-14);
}
#[test]
fn trilinear_constant_field() {
let f = Array3::<f64>::from_elem([5, 4, 3], 7.0);
assert!((trilinear_index_space(f.view(), 2.3, 1.7, 0.5) - 7.0).abs() < 1e-14);
}
#[test]
fn trilinear_linear_field_exact() {
let mut f = Array3::<f64>::zeros([5, 5, 5]);
for i in 0..5usize {
for j in 0..5usize {
for k in 0..5usize {
f[[i, j, k]] = i as f64 + 2.0 * j as f64 + 3.0 * k as f64;
}
}
}
assert!((trilinear_index_space(f.view(), 1.5, 2.5, 0.5) - 8.0).abs() < 1e-12);
}
#[test]
fn trilinear_degenerate_y_z_axes() {
let mut f = Array3::<f64>::zeros([8, 1, 1]);
for i in 0..8usize {
f[[i, 0, 0]] = i as f64;
}
for i in 0..7usize {
let v = trilinear_index_space(f.view(), i as f64 + 0.5, 0.0, 0.0);
assert!((v - (i as f64 + 0.5)).abs() < 1e-12, "i={i} got {v}");
}
}
#[test]
fn trilinear_clamped_oob() {
let f = Array3::<f64>::from_elem([4, 4, 4], 1.0);
let v = trilinear_index_space(f.view(), -2.0, 100.0, 3.5_f64);
assert!((v - 1.0).abs() < 1e-14);
}
}