Revert "Remove unused inverse approximation variants"

This reverts commit 95bbb30.

Author: timschmidt

src/computable/approximation.rs

@@ -101,6 +101,7 @@ pub(super) enum Approximation {
     // rational in the node avoids a child Computable::approx call before
     // entering that series.
     AsinRational(Rational),
+    PrescaledAsin(Computable),
     // Generic non-rational asin uses the stable half-angle atan transform. A
     // deferred node keeps construction thin for symbolic radicals and endpoint
     // inputs that may never be approximated.
@@ -123,6 +124,7 @@ pub(super) enum Approximation {
     // approximation and keeps the exact value symbolic until the kernel rounds.
     AsinhRational(Rational),
     AtanhDirect(Computable),
+    PrescaledAtanh(Computable),
     AtanhRational(Rational),
     PrescaledCos(Computable),
     // Small exact-rational Real::cos construction uses this leaf to avoid
@@ -239,6 +241,7 @@ impl Approximation {
             PrescaledAtan(c) => atan_computable(signal, c, p),
             AtanRational(r) => atan_rational(signal, r, p),
             AsinRational(r) => asin_rational(signal, r, p),
+            PrescaledAsin(c) => asin_computable(signal, c, p),
             AsinDeferred(c) => asin_deferred(signal, c, p),
             AcosPositive(c) => acos_positive(signal, c, p),
             AcosPositiveRational(r) => acos_positive_rational(signal, r, p),
@@ -250,6 +253,7 @@ impl Approximation {
             PrescaledAsinh(c) => asinh_computable(signal, c, p),
             AsinhRational(r) => asinh_rational(signal, r, p),
             AtanhDirect(c) => atanh_direct(signal, c, p),
+            PrescaledAtanh(c) => atanh_computable(signal, c, p),
             AtanhRational(r) => atanh_rational(signal, r, p),
             PrescaledCos(c) => cos(signal, c, p),
             PrescaledCosRational(r) => cos_rational(signal, r, p),
@@ -2107,6 +2111,44 @@ fn asin_rational(signal: &Option<Signal>, r: &Rational, p: Precision) -> BigInt
     scale(sum, calc_precision - p)
 }
 
+// Approximate asin(c) for small |c|.
+fn asin_computable(signal: &Option<Signal>, c: &Computable, p: Precision) -> BigInt {
+    // Dedicated tiny-argument asin series. It avoids the generic atan/sqrt
+    // transform, which is overkill and slower when |x| is already very small.
+    if p >= 1 {
+        return Zero::zero();
+    }
+
+    let iterations_needed: i32 = -p / 2 + 4;
+    let calc_precision = p - bound_log2(2 * iterations_needed) - 5;
+    let op_prec = calc_precision - 3;
+    let op_appr = c.approx_signal(signal, op_prec);
+    let op_squared = scale(&op_appr * &op_appr, op_prec);
+
+    // Borrowed magnitude checks matter here because tiny inverse-trig benches
+    // run many short series from cold caches.
+    let max_trunc_error = BigUint::one()
+        << usize::try_from(p - 4 - calc_precision).expect("truncation shift is nonnegative");
+    let mut current_term = scale(op_appr, op_prec - calc_precision);
+    let mut sum = current_term.clone();
+    let mut n = 0_i32;
+
+    while current_term.magnitude() > &max_trunc_error {
+        if should_stop(signal) {
+            break;
+        }
+        n += 1;
+        current_term = scale(current_term * &op_squared, op_prec);
+        let numerator = (2 * n - 1) * (2 * n - 1);
+        let denominator = (2 * n) * (2 * n + 1);
+        current_term *= numerator;
+        current_term /= denominator;
+        sum += &current_term;
+    }
+
+    scale(sum, calc_precision - p)
+}
+
 fn asin_deferred(signal: &Option<Signal>, c: &Computable, p: Precision) -> BigInt {
     // Generic asin uses asin(x) = 2*atan(x / (sqrt(1-x^2)+1)).
     // Keeping this as one approximation node mirrors the deferred acos and
@@ -2285,6 +2327,42 @@ fn atanh_direct(signal: &Option<Signal>, c: &Computable, p: Precision) -> BigInt
         .approx_signal(signal, p)
 }
 
+// Approximate atanh(c) for small |c|.
+fn atanh_computable(signal: &Option<Signal>, c: &Computable, p: Precision) -> BigInt {
+    // Dedicated tiny-argument atanh series, also reused by the ln1p kernel after
+    // it transforms ln(1+x) into 2*atanh(x/(2+x)).
+    if p >= 1 {
+        return Zero::zero();
+    }
+
+    let iterations_needed: i32 = -p / 2 + 4;
+    let calc_precision = p - bound_log2(2 * iterations_needed) - 5;
+    let op_prec = calc_precision - 3;
+    let op_appr = c.approx_signal(signal, op_prec);
+    let op_squared = scale(&op_appr * &op_appr, op_prec);
+
+    // Borrowed magnitude checks matter here because tiny inverse-hyperbolic
+    // benches run many short series from cold caches.
+    let max_trunc_error = BigUint::one()
+        << usize::try_from(p - 4 - calc_precision).expect("truncation shift is nonnegative");
+    let mut current_power = scale(op_appr, op_prec - calc_precision);
+    let mut current_term = current_power.clone();
+    let mut sum = current_term.clone();
+    let mut n = 1_i32;
+
+    while current_term.magnitude() > &max_trunc_error {
+        if should_stop(signal) {
+            break;
+        }
+        n += 2;
+        current_power = scale(current_power * &op_squared, op_prec);
+        current_term = &current_power / n;
+        sum += &current_term;
+    }
+
+    scale(sum, calc_precision - p)
+}
+
 fn atanh_rational(signal: &Option<Signal>, r: &Rational, p: Precision) -> BigInt {
     // Direct exact-rational variant of the tiny atanh series. This mirrors the
     // direct rational trig kernels: preserve the symbolic rational payload and

src/computable/node.rs

@@ -587,6 +587,9 @@ impl Computable {
                 (Approximation::AsinRational(left), Approximation::AsinRational(right)) => {
                     left == right
                 }
+                (Approximation::PrescaledAsin(left), Approximation::PrescaledAsin(right)) => {
+                    Computable::internal_structural_eq(left, right)
+                }
                 (Approximation::AsinDeferred(left), Approximation::AsinDeferred(right)) => {
                     Computable::internal_structural_eq(left, right)
                 }
@@ -622,6 +625,9 @@ impl Computable {
                 (Approximation::AtanhDirect(left), Approximation::AtanhDirect(right)) => {
                     Computable::internal_structural_eq(left, right)
                 }
+                (Approximation::PrescaledAtanh(left), Approximation::PrescaledAtanh(right)) => {
+                    Computable::internal_structural_eq(left, right)
+                }
                 (Approximation::AtanhRational(left), Approximation::AtanhRational(right)) => {
                     left == right
                 }
@@ -1800,11 +1806,13 @@ impl Computable {
                 | Approximation::AcoshNearOne(_)
                 | Approximation::AcoshDirect(_) => Some(Some(Sign::Plus)),
                 Approximation::PrescaledAtan(child)
+                | Approximation::PrescaledAsin(child)
                 | Approximation::AsinDeferred(child)
                 | Approximation::AsinhNearZero(child)
                 | Approximation::AsinhDirect(child)
                 | Approximation::PrescaledAsinh(child)
-                | Approximation::AtanhDirect(child) => Some(child.exact_sign()),
+                | Approximation::AtanhDirect(child)
+                | Approximation::PrescaledAtanh(child) => Some(child.exact_sign()),
                 Approximation::PrescaledExp(_) => Some(Some(Sign::Plus)),
                 Approximation::Negate(_)
                 | Approximation::Offset(_, _)