use crate::derivative::{partial_derivative, second_derivative};
use mathverse_core::error::{MathError, MathResult};
pub fn gradient(f: &dyn Fn(&[f64]) -> f64, x: &[f64]) -> Vec<f64> {
(0..x.len()).map(|i| partial_derivative(f, x, i)).collect()
}
pub fn divergence(f: &dyn Fn(&[f64]) -> Vec<f64>, x: &[f64]) -> MathResult<f64> {
let fx = f(x);
if fx.len() != x.len() {
return Err(MathError::DimensionMismatch);
}
Ok((0..x.len())
.map(|i| partial_derivative(&|p: &[f64]| f(p)[i], x, i))
.sum())
}
pub fn curl(f: &dyn Fn(&[f64]) -> Vec<f64>, x: &[f64]) -> MathResult<Vec<f64>> {
if x.len() != 3 {
return Err(MathError::DimensionMismatch);
}
if f(x).len() < 3 {
return Err(MathError::DimensionMismatch);
}
let fz = |p: &[f64]| f(p)[2];
let fy = |p: &[f64]| f(p)[1];
let fx = |p: &[f64]| f(p)[0];
Ok(vec![
partial_derivative(&fz, x, 1) - partial_derivative(&fy, x, 2),
partial_derivative(&fx, x, 2) - partial_derivative(&fz, x, 0),
partial_derivative(&fy, x, 0) - partial_derivative(&fx, x, 1),
])
}
pub fn laplacian(f: &dyn Fn(&[f64]) -> f64, x: &[f64]) -> f64 {
let scale = x.iter().map(|&xi| xi.abs()).fold(0.0, f64::max).max(1.0);
let mut scratch = x.to_vec();
let h = 1e-3 * scale;
(0..x.len())
.map(|i| {
let val = {
let mut fi = |t: f64| {
scratch[i] = t;
f(&scratch)
};
(fi(x[i] + h) - 2.0 * fi(x[i]) + fi(x[i] - h)) / (h * h)
};
scratch[i] = x[i]; val
})
.sum()
}
pub fn jacobian(f: &dyn Fn(&[f64]) -> Vec<f64>, x: &[f64]) -> Vec<f64> {
let m = f(x).len();
let n = x.len();
let mut j = vec![0.0; m * n];
for i in 0..m {
for j_idx in 0..n {
j[i * n + j_idx] = partial_derivative(&|p: &[f64]| f(p)[i], x, j_idx);
}
}
j
}
pub fn hessian(f: &dyn Fn(&[f64]) -> f64, x: &[f64]) -> Vec<f64> {
let n = x.len();
let mut h = vec![0.0; n * n];
let scale = x.iter().map(|&xi| xi.abs()).fold(0.0, f64::max).max(1.0);
let step = f64::EPSILON.powf(0.25) * scale;
for i in 0..n {
h[i * n + i] = second_derivative(
&|t| {
let mut p = x.to_vec();
p[i] = t;
f(&p)
},
x[i],
);
}
for i in 0..n {
for j in (i + 1)..n {
let mut p1 = x.to_vec();
let mut p2 = x.to_vec();
let mut p3 = x.to_vec();
let mut p4 = x.to_vec();
p1[i] += step;
p1[j] += step;
p2[i] += step;
p2[j] -= step;
p3[i] -= step;
p3[j] += step;
p4[i] -= step;
p4[j] -= step;
let mixed = (f(&p1) - f(&p2) - f(&p3) + f(&p4)) / (4.0 * step * step);
h[i * n + j] = mixed;
h[j * n + i] = mixed; }
}
h
}
pub fn directional_derivative(f: &dyn Fn(&[f64]) -> f64, x: &[f64], v: &[f64]) -> MathResult<f64> {
if v.len() != x.len() {
return Err(MathError::DimensionMismatch);
}
let grad = gradient(f, x);
let norm: f64 = v.iter().map(|&vi| vi * vi).sum::<f64>().sqrt();
if norm == 0.0 {
return Ok(0.0);
}
Ok(grad.iter().zip(v.iter()).map(|(&gi, &vi)| gi * vi / norm).sum())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn gradient_and_laplacian() {
let f = |x: &[f64]| x[0] * x[0] + x[1] * x[1] + x[2] * x[2];
let g = gradient(&f, &[1.0, 2.0, 3.0]);
assert!((g[0] - 2.0).abs() < 1e-6);
assert!((g[1] - 4.0).abs() < 1e-6);
assert!((g[2] - 6.0).abs() < 1e-6);
assert!((laplacian(&f, &[1.0, 2.0, 3.0]) - 6.0).abs() < 1e-4);
}
#[test]
fn divergence_and_curl() {
let f = |x: &[f64]| x.to_vec();
assert!((divergence(&f, &[1.0, 2.0, 3.0]).unwrap() - 3.0).abs() < 1e-6);
let rot = |x: &[f64]| vec![x[1], x[2], x[0]];
let c = curl(&rot, &[1.0, 2.0, 3.0]).unwrap();
assert!(c.iter().all(|&v| (v + 1.0).abs() < 1e-6));
let g = |x: &[f64]| vec![2.0 * x[0], 2.0 * x[1], 2.0 * x[2]];
assert!(curl(&g, &[1.0, 2.0, 3.0]).unwrap().iter().all(|&v| v.abs() < 1e-6));
assert!(curl(&rot, &[1.0, 2.0]).is_err());
assert!(divergence(&|x: &[f64]| vec![x[0]], &[1.0, 2.0]).is_err());
assert!(curl(&|x: &[f64]| vec![x[0]], &[1.0, 2.0, 3.0]).is_err());
assert!(divergence(&|x: &[f64]| vec![x[0], 0.0, 0.0], &[1.0]).is_err());
}
#[test]
fn jacobian_test() {
let f = |x: &[f64]| vec![x[0] * x[1], x[0] + x[1]];
let j = jacobian(&f, &[2.0, 3.0]);
assert!((j[0] - 3.0).abs() < 1e-6);
assert!((j[1] - 2.0).abs() < 1e-6);
assert!((j[2] - 1.0).abs() < 1e-6);
assert!((j[3] - 1.0).abs() < 1e-6);
}
#[test]
fn hessian_test() {
let f = |x: &[f64]| x[0] * x[0] + x[1] * x[1];
let h = hessian(&f, &[1.0, 2.0]);
assert!((h[0] - 2.0).abs() < 1e-4);
assert!((h[1] - 0.0).abs() < 1e-4);
assert!((h[2] - 0.0).abs() < 1e-4);
assert!((h[3] - 2.0).abs() < 1e-4);
let f2 = |x: &[f64]| x[0] * x[1];
let h2 = hessian(&f2, &[3.0, 4.0]);
assert!((h2[1] - 1.0).abs() < 1e-4 && (h2[2] - 1.0).abs() < 1e-4);
assert!((h2[1] - h2[2]).abs() < 1e-12);
}
#[test]
fn directional_derivative_test() {
let f = |x: &[f64]| x[0] * x[0] + x[1] * x[1];
let v = vec![1.0, 0.0];
assert!((directional_derivative(&f, &[1.0, 2.0], &v).unwrap() - 2.0).abs() < 1e-6);
let v2 = vec![0.0, 1.0];
assert!((directional_derivative(&f, &[1.0, 2.0], &v2).unwrap() - 4.0).abs() < 1e-6);
assert!((directional_derivative(&f, &[1.0, 2.0], &[0.0, 0.0]).unwrap()).abs() < 1e-10);
assert!(directional_derivative(&f, &[1.0, 2.0], &[1.0]).is_err());
}
}