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_INFINITY`` (with
+ if ``overflow_exception`` is ``NULL`` return :c:macro:`!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
This macro expands a to constant expression of type :c:expr:`double`, that
represents the positive infinity.
- On most platforms, this is equivalent to the :c:macro:`!INFINITY` macro from
- the C11 standard ``<math.h>`` header.
+ It is equivalent to the :c:macro:`!INFINITY` macro from the C11 standard
+ ``<math.h>`` header.
+
+ .. deprecated:: 3.15
+ The macro is soft deprecated.
.. c:macro:: Py_NAN
-----------------
* The :c:macro:`!Py_HUGE_VAL` macro is now :term:`soft deprecated`.
- Use :c:macro:`!Py_INFINITY` instead.
+ Use :c:macro:`!INFINITY` instead.
(Contributed by Sergey B Kirpichev in :gh:`120026`.)
* The :c:macro:`!Py_IS_NAN`, :c:macro:`!Py_IS_INFINITY`,
since 3.15 and will be removed in 3.17.
(Contributed by Nikita Sobolev in :gh:`136355`.)
+* :c:macro:`!Py_INFINITY` macro is :term:`soft deprecated`,
+ use the C11 standard ``<math.h>`` :c:macro:`!INFINITY` instead.
+ (Contributed by Sergey B Kirpichev in :gh:`141004`.)
+
* :c:macro:`!Py_MATH_El` and :c:macro:`!Py_MATH_PIl` are deprecated
since 3.15 and will be removed in 3.20.
(Contributed by Sergey B Kirpichev in :gh:`141004`.)
#define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN)
-#define Py_RETURN_INF(sign) \
- do { \
- if (copysign(1., sign) == 1.) { \
- return PyFloat_FromDouble(Py_INFINITY); \
- } \
- else { \
- return PyFloat_FromDouble(-Py_INFINITY); \
- } \
+#define Py_RETURN_INF(sign) \
+ do { \
+ if (copysign(1., sign) == 1.) { \
+ return PyFloat_FromDouble(INFINITY); \
+ } \
+ else { \
+ return PyFloat_FromDouble(-INFINITY); \
+ } \
} while(0)
PyAPI_FUNC(double) PyFloat_GetMax(void);
static inline void _Py_ADJUST_ERANGE1(double x)
{
if (errno == 0) {
- if (x == Py_INFINITY || x == -Py_INFINITY) {
+ if (x == INFINITY || x == -INFINITY) {
errno = ERANGE;
}
}
static inline void _Py_ADJUST_ERANGE2(double x, double y)
{
- if (x == Py_INFINITY || x == -Py_INFINITY ||
- y == Py_INFINITY || y == -Py_INFINITY)
+ if (x == INFINITY || x == -INFINITY ||
+ y == INFINITY || y == -INFINITY)
{
if (errno == 0) {
errno = ERANGE;
#define Py_IS_FINITE(X) isfinite(X)
// Py_INFINITY: Value that evaluates to a positive double infinity.
+// Soft deprecated since Python 3.15, use INFINITY instead.
#ifndef Py_INFINITY
# define Py_INFINITY ((double)INFINITY)
#endif
/* 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. The macro was soft deprecated in Python 3.14, use Py_INFINITY instead.
+ * conformity. The macro was soft deprecated in Python 3.14, use INFINITY instead.
*/
#ifndef Py_HUGE_VAL
# define Py_HUGE_VAL HUGE_VAL
--- /dev/null
+The :c:macro:`!Py_INFINITY` macro is :term:`soft deprecated`.
#define P14 0.25*Py_MATH_PI
#define P12 0.5*Py_MATH_PI
#define P34 0.75*Py_MATH_PI
-#define INF Py_INFINITY
+#define INF INFINITY
#define N Py_NAN
#define U -9.5426319407711027e33 /* unlikely value, used as placeholder */
if (PyModule_Add(mod, "tau", PyFloat_FromDouble(Py_MATH_TAU)) < 0) {
return -1;
}
- if (PyModule_Add(mod, "inf", PyFloat_FromDouble(Py_INFINITY)) < 0) {
+ if (PyModule_Add(mod, "inf", PyFloat_FromDouble(INFINITY)) < 0) {
return -1;
}
- Py_complex infj = {0.0, Py_INFINITY};
+ Py_complex infj = {0.0, INFINITY};
if (PyModule_Add(mod, "infj", PyComplex_FromCComplex(infj)) < 0) {
return -1;
}
if (x == 0.0) {
errno = EDOM;
/* tgamma(+-0.0) = +-inf, divide-by-zero */
- return copysign(Py_INFINITY, x);
+ return copysign(INFINITY, x);
}
/* integer arguments */
}
else {
errno = ERANGE;
- return Py_INFINITY;
+ return INFINITY;
}
}
if (isnan(x))
return x; /* lgamma(nan) = nan */
else
- return Py_INFINITY; /* lgamma(+-inf) = +inf */
+ return 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_INFINITY; /* integers n <= 0 */
+ return INFINITY; /* integers n <= 0 */
}
else {
return 0.0; /* lgamma(1) = lgamma(2) = 0.0 */
return log(x);
errno = EDOM;
if (x == 0.0)
- return -Py_INFINITY; /* log(0) = -inf */
+ return -INFINITY; /* log(0) = -inf */
else
return Py_NAN; /* log(-ve) = nan */
}
}
else if (x == 0.0) {
errno = EDOM;
- return -Py_INFINITY; /* log2(0) = -inf, divide-by-zero */
+ return -INFINITY; /* log2(0) = -inf, divide-by-zero */
}
else {
errno = EDOM;
return log10(x);
errno = EDOM;
if (x == 0.0)
- return -Py_INFINITY; /* log10(0) = -inf */
+ return -INFINITY; /* log10(0) = -inf */
else
return Py_NAN; /* log10(-ve) = nan */
}
errno = 0;
} else if (exp > INT_MAX) {
/* overflow */
- r = copysign(Py_INFINITY, x);
+ r = copysign(INFINITY, x);
errno = ERANGE;
} else if (exp < INT_MIN) {
/* underflow to +-0 */
if (isinf(x)) {
return x;
}
- double inf = Py_INFINITY;
+ double inf = INFINITY;
double x2 = nextafter(x, inf);
if (isinf(x2)) {
/* special case: x is the largest positive representable float */
if (PyModule_Add(module, "tau", PyFloat_FromDouble(Py_MATH_TAU)) < 0) {
return -1;
}
- if (PyModule_Add(module, "inf", PyFloat_FromDouble(Py_INFINITY)) < 0) {
+ if (PyModule_Add(module, "inf", PyFloat_FromDouble(INFINITY)) < 0) {
return -1;
}
if (PyModule_Add(module, "nan", PyFloat_FromDouble(fabs(Py_NAN))) < 0) {
recalc = 1;
}
if (recalc) {
- r.real = Py_INFINITY*(a*c - b*d);
- r.imag = Py_INFINITY*(a*d + b*c);
+ r.real = INFINITY*(a*c - b*d);
+ r.imag = INFINITY*(a*d + b*c);
}
}
{
const double x = copysign(isinf(a.real) ? 1.0 : 0.0, a.real);
const double y = copysign(isinf(a.imag) ? 1.0 : 0.0, a.imag);
- r.real = Py_INFINITY * (x*b.real + y*b.imag);
- r.imag = Py_INFINITY * (y*b.real - x*b.imag);
+ r.real = INFINITY * (x*b.real + y*b.imag);
+ r.imag = INFINITY * (y*b.real - x*b.imag);
}
else if ((isinf(abs_breal) || isinf(abs_bimag))
&& isfinite(a.real) && isfinite(a.imag))
if (e == 0x1f) {
if (f == 0) {
/* Infinity */
- return sign ? -Py_INFINITY : Py_INFINITY;
+ return sign ? -INFINITY : INFINITY;
}
else {
/* NaN */
s += 3;
if (case_insensitive_match(s, "inity"))
s += 5;
- retval = negate ? -Py_INFINITY : Py_INFINITY;
+ retval = negate ? -INFINITY : INFINITY;
}
else if (case_insensitive_match(s, "nan")) {
s += 3;
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_INFINITY is returned, and no Python
+ if overflow_exception is NULL then +-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.
projects / thirdparty / Python / cpython.git / commitdiff
