From 4b9a2dcf19e5d13c3bc2afea2de1f65cd994c699 Mon Sep 17 00:00:00 2001
From: Mark Dickinson <mdickinson@enthought.com>
Date: Tue, 17 Aug 2021 17:51:28 +0100
Subject: bpo-44698: Restore complex pow behaviour for small integral exponents
 (GH-27772)

---
 Lib/test/test_complex.py                           | 28 ++++++++++++++++++++++
 .../2021-08-15-10-39-06.bpo-44698.lITKNc.rst       |  2 ++
 Objects/complexobject.c                            | 28 ++++++----------------
 3 files changed, 37 insertions(+), 21 deletions(-)
 create mode 100644 Misc/NEWS.d/next/Core and Builtins/2021-08-15-10-39-06.bpo-44698.lITKNc.rst

diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py
index badb234..abd7e39 100644
--- a/Lib/test/test_complex.py
+++ b/Lib/test/test_complex.py
@@ -269,6 +269,34 @@ class ComplexTest(unittest.TestCase):
                     except OverflowError:
                         pass
 
+    def test_pow_with_small_integer_exponents(self):
+        # Check that small integer exponents are handled identically
+        # regardless of their type.
+        values = [
+            complex(5.0, 12.0),
+            complex(5.0e100, 12.0e100),
+            complex(-4.0, INF),
+            complex(INF, 0.0),
+        ]
+        exponents = [-19, -5, -3, -2, -1, 0, 1, 2, 3, 5, 19]
+        for value in values:
+            for exponent in exponents:
+                with self.subTest(value=value, exponent=exponent):
+                    try:
+                        int_pow = value**exponent
+                    except OverflowError:
+                        int_pow = "overflow"
+                    try:
+                        float_pow = value**float(exponent)
+                    except OverflowError:
+                        float_pow = "overflow"
+                    try:
+                        complex_pow = value**complex(exponent)
+                    except OverflowError:
+                        complex_pow = "overflow"
+                    self.assertEqual(str(float_pow), str(int_pow))
+                    self.assertEqual(str(complex_pow), str(int_pow))
+
     def test_boolcontext(self):
         for i in range(100):
             self.assertTrue(complex(random() + 1e-6, random() + 1e-6))
diff --git a/Misc/NEWS.d/next/Core and Builtins/2021-08-15-10-39-06.bpo-44698.lITKNc.rst b/Misc/NEWS.d/next/Core and Builtins/2021-08-15-10-39-06.bpo-44698.lITKNc.rst
new file mode 100644
index 0000000..f197253
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2021-08-15-10-39-06.bpo-44698.lITKNc.rst	
@@ -0,0 +1,2 @@
+Restore behaviour of complex exponentiation with integer-valued exponent of
+type :class:`float` or :class:`complex`.
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index 05cae32..3e47949 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -172,14 +172,7 @@ c_powu(Py_complex x, long n)
 static Py_complex
 c_powi(Py_complex x, long n)
 {
-    Py_complex cn;
-
-    if (n > 100 || n < -100) {
-        cn.real = (double) n;
-        cn.imag = 0.;
-        return _Py_c_pow(x,cn);
-    }
-    else if (n > 0)
+    if (n > 0)
         return c_powu(x,n);
     else
         return _Py_c_quot(c_1, c_powu(x,-n));
@@ -523,19 +516,12 @@ complex_pow(PyObject *v, PyObject *w, PyObject *z)
         return NULL;
     }
     errno = 0;
-    // Check if w is an integer value that fits inside a C long, so we can
-    // use a faster algorithm. TO_COMPLEX(w, b), above, already handled the
-    // conversion from larger longs, as well as other types.
-    if (PyLong_Check(w)) {
-        int overflow = 0;
-        long int_exponent = PyLong_AsLongAndOverflow(w, &overflow);
-        if (int_exponent == -1 && PyErr_Occurred())
-            return NULL;
-        if (overflow == 0)
-            p = c_powi(a, int_exponent);
-        else
-            p = _Py_c_pow(a, b);
-    } else {
+    // Check whether the exponent has a small integer value, and if so use
+    // a faster and more accurate algorithm.
+    if (b.imag == 0.0 && b.real == floor(b.real) && fabs(b.real) <= 100.0) {
+        p = c_powi(a, (long)b.real);
+    }
+    else {
         p = _Py_c_pow(a, b);
     }
 
-- 
cgit v0.12