#![expect(
clippy::unwrap_used,
reason = "test code: unwraps on fixed fixtures are the floor's test exemption"
)]
use super::super::*;
use leto::Array3;
#[test]
fn central2_x_of_linear_function_is_exact() {
let dx = 0.1;
let op = FiniteDifference3D::<f64>::central_second_order(dx, dx, dx).unwrap();
let mut field = Array3::zeros([20, 5, 5]);
for i in 0..20 {
for j in 0..5 {
for k in 0..5 {
field[[i, j, k]] = 3.7 * (i as f64) * dx + 0.2 * (j as f64) * dx;
}
}
}
let mut g = Array3::zeros([20, 5, 5]);
op.apply_x_into(field.view(), &mut g.view_mut()).unwrap();
for i in 0..20 {
assert!((g[[i, 2, 2]] - 3.7).abs() < 1e-12, "i={i}");
}
}
#[test]
fn central4_x_of_quadratic_is_exact() {
let dx = 0.1;
let op = FiniteDifference3D::<f64>::central_fourth_order(dx, dx, dx).unwrap();
let mut field = Array3::zeros([20, 5, 5]);
for i in 0..20 {
let x = (i as f64) * dx;
for j in 0..5 {
for k in 0..5 {
field[[i, j, k]] = x * x;
}
}
}
let mut g = Array3::zeros([20, 5, 5]);
op.apply_x_into(field.view(), &mut g.view_mut()).unwrap();
for i in 2..18 {
let x = (i as f64) * dx;
assert!((g[[i, 2, 2]] - 2.0 * x).abs() < 1e-12, "i={i}");
}
}
#[test]
fn central6_x_of_quartic_polynomial_is_exact() {
let dx = 0.1;
let op = FiniteDifference3D::<f64>::central_sixth_order(dx, dx, dx).unwrap();
let mut field = Array3::zeros([20, 5, 5]);
for i in 0..20 {
let x = (i as f64) * dx;
for j in 0..5 {
for k in 0..5 {
field[[i, j, k]] = x.powi(4);
}
}
}
let mut g = Array3::zeros([20, 5, 5]);
op.apply_x_into(field.view(), &mut g.view_mut()).unwrap();
for i in 3..17 {
let x = (i as f64) * dx;
let expected = 4.0 * x.powi(3);
assert!((g[[i, 2, 2]] - expected).abs() < 1e-10, "i={i}");
}
}
#[test]
fn central2_y_of_linear_function_is_exact() {
let dx = 0.1;
let op = FiniteDifference3D::<f64>::central_second_order(dx, dx, dx).unwrap();
let mut field = Array3::zeros([5, 20, 5]);
for i in 0..5 {
for j in 0..20 {
for k in 0..5 {
field[[i, j, k]] = 2.5 * (j as f64) * dx + 0.7 * (i as f64) * dx;
}
}
}
let mut g = Array3::zeros([5, 20, 5]);
op.apply_y_into(field.view(), &mut g.view_mut()).unwrap();
for j in 0..20 {
assert!((g[[2, j, 2]] - 2.5).abs() < 1e-12, "j={j}");
}
}
#[test]
fn central4_z_of_quadratic_is_exact() {
let dx = 0.1;
let op = FiniteDifference3D::<f64>::central_fourth_order(dx, dx, dx).unwrap();
let mut field = Array3::zeros([5, 5, 20]);
for i in 0..5 {
for j in 0..5 {
for k in 0..20 {
let z = (k as f64) * dx;
field[[i, j, k]] = z * z;
}
}
}
let mut g = Array3::zeros([5, 5, 20]);
op.apply_z_into(field.view(), &mut g.view_mut()).unwrap();
for k in 2..18 {
let z = (k as f64) * dx;
assert!((g[[2, 2, k]] - 2.0 * z).abs() < 1e-12, "k={k}");
}
}
#[test]
fn central6_z_linear_function_is_exact() {
let dx = 0.1;
let op = FiniteDifference3D::<f64>::central_sixth_order(dx, dx, dx).unwrap();
let mut field = Array3::zeros([5, 5, 20]);
for i in 0..5 {
for j in 0..5 {
for k in 0..20 {
let z = (k as f64) * dx;
field[[i, j, k]] = 4.0 * z;
}
}
}
let mut g = Array3::zeros([5, 5, 20]);
op.apply_z_into(field.view(), &mut g.view_mut()).unwrap();
for k in 0..20 {
assert!((g[[2, 2, k]] - 4.0).abs() < 1e-12, "k={k}");
}
}
#[test]
fn central6_x_boundary_fall_back_orders() {
let dx = 0.1;
let op = FiniteDifference3D::<f64>::central_sixth_order(dx, dx, dx).unwrap();
let nx = 12_usize;
let mut field = Array3::zeros([nx, 5, 5]);
for i in 0..nx {
let x = (i as f64) * dx;
for j in 0..5 {
for k in 0..5 {
field[[i, j, k]] = x.powi(5);
}
}
}
let mut g = Array3::zeros([nx, 5, 5]);
op.apply_x_into(field.view(), &mut g.view_mut()).unwrap();
let x_interior = 6.0 * dx;
let exact_interior: f64 = 5.0 * x_interior.powi(4);
assert!(
(g[[interior_i(6), 2, 2]] - exact_interior).abs() < 1e-10,
"interior mismatch"
);
let x_near = 2.0 * dx;
let exact_near: f64 = 5.0 * x_near.powi(4);
let err_near = (g[[2, 2, 2]] - exact_near).abs();
let err_coefficient = err_near / dx.powi(4);
assert!(
err_coefficient > 1.0 && err_coefficient < 10.0,
"4th-order fall-back O(h⁴) error coefficient out of expected band: {err_coefficient}"
);
let x_nb1 = 1.0 * dx;
let exact_nb1: f64 = 5.0 * x_nb1.powi(4);
let err_nb1 = (g[[1, 2, 2]] - exact_nb1).abs();
let err_coefficient_2nd = err_nb1 / dx.powi(2);
assert!(
err_coefficient_2nd > 0.1,
"2nd-order fall-back O(h²) error coefficient too small: {err_coefficient_2nd}"
);
let computed_boundary = (field[[1, 2, 2]] - field[[0, 2, 2]]) / dx;
assert!(
(g[[0, 2, 2]] - computed_boundary).abs() < 1e-12,
"1st-order forward fall-back must return (f[1]-f[0])/dx at i=0"
);
assert!(
(g[[0, 2, 2]] - 1e-4).abs() < 1e-12,
"quintic 1st-order @ origin must equal dx⁴ = 1e-4"
);
}
fn interior_i(_idx: usize) -> usize {
6
}