address review and align tests with C11 standard

Author: picnixz

Doc/library/math.rst

@@ -253,8 +253,10 @@ Floating point arithmetic
 
    Get the larger of two floating-point values, treating NaNs as missing data.
 
-   When both operands are NaNs, return ``nan`` (the sign of the result is
-   implementation-defined).
+   When both operands are (signed) NaNs or zeroes, return ``nan`` and ``0``
+   respectively and the sign of the result is implementation-defined, that
+   is, :func:`!fmax` is not required to be sensitive to the sign of such
+   operands (see ISO C11, Annexes F.10.0.3 and F.10.9.2).
 
    .. versionadded:: next
 
@@ -263,8 +265,10 @@ Floating point arithmetic
 
    Get the smaller of two floating-point values, treating NaNs as missing data.
 
-   When both operands are NaNs, return ``nan`` (the sign of the result is
-   implementation-defined).
+   When both operands are (signed) NaNs or zeroes, return ``nan`` and ``0``
+   respectively and the sign of the result is implementation-defined, that
+   is, :func:`!fmin` is not required to be sensitive to the sign of such
+   operands (see ISO C11, Annexes F.10.0.3 and F.10.9.3).
 
    .. versionadded:: next
 

Lib/test/test_math.py

@@ -629,8 +629,9 @@ def test_fmax(self):
         self.assertRaises(TypeError, math.fmax, 'x', 'y')
 
         self.assertEqual(math.fmax(0., 0.), 0.)
-        self.assertEqual(math.fmax(0., -0.), 0.)
-        self.assertEqual(math.fmax(-0., 0.), 0.)
+        # fmax() does not need to be sensitive to the sign of 0 (F.10.9.2.3).
+        self.assertIn(math.fmax(0., -0.), {-0., 0.})
+        self.assertIn(math.fmax(-0., 0.), {-0., 0.})
 
         self.assertEqual(math.fmax(1., 0.), 1.)
         self.assertEqual(math.fmax(0., 1.), 1.)
@@ -645,26 +646,23 @@ def test_fmax(self):
         for x in [NINF, -1., -0., 0., 1., INF]:
             self.assertFalse(math.isnan(x))
 
-            with self.subTest("math.fmax(INF, x)", x=x):
+            with self.subTest(x=x, is_negative=math.copysign(1, x) < 0):
                 self.assertEqual(math.fmax(INF, x), INF)
-            with self.subTest("math.fmax(x, INF)", x=x):
                 self.assertEqual(math.fmax(x, INF), INF)
-
-            with self.subTest("math.fmax(NINF, x)", x=x):
                 self.assertEqual(math.fmax(NINF, x), x)
-            with self.subTest("math.fmax(x, NINF)", x=x):
                 self.assertEqual(math.fmax(x, NINF), x)
 
     @requires_IEEE_754
     def test_fmax_nans(self):
         # When exactly one operand is NaN, the other is returned.
         for x in [NINF, -1., -0., 0., 1., INF]:
-            with self.subTest(x=x):
+            with self.subTest(x=x, is_negative=math.copysign(1, x) < 0):
                 self.assertFalse(math.isnan(math.fmax(NAN, x)))
                 self.assertFalse(math.isnan(math.fmax(x, NAN)))
                 self.assertFalse(math.isnan(math.fmax(NNAN, x)))
                 self.assertFalse(math.isnan(math.fmax(x, NNAN)))
-        # When both operands are NaNs, fmax() returns NaN (see C11, F.10.9.2).
+        # When both operands are NaNs, fmax() returns NaN (see C11, F.10.9.2)
+        # whose sign is implementation-defined (see C11, F.10.0.3).
         self.assertTrue(math.isnan(math.fmax(NAN, NAN)))
         self.assertTrue(math.isnan(math.fmax(NNAN, NNAN)))
         self.assertTrue(math.isnan(math.fmax(NAN, NNAN)))
@@ -675,8 +673,9 @@ def test_fmin(self):
         self.assertRaises(TypeError, math.fmin, 'x', 'y')
 
         self.assertEqual(math.fmin(0., 0.), 0.)
