gh-120026: soft deprecate Py_HUGE_VAL macro (#120027)

Co-authored-by: Adam Turner <9087854+AA-Turner@users.noreply.github.com>

diff --git a/Doc/c-api/conversion.rst b/Doc/c-api/conversion.rst
index 4aaf3905e81c8a6e637107d046e05ce1d98dc71e..c92ef4c653a675fc894025ecd6ec3eb29a0ee33c 100644 (file)
--- a/Doc/c-api/conversion.rst
+++ b/Doc/c-api/conversion.rst
@@ -105,7 +105,7 @@ The following functions provide locale-independent string to number conversions.
 
    If ``s`` represents a value that is too large to store in a float
    (for example, ``"1e500"`` is such a string on many platforms) then
-   if ``overflow_exception`` is ``NULL`` return ``Py_HUGE_VAL`` (with
+   if ``overflow_exception`` is ``NULL`` return ``Py_INFINITY`` (with
    an appropriate sign) and don't set any exception.  Otherwise,
    ``overflow_exception`` must point to a Python exception object;
    raise that exception and return ``-1.0``.  In both cases, set

diff --git a/Doc/whatsnew/3.14.rst b/Doc/whatsnew/3.14.rst
index db32be89cf88ffaa06fe7d86436b897a06e363c5..21bc289c2be5d8113f860960af704843ffd25716 100644 (file)
--- a/Doc/whatsnew/3.14.rst
+++ b/Doc/whatsnew/3.14.rst
@@ -812,6 +812,10 @@ Porting to Python 3.14
 Deprecated
 ----------
 
+* The :c:macro:`!Py_HUGE_VAL` macro is :term:`soft deprecated`,
+  use :c:macro:`!Py_INFINITY` instead.
+  (Contributed by Sergey B Kirpichev in :gh:`120026`.)
+
 * Macros :c:macro:`!Py_IS_NAN`, :c:macro:`!Py_IS_INFINITY`
   and :c:macro:`!Py_IS_FINITE` are :term:`soft deprecated`,
   use instead :c:macro:`!isnan`, :c:macro:`!isinf` and

diff --git a/Include/floatobject.h b/Include/floatobject.h
index 8963c16832a4bc6f7f38b9db2327e76ba44464e5..4d24a76edd5de1bd88b901f27f624c75ef4f861c 100644 (file)
--- a/Include/floatobject.h
+++ b/Include/floatobject.h
@@ -21,10 +21,10 @@ PyAPI_DATA(PyTypeObject) PyFloat_Type;
 #define Py_RETURN_INF(sign)                          \
     do {                                             \
         if (copysign(1., sign) == 1.) {              \
-            return PyFloat_FromDouble(Py_HUGE_VAL);  \
+            return PyFloat_FromDouble(Py_INFINITY);  \
         }                                            \
         else {                                       \
-            return PyFloat_FromDouble(-Py_HUGE_VAL); \
+            return PyFloat_FromDouble(-Py_INFINITY); \
         }                                            \
     } while(0)
 

diff --git a/Include/internal/pycore_pymath.h b/Include/internal/pycore_pymath.h
index 7a4e1c1eb714f732a399baaecb81848b8d0f5527..eea8996ba68ca0868ab0dfda35ee7c2e7e037053 100644 (file)
--- a/Include/internal/pycore_pymath.h
+++ b/Include/internal/pycore_pymath.h
@@ -33,7 +33,7 @@ extern "C" {
 static inline void _Py_ADJUST_ERANGE1(double x)
 {
     if (errno == 0) {
-        if (x == Py_HUGE_VAL || x == -Py_HUGE_VAL) {
+        if (x == Py_INFINITY || x == -Py_INFINITY) {
             errno = ERANGE;
         }
     }
@@ -44,8 +44,8 @@ static inline void _Py_ADJUST_ERANGE1(double x)
 
 static inline void _Py_ADJUST_ERANGE2(double x, double y)
 {
-    if (x == Py_HUGE_VAL || x == -Py_HUGE_VAL ||
-        y == Py_HUGE_VAL || y == -Py_HUGE_VAL)
+    if (x == Py_INFINITY || x == -Py_INFINITY ||
+        y == Py_INFINITY || y == -Py_INFINITY)
     {
         if (errno == 0) {
             errno = ERANGE;

diff --git a/Include/pymath.h b/Include/pymath.h
index d8f763f808d6620360be6f359273a4d696ee8778..0ead1f95670fdee9d7f5b7e43bee81d6bfd5fa33 100644 (file)
--- a/Include/pymath.h
+++ b/Include/pymath.h
@@ -49,7 +49,7 @@
 
 /* Py_HUGE_VAL should always be the same as Py_INFINITY.  But historically
  * this was not reliable and Python did not require IEEE floats and C99
- * conformity.  Prefer Py_INFINITY for new code.
+ * conformity.  The macro was soft deprecated in Python 3.14, use Py_INFINITY instead.
  */
 #ifndef Py_HUGE_VAL
 #  define Py_HUGE_VAL HUGE_VAL

diff --git a/Misc/NEWS.d/next/C_API/2024-06-04-13-38-44.gh-issue-120026.uhEvJ9.rst b/Misc/NEWS.d/next/C_API/2024-06-04-13-38-44.gh-issue-120026.uhEvJ9.rst
new file mode 100644 (file)
index 0000000..d43a138
--- /dev/null
+++ b/Misc/NEWS.d/next/C_API/2024-06-04-13-38-44.gh-issue-120026.uhEvJ9.rst
@@ -0,0 +1 @@
+The :c:macro:`!Py_HUGE_VAL` macro is :term:`soft deprecated`.

diff --git a/Modules/cmathmodule.c b/Modules/cmathmodule.c
index e07c2dbd26235488584f155b3d06bc8738b22c37..81cbf0d554de3c93c0b3da8bbd34b3e57cf21499 100644 (file)
--- a/Modules/cmathmodule.c
+++ b/Modules/cmathmodule.c
@@ -150,7 +150,7 @@ special_type(double d)
 #define P14 0.25*Py_MATH_PI
 #define P12 0.5*Py_MATH_PI
 #define P34 0.75*Py_MATH_PI
-#define INF Py_HUGE_VAL
+#define INF Py_INFINITY
 #define N Py_NAN
 #define U -9.5426319407711027e33 /* unlikely value, used as placeholder */
 

diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index ad23dadd7b86cc3efdf89d24dbd427d618c9e89f..7e8d8b3f5bafa23eb6cc27f63461e007b0a106d1 100644 (file)
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -438,7 +438,7 @@ m_tgamma(double x)
         }
         else {
             errno = ERANGE;
-            return Py_HUGE_VAL;
+            return Py_INFINITY;
         }
     }
 
@@ -502,14 +502,14 @@ m_lgamma(double x)
         if (isnan(x))
             return x;  /* lgamma(nan) = nan */
         else
-            return Py_HUGE_VAL; /* lgamma(+-inf) = +inf */
+            return Py_INFINITY; /* lgamma(+-inf) = +inf */
     }
 
     /* integer arguments */
     if (x == floor(x) && x <= 2.0) {
         if (x <= 0.0) {
             errno = EDOM;  /* lgamma(n) = inf, divide-by-zero for */
-            return Py_HUGE_VAL; /* integers n <= 0 */
+            return Py_INFINITY; /* integers n <= 0 */
         }
         else {
             return 0.0; /* lgamma(1) = lgamma(2) = 0.0 */
@@ -645,7 +645,7 @@ m_log(double x)
             return log(x);
         errno = EDOM;
         if (x == 0.0)
-            return -Py_HUGE_VAL; /* log(0) = -inf */
+            return -Py_INFINITY; /* log(0) = -inf */
         else
             return Py_NAN; /* log(-ve) = nan */
     }
@@ -688,7 +688,7 @@ m_log2(double x)
     }
     else if (x == 0.0) {
         errno = EDOM;
-        return -Py_HUGE_VAL; /* log2(0) = -inf, divide-by-zero */
+        return -Py_INFINITY; /* log2(0) = -inf, divide-by-zero */
     }
     else {
         errno = EDOM;
@@ -704,7 +704,7 @@ m_log10(double x)
             return log10(x);
         errno = EDOM;
         if (x == 0.0)
-            return -Py_HUGE_VAL; /* log10(0) = -inf */
+            return -Py_INFINITY; /* log10(0) = -inf */
         else
             return Py_NAN; /* log10(-ve) = nan */
     }
@@ -2126,7 +2126,7 @@ math_ldexp_impl(PyObject *module, double x, PyObject *i)
         errno = 0;
     } else if (exp > INT_MAX) {
         /* overflow */
-        r = copysign(Py_HUGE_VAL, x);
+        r = copysign(Py_INFINITY, x);
         errno = ERANGE;
     } else if (exp < INT_MIN) {
         /* underflow to +-0 */

diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index d66863febe8c863e869b0928e1ad2f572be37907..7e14a8ad959590ce130733dd85b56b957899270c 100644 (file)
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -2390,7 +2390,7 @@ PyFloat_Unpack2(const char *data, int le)
     if (e == 0x1f) {
         if (f == 0) {
             /* Infinity */
-            return sign ? -Py_HUGE_VAL : Py_HUGE_VAL;
+            return sign ? -Py_INFINITY : Py_INFINITY;
         }
         else {
             /* NaN */

diff --git a/Python/pystrtod.c b/Python/pystrtod.c
index 2f2b588bd147d8998f33efda9b919807e3b42d0b..7b74f613ed563b56ddce89e10da63596191d7ba8 100644 (file)
--- a/Python/pystrtod.c
+++ b/Python/pystrtod.c
@@ -43,7 +43,7 @@ _Py_parse_inf_or_nan(const char *p, char **endptr)
         s += 3;
         if (case_insensitive_match(s, "inity"))
             s += 5;
-        retval = negate ? -Py_HUGE_VAL : Py_HUGE_VAL;
+        retval = negate ? -Py_INFINITY : Py_INFINITY;
     }
     else if (case_insensitive_match(s, "nan")) {
         s += 3;
@@ -286,7 +286,7 @@ _PyOS_ascii_strtod(const char *nptr, char **endptr)
    string, -1.0 is returned and again ValueError is raised.
 
    On overflow (e.g., when trying to convert '1e500' on an IEEE 754 machine),
-   if overflow_exception is NULL then +-Py_HUGE_VAL is returned, and no Python
+   if overflow_exception is NULL then +-Py_INFINITY is returned, and no Python
    exception is raised.  Otherwise, overflow_exception should point to
    a Python exception, this exception will be raised, -1.0 will be returned,
    and *endptr will point just past the end of the converted value.