gh-119613: Use C99+ functions instead of Py_IS_NAN/INFINITY/FINITE (#119619)

diff --git a/Modules/_decimal/_decimal.c b/Modules/_decimal/_decimal.c
index 2daa24c823a54287b5b5b23a4307a64765072e14..94a2cc2c8e5f8a945f00542ee1342d958b24c93b 100644 (file)
--- a/Modules/_decimal/_decimal.c
+++ b/Modules/_decimal/_decimal.c
@@ -2425,12 +2425,12 @@ PyDecType_FromFloatExact(PyTypeObject *type, PyObject *v,
     }
     sign = (copysign(1.0, x) == 1.0) ? 0 : 1;
 
-    if (Py_IS_NAN(x) || Py_IS_INFINITY(x)) {
+    if (isnan(x) || isinf(x)) {
         dec = PyDecType_New(type);
         if (dec == NULL) {
             return NULL;
         }
-        if (Py_IS_NAN(x)) {
+        if (isnan(x)) {
             /* decimal.py calls repr(float(+-nan)),
              * which always gives a positive result. */
             mpd_setspecial(MPD(dec), MPD_POS, MPD_NAN);

diff --git a/Modules/_json.c b/Modules/_json.c
index e33ef1f5eea92f04904f458fbdbb7c4149cab082..c7fe1561bb10186e95be60a88a725ba2c2a9ac1f 100644 (file)
--- a/Modules/_json.c
+++ b/Modules/_json.c
@@ -1326,7 +1326,7 @@ encoder_encode_float(PyEncoderObject *s, PyObject *obj)
 {
     /* Return the JSON representation of a PyFloat. */
     double i = PyFloat_AS_DOUBLE(obj);
-    if (!Py_IS_FINITE(i)) {
+    if (!isfinite(i)) {
         if (!s->allow_nan) {
             PyErr_Format(
                     PyExc_ValueError,

diff --git a/Modules/cmathmodule.c b/Modules/cmathmodule.c
index d901b350bc53430932028234d0d0e9588a76ce35..bf86a211bcb18826721c6e1fc17879706a6de85a 100644 (file)
--- a/Modules/cmathmodule.c
+++ b/Modules/cmathmodule.c
@@ -117,7 +117,7 @@ enum special_types {
 static enum special_types
 special_type(double d)
 {
-    if (Py_IS_FINITE(d)) {
+    if (isfinite(d)) {
         if (d != 0) {
             if (copysign(1., d) == 1.)
                 return ST_POS;
@@ -131,7 +131,7 @@ special_type(double d)
                 return ST_NZERO;
         }
     }
-    if (Py_IS_NAN(d))
+    if (isnan(d))
         return ST_NAN;
     if (copysign(1., d) == 1.)
         return ST_PINF;
@@ -139,11 +139,11 @@ special_type(double d)
         return ST_NINF;
 }
 
-#define SPECIAL_VALUE(z, table)                                         \
-    if (!Py_IS_FINITE((z).real) || !Py_IS_FINITE((z).imag)) {           \
-        errno = 0;                                              \
-        return table[special_type((z).real)]                            \
-                    [special_type((z).imag)];                           \
+#define SPECIAL_VALUE(z, table)                       \
+    if (!isfinite((z).real) || !isfinite((z).imag)) { \
+        errno = 0;                                    \
+        return table[special_type((z).real)]          \
+                    [special_type((z).imag)];         \
     }
 
 #define P Py_MATH_PI
@@ -329,10 +329,10 @@ cmath_atan_impl(PyObject *module, Py_complex z)
 static double
 c_atan2(Py_complex z)
 {
-    if (Py_IS_NAN(z.real) || Py_IS_NAN(z.imag))
+    if (isnan(z.real) || isnan(z.imag))
         return Py_NAN;
-    if (Py_IS_INFINITY(z.imag)) {
-        if (Py_IS_INFINITY(z.real)) {
+    if (isinf(z.imag)) {
+        if (isinf(z.real)) {
             if (copysign(1., z.real) == 1.)
                 /* atan2(+-inf, +inf) == +-pi/4 */
                 return copysign(0.25*Py_MATH_PI, z.imag);
@@ -343,7 +343,7 @@ c_atan2(Py_complex z)
         /* atan2(+-inf, x) == +-pi/2 for finite x */
         return copysign(0.5*Py_MATH_PI, z.imag);
     }
-    if (Py_IS_INFINITY(z.real) || z.imag == 0.) {
+    if (isinf(z.real) || z.imag == 0.) {
         if (copysign(1., z.real) == 1.)
             /* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
             return copysign(0., z.imag);
@@ -448,8 +448,8 @@ cmath_cosh_impl(PyObject *module, Py_complex z)
     double x_minus_one;
 
     /* special treatment for cosh(+/-inf + iy) if y is not a NaN */
-    if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
-        if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag) &&
+    if (!isfinite(z.real) || !isfinite(z.imag)) {
+        if (isinf(z.real) && isfinite(z.imag) &&
             (z.imag != 0.)) {
             if (z.real > 0) {
                 r.real = copysign(INF, cos(z.imag));
@@ -466,7 +466,7 @@ cmath_cosh_impl(PyObject *module, Py_complex z)
         }
         /* need to set errno = EDOM if y is +/- infinity and x is not
            a NaN */
-        if (Py_IS_INFINITY(z.imag) && !Py_IS_NAN(z.real))
+        if (isinf(z.imag) && !isnan(z.real))
             errno = EDOM;
         else
             errno = 0;
@@ -484,7 +484,7 @@ cmath_cosh_impl(PyObject *module, Py_complex z)
         r.imag = sin(z.imag) * sinh(z.real);
     }
     /* detect overflow, and set errno accordingly */
-    if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag))
+    if (isinf(r.real) || isinf(r.imag))
         errno = ERANGE;
     else
         errno = 0;
@@ -509,8 +509,8 @@ cmath_exp_impl(PyObject *module, Py_complex z)
     Py_complex r;
     double l;
 
-    if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
-        if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag)
+    if (!isfinite(z.real) || !isfinite(z.imag)) {
+        if (isinf(z.real) && isfinite(z.imag)
             && (z.imag != 0.)) {
             if (z.real > 0) {
                 r.real = copysign(INF, cos(z.imag));
@@ -527,9 +527,9 @@ cmath_exp_impl(PyObject *module, Py_complex z)
         }
         /* need to set errno = EDOM if y is +/- infinity and x is not
            a NaN and not -infinity */
-        if (Py_IS_INFINITY(z.imag) &&
-            (Py_IS_FINITE(z.real) ||
-             (Py_IS_INFINITY(z.real) && z.real > 0)))
+        if (isinf(z.imag) &&
+            (isfinite(z.real) ||
+             (isinf(z.real) && z.real > 0)))
             errno = EDOM;
         else
             errno = 0;
@@ -546,7 +546,7 @@ cmath_exp_impl(PyObject *module, Py_complex z)
         r.imag = l*sin(z.imag);
     }
     /* detect overflow, and set errno accordingly */
-    if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag))
+    if (isinf(r.real) || isinf(r.imag))
         errno = ERANGE;
     else
         errno = 0;
@@ -686,8 +686,8 @@ cmath_sinh_impl(PyObject *module, Py_complex z)
 
     /* special treatment for sinh(+/-inf + iy) if y is finite and
        nonzero */
-    if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
-        if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag)
+    if (!isfinite(z.real) || !isfinite(z.imag)) {
+        if (isinf(z.real) && isfinite(z.imag)
             && (z.imag != 0.)) {
             if (z.real > 0) {
                 r.real = copysign(INF, cos(z.imag));
@@ -704,7 +704,7 @@ cmath_sinh_impl(PyObject *module, Py_complex z)
         }
         /* need to set errno = EDOM if y is +/- infinity and x is not
            a NaN */
-        if (Py_IS_INFINITY(z.imag) && !Py_IS_NAN(z.real))
+        if (isinf(z.imag) && !isnan(z.real))
             errno = EDOM;
         else
             errno = 0;
@@ -720,7 +720,7 @@ cmath_sinh_impl(PyObject *module, Py_complex z)
         r.imag = sin(z.imag) * cosh(z.real);
     }
     /* detect overflow, and set errno accordingly */
-    if (Py_IS_INFINITY(r.real) || Py_IS_INFINITY(r.imag))
+    if (isinf(r.real) || isinf(r.imag))
         errno = ERANGE;
     else
         errno = 0;
@@ -856,8 +856,8 @@ cmath_tanh_impl(PyObject *module, Py_complex z)
 
     /* special treatment for tanh(+/-inf + iy) if y is finite and
        nonzero */
-    if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
-        if (Py_IS_INFINITY(z.real) && Py_IS_FINITE(z.imag)
+    if (!isfinite(z.real) || !isfinite(z.imag)) {
+        if (isinf(z.real) && isfinite(z.imag)
             && (z.imag != 0.)) {
             if (z.real > 0) {
                 r.real = 1.0;
@@ -876,7 +876,7 @@ cmath_tanh_impl(PyObject *module, Py_complex z)
         }
         /* need to set errno = EDOM if z.imag is +/-infinity and
            z.real is finite */
-        if (Py_IS_INFINITY(z.imag) && Py_IS_FINITE(z.real))
+        if (isinf(z.imag) && isfinite(z.real))
             errno = EDOM;
         else
             errno = 0;
@@ -1030,11 +1030,11 @@ cmath_rect_impl(PyObject *module, double r, double phi)
     errno = 0;
 
     /* deal with special values */
-    if (!Py_IS_FINITE(r) || !Py_IS_FINITE(phi)) {
+    if (!isfinite(r) || !isfinite(phi)) {
         /* if r is +/-infinity and phi is finite but nonzero then
            result is (+-INF +-INF i), but we need to compute cos(phi)
            and sin(phi) to figure out the signs. */
-        if (Py_IS_INFINITY(r) && (Py_IS_FINITE(phi)
+        if (isinf(r) && (isfinite(phi)
                                   && (phi != 0.))) {
             if (r > 0) {
                 z.real = copysign(INF, cos(phi));
@@ -1051,7 +1051,7 @@ cmath_rect_impl(PyObject *module, double r, double phi)
         }
         /* need to set errno = EDOM if r is a nonzero number and phi
            is infinite */
-        if (r != 0. && !Py_IS_NAN(r) && Py_IS_INFINITY(phi))
+        if (r != 0. && !isnan(r) && isinf(phi))
             errno = EDOM;
         else
             errno = 0;
@@ -1085,7 +1085,7 @@ static PyObject *
 cmath_isfinite_impl(PyObject *module, Py_complex z)
 /*[clinic end generated code: output=ac76611e2c774a36 input=848e7ee701895815]*/
 {
-    return PyBool_FromLong(Py_IS_FINITE(z.real) && Py_IS_FINITE(z.imag));
+    return PyBool_FromLong(isfinite(z.real) && isfinite(z.imag));
 }
 
 /*[clinic input]
@@ -1098,7 +1098,7 @@ static PyObject *
 cmath_isnan_impl(PyObject *module, Py_complex z)
 /*[clinic end generated code: output=e7abf6e0b28beab7 input=71799f5d284c9baf]*/
 {
-    return PyBool_FromLong(Py_IS_NAN(z.real) || Py_IS_NAN(z.imag));
+    return PyBool_FromLong(isnan(z.real) || isnan(z.imag));
 }
 
 /*[clinic input]
@@ -1111,8 +1111,7 @@ static PyObject *
 cmath_isinf_impl(PyObject *module, Py_complex z)
 /*[clinic end generated code: output=502a75a79c773469 input=363df155c7181329]*/
 {
-    return PyBool_FromLong(Py_IS_INFINITY(z.real) ||
-                           Py_IS_INFINITY(z.imag));
+    return PyBool_FromLong(isinf(z.real) || isinf(z.imag));
 }
 
 /*[clinic input]
@@ -1167,8 +1166,7 @@ cmath_isclose_impl(PyObject *module, Py_complex a, Py_complex b,
        above.
     */
 
-    if (Py_IS_INFINITY(a.real) || Py_IS_INFINITY(a.imag) ||
-        Py_IS_INFINITY(b.real) || Py_IS_INFINITY(b.imag)) {
+    if (isinf(a.real) || isinf(a.imag) || isinf(b.real) || isinf(b.imag)) {
         return 0;
     }
 

diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index a79694730a8e4e8136fdc5dccb7975220064c124..6defa973da09522125a8ab9ad02a2b8019665008 100644 (file)
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -237,7 +237,7 @@ m_sinpi(double x)
     double y, r;
     int n;
     /* this function should only ever be called for finite arguments */
-    assert(Py_IS_FINITE(x));
+    assert(isfinite(x));
     y = fmod(fabs(x), 2.0);
     n = (int)round(2.0*y);
     assert(0 <= n && n <= 4);
@@ -396,8 +396,8 @@ m_tgamma(double x)
     double absx, r, y, z, sqrtpow;
 
     /* special cases */
-    if (!Py_IS_FINITE(x)) {
-        if (Py_IS_NAN(x) || x > 0.0)
+    if (!isfinite(x)) {
+        if (isnan(x) || x > 0.0)
             return x;  /* tgamma(nan) = nan, tgamma(inf) = inf */
         else {
             errno = EDOM;
@@ -424,7 +424,7 @@ m_tgamma(double x)
     /* tiny arguments:  tgamma(x) ~ 1/x for x near 0 */
     if (absx < 1e-20) {
         r = 1.0/x;
-        if (Py_IS_INFINITY(r))
+        if (isinf(r))
             errno = ERANGE;
         return r;
     }
@@ -481,7 +481,7 @@ m_tgamma(double x)
             r *= sqrtpow;
         }
     }
-    if (Py_IS_INFINITY(r))
+    if (isinf(r))
         errno = ERANGE;
     return r;
 }
@@ -498,8 +498,8 @@ m_lgamma(double x)
     double absx;
 
     /* special cases */
-    if (!Py_IS_FINITE(x)) {
-        if (Py_IS_NAN(x))
+    if (!isfinite(x)) {
+        if (isnan(x))
             return x;  /* lgamma(nan) = nan */
         else
             return Py_HUGE_VAL; /* lgamma(+-inf) = +inf */
@@ -530,7 +530,7 @@ m_lgamma(double x)
     if (x < 0.0)
         /* Use reflection formula to get value for negative x. */
         r = logpi - log(fabs(m_sinpi(absx))) - log(absx) - r;
-    if (Py_IS_INFINITY(r))
+    if (isinf(r))
         errno = ERANGE;
     return r;
 }
@@ -546,10 +546,10 @@ m_lgamma(double x)
 static double
 m_atan2(double y, double x)
 {
-    if (Py_IS_NAN(x) || Py_IS_NAN(y))
+    if (isnan(x) || isnan(y))
         return Py_NAN;
-    if (Py_IS_INFINITY(y)) {
-        if (Py_IS_INFINITY(x)) {
+    if (isinf(y)) {
+        if (isinf(x)) {
             if (copysign(1., x) == 1.)
                 /* atan2(+-inf, +inf) == +-pi/4 */
                 return copysign(0.25*Py_MATH_PI, y);
@@ -560,7 +560,7 @@ m_atan2(double y, double x)
         /* atan2(+-inf, x) == +-pi/2 for finite x */
         return copysign(0.5*Py_MATH_PI, y);
     }
-    if (Py_IS_INFINITY(x) || y == 0.) {
+    if (isinf(x) || y == 0.) {
         if (copysign(1., x) == 1.)
             /* atan2(+-y, +inf) = atan2(+-0, +x) = +-0. */
             return copysign(0., y);
@@ -580,7 +580,7 @@ static double
 m_remainder(double x, double y)
 {
     /* Deal with most common case first. */
-    if (Py_IS_FINITE(x) && Py_IS_FINITE(y)) {
+    if (isfinite(x) && isfinite(y)) {
         double absx, absy, c, m, r;
 
         if (y == 0.0) {
@@ -653,16 +653,16 @@ m_remainder(double x, double y)
     }
 
     /* Special values. */
-    if (Py_IS_NAN(x)) {
+    if (isnan(x)) {
         return x;
     }
-    if (Py_IS_NAN(y)) {
+    if (isnan(y)) {
         return y;
     }
-    if (Py_IS_INFINITY(x)) {
+    if (isinf(x)) {
         return Py_NAN;
     }
-    assert(Py_IS_INFINITY(y));
+    assert(isinf(y));
     return x;
 }
 
@@ -677,7 +677,7 @@ m_remainder(double x, double y)
 static double
 m_log(double x)
 {
-    if (Py_IS_FINITE(x)) {
+    if (isfinite(x)) {
         if (x > 0.0)
             return log(x);
         errno = EDOM;
@@ -686,7 +686,7 @@ m_log(double x)
         else
             return Py_NAN; /* log(-ve) = nan */
     }
-    else if (Py_IS_NAN(x))
+    else if (isnan(x))
         return x; /* log(nan) = nan */
     else if (x > 0.0)
         return x; /* log(inf) = inf */
@@ -709,8 +709,8 @@ m_log(double x)
 static double
 m_log2(double x)
 {
-    if (!Py_IS_FINITE(x)) {
-        if (Py_IS_NAN(x))
+    if (!isfinite(x)) {
+        if (isnan(x))
             return x; /* log2(nan) = nan */
         else if (x > 0.0)
             return x; /* log2(+inf) = +inf */
@@ -736,7 +736,7 @@ m_log2(double x)
 static double
 m_log10(double x)
 {
-    if (Py_IS_FINITE(x)) {
+    if (isfinite(x)) {
         if (x > 0.0)
             return log10(x);
         errno = EDOM;
@@ -745,7 +745,7 @@ m_log10(double x)
         else
             return Py_NAN; /* log10(-ve) = nan */
     }
-    else if (Py_IS_NAN(x))
+    else if (isnan(x))
         return x; /* log10(nan) = nan */
     else if (x > 0.0)
         return x; /* log10(inf) = inf */
@@ -966,12 +966,12 @@ math_1(PyObject *arg, double (*func) (double), int can_overflow)
         return NULL;
     errno = 0;
     r = (*func)(x);
-    if (Py_IS_NAN(r) && !Py_IS_NAN(x)) {
+    if (isnan(r) && !isnan(x)) {
         PyErr_SetString(PyExc_ValueError,
                         "math domain error"); /* invalid arg */
         return NULL;
     }
-    if (Py_IS_INFINITY(r) && Py_IS_FINITE(x)) {
+    if (isinf(r) && isfinite(x)) {
         if (can_overflow)
             PyErr_SetString(PyExc_OverflowError,
                             "math range error"); /* overflow */
@@ -980,7 +980,7 @@ math_1(PyObject *arg, double (*func) (double), int can_overflow)
                             "math domain error"); /* singularity */
         return NULL;
     }
-    if (Py_IS_FINITE(r) && errno && is_error(r))
+    if (isfinite(r) && errno && is_error(r))
         /* this branch unnecessary on most platforms */
         return NULL;
 
@@ -1049,14 +1049,14 @@ math_2(PyObject *const *args, Py_ssize_t nargs,
     }
     errno = 0;
     r = (*func)(x, y);
-    if (Py_IS_NAN(r)) {
-        if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
+    if (isnan(r)) {
+        if (!isnan(x) && !isnan(y))
             errno = EDOM;
         else
             errno = 0;
     }
-    else if (Py_IS_INFINITY(r)) {
-        if (Py_IS_FINITE(x) && Py_IS_FINITE(y))
+    else if (isinf(r)) {
+        if (isfinite(x) && isfinite(y))
             errno = ERANGE;
         else
             errno = 0;
@@ -1403,17 +1403,17 @@ math_fsum(PyObject *module, PyObject *seq)
 
         n = i;                              /* ps[i:] = [x] */
         if (x != 0.0) {
-            if (! Py_IS_FINITE(x)) {
+            if (! isfinite(x)) {
                 /* a nonfinite x could arise either as
                    a result of intermediate overflow, or
                    as a result of a nan or inf in the
                    summands */
-                if (Py_IS_FINITE(xsave)) {
+                if (isfinite(xsave)) {
                     PyErr_SetString(PyExc_OverflowError,
                           "intermediate overflow in fsum");
                     goto _fsum_error;
                 }
-                if (Py_IS_INFINITY(xsave))
+                if (isinf(xsave))
                     inf_sum += xsave;
                 special_sum += xsave;
                 /* reset partials */
@@ -1427,7 +1427,7 @@ math_fsum(PyObject *module, PyObject *seq)
     }
 
     if (special_sum != 0.0) {
-        if (Py_IS_NAN(inf_sum))
+        if (isnan(inf_sum))
             PyErr_SetString(PyExc_ValueError,
                             "-inf + inf in fsum");
         else
@@ -2108,7 +2108,7 @@ math_frexp_impl(PyObject *module, double x)
     int i;
     /* deal with special cases directly, to sidestep platform
        differences */
-    if (Py_IS_NAN(x) || Py_IS_INFINITY(x) || !x) {
+    if (isnan(x) || isinf(x) || !x) {
         i = 0;
     }
     else {
@@ -2153,7 +2153,7 @@ math_ldexp_impl(PyObject *module, double x, PyObject *i)
         return NULL;
     }
 
-    if (x == 0. || !Py_IS_FINITE(x)) {
+    if (x == 0. || !isfinite(x)) {
         /* NaNs, zeros and infinities are returned unchanged */
         r = x;
         errno = 0;
@@ -2168,7 +2168,7 @@ math_ldexp_impl(PyObject *module, double x, PyObject *i)
     } else {
         errno = 0;
         r = ldexp(x, (int)exp);
-        if (Py_IS_INFINITY(r))
+        if (isinf(r))
             errno = ERANGE;
     }
 
@@ -2196,9 +2196,9 @@ math_modf_impl(PyObject *module, double x)
     double y;
     /* some platforms don't do the right thing for NaNs and
        infinities, so we take care of special cases directly. */
-    if (Py_IS_INFINITY(x))
+    if (isinf(x))
         return Py_BuildValue("(dd)", copysign(0., x), x);
-    else if (Py_IS_NAN(x))
+    else if (isnan(x))
         return Py_BuildValue("(dd)", x, x);
 
     errno = 0;
@@ -2341,19 +2341,19 @@ math_fma_impl(PyObject *module, double x, double y, double z)
     double r = fma(x, y, z);
 
     /* Fast path: if we got a finite result, we're done. */
-    if (Py_IS_FINITE(r)) {
+    if (isfinite(r)) {
         return PyFloat_FromDouble(r);
     }
 
     /* Non-finite result. Raise an exception if appropriate, else return r. */
-    if (Py_IS_NAN(r)) {
-        if (!Py_IS_NAN(x) && !Py_IS_NAN(y) && !Py_IS_NAN(z)) {
+    if (isnan(r)) {
+        if (!isnan(x) && !isnan(y) && !isnan(z)) {
             /* NaN result from non-NaN inputs. */
             PyErr_SetString(PyExc_ValueError, "invalid operation in fma");
             return NULL;
         }
     }
-    else if (Py_IS_FINITE(x) && Py_IS_FINITE(y) && Py_IS_FINITE(z)) {
+    else if (isfinite(x) && isfinite(y) && isfinite(z)) {
         /* Infinite result from finite inputs. */
         PyErr_SetString(PyExc_OverflowError, "overflow in fma");
         return NULL;
@@ -2381,12 +2381,12 @@ math_fmod_impl(PyObject *module, double x, double y)
 {
     double r;
     /* fmod(x, +/-Inf) returns x for finite x. */
-    if (Py_IS_INFINITY(y) && Py_IS_FINITE(x))
+    if (isinf(y) && isfinite(x))
         return PyFloat_FromDouble(x);
     errno = 0;
     r = fmod(x, y);
-    if (Py_IS_NAN(r)) {
-        if (!Py_IS_NAN(x) && !Py_IS_NAN(y))
+    if (isnan(r)) {
+        if (!isnan(x) && !isnan(y))
             errno = EDOM;
         else
             errno = 0;
@@ -2508,7 +2508,7 @@ vector_norm(Py_ssize_t n, double *vec, double max, int found_nan)
     int max_e;
     Py_ssize_t i;
 
-    if (Py_IS_INFINITY(max)) {
+    if (isinf(max)) {
         return max;
     }
     if (found_nan) {
@@ -2530,7 +2530,7 @@ vector_norm(Py_ssize_t n, double *vec, double max, int found_nan)
     assert(max * scale < 1.0);
     for (i=0 ; i < n ; i++) {
         x = vec[i];
-        assert(Py_IS_FINITE(x) && fabs(x) <= max);
+        assert(isfinite(x) && fabs(x) <= max);
         x *= scale;                     // lossless scaling
         assert(fabs(x) < 1.0);
         pr = dl_mul(x, x);              // lossless squaring
@@ -2620,7 +2620,7 @@ math_dist_impl(PyObject *module, PyObject *p, PyObject *q)
         ASSIGN_DOUBLE(qx, item, error_exit);
         x = fabs(px - qx);
         diffs[i] = x;
-        found_nan |= Py_IS_NAN(x);
+        found_nan |= isnan(x);
         if (x > max) {
             max = x;
         }
@@ -2673,7 +2673,7 @@ math_hypot(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         ASSIGN_DOUBLE(x, item, error_exit);
         x = fabs(x);
         coordinates[i] = x;
-        found_nan |= Py_IS_NAN(x);
+        found_nan |= isnan(x);
         if (x > max) {
             max = x;
         }
@@ -2976,14 +2976,14 @@ math_pow_impl(PyObject *module, double x, double y)
     /* deal directly with IEEE specials, to cope with problems on various
        platforms whose semantics don't exactly match C99 */
     r = 0.; /* silence compiler warning */
-    if (!Py_IS_FINITE(x) || !Py_IS_FINITE(y)) {
+    if (!isfinite(x) || !isfinite(y)) {
         errno = 0;
-        if (Py_IS_NAN(x))
+        if (isnan(x))
             r = y == 0. ? 1. : x; /* NaN**0 = 1 */
-        else if (Py_IS_NAN(y))
+        else if (isnan(y))
             r = x == 1. ? 1. : y; /* 1**NaN = 1 */
-        else if (Py_IS_INFINITY(x)) {
-            odd_y = Py_IS_FINITE(y) && fmod(fabs(y), 2.0) == 1.0;
+        else if (isinf(x)) {
+            odd_y = isfinite(y) && fmod(fabs(y), 2.0) == 1.0;
             if (y > 0.)
                 r = odd_y ? x : fabs(x);
             else if (y == 0.)
@@ -2992,7 +2992,7 @@ math_pow_impl(PyObject *module, double x, double y)
                 r = odd_y ? copysign(0., x) : 0.;
         }
         else {
-            assert(Py_IS_INFINITY(y));
+            assert(isinf(y));
             if (fabs(x) == 1.0)
                 r = 1.;
             else if (y > 0. && fabs(x) > 1.0)
@@ -3010,8 +3010,8 @@ math_pow_impl(PyObject *module, double x, double y)
         r = pow(x, y);
         /* a NaN result should arise only from (-ve)**(finite
            non-integer); in this case we want to raise ValueError. */
-        if (!Py_IS_FINITE(r)) {
-            if (Py_IS_NAN(r)) {
+        if (!isfinite(r)) {
+            if (isnan(r)) {
                 errno = EDOM;
             }
             /*
@@ -3019,7 +3019,7 @@ math_pow_impl(PyObject *module, double x, double y)
                (A) (+/-0.)**negative (-> divide-by-zero)
                (B) overflow of x**y with x and y finite
             */
-            else if (Py_IS_INFINITY(r)) {
+            else if (isinf(r)) {
                 if (x == 0.)
                     errno = EDOM;
                 else
@@ -3085,7 +3085,7 @@ static PyObject *
 math_isfinite_impl(PyObject *module, double x)
 /*[clinic end generated code: output=8ba1f396440c9901 input=46967d254812e54a]*/
 {
-    return PyBool_FromLong((long)Py_IS_FINITE(x));
+    return PyBool_FromLong((long)isfinite(x));
 }
 
 
@@ -3102,7 +3102,7 @@ static PyObject *
 math_isnan_impl(PyObject *module, double x)
 /*[clinic end generated code: output=f537b4d6df878c3e input=935891e66083f46a]*/
 {
-    return PyBool_FromLong((long)Py_IS_NAN(x));
+    return PyBool_FromLong((long)isnan(x));
 }
 
 
@@ -3119,7 +3119,7 @@ static PyObject *
 math_isinf_impl(PyObject *module, double x)
 /*[clinic end generated code: output=9f00cbec4de7b06b input=32630e4212cf961f]*/
 {
-    return PyBool_FromLong((long)Py_IS_INFINITY(x));
+    return PyBool_FromLong((long)isinf(x));
 }
 
 
@@ -3176,7 +3176,7 @@ math_isclose_impl(PyObject *module, double a, double b, double rel_tol,
        above.
     */
 
-    if (Py_IS_INFINITY(a) || Py_IS_INFINITY(b)) {
+    if (isinf(a) || isinf(b)) {
         return 0;
     }
 
@@ -3926,10 +3926,10 @@ math_nextafter_impl(PyObject *module, double x, double y, PyObject *steps)
            Bug fixed in bos.adt.libm 7.2.2.0 by APAR IV95512. */
         return PyFloat_FromDouble(y);
     }
-    if (Py_IS_NAN(x)) {
+    if (isnan(x)) {
         return PyFloat_FromDouble(x);
     }
-    if (Py_IS_NAN(y)) {
+    if (isnan(y)) {
         return PyFloat_FromDouble(y);
     }
 #endif
@@ -3975,10 +3975,10 @@ math_nextafter_impl(PyObject *module, double x, double y, PyObject *steps)
     if (usteps == 0) {
         return PyFloat_FromDouble(x);
     }
-    if (Py_IS_NAN(x)) {
+    if (isnan(x)) {
         return PyFloat_FromDouble(x);
     }
-    if (Py_IS_NAN(y)) {
+    if (isnan(y)) {
         return PyFloat_FromDouble(y);
     }
 
@@ -4044,16 +4044,16 @@ static double
 math_ulp_impl(PyObject *module, double x)
 /*[clinic end generated code: output=f5207867a9384dd4 input=31f9bfbbe373fcaa]*/
 {
-    if (Py_IS_NAN(x)) {
+    if (isnan(x)) {
         return x;
     }
     x = fabs(x);
-    if (Py_IS_INFINITY(x)) {
+    if (isinf(x)) {
         return x;
     }
     double inf = Py_INFINITY;
     double x2 = nextafter(x, inf);
-    if (Py_IS_INFINITY(x2)) {
+    if (isinf(x2)) {
         /* special case: x is the largest positive representable float */
         x2 = nextafter(x, -inf);
         return x - x2;

diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index d8b0e84da5df4a16e9ad7725faf4ca18bdfcf7f2..943c5ccabfd5c42ff173656d314b37455ac78504 100644 (file)
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -188,16 +188,16 @@ _Py_c_abs(Py_complex z)
     /* sets errno = ERANGE on overflow;  otherwise errno = 0 */
     double result;
 
-    if (!Py_IS_FINITE(z.real) || !Py_IS_FINITE(z.imag)) {
+    if (!isfinite(z.real) || !isfinite(z.imag)) {
         /* C99 rules: if either the real or the imaginary part is an
            infinity, return infinity, even if the other part is a
            NaN. */
-        if (Py_IS_INFINITY(z.real)) {
+        if (isinf(z.real)) {
             result = fabs(z.real);
             errno = 0;
             return result;
         }
-        if (Py_IS_INFINITY(z.imag)) {
+        if (isinf(z.imag)) {
             result = fabs(z.imag);
             errno = 0;
             return result;
@@ -207,7 +207,7 @@ _Py_c_abs(Py_complex z)
         return Py_NAN;
     }
     result = hypot(z.real, z.imag);
-    if (!Py_IS_FINITE(result))
+    if (!isfinite(result))
         errno = ERANGE;
     else
         errno = 0;

diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 96227f2cf7d76fa2fbbad11a61a33357713a7ad4..a5bf356cc9c7f0eb1d8a6515beafc80e06a3e552 100644 (file)
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -418,7 +418,7 @@ float_richcompare(PyObject *v, PyObject *w, int op)
     if (PyFloat_Check(w))
         j = PyFloat_AS_DOUBLE(w);
 
-    else if (!Py_IS_FINITE(i)) {
+    else if (!isfinite(i)) {
         if (PyLong_Check(w))
             /* If i is an infinity, its magnitude exceeds any
              * finite integer, so it doesn't matter which int we
@@ -749,13 +749,13 @@ float_pow(PyObject *v, PyObject *w, PyObject *z)
     if (iw == 0) {              /* v**0 is 1, even 0**0 */
         return PyFloat_FromDouble(1.0);
     }
-    if (Py_IS_NAN(iv)) {        /* nan**w = nan, unless w == 0 */
+    if (isnan(iv)) {        /* nan**w = nan, unless w == 0 */
         return PyFloat_FromDouble(iv);
     }
-    if (Py_IS_NAN(iw)) {        /* v**nan = nan, unless v == 1; 1**nan = 1 */
+    if (isnan(iw)) {        /* v**nan = nan, unless v == 1; 1**nan = 1 */
         return PyFloat_FromDouble(iv == 1.0 ? 1.0 : iw);
     }
-    if (Py_IS_INFINITY(iw)) {
+    if (isinf(iw)) {
         /* v**inf is: 0.0 if abs(v) < 1; 1.0 if abs(v) == 1; inf if
          *     abs(v) > 1 (including case where v infinite)
          *
@@ -770,7 +770,7 @@ float_pow(PyObject *v, PyObject *w, PyObject *z)
         else
             return PyFloat_FromDouble(0.0);
     }
-    if (Py_IS_INFINITY(iv)) {
+    if (isinf(iv)) {
         /* (+-inf)**w is: inf for w positive, 0 for w negative; in
          *     both cases, we need to add the appropriate sign if w is
          *     an odd integer.
@@ -885,7 +885,7 @@ float_is_integer_impl(PyObject *self)
 
     if (x == -1.0 && PyErr_Occurred())
         return NULL;
-    if (!Py_IS_FINITE(x))
+    if (!isfinite(x))
         Py_RETURN_FALSE;
     errno = 0;
     o = (floor(x) == x) ? Py_True : Py_False;
@@ -1021,7 +1021,7 @@ double_round(double x, int ndigits) {
         }
         y = (x*pow1)*pow2;
         /* if y overflows, then rounded value is exactly x */
-        if (!Py_IS_FINITE(y))
+        if (!isfinite(y))
             return PyFloat_FromDouble(x);
     }
     else {
@@ -1041,7 +1041,7 @@ double_round(double x, int ndigits) {
         z *= pow1;
 
     /* if computation resulted in overflow, raise OverflowError */
-    if (!Py_IS_FINITE(z)) {
+    if (!isfinite(z)) {
         PyErr_SetString(PyExc_OverflowError,
                         "overflow occurred during round");
         return NULL;
@@ -1089,7 +1089,7 @@ float___round___impl(PyObject *self, PyObject *o_ndigits)
         return NULL;
 
     /* nans and infinities round to themselves */
-    if (!Py_IS_FINITE(x))
+    if (!isfinite(x))
         return PyFloat_FromDouble(x);
 
     /* Deal with extreme values for ndigits. For ndigits > NDIGITS_MAX, x
@@ -1237,7 +1237,7 @@ float_hex_impl(PyObject *self)
 
     CONVERT_TO_DOUBLE(self, x);
 
-    if (Py_IS_NAN(x) || Py_IS_INFINITY(x))
+    if (isnan(x) || isinf(x))
         return float_repr((PyFloatObject *)self);
 
     if (x == 0.0) {
@@ -1570,12 +1570,12 @@ float_as_integer_ratio_impl(PyObject *self)
 
     CONVERT_TO_DOUBLE(self, self_double);
 
-    if (Py_IS_INFINITY(self_double)) {
+    if (isinf(self_double)) {
         PyErr_SetString(PyExc_OverflowError,
                         "cannot convert Infinity to integer ratio");
         return NULL;
     }
-    if (Py_IS_NAN(self_double)) {
+    if (isnan(self_double)) {
         PyErr_SetString(PyExc_ValueError,
                         "cannot convert NaN to integer ratio");
         return NULL;
@@ -2060,12 +2060,12 @@ PyFloat_Pack2(double x, char *data, int le)
         e = 0;
         bits = 0;
     }
-    else if (Py_IS_INFINITY(x)) {
+    else if (isinf(x)) {
         sign = (x < 0.0);
         e = 0x1f;
         bits = 0;
     }
-    else if (Py_IS_NAN(x)) {
+    else if (isnan(x)) {
         /* There are 2046 distinct half-precision NaNs (1022 signaling and
            1024 quiet), but there are only two quiet NaNs that don't arise by
            quieting a signaling NaN; we get those by setting the topmost bit
@@ -2234,7 +2234,7 @@ PyFloat_Pack4(double x, char *data, int le)
         float y = (float)x;
         int i, incr = 1;
 
-        if (Py_IS_INFINITY(y) && !Py_IS_INFINITY(x))
+        if (isinf(y) && !isinf(x))
             goto Overflow;
 
         unsigned char s[sizeof(float)];

diff --git a/Objects/longobject.c b/Objects/longobject.c
index b0456a311409bf9d079a45363bfe14790f5d8ec7..2dc2cb7a47b46030ba67e12b28b096c9deb1ab17 100644 (file)
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -401,12 +401,12 @@ PyLong_FromDouble(double dval)
     double frac;
     int i, ndig, expo, neg;
     neg = 0;
-    if (Py_IS_INFINITY(dval)) {
+    if (isinf(dval)) {
         PyErr_SetString(PyExc_OverflowError,
                         "cannot convert float infinity to integer");
         return NULL;
     }
-    if (Py_IS_NAN(dval)) {
+    if (isnan(dval)) {
         PyErr_SetString(PyExc_ValueError,
                         "cannot convert float NaN to integer");
         return NULL;

diff --git a/Python/ast_unparse.c b/Python/ast_unparse.c
index 8aff045101cc72c422ee8a436b91be45540e8388..27c34008d4d5e60de39ae8f6617e9d41f29a97bf 100644 (file)
--- a/Python/ast_unparse.c
+++ b/Python/ast_unparse.c
@@ -79,7 +79,7 @@ append_repr(_PyUnicodeWriter *writer, PyObject *obj)
         return -1;
     }
 
-    if ((PyFloat_CheckExact(obj) && Py_IS_INFINITY(PyFloat_AS_DOUBLE(obj))) ||
+    if ((PyFloat_CheckExact(obj) && isinf(PyFloat_AS_DOUBLE(obj))) ||
        PyComplex_CheckExact(obj))
     {
         PyInterpreterState *interp = _PyInterpreterState_GET();

diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index d192d5be751cfc99ded50a9f7a80bdf80f84801a..2a02d8161591c60fa786aacb29a5324dc411f8e4 100644 (file)
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -2640,7 +2640,7 @@ builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start)
                 /* Avoid losing the sign on a negative result,
                    and don't let adding the compensation convert
                    an infinite or overflowed sum to a NaN. */
-                if (c && Py_IS_FINITE(c)) {
+                if (c && isfinite(c)) {
                     f_result += c;
                 }
                 return PyFloat_FromDouble(f_result);
@@ -2672,7 +2672,7 @@ builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start)
                     continue;
                 }
             }
-            if (c && Py_IS_FINITE(c)) {
+            if (c && isfinite(c)) {
                 f_result += c;
             }
             result = PyFloat_FromDouble(f_result);

diff --git a/Python/pyhash.c b/Python/pyhash.c
index 5263622ff3126d39039923aff47b7ddc728d7840..4145d9ef4fd7ef90ff8a1688da24da7fa598acdf 100644 (file)
--- a/Python/pyhash.c
+++ b/Python/pyhash.c
@@ -90,8 +90,8 @@ _Py_HashDouble(PyObject *inst, double v)
     double m;
     Py_uhash_t x, y;
 
-    if (!Py_IS_FINITE(v)) {
-        if (Py_IS_INFINITY(v))
+    if (!isfinite(v)) {
+        if (isinf(v))
             return v > 0 ? _PyHASH_INF : -_PyHASH_INF;
         else
             return PyObject_GenericHash(inst);

diff --git a/Python/pystrtod.c b/Python/pystrtod.c
index 16bf06f0e6cca2fb4ea5bcbbcdd8fbb05969b0a0..5c8be0447ace4bbd13788b9a7f6990072ed06f7b 100644 (file)
--- a/Python/pystrtod.c
+++ b/Python/pystrtod.c
@@ -842,7 +842,7 @@ char * PyOS_double_to_string(double val,
 
     */
 
-    if (Py_IS_NAN(val) || Py_IS_INFINITY(val))
+    if (isnan(val) || isinf(val))
         /* 3 for 'inf'/'nan', 1 for sign, 1 for '\0' */
         bufsize = 5;
     else {
@@ -860,10 +860,10 @@ char * PyOS_double_to_string(double val,
     }
 
     /* Handle nan and inf. */
-    if (Py_IS_NAN(val)) {
+    if (isnan(val)) {
         strcpy(buf, "nan");
         t = Py_DTST_NAN;
-    } else if (Py_IS_INFINITY(val)) {
+    } else if (isinf(val)) {
         if (copysign(1., val) == 1.)
             strcpy(buf, "inf");
         else

diff --git a/Python/pytime.c b/Python/pytime.c
index 560aea33f201a07550ac0b40bb33193b5dc07a24..cd76970718622f33885001131f7387ed3eb0288f 100644 (file)
--- a/Python/pytime.c
+++ b/Python/pytime.c
@@ -375,7 +375,7 @@ pytime_object_to_denominator(PyObject *obj, time_t *sec, long *numerator,
 
     if (PyFloat_Check(obj)) {
         double d = PyFloat_AsDouble(obj);
-        if (Py_IS_NAN(d)) {
+        if (isnan(d)) {
             *numerator = 0;
             PyErr_SetString(PyExc_ValueError, "Invalid value NaN (not a number)");
             return -1;
@@ -403,7 +403,7 @@ _PyTime_ObjectToTime_t(PyObject *obj, time_t *sec, _PyTime_round_t round)
         volatile double d;
 
         d = PyFloat_AsDouble(obj);
-        if (Py_IS_NAN(d)) {
+        if (isnan(d)) {
             PyErr_SetString(PyExc_ValueError, "Invalid value NaN (not a number)");
             return -1;
         }
@@ -590,7 +590,7 @@ pytime_from_object(PyTime_t *tp, PyObject *obj, _PyTime_round_t round,
     if (PyFloat_Check(obj)) {
         double d;
         d = PyFloat_AsDouble(obj);
-        if (Py_IS_NAN(d)) {
+        if (isnan(d)) {
             PyErr_SetString(PyExc_ValueError, "Invalid value NaN (not a number)");
             return -1;
         }