use deep_causality_algebra::RealField;
use deep_causality_num::{Float, Float106, FromPrimitive, lift};
const U_CLAMP_LO: f64 = 1e-300;
const U_CLAMP_HI: f64 = 1.0 - f64::EPSILON;
fn acklam(u: f64) -> f64 {
const A: [f64; 6] = [
-3.969683028665376e+01,
2.209460984245205e+02,
-2.759285104469687e+02,
1.38357751867269e+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 u = u.clamp(U_CLAMP_LO, U_CLAMP_HI);
if u < P_LOW {
let q = (-2.0 * u.ln()).sqrt();
(((((C[0] * q + C[1]) * q + C[2]) * q + C[3]) * q + C[4]) * q + C[5])
/ ((((D[0] * q + D[1]) * q + D[2]) * q + D[3]) * q + 1.0)
} else if u <= P_HIGH {
let q = u - 0.5;
let r = q * q;
(((((A[0] * r + A[1]) * r + A[2]) * r + A[3]) * r + A[4]) * r + A[5]) * q
/ (((((B[0] * r + B[1]) * r + B[2]) * r + B[3]) * r + B[4]) * r + 1.0)
} else {
let q = (-2.0 * (1.0 - u).ln()).sqrt();
-(((((C[0] * q + C[1]) * q + C[2]) * q + C[3]) * q + C[4]) * q + C[5])
/ ((((D[0] * q + D[1]) * q + D[2]) * q + D[3]) * q + 1.0)
}
}
fn refine_f106(u: Float106, x0: Float106) -> Float106 {
let half = Float106::from(0.5);
let two = Float106::from(2.0);
let sqrt2 = two.sqrt();
let inv_sqrt_2pi = Float106::from(1.0) / Float106::TWO_PI.sqrt();
let mut x = x0;
for _ in 0..3 {
let cdf = half * (-x / sqrt2).erfc();
let pdf = (-(x * x) * half).exp() * inv_sqrt_2pi;
let diff = cdf - u;
let denom = two * pdf + x * diff;
x -= two * diff / denom;
}
x
}
pub fn standard_normal_inverse_cdf(u: f64) -> f64 {
let u_c = u.clamp(U_CLAMP_LO, U_CLAMP_HI);
refine_f106(Float106::from(u_c), Float106::from(acklam(u_c))).to_f64()
}
pub fn standard_normal_inverse_cdf_f106(u: Float106) -> Float106 {
let u_c = u.hi().clamp(U_CLAMP_LO, U_CLAMP_HI);
let u_full = if u.hi() <= U_CLAMP_LO || u.hi() >= U_CLAMP_HI {
Float106::from(u_c)
} else {
u
};
refine_f106(u_full, Float106::from(acklam(u_c)))
}
pub fn standard_normal_inverse_cdf_at<R>(u: f64) -> R
where
R: RealField + FromPrimitive,
{
let z = standard_normal_inverse_cdf_f106(Float106::from(u));
lift::<R>(z.hi()) + lift::<R>(z.lo())
}
pub fn uniform_inverse_cdf<R: RealField>(u: R, low: R, high: R) -> R {
low + u * (high - low)
}
pub fn bernoulli_inverse_cdf(u: f64, p: f64) -> bool {
u < p
}