more edge values

Author: youknowone

.gitignore

@@ -1,2 +1,3 @@
 /target
 Cargo.lock
+cpython

src/math/integer.rs

@@ -715,7 +715,7 @@ mod tests {
     use pyo3::prelude::*;
 
     /// Edge i64 values for testing integer math functions (gcd, lcm, isqrt, factorial, comb, perm)
-    const EDGE_I64: [i64; 24] = [
+    const EDGE_I64: [i64; 44] = [
         // Zero and small values
         0,
         1,
@@ -726,27 +726,50 @@ mod tests {
         7,
         13,
         97,
-        // Powers of 2
+        127,  // table boundary in comb/perm
+        128,  // Table boundary + 1
+        // Powers of 2 and boundaries
         64,
+        63,   // 2^6 - 1
+        65,   // 2^6 + 1
         1024,
-        65536,
+        65535,  // 2^16 - 1
+        65536,  // 2^16
+        65537,  // 2^16 + 1 (Fermat prime)
         // Factorial-relevant
+        12, // 12! = 479001600 fits in u32
+        13, // 13! overflows u32
         20, // 20! fits in u64
         21, // 21! overflows u64
+        170, // factorial(170) is the largest that fits in f64
+        171, // factorial(171) overflows f64
+        // Comb/perm algorithm switching points
+        34,  // FAST_COMB_LIMITS1 boundary
+        35,
         // Large values
         1_000_000,
         -1_000_000,
         i32::MAX as i64,
+        i32::MAX as i64 + 1,
         i32::MIN as i64,
+        i32::MIN as i64 - 1,
         // Near i64 bounds
         i64::MAX,
         i64::MIN,
         i64::MAX - 1,
         i64::MIN + 1,
         // Square root boundaries
-        (1i64 << 31) - 1, // sqrt fits in u32
-        1i64 << 32,       // sqrt boundary
+        (1i64 << 15) - 1, // 32767, sqrt = 181
+        1i64 << 16,       // 65536, sqrt = 256 (exact)
+        (1i64 << 31) - 1, // sqrt fits in u16
+        1i64 << 32,       // sqrt boundary (exact power of 2)
+        (1i64 << 32) - 1, // near sqrt boundary
+        (1i64 << 32) + 1, // just above sqrt boundary
         (1i64 << 62) - 1, // large but valid for isqrt
+        1i64 << 62,       // exact power of 2
+        // Near perfect squares
+        99,   // sqrt(99) = 9.949...
+        101,  // sqrt(101) = 10.049...
     ];
 
     fn test_gcd_impl(args: &[i64]) {

src/test.rs

@@ -3,7 +3,7 @@ use pyo3::{Python, prelude::*};
 
 /// Edge values for testing floating-point functions.
 /// Includes: zeros, infinities, various NaNs, subnormals, and values at different scales.
-pub(crate) const EDGE_VALUES: [f64; 30] = [
+pub(crate) const EDGE_VALUES: [f64; 49] = [
     // Zeros
     0.0,
     -0.0,
@@ -15,9 +15,13 @@ pub(crate) const EDGE_VALUES: [f64; 30] = [
     -f64::NAN,
     // Additional NaN with different payload (quiet NaN with payload 1)
     f64::from_bits(0x7FF8_0000_0000_0001_u64),
+    // Signaling NaN (sNaN) - may trigger FP exceptions on some platforms
+    f64::from_bits(0x7FF0_0000_0000_0001_u64),
     // Subnormal (denormalized) values
     f64::MIN_POSITIVE * 0.5, // smallest subnormal
     -f64::MIN_POSITIVE * 0.5,
+    5e-324, // smallest positive subnormal
+    -5e-324,
     // Boundary values
     f64::MIN_POSITIVE, // smallest positive normal
     f64::MAX,          // largest finite
@@ -27,23 +31,43 @@ pub(crate) const EDGE_VALUES: [f64; 30] = [
     -f64::MAX * 0.5,
     1e308,
     -1e308,
+    // Values near overflow threshold for common operations
+    1e154,  // sqrt of this is ~1e77, exp of this overflows
+    -1e154,
+    710.0,  // exp(710) ≈ overflow threshold
+    -745.0, // exp(-745) ≈ underflow threshold
     // Small scale
     1e-10,
     -1e-10,
     1e-300,
+    -1e-300,
     // Normal scale
     1.0,
     -1.0,
     0.5,
     -0.5,
     2.0,
-    // Trigonometric special values (where sin/cos/tan have exact or near-zero results)
-    std::f64::consts::PI, // sin(PI) ≈ 0
+    -2.0,
+    // Values near 1.0 (important for log, expm1, log1p)
+    1.0 - 1e-15, // just below 1
+    1.0 + 1e-15, // just above 1
+    f64::EPSILON,
+    1.0 - f64::EPSILON,
+    1.0 + f64::EPSILON,
+    // Mathematical constants
+    std::f64::consts::E,
+    std::f64::consts::LN_2,
+    std::f64::consts::LOG10_E,
+    // Trigonometric special values
+    std::f64::consts::PI,
     -std::f64::consts::PI,
-    std::f64::consts::FRAC_PI_2, // cos(PI/2) ≈ 0
+    std::f64::consts::FRAC_PI_2,
     -std::f64::consts::FRAC_PI_2,
-    std::f64::consts::FRAC_PI_4, // tan(PI/4) = 1
-    std::f64::consts::TAU,       // sin(2*PI) ≈ 0, cos(2*PI) = 1
+    std::f64::consts::FRAC_PI_4,
+    std::f64::consts::TAU,
+    // Near-integer values (important for ceil, floor, trunc, round)
+    0.49999999999999994, // rounds to 0
+    0.50000000000000006, // rounds to 1
 ];
 
 pub(crate) fn unwrap<'py>(