[PYTHON] 파이썬을 사용하여 한 쌍의 비선형 방정식을 푸는 방법?

파이썬을 사용하여 한 쌍의 비선형 방정식을 푸는 방법?

파이썬을 사용하여 한 쌍의 비선형 방정식을 푸는 가장 좋은 방법은 무엇입니까? (Numpy, Scipy 또는 Sympy)

예 :

위의 쌍을 해결하는 코드 스 니펫은 훌륭합니다.

해결법

1. ==============================

   1.수치 솔루션의 경우 fsolve를 사용할 수 있습니다.

   수치 솔루션의 경우 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))
   

2. ==============================

   2.sympy를 선호한다면 nsolve를 사용할 수 있습니다.

   sympy를 선호한다면 nsolve를 사용할 수 있습니다.

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

   첫 번째 인수는 방정식 목록이고 두 번째 인수는 변수 목록이며 세 번째 인수는 초기 추측입니다.

3. ==============================

   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
   

   참고하시기 바랍니다. 위에서 언급 한 바와 같이 'broyden 's approximation'을 'fsolve'를 'broyden1'로 대체하여 사용할 수도 있습니다. 그것은 작동합니다. 나는 그것을했다.

   Broyden의 근사가 어떻게 작동하는지 정확히 알 수는 없지만 0.02 초가 걸립니다.

   그리고 나는 Sympy의 기능을 사용하지 말 것을 권한다. - 속도는 꽤 느리다. 너 볼거야.

4. ==============================

   4.openopt 패키지와 NLP 메소드를 사용할 수 있습니다. 그것은 비선형 대수 방정식을 풀기위한 많은 동적 프로그래밍 알고리즘을 가지고 있습니다 : scrapy_cg, scipy_ncg, amsg2p, scipy_lbfgsb, scipy_tnc, bobyqa, ralg, ipopt, scipy_slsqp, scipy_cobyla, lincher, algencan 중에서 선택할 수 있습니다. 후자의 알고리즘 중 일부는 제한된 비선형 프로그래밍 문제를 해결할 수 있습니다. 그래서 openopt.NLP ()에 방정식 시스템을 다음과 같은 함수로 소개 할 수 있습니다 :

   openopt 패키지와 NLP 메소드를 사용할 수 있습니다. 그것은 비선형 대수 방정식을 풀기위한 많은 동적 프로그래밍 알고리즘을 가지고 있습니다 : scrapy_cg, scipy_ncg, amsg2p, scipy_lbfgsb, scipy_tnc, bobyqa, ralg, ipopt, scipy_slsqp, scipy_cobyla, lincher, algencan 중에서 선택할 수 있습니다. 후자의 알고리즘 중 일부는 제한된 비선형 프로그래밍 문제를 해결할 수 있습니다. 그래서 openopt.NLP ()에 방정식 시스템을 다음과 같은 함수로 소개 할 수 있습니다 :

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

5. ==============================

   5.나는 IDL에서 결합 된 비선형 방정식 (일반적으로 다항식과 지수 포함)을 처리하는 Broyden의 방법을 얻었지만 파이썬에서는 시도하지 않았습니다 :

   나는 IDL에서 결합 된 비선형 방정식 (일반적으로 다항식과 지수 포함)을 처리하는 Broyden의 방법을 얻었지만 파이썬에서는 시도하지 않았습니다 :

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

6. ==============================

   6.

   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])
   

7. ==============================

   7.fsolve의 대안은 root입니다.

   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]
   

   해결책이 정확한지 확인합니다.

from https://stackoverflow.com/questions/8739227/how-to-solve-a-pair-of-nonlinear-equations-using-python by cc-by-sa and MIT license