gh-153144: Avoid checking errno for atan2

Lib/test/test_cmath.py

@@ -406,8 +406,6 @@ def polar_with_errno_set(z):
                 _testcapi.set_errno(0)
         self.check_polar(polar_with_errno_set)
 
-    @unittest.skipIf(sys.platform.startswith("sunos"),
-                     "skipping, see gh-138573")
     def test_phase(self):
         self.assertAlmostEqual(phase(0), 0.)
         self.assertAlmostEqual(phase(1.), 0.)
@@ -423,6 +421,16 @@ def test_phase(self):
         self.assertEqual(phase(complex(-0.0, 0.0)), pi)
         self.assertEqual(phase(complex(-0.0, -0.0)), -pi)
 
+        # overflow and underflow of imag/real
+        self.assertEqual(phase(complex(1E300, 1E-320)), 0.0)
+        self.assertEqual(phase(complex(1E300, -1E-320)), -0.0)
+        self.assertAlmostEqual(phase(complex(1E-320, 1E300)), pi/2)
+        self.assertAlmostEqual(phase(complex(-1E-320, 1E300)), pi/2)
+        self.assertAlmostEqual(phase(complex(-1E300, 1E-320)), pi)
+        self.assertAlmostEqual(phase(complex(-1E300, -1E-320)), -pi)
+        self.assertAlmostEqual(phase(complex(1E-320, -1E300)), -pi/2)
+        self.assertAlmostEqual(phase(complex(-1E-320, -1E300)), -pi/2)
+
         # infinities
         self.assertAlmostEqual(phase(complex(-INF, -0.0)), -pi)
         self.assertAlmostEqual(phase(complex(-INF, -2.3)), -pi)

Lib/test/test_math.py

@@ -287,8 +287,6 @@ def testAtanh(self):
         self.assertRaises(ValueError, math.atanh, NINF)
         self.assertTrue(math.isnan(math.atanh(NAN)))
 
-    @unittest.skipIf(sys.platform.startswith("sunos"),
-                     "skipping, see gh-138573")
     def testAtan2(self):
         self.assertRaises(TypeError, math.atan2)
         self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2)
@@ -350,6 +348,15 @@ def testAtan2(self):
         self.assertTrue(math.isnan(math.atan2(NAN, 2.3)))
         self.assertTrue(math.isnan(math.atan2(NAN, INF)))
         self.assertTrue(math.isnan(math.atan2(NAN, NAN)))
+        # overflow and underflow of y/x
+        self.assertEqual(math.atan2(1E-320, 1E300), 0.0)
+        self.assertEqual(math.atan2(-1E-320, 1E300), -0.0)
+        self.assertAlmostEqual(math.atan2(1E300, 1E-320), math.pi/2)
+        self.assertAlmostEqual(math.atan2(1E300, -1E-320), math.pi/2)
+        self.assertAlmostEqual(math.atan2(1E-320, -1E300), math.pi)
+        self.assertAlmostEqual(math.atan2(-1E-320, -1E300), -math.pi)
+        self.assertAlmostEqual(math.atan2(-1E300, 1E-320), -math.pi/2)
+        self.assertAlmostEqual(math.atan2(-1E300, -1E-320), -math.pi/2)
 
     def testCbrt(self):
         self.assertRaises(TypeError, math.cbrt)

Misc/NEWS.d/next/Library/2026-07-20-09-35-32.gh-issue-153144.0a2AoO.rst

@@ -0,0 +1,4 @@
+:func:`math.atan2` and :func:`math.atan2pi` no longer raise :exc:`ValueError`.
+:func:`cmath.phase` no longer raises :exc:`OverflowError` or :exc:`ValueError`,
+and the values of ``math.atan2(b, a)`` and ``cmath.phase(complex(a, b))`` always
+match.  Contributed by High Performance Kernels LLC.

Misc/NEWS.d/next/Library/2026-10-02-22-32-10.gh-issue-156145.9l_tZb.rst

@@ -0,0 +1,2 @@
+The function :func:`math.copysign` no longer sets ``errno`` to zero.
+Contributed by High Performance Kernels LLC.

Modules/cmathmodule.c

