// SPDX-License-Identifier: AGPL-3.0-or-later
// Legendre polynomials Pₙ(x) and associated Legendre functions Pₙᵐ(x) — f64 precision
// Uses three-term recurrence relations:
// P₀(x) = 1
// P₁(x) = x
// (n+1)Pₙ₊₁(x) = (2n+1)x·Pₙ(x) - n·Pₙ₋₁(x)
//
// Associated Legendre Pₙᵐ(x) uses Condon-Shortley phase convention.
//
// Applications: angular momentum, spherical harmonics, multipole expansion
// Reference: Abramowitz & Stegun §8.5, DLMF §14
//
// **f64 precision**: Required for high-order terms in scientific computing
@group(0) @binding(0) var<storage, read> input: array<f64>;
@group(0) @binding(1) var<storage, read_write> output: array<f64>;
@group(0) @binding(2) var<uniform> params: Params;
struct Params {
size: u32,
n: u32, // Degree (0, 1, 2, ...)
m: u32, // Order for associated Legendre (0 for regular Pₙ)
is_assoc: u32, // 0 = regular Legendre Pₙ(x), 1 = associated Pₙᵐ(x)
}
// Double factorial (2m-1)!! = 1*3*5*...*(2m-1)
fn double_factorial(m: u32) -> f64 {
if (m == 0u) {
return f64(1.0);
}
var r: f64 = f64(1.0);
for (var k = 1u; k <= m; k = k + 1u) {
let term = 2u * k - 1u;
r = r * f64(term);
}
return r;
}
// Regular Legendre polynomial Pₙ(x)
fn legendre(n: u32, x: f64) -> f64 {
if (n == 0u) {
return f64(1.0);
}
if (n == 1u) {
return x;
}
var p_prev: f64 = f64(1.0); // P₀
var p_curr: f64 = x; // P₁
for (var k = 1u; k < n; k = k + 1u) {
let k_f64 = f64(k);
let p_next = ((f64(2.0) * k_f64 + f64(1.0)) * x * p_curr - k_f64 * p_prev) / (k_f64 + f64(1.0));
p_prev = p_curr;
p_curr = p_next;
}
return p_curr;
}
// Associated Legendre function Pₙᵐ(x) with Condon-Shortley phase
fn assoc_legendre(n: u32, m: u32, x: f64) -> f64 {
if (m > n) {
return f64(0.0);
}
if (m == 0u) {
return legendre(n, x);
}
// Compute (1 - x²)^(m/2)
let sin_sq = f64(1.0) - x * x;
if (sin_sq <= f64(0.0)) {
return f64(0.0); // x = ±1, Pₙᵐ = 0 for m > 0
}
let sin_theta_m = pow(sqrt(sin_sq), f64(m));
// P_m^m = (-1)^m (2m-1)!! (1-x²)^(m/2) [Condon-Shortley]
var pmm = double_factorial(m) * sin_theta_m;
if (m % 2u == 1u) {
pmm = -pmm;
}
if (n == m) {
return pmm;
}
// P_{m+1}^m = x(2m+1) P_m^m
let term_2m1 = 2u * m + 1u;
var pm1m = x * f64(term_2m1) * pmm;
if (n == m + 1u) {
return pm1m;
}
// Upward recurrence for l = m+2, ..., n
var pl_minus2 = pmm;
var pl_minus1 = pm1m;
for (var l = m + 2u; l <= n; l = l + 1u) {
let l_f64 = f64(l);
let m_f64 = f64(m);
let pl = ((f64(2.0) * l_f64 - f64(1.0)) * x * pl_minus1 - (l_f64 + m_f64 - f64(1.0)) * pl_minus2) / (l_f64 - m_f64);
pl_minus2 = pl_minus1;
pl_minus1 = pl;
}
return pl_minus1;
}
@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
let idx = global_id.x;
if (idx >= params.size) {
return;
}
let x = input[idx];
if (params.is_assoc == 0u) {
output[idx] = legendre(params.n, x);
} else {
output[idx] = assoc_legendre(params.n, params.m, x);
}
}