use crate::Complex;
pub struct ComplexSpecialFunctions;
impl ComplexSpecialFunctions {
pub fn gamma(z: Complex) -> Complex {
const P: [f64; 9] = [
0.99999999999980993,
676.5203681218851,
-1259.1392167224028,
771.32342877765313,
-176.61502916214059,
12.507343278686905,
-0.13857109526572012,
9.9843695780195716e-6,
1.5056327351493116e-7,
];
if z.re < 0.5 {
let pi = Complex::new(std::f64::consts::PI, 0.0);
let sin_pi_z = (pi * z).sin();
let gamma_reflected = Self::gamma(Complex::one() - z);
return pi / (sin_pi_z * gamma_reflected);
}
let z_minus_1 = z - Complex::one();
let mut x = Complex::real(P[0]);
for i in 1..P.len() {
let coeff = Complex::real(P[i]);
let denominator = z_minus_1 + Complex::real(i as f64);
x = x + coeff / denominator;
}
let sqrt_2pi = (2.0 * std::f64::consts::PI).sqrt();
let t = z_minus_1 + Complex::real((P.len() - 2) as f64) + Complex::real(0.5);
let sqrt_2pi_t = Complex::real(sqrt_2pi) * t.pow(z - Complex::real(0.5));
let exp_t = (-t).exp();
sqrt_2pi_t * exp_t * x
}
pub fn digamma(z: Complex) -> Complex {
if z.norm() >= 10.0 {
let inv_z = Complex::one() / z;
let inv_z2 = inv_z * inv_z;
let inv_z4 = inv_z2 * inv_z2;
let term2 = inv_z2 / Complex::real(12.0);
let term4 = inv_z4 / Complex::real(120.0);
let term6 = inv_z2 * inv_z4 / Complex::real(252.0);
z.ln() - Complex::real(0.5) * inv_z - term2 + term4 - term6
} else {
let mut n = 0;
let mut z_shifted = z;
while z_shifted.norm() < 10.0 && n < 100 {
z_shifted = z_shifted + Complex::one();
n += 1;
}
let psi_shifted = Self::digamma(z_shifted);
let mut result = psi_shifted;
for k in 0..n {
result = result - Complex::one() / (z + Complex::real(k as f64));
}
result
}
}
pub fn zeta(z: Complex, iterations: usize) -> Complex {
if z.re < 0.0 {
let s = z;
let pi = Complex::new(std::f64::consts::PI, 0.0);
let factor = Complex::real(2.0).pow(s)
* pi.pow(s - Complex::one())
* (pi * s / Complex::real(2.0)).sin()
* Self::gamma(Complex::one() - s);
return factor * Self::zeta(Complex::one() - s, iterations);
}
Self::zeta_euler_maclaurin(z, iterations)
}
fn zeta_euler_maclaurin(s: Complex, n_terms: usize) -> Complex {
const BERNOULLI: [f64; 6] = [
1.0 / 6.0,
-1.0 / 30.0,
1.0 / 42.0,
-1.0 / 30.0,
5.0 / 66.0,
-691.0 / 2730.0,
];
let n = n_terms.max(10) as f64;
let n_c = Complex::real(n);
let mut sum = Complex::zero();
for k in 1..n as usize {
sum = sum + Complex::real(k as f64).pow(-s);
}
sum = sum + n_c.pow(Complex::one() - s) / (s - Complex::one()) + n_c.pow(-s) / Complex::real(2.0);
for (i, &b) in BERNOULLI.iter().enumerate() {
let k2 = 2 * (i + 1);
let mut rising = s;
for j in 1..k2 - 1 {
rising = rising * (s + Complex::real(j as f64));
}
let mut factorial = 1.0;
for j in 2..=k2 {
factorial *= j as f64;
}
let term = Complex::real(b) * rising / Complex::real(factorial)
* n_c.pow(-s - Complex::real((k2 - 1) as f64));
sum = sum + term;
}
sum
}
pub fn polylog(s: Complex, z: Complex, iterations: usize) -> Complex {
if z.norm() < 1.0 {
let mut sum = Complex::zero();
for n in 1..=iterations {
let n_complex = Complex::real(n as f64);
let term = z.pow(n_complex) / n_complex.pow(s);
sum = sum + term;
}
sum
} else if z.norm() > 1.0 {
let log_minus_z = (Complex::one() - z).ln();
let mut sum = Complex::zero();
for k in 0..=iterations {
let k_complex = Complex::real(k as f64);
let binomial = Self::binomial_coefficient_complex(s + k_complex - Complex::one(), k_complex);
let term = binomial * (log_minus_z).pow(k_complex) * Self::zeta(s + k_complex, 50);
if k % 2 == 0 {
sum = sum + term;
} else {
sum = sum - term;
}
}
sum
} else {
Complex::zero()
}
}
fn binomial_coefficient_complex(z: Complex, k: Complex) -> Complex {
let numerator = Self::gamma(z + Complex::one());
let denominator = Self::gamma(k + Complex::one()) * Self::gamma(z - k + Complex::one());
numerator / denominator
}
pub fn erf(z: Complex, iterations: usize) -> Complex {
let mut sum = Complex::zero();
let _z2 = z * z;
for n in 0..=iterations {
let _n_complex = Complex::real(n as f64);
let sign = if n % 2 == 0 { Complex::one() } else { -Complex::one() };
let factorial: f64 = (1..=n).map(|x| x as f64).product();
let denominator = Complex::real((2 * n + 1) as f64 * factorial);
let term = sign * z.pow(Complex::real((2 * n + 1) as f64)) / denominator;
sum = sum + term;
}
sum * Complex::new(2.0 / std::f64::consts::PI.sqrt(), 0.0)
}
pub fn erfc(z: Complex, iterations: usize) -> Complex {
Complex::one() - Self::erf(z, iterations)
}
pub fn exponential_integral(z: Complex, iterations: usize) -> Complex {
if z.norm() < 20.0 {
let mut sum = Complex::real(0.57721566490153286060651209008240243104215933593992); sum = sum + z.ln();
for n in 1..=iterations {
let n_complex = Complex::real(n as f64);
let factorial: f64 = (1..=n).map(|x| x as f64).product();
sum = sum + z.pow(n_complex) / (n_complex * Complex::real(factorial));
}
sum
} else {
let inv_z = Complex::one() / z;
let mut sum = inv_z;
let mut prev_mag = sum.norm();
for n in 1..=iterations {
let n_complex = Complex::real(n as f64);
let factorial: f64 = (1..=n).map(|x| x as f64).product();
let term = Complex::real(factorial) * inv_z.pow(n_complex + Complex::one());
let mag = term.norm();
if mag > prev_mag {
break;
}
sum = sum + term;
prev_mag = mag;
}
sum * z.exp()
}
}
pub fn fresnel(z: Complex, iterations: usize) -> (Complex, Complex) {
let mut c = Complex::zero();
let mut s = Complex::zero();
for n in 0..=iterations {
let _n_complex = Complex::real(n as f64);
let sign = if n % 2 == 0 { Complex::one() } else { -Complex::one() };
let factorial_2n: f64 = (1..=2 * n).map(|x| x as f64).product();
let factorial_2n1: f64 = (1..=2 * n + 1).map(|x| x as f64).product();
let term_c = sign * z.pow(Complex::real(4.0 * n as f64 + 1.0))
/ Complex::real((4 * n + 1) as f64 * factorial_2n);
let term_s = sign * z.pow(Complex::real(4.0 * n as f64 + 3.0))
/ Complex::real((4 * n + 3) as f64 * factorial_2n1);
c = c + term_c;
s = s + term_s;
}
(c, s)
}
pub fn airy(z: Complex, iterations: usize) -> (Complex, Complex) {
if z.norm() < 1e-15 {
let c1 = Complex::real(3.0_f64.powf(-2.0 / 3.0)) / Self::gamma(Complex::real(2.0 / 3.0));
let sqrt3 = Complex::real(3.0_f64.sqrt());
return (c1, sqrt3 * c1);
}
if z.norm() < 2.0 {
let mut f = Complex::zero();
let mut g = Complex::zero();
for n in 0..=iterations {
let n_complex = Complex::real(n as f64);
let factorial: f64 = (1..=n).map(|x| x as f64).product();
let nine_pow_n = 9.0_f64.powi(n as i32);
let gamma_f = Self::gamma(n_complex + Complex::real(2.0 / 3.0));
let gamma_g = Self::gamma(n_complex + Complex::real(4.0 / 3.0));
f = f + z.pow(Complex::real(3.0 * n as f64))
/ (Complex::real(nine_pow_n * factorial) * gamma_f);
g = g + z.pow(Complex::real(3.0 * n as f64 + 1.0))
/ (Complex::real(nine_pow_n * factorial) * gamma_g);
}
let c1 = Complex::real(3.0_f64.powf(-2.0 / 3.0));
let c2 = Complex::real(3.0_f64.powf(-4.0 / 3.0));
let sqrt3 = Complex::real(3.0_f64.sqrt());
let ai = c1 * f - c2 * g;
let bi = sqrt3 * (c1 * f + c2 * g);
(ai, bi)
} else {
let t = Complex::real(2.0 / 3.0) * z.pow(Complex::real(1.5));
let z_pow_quarter = z.pow(Complex::real(0.25));
let ai = (-t).exp() / (Complex::real(2.0) * Complex::real(std::f64::consts::PI.sqrt()) * z_pow_quarter);
let bi = t.exp() / (Complex::real(std::f64::consts::PI.sqrt()) * z_pow_quarter);
(ai, bi)
}
}
pub fn bessel_j(v: Complex, z: Complex, iterations: usize) -> Complex {
if z.norm() < 1e-15 {
return if v == Complex::zero() { Complex::one() } else { Complex::zero() };
}
if z.norm() < 10.0 {
let mut sum = Complex::zero();
for n in 0..=iterations {
let n_complex = Complex::real(n as f64);
let factorial_n: f64 = if n == 0 { 1.0 } else { (1..=n).map(|x| x as f64).product() };
let gamma_v_n = Self::gamma(v + n_complex + Complex::one());
let term = (Complex::real((-1.0_f64).powi(n as i32)) * (z / Complex::real(2.0)).pow(v + Complex::real(2.0) * n_complex))
/ (Complex::real(factorial_n) * gamma_v_n);
sum = sum + term;
}
sum
} else {
let sqrt_term = (Complex::real(2.0) / (Complex::real(std::f64::consts::PI) * z)).sqrt();
let phase = z - v * Complex::real(std::f64::consts::FRAC_PI_2) - Complex::real(std::f64::consts::FRAC_PI_4);
sqrt_term * phase.cos()
}
}
pub fn bessel_y(v: Complex, z: Complex, iterations: usize) -> Complex {
if v.im.abs() < 1e-15 && (v.re - v.re.round()).abs() < 1e-15 {
let n = v.re.round() as i64;
let n_abs = n.unsigned_abs() as usize;
let y = Self::bessel_y_integer(n_abs, z, iterations);
if n < 0 && n % 2 != 0 { -y } else { y }
} else {
let j_v = Self::bessel_j(v, z, iterations);
let j_minus_v = Self::bessel_j(-v, z, iterations);
let cos_v_pi = (v * Complex::new(std::f64::consts::PI, 0.0)).cos();
(j_v * cos_v_pi - j_minus_v) / (v * Complex::new(std::f64::consts::PI, 0.0)).sin()
}
}
fn bessel_y_integer(n: usize, z: Complex, iterations: usize) -> Complex {
let pi = std::f64::consts::PI;
let z_over_2 = z / Complex::real(2.0);
let j_n = Self::bessel_j(Complex::real(n as f64), z, iterations);
let mut sum1 = Complex::zero();
for k in 0..n {
let fact_n_k_1: f64 = (1..=n - k - 1).map(|x| x as f64).product();
let fact_k: f64 = (1..=k).map(|x| x as f64).product();
sum1 = sum1 + Complex::real(fact_n_k_1 / fact_k)
* z_over_2.pow(Complex::real((2 * k) as f64 - n as f64));
}
let mut sum2 = Complex::zero();
for k in 0..=iterations {
let sign = if k % 2 == 0 { Complex::one() } else { -Complex::one() };
let fact_k: f64 = (1..=k).map(|x| x as f64).product();
let fact_k_n: f64 = (1..=k + n).map(|x| x as f64).product();
let psi = Self::digamma(Complex::real((k + 1) as f64))
+ Self::digamma(Complex::real((k + n + 1) as f64));
sum2 = sum2 + sign * psi / Complex::real(fact_k * fact_k_n)
* z_over_2.pow(Complex::real((2 * k + n) as f64));
}
Complex::real(2.0 / pi) * z_over_2.ln() * j_n
- Complex::real(1.0 / pi) * (sum1 + sum2)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_gamma() {
let result = ComplexSpecialFunctions::gamma(Complex::one());
assert!((result.re - 1.0).abs() < 0.1);
let result = ComplexSpecialFunctions::gamma(Complex::real(2.0));
assert!((result.re - 1.0).abs() < 0.1);
}
#[test]
fn test_digamma() {
let result = ComplexSpecialFunctions::digamma(Complex::one());
let gamma = 0.57721566490153286060651209008240243104215933593992;
assert!((result.re + gamma).abs() < 0.1);
}
#[test]
fn test_zeta() {
let result = ComplexSpecialFunctions::zeta(Complex::real(2.0), 1000);
let expected = std::f64::consts::PI * std::f64::consts::PI / 6.0;
assert!((result.re - expected).abs() < 0.1);
}
#[test]
fn test_polylog() {
let z = Complex::real(0.5);
let result = ComplexSpecialFunctions::polylog(Complex::one(), z, 100);
let expected = -(Complex::one() - z).ln();
assert!((result.re - expected.re).abs() < 0.1);
assert!((result.im - expected.im).abs() < 0.1);
}
#[test]
fn test_erf() {
let result = ComplexSpecialFunctions::erf(Complex::zero(), 50);
assert!(result.norm() < 0.1);
}
#[test]
fn test_bessel_j() {
let result = ComplexSpecialFunctions::bessel_j(Complex::zero(), Complex::zero(), 50);
assert!((result.re - 1.0).abs() < 0.5);
}
#[test]
fn test_digamma_known_values() {
let result = ComplexSpecialFunctions::digamma(Complex::one());
let gamma = 0.57721566490153286060651209008240243104215933593992;
assert!((result.re + gamma).abs() < 1e-6);
let psi5 = ComplexSpecialFunctions::digamma(Complex::real(5.0));
let expected = -gamma + 25.0 / 12.0;
assert!((psi5.re - expected).abs() < 1e-8);
}
#[test]
fn test_zeta_critical_values() {
let z0 = ComplexSpecialFunctions::zeta(Complex::zero(), 100);
assert!((z0.re + 0.5).abs() < 1e-8);
assert!(z0.im.abs() < 1e-8);
let zm1 = ComplexSpecialFunctions::zeta(Complex::real(-1.0), 100);
assert!((zm1.re + 1.0 / 12.0).abs() < 1e-6);
assert!(zm1.im.abs() < 1e-6);
let zhalf = ComplexSpecialFunctions::zeta(Complex::real(0.5), 100);
assert!((zhalf.re + 1.4603545088).abs() < 1e-4);
let z2 = ComplexSpecialFunctions::zeta(Complex::real(2.0), 1000);
let expected = std::f64::consts::PI * std::f64::consts::PI / 6.0;
assert!((z2.re - expected).abs() < 0.1);
let critical = ComplexSpecialFunctions::zeta(Complex::new(0.5, 14.0), 100);
assert!(critical.is_finite());
}
#[test]
fn test_fresnel_small_z() {
let (c, s) = ComplexSpecialFunctions::fresnel(Complex::real(0.1), 30);
assert!((c.re - 0.1).abs() < 1e-6);
assert!((s.re - 0.1f64.powi(3) / 3.0).abs() < 1e-6);
}
#[test]
fn test_fresnel_unit_values() {
let (c, s) = ComplexSpecialFunctions::fresnel(Complex::one(), 30);
assert!((c.re - 0.9045242379).abs() < 1e-5);
assert!((s.re - 0.3102683017).abs() < 1e-5);
}
#[test]
fn test_airy_known_values() {
let (ai0, bi0) = ComplexSpecialFunctions::airy(Complex::zero(), 30);
assert!((ai0.re - 0.3550280539).abs() < 1e-6);
assert!((bi0.re - 0.6149266274).abs() < 1e-6);
let (ai1, bi1) = ComplexSpecialFunctions::airy(Complex::one(), 30);
assert!((ai1.re - 0.1352924163).abs() < 1e-5);
assert!((bi1.re - 1.2074235949).abs() < 1e-4);
}
#[test]
fn test_bessel_j_known_values() {
let j0 = ComplexSpecialFunctions::bessel_j(Complex::zero(), Complex::real(1.0), 30);
assert!((j0.re - 0.7651976866).abs() < 1e-6);
let j1 = ComplexSpecialFunctions::bessel_j(Complex::one(), Complex::real(1.0), 30);
assert!((j1.re - 0.4400505857).abs() < 1e-6);
}
#[test]
fn test_bessel_y_integer_order() {
let y0 = ComplexSpecialFunctions::bessel_y(Complex::zero(), Complex::real(1.0), 40);
assert!(!y0.is_nan());
assert!((y0.re - 0.0882569642).abs() < 1e-4);
let y1 = ComplexSpecialFunctions::bessel_y(Complex::one(), Complex::real(1.0), 40);
assert!(!y1.is_nan());
assert!((y1.re + 0.7812128213).abs() < 1e-4);
}
#[test]
fn test_exponential_integral_known_values() {
let ei1 = ComplexSpecialFunctions::exponential_integral(Complex::one(), 40);
assert!((ei1.re - 1.8951178164).abs() < 1e-4);
let ei5 = ComplexSpecialFunctions::exponential_integral(Complex::real(5.0), 40);
assert!((ei5.re - 40.1852753558).abs() < 1e-2);
}
}