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:
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
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:
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):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:
Has this already been discussed elsewhere?
No response given
Links to previous discussion of this feature:
No response