use crate::special::erf;
use std::f64::consts::SQRT_2;
#[must_use]
pub fn norm_cdf(x: f64) -> f64 {
0.5 * (1.0 + erf(x / SQRT_2))
}
#[must_use]
pub fn norm_pdf(x: f64) -> f64 {
const INV_SQRT_2PI: f64 = 0.3989422804014327; INV_SQRT_2PI * (-0.5 * x * x).exp()
}
#[expect(
clippy::excessive_precision,
reason = "Acklam algorithm coefficients; precision intentional"
)]
#[must_use]
pub fn norm_ppf(p: f64) -> f64 {
if p <= 0.0 {
return f64::NEG_INFINITY;
}
if p >= 1.0 {
return f64::INFINITY;
}
const A: [f64; 6] = [
-3.969683028665376e+01,
2.209460984245205e+02,
-2.759285104469687e+02,
1.383577518672690e+02,
-3.066479806614716e+01,
2.506628277459239e+00,
];
const B: [f64; 5] = [
-5.447609879822406e+01,
1.615858368580409e+02,
-1.556989798598866e+02,
6.680131188771972e+01,
-1.328068155288572e+01,
];
const C: [f64; 6] = [
-7.784894002430293e-03,
-3.223964580411365e-01,
-2.400758277161838e+00,
-2.549732539343734e+00,
4.374664141464968e+00,
2.938163982698783e+00,
];
const D: [f64; 4] = [
7.784695709041462e-03,
3.224671290700398e-01,
2.445134137142996e+00,
3.754408661907416e+00,
];
const P_LOW: f64 = 0.02425;
const P_HIGH: f64 = 1.0 - P_LOW;
let x: f64;
if p < P_LOW {
let q = (-2.0 * p.ln()).sqrt();
x = C[0]
.mul_add(q, C[1])
.mul_add(q, C[2])
.mul_add(q, C[3])
.mul_add(q, C[4])
.mul_add(q, C[5])
/ (D[0]
.mul_add(q, D[1])
.mul_add(q, D[2])
.mul_add(q, D[3])
.mul_add(q, 1.0));
} else if p <= P_HIGH {
let q = p - 0.5;
let r = q * q;
x = A[0]
.mul_add(r, A[1])
.mul_add(r, A[2])
.mul_add(r, A[3])
.mul_add(r, A[4])
.mul_add(r, A[5])
* q
/ (B[0]
.mul_add(r, B[1])
.mul_add(r, B[2])
.mul_add(r, B[3])
.mul_add(r, B[4])
.mul_add(r, 1.0));
} else {
let q = (-2.0 * (1.0 - p).ln()).sqrt();
x = -(C[0]
.mul_add(q, C[1])
.mul_add(q, C[2])
.mul_add(q, C[3])
.mul_add(q, C[4])
.mul_add(q, C[5])
/ D[0]
.mul_add(q, D[1])
.mul_add(q, D[2])
.mul_add(q, D[3])
.mul_add(q, 1.0));
}
x
}
#[must_use]
pub fn norm_cdf_batch(x: &[f64]) -> Vec<f64> {
x.iter().map(|&v| norm_cdf(v)).collect()
}
#[must_use]
pub fn norm_pdf_batch(x: &[f64]) -> Vec<f64> {
x.iter().map(|&v| norm_pdf(v)).collect()
}
#[must_use]
pub fn norm_cdf_general(x: f64, mu: f64, sigma: f64) -> f64 {
norm_cdf((x - mu) / sigma)
}
#[must_use]
pub fn norm_pdf_general(x: f64, mu: f64, sigma: f64) -> f64 {
norm_pdf((x - mu) / sigma) / sigma
}
#[must_use]
pub fn norm_ppf_general(p: f64, mu: f64, sigma: f64) -> f64 {
sigma.mul_add(norm_ppf(p), mu)
}
#[cfg(test)]
mod tests {
use super::*;
use std::f64::consts::PI;
#[test]
fn test_norm_cdf_zero() {
assert!((norm_cdf(0.0) - 0.5).abs() < 1e-10);
}
#[test]
fn test_norm_cdf_positive() {
assert!((norm_cdf(1.0) - 0.8413447460685429).abs() < 2e-6);
assert!((norm_cdf(2.0) - 0.9772498680518208).abs() < 2e-6);
}
#[test]
fn test_norm_cdf_negative() {
assert!((norm_cdf(-1.0) - (1.0 - norm_cdf(1.0))).abs() < 1e-14);
assert!((norm_cdf(-2.0) - (1.0 - norm_cdf(2.0))).abs() < 1e-14);
}
#[test]
fn test_norm_cdf_critical_values() {
assert!((norm_cdf(1.645) - 0.95).abs() < 2e-3); assert!((norm_cdf(1.96) - 0.975).abs() < 2e-3); assert!((norm_cdf(2.576) - 0.995).abs() < 2e-3); }
#[test]
fn test_norm_pdf_peak() {
let peak = 1.0 / (2.0 * PI).sqrt();
assert!((norm_pdf(0.0) - peak).abs() < 1e-14);
}
#[test]
fn test_norm_pdf_symmetry() {
for x in [0.5, 1.0, 2.0, 3.0] {
assert!((norm_pdf(x) - norm_pdf(-x)).abs() < 1e-14);
}
}
#[test]
fn test_norm_pdf_decay() {
assert!(norm_pdf(0.0) > norm_pdf(1.0));
assert!(norm_pdf(1.0) > norm_pdf(2.0));
assert!(norm_pdf(2.0) > norm_pdf(3.0));
}
#[test]
fn test_norm_ppf_median() {
assert!((norm_ppf(0.5) - 0.0).abs() < 1e-10);
}
#[test]
fn test_norm_ppf_critical_values() {
assert!(
(norm_ppf(0.95) - 1.6448536269514722).abs() < 1e-2,
"ppf(0.95) = {}",
norm_ppf(0.95)
);
assert!(
(norm_ppf(0.975) - 1.9599639845400545).abs() < 1e-2,
"ppf(0.975) = {}",
norm_ppf(0.975)
);
assert!(
(norm_ppf(0.995) - 2.5758293035489004).abs() < 1e-2,
"ppf(0.995) = {}",
norm_ppf(0.995)
);
}
#[test]
fn test_norm_ppf_symmetry() {
for p in [0.1, 0.2, 0.3, 0.4] {
assert!((norm_ppf(p) + norm_ppf(1.0 - p)).abs() < 1e-10);
}
}
#[test]
fn test_norm_ppf_cdf_inverse() {
for x in [-1.0, 0.0, 1.0] {
let roundtrip = norm_ppf(norm_cdf(x));
assert!((roundtrip - x).abs() < 0.1, "ppf(cdf({x})) = {roundtrip}");
}
}
#[test]
fn test_norm_ppf_tails() {
assert!(norm_ppf(0.001) < -3.0);
assert!(norm_ppf(1e-6) < -4.0);
assert!(norm_ppf(0.999) > 3.0);
assert!(norm_ppf(1.0 - 1e-6) > 4.0);
}
#[test]
fn test_norm_ppf_boundaries() {
assert!(norm_ppf(0.0).is_infinite() && norm_ppf(0.0) < 0.0);
assert!(norm_ppf(1.0).is_infinite() && norm_ppf(1.0) > 0.0);
}
#[test]
fn test_norm_cdf_batch() {
let x = vec![-1.0, 0.0, 1.0];
let result = norm_cdf_batch(&x);
assert_eq!(result.len(), 3);
assert!((result[1] - 0.5).abs() < 1e-10);
}
#[test]
fn test_general_normal() {
let mu = 10.0;
let sigma = 2.0;
assert!((norm_cdf_general(mu, mu, sigma) - 0.5).abs() < 1e-10);
let pdf_at_mean = norm_pdf_general(mu, mu, sigma);
assert!(pdf_at_mean > norm_pdf_general(mu + 1.0, mu, sigma));
assert!((norm_ppf_general(0.5, mu, sigma) - mu).abs() < 1e-10);
}
}