Speed up solving time of this function

Question

This function is working fine but it takes too much time to solve. Please suggest me how to improve the solving time.

from sympy.solvers import solve
from sympy import Symbol

QD = 25.45
CDI = 0.65
AIN = 33.6
GTL = 10
GTSELV = 2300.1
CDGT = 1.9

def fun(HWE):
    TWE = Symbol('TWE')
    expression = (CDI*AIN*(2*9.81*(HWE-TWE))**0.5) - (CDGT*GTL*(TWE-GTSELV)**1.5)-QD
    solution = solve(expression)
    return solution

Function fun(2303) gives [2302.23386564786] which is correct but solving time is about 30 seconds. I need to run this for many arguments.

Answer 1

The dReal system can handle these sorts of problems, using the notion of delta-satisfiability. (See http://dreal.github.io for details.)

This is how your program is coded using dReal's Python interface (To install, see the notes at https://github.com/dreal/dreal4#python-binding):

from dreal import *

QD     = 25.45
CDI    = 0.65
AIN    = 33.6
GTL    = 10
GTSELV = 2300.1
CDGT   = 1.9

def fun(HWE):
    TWE = Variable("TWE")
    expression = (CDI*AIN*(2*9.81*(HWE-TWE))**0.5) - (CDGT*GTL*(TWE-GTSELV)**1.5)-QD
    return (expression == 0)

result = CheckSatisfiability(fun(2303), 0.001)
print(result)

When I run it on my now 3 year old computer, I get:

$ time python a.py
TWE : [2302.2338656478555, 2302.2338656478582]
python3 a.py  0.03s user 0.01s system 92% cpu 0.044 total

So, it takes about 0.044 seconds to go through, which does include loading the entire Python echo-system. (So, if you run many problems one after another, each instance should go even faster.)

Note that dReal shows you an interval for the acceptable solution, within a user-specified numerical error bound. The bound is the second argument to CheckSatisfiability, which we set at 0.001 for this problem. You can increase this precision at the cost of potentially more computation time, but looks like 0.001 seems to be doing quite well in this case. Also note that you get an "interval" for the solution for each variable. If you increase the precision, this interval might get smaller. For instance, when I change the call to:

result = CheckSatisfiability(fun(2303), 0.0000000000001)

I get:

$ time python a.py
TWE : [2302.2338656478569, 2302.2338656478569]
python3 a.py  0.03s user 0.01s system 84% cpu 0.050 total

where the interval has reduced to a single-point, but the program took slightly longer to run. For each problem, you should experiment with an appropriate delta to make sure the interval you get for the results is reasonable.

Answer 2

Use solve when you want a solution in terms of symbols. Use nsolve when you want a numerical solution. In your case, replace solve with nsolve and add the argument HWE to the call statement (i.e. nsolve(expression, HWE)). That 2nd argument is a guess at where the solution is near. Alternatively, give fun a 2nd arg guess and use that as the 2nd arg for nsolve. If you slowly change some parameter, using the last solution as the guess for the next solution will speed up the process (which is already quite fast).

If you know that the solution is real then you might want to take the real part of it with re(solution) since the solution comes back with a small imaginary component.