From 84e6311dee71bb104e1779c89cf22ff703799086 Mon Sep 17 00:00:00 2001
From: Mark Dickinson <dickinsm@gmail.com>
Date: Mon, 29 Aug 2016 13:56:58 +0100
Subject: Issue 23229: add cmath.inf, cmath.nan, cmath.infj and cmath.nanj.

---
 Doc/library/cmath.rst  | 28 ++++++++++++++++++++++++++
 Lib/test/test_cmath.py | 17 ++++++++++++++++
 Misc/NEWS              |  4 ++++
 Modules/cmathmodule.c  | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 103 insertions(+)

diff --git a/Doc/library/cmath.rst b/Doc/library/cmath.rst
index 85393dc..d935c41 100644
--- a/Doc/library/cmath.rst
+++ b/Doc/library/cmath.rst
@@ -259,6 +259,34 @@ Constants
 
    .. versionadded:: 3.6
 
+.. data:: inf
+
+   Floating-point positive infinity. Equivalent to ``float('inf')``.
+
+   .. versionadded:: 3.6
+
+.. data:: infj
+
+   Complex number with zero real part and positive infinity imaginary
+   part. Equivalent to ``complex(0.0, float('inf'))``.
+
+   .. versionadded:: 3.6
+
+.. data:: nan
+
+   A floating-point "not a number" (NaN) value.  Equivalent to
+   ``float('nan')``.
+
+   .. versionadded:: 3.6
+
+.. data:: nanj
+
+   Complex number with zero real part and NaN imaginary part. Equivalent to
+   ``complex(0.0, float('nan'))``.
+
+   .. versionadded:: 3.6
+
+
 .. index:: module: math
 
 Note that the selection of functions is similar, but not identical, to that in
diff --git a/Lib/test/test_cmath.py b/Lib/test/test_cmath.py
index 1f884e5..11b0c61 100644
--- a/Lib/test/test_cmath.py
+++ b/Lib/test/test_cmath.py
@@ -154,6 +154,23 @@ class CMathTests(unittest.TestCase):
         self.assertAlmostEqual(cmath.e, e_expected, places=9,
             msg="cmath.e is {}; should be {}".format(cmath.e, e_expected))
 
+    def test_infinity_and_nan_constants(self):
+        self.assertEqual(cmath.inf.real, math.inf)
+        self.assertEqual(cmath.inf.imag, 0.0)
+        self.assertEqual(cmath.infj.real, 0.0)
+        self.assertEqual(cmath.infj.imag, math.inf)
+
+        self.assertTrue(math.isnan(cmath.nan.real))
+        self.assertEqual(cmath.nan.imag, 0.0)
+        self.assertEqual(cmath.nanj.real, 0.0)
+        self.assertTrue(math.isnan(cmath.nanj.imag))
+
+        # Check consistency with reprs.
+        self.assertEqual(repr(cmath.inf), "inf")
+        self.assertEqual(repr(cmath.infj), "infj")
+        self.assertEqual(repr(cmath.nan), "nan")
+        self.assertEqual(repr(cmath.nanj), "nanj")
+
     def test_user_object(self):
         # Test automatic calling of __complex__ and __float__ by cmath
         # functions
diff --git a/Misc/NEWS b/Misc/NEWS
index 519a787..36cf589 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -49,6 +49,10 @@ Core and Builtins
 Library
 -------
 
+- Issue #23229: Add new ``cmath`` constants: ``cmath.inf`` and ``cmath.nan`` to
+  match ``math.inf`` and ``math.nan``, and also ``cmath.infj`` and
+  ``cmath.nanj`` to match the format used by complex repr.
+
 - Issue #27861: Fixed a crash in sqlite3.Connection.cursor() when a factory
   creates not a cursor.  Patch by Xiang Zhang.
 
diff --git a/Modules/cmathmodule.c b/Modules/cmathmodule.c
index 0e7d4db..8319767 100644
--- a/Modules/cmathmodule.c
+++ b/Modules/cmathmodule.c
@@ -81,6 +81,54 @@ else {
 #endif
 #define CM_SCALE_DOWN (-(CM_SCALE_UP+1)/2)
 
+/* Constants cmath.inf, cmath.infj, cmath.nan, cmath.nanj.
+   cmath.nan and cmath.nanj are defined only when either
+   PY_NO_SHORT_FLOAT_REPR is *not* defined (which should be
+   the most common situation on machines using an IEEE 754
+   representation), or Py_NAN is defined. */
+
+static double
+m_inf(void)
+{
+#ifndef PY_NO_SHORT_FLOAT_REPR
+    return _Py_dg_infinity(0);
+#else
+    return Py_HUGE_VAL;
+#endif
+}
+
+static Py_complex
+c_infj(void)
+{
+    Py_complex r;
+    r.real = 0.0;
+    r.imag = m_inf();
+    return r;
+}
+
+#if !defined(PY_NO_SHORT_FLOAT_REPR) || defined(Py_NAN)
+
+static double
+m_nan(void)
+{
+#ifndef PY_NO_SHORT_FLOAT_REPR
+    return _Py_dg_stdnan(0);
+#else
+    return Py_NAN;
+#endif
+}
+
+static Py_complex
+c_nanj(void)
+{
+    Py_complex r;
+    r.real = 0.0;
+    r.imag = m_nan();
+    return r;
+}
+
+#endif
+
 /* forward declarations */
 static Py_complex cmath_asinh_impl(PyObject *, Py_complex);
 static Py_complex cmath_atanh_impl(PyObject *, Py_complex);
@@ -1240,6 +1288,12 @@ PyInit_cmath(void)
                        PyFloat_FromDouble(Py_MATH_PI));
     PyModule_AddObject(m, "e", PyFloat_FromDouble(Py_MATH_E));
     PyModule_AddObject(m, "tau", PyFloat_FromDouble(Py_MATH_TAU)); /* 2pi */
+    PyModule_AddObject(m, "inf", PyFloat_FromDouble(m_inf()));
+    PyModule_AddObject(m, "infj", PyComplex_FromCComplex(c_infj()));
+#if !defined(PY_NO_SHORT_FLOAT_REPR) || defined(Py_NAN)
+    PyModule_AddObject(m, "nan", PyFloat_FromDouble(m_nan()));
+    PyModule_AddObject(m, "nanj", PyComplex_FromCComplex(c_nanj()));
+#endif
 
     /* initialize special value tables */
 
-- 
cgit v0.12