5

When using solve to compute the roots of a quadratic equation, SymPy returns expressions which could be simplified but I can't get it to simplify them. A minimal example looks like so:

from sympy import *
sqrt(-24-70*I)

Here, SymPy just returns sqrt(-24-70*I) while Mathematica or Maple will answer with the equivalent of 5-7*I.

I'm aware that there are two square roots, but this behavior entails that SymPy will, for example, return pretty complicated solutions from

z = symbols("z")
solve(z ** 2 + (1 + I) * z + (6 + 18 * I), z)

while, again, Maple and Mathematica will both happily give me the two Gaussian integers that solve this equation.

Is there an option or something that I'm missing?

Frunobulax
  • 345
  • 2
  • 13

3 Answers3

3

Finding the square root of z is logically the same as solving the equation (x+I*y)**2 = z. So you can do just that: 

from sympy import *
z = -24-70*I
x, y = symbols('x y', real=True)
result = solve((x+I*y)**2 - z, (x, y))

The result is [(-5, 7), (5, -7)]

For convenience, this can be wrapped as a function:

def my_sqrt(z):
    x, y = symbols('x y', real=True)
    sol = solve((x+I*y)**2 - z, (x, y))
    return sol[0][0] + sol[0][1]*I

Now you can use my_sqrt(-24-70*I) and get -5 + 7*I

The same strategy helps in your example with a quadratic equation:

x, y = symbols('x y', real=True)
z = x + I*y
solve(z ** 2 + (1 + I) * z + (6 + 18 * I), (x, y))

Output: [(-3, 3), (2, -4)]

1

Another workaround is to use:

sqrt(-24-70*I).as_real_imag()

This returns the real and imaginary parts in a list, that can further be processed to recover a complex number.

Strange, though, that there is no built-in way of demanding the evaluation of the complex square root.

ouflak
  • 2,458
  • 10
  • 44
  • 49
0

If you have the mpmath package, you can do something like

from sympy import *
import mpmath

a = -24-70*I
b = mpmath.mpc(re(a), im(a))  # a as mpmath.mpc object
c = mpmath.sqrt(b)
d = simplify(c)  # Convert back to sympy object
print(d)  # 5.0 - 7.0*I

Note that there may be a cheaper way (than simplify) to do the conversion back to a sympy object.

Update

As pointed out in the comments, this performs numeric evaluation, not symbolic. That is, the above is not really superior to this:

import cmath
result = cmath.sqrt(-24 - 70j)
print(result)  # 5 - 7j

The above have two interesting aspects. First, the cmath module is part of the standard library. Secondly, since result is given in terms of integers, we are guaranteed that result is actually the exact symbolic value (and it can easily be converted to a sympy object). If the solution is non-integer, the result is expressed as floats. This is of course not a general good solution to the problem of symbolic complex square roots, but it is useful if you know beforehand that the solution is integer.

jmd_dk
  • 12,125
  • 9
  • 63
  • 94
  • 2
    It should be noted that this performs floating-point evaluation, not symbolic simplification. Simple `N(sqrt(-24-70*I))` would do the same without going through mpmath; but I don't think this is what the OP wants. –  Dec 25 '16 at 21:43
  • Thanks, I wasn't aware of that. But as @zaq already guessed, I was interested in an exact solution. – Frunobulax Dec 25 '16 at 21:46