पायथन का उपयोग करके nonlinear समीकरणों की एक जोड़ी को हल करने के लिए कैसे?

Question

पाइथन का उपयोग करके गैर रेखीय समीकरणों को हल करने का सबसे अच्छा तरीका क्या है। (Numpy, SciPy या Sympy)

जैसे:

• x + y^2 = 4
• ई^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

आप ओपनोपट पैकेज और इसकी एनएलपी विधि का उपयोग कर सकते हैं। इसे हल करने nonlinear बीजीय समीकरणों मिलकर कई गतिशील प्रोग्रामिंग एल्गोरिदम है:
goldenSection, scipy_fminbound, scipy_bfgs, scipy_cg, scipy_ncg, amsg2p, scipy_lbfgsb, scipy_tnc, bobyqa, ralg, ipopt, scipy_slsqp, scipy_cobyla, lincher, algencan, जो आप कर सकते हैं से चुनें।
बाद के कुछ एल्गोरिदम बाधित nonlinear प्रोग्रामिंग समस्या को हल कर सकते हैं।

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

Answer 4

मैं मिलकर गैर रेखीय समीकरण (आम तौर पर शामिल बहुआयामी पद के लिए काम करने के लिए Broyden की विधि है: तो, अगर आप इस तरह एक समारोह के साथ openopt.NLP() के समीकरणों के अपने सिस्टम लागू कर सकते हैं और exponentials) आईडीएल में, लेकिन मैं इसे अजगर में प्रयास नहीं किया है:

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] 

Broyden का पहला Jacobian सन्निकटन का उपयोग कर, एक समारोह का मूल पता लगाएं।

इस विधि को "ब्रॉइडन की अच्छी विधि" भी कहा जाता है।

Answer 5

इसे आज़माएं, मैं आपको आश्वासन देता हूं कि यह पूरी तरह से काम करेगा।

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 

FYI। जैसा ऊपर बताया गया है, आप 'ब्रॉडेन 1' के साथ 'fsolve' को बदलकर 'ब्रॉइडन का अनुमान' भी उपयोग कर सकते हैं। यह काम करता हैं। मैंने यह किया।

मुझे नहीं पता कि ब्रॉइडन का अनुमान कैसे काम करता है, लेकिन यह 0 ले गया।02 एस

और मैं आपको सलाह देता हूं कि आप सिम्पी के कार्यों का उपयोग न करें < - वास्तव में सुविधाजनक, लेकिन गति के मामले में, यह काफी धीमी है। तुम देखोगे।

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