#[must_use]
pub fn legendre(n: usize, x: f64) -> f64 {
if n == 0 {
return 1.0;
}
if n == 1 {
return x;
}
let mut p_prev = 1.0; let mut p_curr = x;
for k in 1..n {
let k_f64 = k as f64;
let p_next =
(2.0f64.mul_add(k_f64, 1.0) * x).mul_add(p_curr, -(k_f64 * p_prev)) / (k_f64 + 1.0);
p_prev = p_curr;
p_curr = p_next;
}
p_curr
}
#[must_use]
pub fn legendre_all(n: usize, x: f64) -> Vec<f64> {
let mut result = Vec::with_capacity(n + 1);
if n == 0 {
result.push(1.0);
return result;
}
result.push(1.0); result.push(x);
for k in 1..n {
let k_f64 = k as f64;
let p_next = (2.0f64.mul_add(k_f64, 1.0) * x).mul_add(result[k], -(k_f64 * result[k - 1]))
/ (k_f64 + 1.0);
result.push(p_next);
}
result
}
#[expect(
clippy::manual_is_multiple_of,
reason = "is_multiple_of is nightly-only (not stable as of MSRV 1.87)"
)]
#[must_use]
pub fn assoc_legendre(n: usize, m: i32, x: f64) -> f64 {
let m_abs = m.unsigned_abs() as usize;
if m_abs > n {
return 0.0;
}
if m == 0 {
return legendre(n, x);
}
let sin_theta = x.mul_add(-x, 1.0).sqrt();
let mut pmm = 1.0;
let mut fact = 1.0;
for _i in 1..=m_abs {
pmm *= -fact * sin_theta;
fact += 2.0;
}
if n == m_abs {
return if m < 0 {
let sign = if m_abs % 2 == 0 { 1.0 } else { -1.0 };
let factor = factorial_ratio(n, m_abs);
sign * factor * pmm
} else {
pmm
};
}
let mut pmmp1 = x * (2 * m_abs + 1) as f64 * pmm;
if n == m_abs + 1 {
return if m < 0 {
let sign = if m_abs % 2 == 0 { 1.0 } else { -1.0 };
let factor = factorial_ratio(n, m_abs);
sign * factor * pmmp1
} else {
pmmp1
};
}
let mut pnm = 0.0;
for l in (m_abs + 2)..=n {
let l_f64 = l as f64;
let m_f64 = m_abs as f64;
pnm = (x * 2.0f64.mul_add(l_f64, -1.0)).mul_add(pmmp1, -((l_f64 + m_f64 - 1.0) * pmm))
/ (l_f64 - m_f64);
pmm = pmmp1;
pmmp1 = pnm;
}
if m < 0 {
let sign = if m_abs % 2 == 0 { 1.0 } else { -1.0 };
let factor = factorial_ratio(n, m_abs);
sign * factor * pnm
} else {
pnm
}
}
fn factorial_ratio(n: usize, m: usize) -> f64 {
let mut result = 1.0;
for k in (n - m + 1)..=(n + m) {
result /= k as f64;
}
result
}
#[must_use]
pub fn legendre_batch(n: usize, x: &[f64]) -> Vec<f64> {
x.iter().map(|&xi| legendre(n, xi)).collect()
}
#[must_use]
pub fn assoc_legendre_batch(n: usize, m: i32, x: &[f64]) -> Vec<f64> {
x.iter().map(|&xi| assoc_legendre(n, m, xi)).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_legendre_p0() {
assert!((legendre(0, 0.0) - 1.0).abs() < 1e-14);
assert!((legendre(0, 0.5) - 1.0).abs() < 1e-14);
assert!((legendre(0, 1.0) - 1.0).abs() < 1e-14);
}
#[test]
fn test_legendre_p1() {
assert!((legendre(1, 0.0) - 0.0).abs() < 1e-14);
assert!((legendre(1, 0.5) - 0.5).abs() < 1e-14);
assert!((legendre(1, 1.0) - 1.0).abs() < 1e-14);
}
#[test]
fn test_legendre_p2() {
assert!((legendre(2, 0.0) - (-0.5)).abs() < 1e-14);
assert!((legendre(2, 0.5) - (-0.125)).abs() < 1e-14);
assert!((legendre(2, 1.0) - 1.0).abs() < 1e-14);
}
#[test]
fn test_legendre_p3() {
assert!((legendre(3, 0.0) - 0.0).abs() < 1e-14);
let p3_half = 5.0f64.mul_add(0.125, -1.5) / 2.0; assert!((legendre(3, 0.5) - p3_half).abs() < 1e-14);
}
#[test]
fn test_legendre_at_one() {
for n in 0..10 {
assert!((legendre(n, 1.0) - 1.0).abs() < 1e-13);
}
}
#[test]
fn test_legendre_at_minus_one() {
for n in 0..10 {
let expected = if n % 2 == 0 { 1.0 } else { -1.0 };
assert!((legendre(n, -1.0) - expected).abs() < 1e-13);
}
}
#[test]
fn test_legendre_parity() {
let x = 0.3;
for n in 0..8 {
let sign = if n % 2 == 0 { 1.0 } else { -1.0 };
assert!((legendre(n, -x) - sign * legendre(n, x)).abs() < 1e-13);
}
}
#[test]
fn test_legendre_explicit_values() {
assert!((legendre(5, 0.3) - 0.345386).abs() < 1e-5);
assert!((legendre(10, 0.5) - (-0.1882286071777344)).abs() < 1e-10);
}
#[test]
fn test_legendre_all() {
let p = legendre_all(3, 0.5);
assert_eq!(p.len(), 4);
assert!((p[0] - 1.0).abs() < 1e-14);
assert!((p[1] - 0.5).abs() < 1e-14);
assert!((p[2] - (-0.125)).abs() < 1e-14);
}
#[test]
fn test_assoc_legendre_m0() {
for n in 0..5 {
for x in [0.0, 0.3, 0.5, 0.8, 1.0] {
assert!((assoc_legendre(n, 0, x) - legendre(n, x)).abs() < 1e-13);
}
}
}
#[test]
fn test_assoc_legendre_p11() {
let x: f64 = 0.5;
let expected = -x.mul_add(-x, 1.0).sqrt();
assert!((assoc_legendre(1, 1, x) - expected).abs() < 1e-13);
}
#[test]
fn test_assoc_legendre_p21() {
let x: f64 = 0.5;
let expected = -3.0 * x * x.mul_add(-x, 1.0).sqrt();
assert!((assoc_legendre(2, 1, x) - expected).abs() < 1e-13);
}
#[test]
fn test_assoc_legendre_p22() {
let x = 0.5;
let expected = 3.0 * (1.0 - x * x);
assert!((assoc_legendre(2, 2, x) - expected).abs() < 1e-13);
}
#[test]
fn test_assoc_legendre_recurrence() {
assert!((assoc_legendre(3, 2, 0.5) - 5.625).abs() < 1e-7);
}
#[test]
fn test_assoc_legendre_m_greater_n() {
assert_eq!(assoc_legendre(2, 3, 0.5), 0.0);
assert_eq!(assoc_legendre(1, 5, 0.5), 0.0);
}
#[test]
fn test_legendre_batch() {
let x = vec![0.0, 0.5, 1.0];
let p2 = legendre_batch(2, &x);
assert_eq!(p2.len(), 3);
assert!((p2[0] - (-0.5)).abs() < 1e-14);
assert!((p2[1] - (-0.125)).abs() < 1e-14);
assert!((p2[2] - 1.0).abs() < 1e-14);
}
}