Sistema de resolución de ecuaciones no lineales con python.

¿Puedo resolver un sistema de ecuaciones no lineales en términos de parámetros en python? ¿Hay algún ejemplo o tutorial? Puedo hacer esto fácilmente en Maple, pero las expresiones de mi sistema en particular son bastante grandes y copiarlas es bastante difícil.

Ejemplo:

sigma*(yx) = 0 x*(rho-z)-y = 0 x*y-beta*z = 0 

Deberías obtener las soluciones:

 [[x = 0, y = 0, z = 0], [x = sqrt(beta*rho-beta), y = sqrt(beta*rho-beta), z = rho-1], [x = -sqrt(beta*rho-beta), y = -sqrt(beta*rho-beta), z = rho-1]] 

El motivo por el que lo pregunto: tengo un gran sistema de EDO no lineales. Quiero resolver los puntos fijos (esto es factible, se ha hecho en arce, pero son grandes y feos). Quiero crear más expresiones desde los puntos fijos y luego usar el paquete de optimización en scipy. Prefiero hacerlo todo en python que traducir las cosas de un lado a otro, ya que es muy ineficiente y se pueden cometer errores.

Reiterando la respuesta de sympy , esto se puede lograr fácilmente en sympy . Por ejemplo:

 In [1]: import sympy as sp In [2]: x, y, z = sp.symbols('x, y, z') In [3]: rho, sigma, beta = sp.symbols('rho, sigma, beta') In [4]: f1 = sigma * (y - x) In [5]: f2 = x * (rho - z) - y In [6]: f3 = x * y - beta * z In [7]: sp.solvers.solve((f1, f2, f3), (x, y, z)) Out[7]: [(0, 0, 0), (-sqrt(beta*rho - beta), -sqrt(beta*(rho - 1)), rho - 1), (sqrt(beta*rho - beta), sqrt(beta*(rho - 1)), rho - 1)] 

donde el formato de salida es 3 tuplas posibles de los valores posibles para (x, y, z) .

Advertencia , soy un desarrollador de Sage, por lo que podría no ser neutral.

No sé cómo hacerlo en Python puro, pero recomendaría el sistema Sage cuya interfaz está en Python (en realidad, la línea de comandos es un IPython específicamente configurado) y que permite hacer eso:

 +--------------------------------------------------------------------+ | Sage Version 5.10, Release Date: 2013-06-17 | | Type "notebook()" for the browser-based notebook interface. | | Type "help()" for help. | +--------------------------------------------------------------------+ sage: var("sigma yx rho beta z") (sigma, y, x, rho, beta, z) sage: sys = [sigma*(yx), x*(rho-z)-y, x*y-beta*z] sage: solve(sys, x, y, z) [[x == sqrt(beta*rho - beta), y == (beta*rho - beta)/(sqrt(rho - 1)*sqrt(beta)), z == rho - 1], [x == -sqrt(beta*rho - beta), y == -(beta*rho - beta)/(sqrt(rho - 1)*sqrt(beta)), z == rho - 1], [x == 0, y == 0, z == 0]] 

Generalmente es más fácil de usar así:

 sage: solve(sys, x, y, z, solution_dict=True) [{z: rho - 1, x: sqrt(beta*rho - beta), y: (beta*rho - beta)/(sqrt(rho - 1)*sqrt(beta))}, {z: rho - 1, x: -sqrt(beta*rho - beta), y: -(beta*rho - beta)/(sqrt(rho - 1)*sqrt(beta))}, {z: 0, x: 0, y: 0}] 

El principal inconveniente es que Sage es una distribución completa de software matemático que incluye su propio intérprete de Python (junto con un montón de otras cosas escritas en muchos idiomas, incluyendo C / C ++, Cython, lisp, fortran) y es muy difícil de instalar si Quieres usar tu propio intérprete.

Una buena noticia para su problema es que Scipy ya se ha enviado con Sage.

SymPy podría ayudar; No sé qué tan bueno es para resolver ecuaciones no lineales: http://scipy-lectures.github.io/advanced/sympy.html#id23

Debería poder ejecutar código similar (siguiendo los ejemplos de enlaces anteriores):

 from sympy import * x = Symbol('x') y = Symbol('y') z = Symbol('z') beta = Symbol('beta') rho = Symbol('rho') sigma = Symbol('sigma') solve([sigma*(yx), x*(rho-z)-y, x*y-beta*z], [x, y, z]) 

No he probado si funciona (no lo tengo a mano para esta máquina).