-        self.assertEqual(math.fmin(0., -0.), -0.)
-        self.assertEqual(math.fmin(-0., 0.), -0.)
+        # fmin() does not need to be sensitive to the sign of 0 (F.10.9.3.1).
+        self.assertIn(math.fmin(0., -0.), {-0., 0.})
+        self.assertIn(math.fmin(-0., 0.), {-0., 0.})
 
         self.assertEqual(math.fmin(1., 0.), 0.)
         self.assertEqual(math.fmin(0., 1.), 0.)
@@ -691,26 +690,23 @@ def test_fmin(self):
         for x in [NINF, -1., -0., 0., 1., INF]:
             self.assertFalse(math.isnan(x))
 
-            with self.subTest("math.fmin(INF, x)", x=x):
+            with self.subTest(x=x, is_negative=math.copysign(1, x) < 0):
                 self.assertEqual(math.fmin(INF, x), x)
-            with self.subTest("math.fmin(x, INF)", x=x):
                 self.assertEqual(math.fmin(x, INF), x)
-
-            with self.subTest("math.fmin(NINF, x)", x=x):
                 self.assertEqual(math.fmin(NINF, x), NINF)
-            with self.subTest("math.fmin(x, NINF)", x=x):
                 self.assertEqual(math.fmin(x, NINF), NINF)
 
     @requires_IEEE_754
     def test_fmin_nans(self):
         # When exactly one operand is NaN, the other is returned.
         for x in [NINF, -1., -0., 0., 1., INF]:
-            with self.subTest(x=x):
+            with self.subTest(x=x, is_negative=math.copysign(1, x) < 0):
                 self.assertFalse(math.isnan(math.fmin(NAN, x)))
                 self.assertFalse(math.isnan(math.fmin(x, NAN)))
                 self.assertFalse(math.isnan(math.fmin(NNAN, x)))
                 self.assertFalse(math.isnan(math.fmin(x, NNAN)))
-        # When both operands are NaNs, fmin() returns NaN (see C11, F.10.9.3).
+        # When both operands are NaNs, fmin() returns NaN (see C11, F.10.9.2)
+        # whose sign is implementation-defined (see C11, F.10.0.3).
         self.assertTrue(math.isnan(math.fmin(NAN, NAN)))
         self.assertTrue(math.isnan(math.fmin(NNAN, NNAN)))
         self.assertTrue(math.isnan(math.fmin(NAN, NNAN)))

Misc/NEWS.d/next/Library/2025-06-24-13-30-47.gh-issue-135853.7ejTvK.rst

@@ -1,2 +1,2 @@
-Add :func:`math.fmax` and :math:`math.fmin` to get the larger and smaller of
+Add :func:`math.fmax` and :func:`math.fmin` to get the larger and smaller of
 two floating-point values. Patch by Bénédikt Tran.

Modules/clinic/mathmodule.c.h

@@ -1221,12 +1221,12 @@ math.fmax -> double
     y: double
     /
 
-Returns the larger of two floating-point arguments.
+Return the larger of two floating-point arguments.
 [clinic start generated code]*/
 
 static double
 math_fmax_impl(PyObject *module, double x, double y)
-/*[clinic end generated code: output=00692358d312fee2 input=e64ab9f40a60f4f1]*/
+/*[clinic end generated code: output=00692358d312fee2 input=021596c027336ffe]*/
 {
     return fmax(x, y);
 }
@@ -1238,12 +1238,12 @@ math.fmin -> double
     y: double
     /
 
-Returns the smaller of two floating-point arguments.
+Return the smaller of two floating-point arguments.
 [clinic start generated code]*/
 
 static double
 math_fmin_impl(PyObject *module, double x, double y)
-/*[clinic end generated code: output=3d5b7826bd292dd9 input=f7b5c91de01d766f]*/
+/*[clinic end generated code: output=3d5b7826bd292dd9 input=d12e64ccc33f878a]*/
 {
     return fmin(x, y);
 }