Как решить пару нелинейных уравнений с помощью Python?

Question

Какой (лучший) способ решить пару нелинейных уравнений с использованием Python. (Numpy, Scipy или Sympy)

Например:

• x + y ^ 2 = 4
• e ^ x + xy = 3

Фрагмент кода, который решает вышеуказанную пару, будет великолепен

Answer 1

для численного решения вы можете использовать fsolve:

http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fsolve.html#scipy.optimize.fsolve

from scipy.optimize import fsolve
import math

def equations(p):
    x, y = p
    return (x+y**2-4, math.exp(x) + x*y - 3)

x, y =  fsolve(equations, (1, 1))

print equations((x, y))

Answer 2

Если вы предпочитаете sympy, вы можете использовать nsolve .

>>> nsolve([x+y**2-4, exp(x)+x*y-3], [x, y], [1, 1])
[0.620344523485226]
[1.83838393066159]

Первый аргумент - это список уравнений, второй - это список переменных, а третий - первоначальное предположение.

Answer 3

Попробуйте, уверяю вас, это будет отлично работать.

    import scipy.optimize as opt
    from numpy import exp
    import timeit

    st1 = timeit.default_timer()

    def f(variables) :
        (x,y) = variables

        first_eq = x + y**2 -4
        second_eq = exp(x) + x*y - 3
        return [first_eq, second_eq]

    solution = opt.fsolve(f, (0.1,1) )
    print(solution)


    st2 = timeit.default_timer()
    print("RUN TIME : {0}".format(st2-st1))

->

[ 0.62034452  1.83838393]
RUN TIME : 0.0009331008900937708

К вашему сведению.как упоминалось выше, вы также можете использовать «приближение Бройдена», заменив «fsolve» на «broyden1».Оно работает.Я сделал это.

Я не знаю точно, как работает приближение Бройдена, но это заняло 0,02 с.

И я рекомендую не использовать функции Sympy <- действительно удобно, но с точки зренияскорости, это довольно медленно.Ты увидишь.</p>

Answer 4

from scipy.optimize import fsolve

def double_solve(f1,f2,x0,y0):
    func = lambda x: [f1(x[0], x[1]), f2(x[0], x[1])]
    return fsolve(func,[x0,y0])

def n_solve(functions,variables):
    func = lambda x: [ f(*x) for f in functions]
    return fsolve(func, variables)

f1 = lambda x,y : x**2+y**2-1
f2 = lambda x,y : x-y

res = double_solve(f1,f2,1,0)
res = n_solve([f1,f2],[1.0,0.0])

Answer 5

Я заставил метод Бройдена работать для связанных нелинейных уравнений (обычно с полиномами и экспонентами) в IDL, но я не пробовал его в Python:

http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.broyden1.html#scipy.optimize.broyden1

scipy.optimize.broyden1

scipy.optimize.broyden1(F, xin, iter=None, alpha=None, reduction_method='restart', max_rank=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)[source]

Найдите корень функции, используя первое якобианское приближение Бройдена.

Этот метод также известен как «хороший метод Бройдена».

Answer 6

Вы можете использовать пакет openopt и его метод НЛП.Он имеет много алгоритмов динамического программирования для решения нелинейных алгебраических уравнений, состоящих из: goldenSection, scipy_fminbound, scipy_bfgs, scipy_cg, scipy_ncg, amsg2p, scipy_lbfgsb, scipy_tnc, bobyqa, ralg, ipopt, scipy_slsqp, scipy_co2la *, можете выбрать, можете из любого другогоНекоторые из последних алгоритмов могут решить ограниченную задачу нелинейного программирования.Итак, вы можете представить свою систему уравнений для openopt.NLP () с помощью такой функции:

lambda x: x[0] + x[1]**2 - 4, np.exp(x[0]) + x[0]*x[1]

Answer 7

Альтернативой fsolve является root:

import numpy as np
from scipy.optimize import root    

def your_funcs(X):

    x, y = X
    # all RHS have to be 0
    f = [x + y**2 - 4,
         np.exp(x) + x * y - 3]

    return f

sol = root(your_funcs, [1.0, 1.0])
print(sol.x)

Это напечатает

[0.62034452 1.83838393]

Если вы тогда отметите

print(your_funcs(sol.x))

вы получите

[4.4508396968012676e-11, -1.0512035686360832e-11]

подтверждение правильности решения.