fix linux compat

Author: youknowone

src/cmath/misc.rs

@@ -17,8 +17,15 @@ static RECT_SPECIAL_VALUES: [[Complex64; 7]; 7] = [
 
 /// Return the phase angle (argument) of z.
 #[inline]
-pub fn phase(z: Complex64) -> f64 {
-    m::atan2(z.im, z.re)
+pub fn phase(z: Complex64) -> Result<f64> {
+    crate::err::set_errno(0);
+    let phi = m::atan2(z.im, z.re);
+    match crate::err::get_errno() {
+        0 => Ok(phi),
+        libc::EDOM => Err(Error::EDOM),
+        libc::ERANGE => Err(Error::ERANGE),
+        _ => Err(Error::EDOM), // Unknown errno treated as domain error (like PyErr_SetFromErrno)
+    }
 }
 
 /// Convert z to polar coordinates (r, phi).
@@ -123,20 +130,40 @@ mod tests {
         pyo3::Python::attach(|py| {
             let cmath = pyo3::types::PyModule::import(py, "cmath").unwrap();
             let py_func = cmath.getattr("phase").unwrap();
-            let py_result: f64 = py_func
-                .call1((pyo3::types::PyComplex::from_doubles(py, re, im),))
-                .unwrap()
-                .extract()
-                .unwrap();
-
-            if py_result.is_nan() && rs_result.is_nan() {
-                return;
+            let py_result = py_func.call1((pyo3::types::PyComplex::from_doubles(py, re, im),));
+
+            match py_result {
+                Ok(result) => {
+                    let py_val: f64 = result.extract().unwrap();
+                    match rs_result {
+                        Ok(rs_val) => {
+                            if py_val.is_nan() && rs_val.is_nan() {
+                                return;
+                            }
+                            assert_eq!(
+                                py_val.to_bits(),
+                                rs_val.to_bits(),
+                                "phase({re}, {im}): py={py_val} vs rs={rs_val}"
+                            );
+                        }
+                        Err(e) => {
+                            panic!("phase({re}, {im}): py={py_val} but rs returned error {e:?}");
+                        }
+                    }
+                }
+                Err(e) => {
+                    // Python raised an exception - check we got an error too
+                    if rs_result.is_ok() {
+                        let rs_val = rs_result.unwrap();
+                        if e.is_instance_of::<pyo3::exceptions::PyValueError>(py) {
+                            panic!("phase({re}, {im}): py raised ValueError but rs={rs_val}");
+                        } else if e.is_instance_of::<pyo3::exceptions::PyOverflowError>(py) {
+                            panic!("phase({re}, {im}): py raised OverflowError but rs={rs_val}");
+                        }
+                    }
+                    // Both raised errors - OK
+                }
             }
-            assert_eq!(
-                py_result.to_bits(),
-                rs_result.to_bits(),
-                "phase({re}, {im}): py={py_result} vs rs={rs_result}"
-            );
         });
     }
 

src/m_sys.rs

@@ -1,5 +1,6 @@
 // These symbols are all defined by `libm`,
 // or by `compiler-builtins` on unsupported platforms.
+#[cfg_attr(unix, link(name = "m"))]
 #[allow(dead_code)]
 unsafe extern "C" {
     // Trigonometric functions

src/math.rs

@@ -48,8 +48,10 @@ pub(crate) use libm_simple;
 /// math_1: wrapper for 1-arg functions
 /// - isnan(r) && !isnan(x) -> domain error
 /// - isinf(r) && isfinite(x) -> overflow (can_overflow=true) or domain error (can_overflow=false)
+/// - isfinite(r) && errno -> check errno (unnecessary on most platforms)
 #[inline]
 pub(crate) fn math_1(x: f64, func: fn(f64) -> f64, can_overflow: bool) -> crate::Result<f64> {
+    crate::err::set_errno(0);
     let r = func(x);
     if r.is_nan() && !x.is_nan() {
         return Err(crate::Error::EDOM);
@@ -61,6 +63,10 @@ pub(crate) fn math_1(x: f64, func: fn(f64) -> f64, can_overflow: bool) -> crate:
             crate::Error::EDOM
         });
     }
+    // This branch unnecessary on most platforms
+    if r.is_finite() && crate::err::get_errno() != 0 {
+        return crate::err::is_error(r);
+    }
     Ok(r)
 }
 

src/math/aggregate.rs

@@ -27,36 +27,13 @@ fn dl_sum(a: f64, b: f64) -> DoubleLength {
 }
 
 /// Algorithm 3.5. Error-free transformation of a product using FMA
-#[cfg(any(feature = "mul_add", target_os = "windows"))]
 #[inline]
 fn dl_mul(x: f64, y: f64) -> DoubleLength {
     let z = x * y;
     let zz = x.mul_add(y, -z);
     DoubleLength { hi: z, lo: zz }
 }
 
-/// Dekker's algorithm for error-free product without FMA
-#[cfg(not(any(feature = "mul_add", target_os = "windows")))]
-#[inline]
-fn dl_mul(x: f64, y: f64) -> DoubleLength {
-    // Dekker (5.5) and (5.6) - split
-    fn dl_split(x: f64) -> DoubleLength {
-        let t = x * 134217729.0; // Veltkamp constant = 2^27 + 1
-        let hi = t - (t - x);
-        let lo = x - hi;
-        DoubleLength { hi, lo }
-    }
-
-    // Dekker (5.12) and mul12()
-    let xx = dl_split(x);
-    let yy = dl_split(y);
-    let p = xx.hi * yy.hi;
-    let q = xx.hi * yy.lo + xx.lo * yy.hi;
-    let z = p + q;
-    let zz = p - z + q + xx.lo * yy.lo;
-    DoubleLength { hi: z, lo: zz }
-}
-
 /// Triple-length number for extra precision
 #[derive(Clone, Copy)]
 struct TripleLength {