@@ -1004,12 +1004,11 @@ cmath_phase_impl(PyObject *module, Py_complex z)
 {
     double phi;
 
-    errno = 0;
-    phi = atan2(z.imag, z.real); /* should not cause any exception */
-    if (errno != 0)
-        return math_error();
-    else
-        return PyFloat_FromDouble(phi);
+    phi = atan2(z.imag, z.real);
+    /* gh-153144: Ignore atan2() errno on purpose since it can optionally be
+                  EDOM, which we should ignore, or ERANGE if phi underflows,
+                  which is silent on Python.  Overflow is not possible. */
+    return PyFloat_FromDouble(phi);
 }
 
 /*[clinic input]

Modules/mathmodule.c

@@ -1017,7 +1017,7 @@ math_1a(PyObject *arg, double (*func) (double), const char *err_msg)
    The last rule is used to catch overflow on platforms which follow
    C89 but for which HUGE_VAL is not an infinity.
 
-   For most two-argument functions (copysign, fmod, hypot, atan2)
+   For most two-argument functions (fmod, hypot)
    these rules are enough to ensure that Python's functions behave as
    specified in 'Annex F' of the C99 standard, with the 'invalid' and
    'divide-by-zero' floating-point exceptions mapping to Python's
@@ -1030,8 +1030,9 @@ math_2(PyObject *const *args, Py_ssize_t nargs,
        double (*func) (double, double), const char *funcname)
 {
     double x, y, r;
-    if (!_PyArg_CheckPositional(funcname, nargs, 2, 2))
+    if (!_PyArg_CheckPositional(funcname, nargs, 2, 2)) {
         return NULL;
+    }
     x = PyFloat_AsDouble(args[0]);
     if (x == -1.0 && PyErr_Occurred()) {
         return NULL;
@@ -1060,6 +1061,29 @@ math_2(PyObject *const *args, Py_ssize_t nargs,
         return PyFloat_FromDouble(r);
 }
 
+/* variant of math_2, to be used when the function being wrapped is known NOT
+   to need error checking (i.e., no overflow, invalid, or divide-by-zero).  */
+
+static PyObject *
+math_2ne(PyObject *const *args, Py_ssize_t nargs,
+         double (*func) (double, double), const char *funcname)
+{
+    double x, y, r;
+    if (!_PyArg_CheckPositional(funcname, nargs, 2, 2)) {
+        return NULL;
+    }
+    x = PyFloat_AsDouble(args[0]);
+    if (x == -1.0 && PyErr_Occurred()) {
+        return NULL;
+    }
+    y = PyFloat_AsDouble(args[1]);
+    if (y == -1.0 && PyErr_Occurred()) {
+        return NULL;
+    }
+    r = (*func)(x, y);  // Ignore errno on purpose.
+    return PyFloat_FromDouble(r);
+}
+
 #define FUNC1(funcname, func, can_overflow, docstring)                  \
     static PyObject * math_##funcname(PyObject *self, PyObject *args) { \
         return math_1(args, func, can_overflow, NULL);                  \
@@ -1090,6 +1114,12 @@ math_2(PyObject *const *args, Py_ssize_t nargs,
     }\
     PyDoc_STRVAR(math_##funcname##_doc, docstring);
 
+#define FUNC2NE(funcname, func, docstring) \
+    static PyObject * math_##funcname(PyObject *self, PyObject *const *args, Py_ssize_t nargs) { \
+        return math_2ne(args, nargs, func, #funcname); \
+    }\
+    PyDoc_STRVAR(math_##funcname##_doc, docstring);
+
 FUNC1D(acos, acos, 0,
       "acos($module, x, /)\n--\n\n"
       "Return the arc cosine (measured in radians) of x.\n\n"
@@ -1121,11 +1151,14 @@ FUNC1(atan, atan, 0,
       "atan($module, x, /)\n--\n\n"
       "Return the arc tangent (measured in radians) of x.\n\n"
       "The result is between -pi/2 and pi/2.")
-FUNC2(atan2, atan2,
+/* gh-153144: Ignore atan2 and atan2pi errno on purpose since it can optionally
+ *            be EDOM, which we should ignore, or ERANGE on underflow, which is
+ *            silent on Python.  Overflow is not possible. */
+FUNC2NE(atan2, atan2,
       "atan2($module, y, x, /)\n--\n\n"
       "Return the arc tangent (measured in radians) of y/x.\n\n"
       "Unlike atan(y/x), the signs of both x and y are considered.")
-FUNC2(atan2pi, m_atan2pi,
+FUNC2NE(atan2pi, m_atan2pi,
       "atan2pi($module, y, x, /)\n--\n\n"
       "Return the arc tangent (measured in half-turns) of y/x.\n\n"
       "Unlike atanpi(y/x), the signs of both x and y are considered.")
@@ -1178,7 +1211,7 @@ math_ceil(PyObject *module, PyObject *number)
     return PyLong_FromDouble(ceil(x));
 }
 
-FUNC2(copysign, copysign,
+FUNC2NE(copysign, copysign,
       "copysign($module, x, y, /)\n--\n\n"
        "Return a float with the magnitude (absolute value) of x but the sign of y.\n\n"
       "On platforms that support signed zeros, copysign(1.0, -0.0)\n"