Repository navigation
Specialize complex power for integer/real exponents #137746
Description
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 exponentiationwhich 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
Activity
picnixz commented on Aug 18, 2025
If Python could compute the principal value correctly in order to produce the correct value for $z^a$, then I'm in favor. Even if the C standard doesn't specify what to do, I think we should follow what Mathematica did (I'll need to check what Sage does as well)
skirpichev commented on Aug 19, 2025
Until recent drafts, it has no special case for complex division with lhs real op.
Yes, from https://reference.wolfram.com/language/ref/Power.html:
Though, I don't think that Mathematica has concept of signed zero.
skirpichev commented on Aug 19, 2026
N.B., ISO/IEC 10967 (part 3) has special rules for RxR->C power function (§5.3.1.3).