Specialize complex power for integer/real exponents

Feature or enhancement

Proposal:

With #69639 complex arithmetic in Python was extended to support C-like mixed-more rules, where one operand is a float or an int. However, this doesn't affect exponentiation.

Currently we have, for example:

>>> import cmath
>>> z = complex('inf')
>>> z**0.5
Traceback (most recent call last):
  File "<python-input-2>", line 1, in <module>
    z**0.5
    ~^^~~~
OverflowError: complex exponentiation
>>> cmath.sqrt(z)
(inf+0j)
>>> z**2
Traceback (most recent call last):
  File "<python-input-4>", line 1, in <module>
    z**2
    ~^^~
OverflowError: complex exponentiation

which is just meaningless. Note also, that plain multiplication is not too much better in the last case:

>>> z*z
(inf+nanj)

What we actually want here is exp(log(z)*real_exponent):

>>> import cmath, math
>>> def mypow(b, e):
...     if isinstance(b, (float, int)) and b > 0:
...         if isinstance(e, (float, int)):
...             return math.exp(e*math.log(b))
...         return cmath.exp(e*math.log(b))
...     return cmath.exp(e*cmath.log(b))
...     
>>> mypow(z, 2)
(inf+0j)
>>> mypow(z+123j, 2)
(inf+0j)

This works as expected for real exponents and/or positive bases due to special mixed-mode rules in complex arithmetic (this time - in multiplication).

Special rules for exponentiation will be useful for implementation of complex functions, using known analytic identities. For example:

>>> cmath.asinh(z)
(inf+0j)
>>> myasinh_bad = lambda z: cmath.log(z + cmath.sqrt(1 + z**2))
>>> myasinh_bad(z)
Traceback (most recent call last):
  File "<python-input-11>", line 1, in <module>
    myasinh_bad(z)
    ~~~~~~~~~~~^^^
  File "<python-input-10>", line 1, in <lambda>
    myasinh_bad = lambda z: cmath.log(z + cmath.sqrt(1 + z**2))
                                                         ~^^~
OverflowError: complex exponentiation
>>> myasinh_bad2 = lambda z: cmath.log(z + cmath.sqrt(1 + z*z))
>>> myasinh_bad2(z)
(inf+nanj)
>>> myasinh_good = lambda z: cmath.log(z + cmath.sqrt(1 + mypow(z, 2)))
>>> myasinh_good(z)
(inf+0j)

Has this already been discussed elsewhere?

No response given

Links to previous discussion of this feature:

No response