una - ¿Cómo puedo resolver ecuaciones en Python?

transpuesta de una matriz en python numpy

Question

Digamos que tengo una ecuación:

2x + 6 = 12

Con el álgebra podemos ver que x = 3 . ¿Cómo puedo hacer un programa en Python que pueda resolver para x ? Soy nuevo en programación, y miré eval() y exec() pero no puedo encontrar la manera de hacer que hagan lo que quiero. No quiero usar bibliotecas externas (por ejemplo, SAGE), quiero hacer esto simplemente en Python.

Answer 1

¿Qué tal SymPy ? Su solver parece a lo que necesitas. Echa un vistazo a su código fuente si quieres construir la biblioteca tú mismo ...

Answer 2

Hay dos formas de abordar este problema: numérica y simbólicamente.

Para resolverlo numéricamente, primero debe codificarlo como una función "ejecutable": pegar un valor, obtener un valor. Por ejemplo,

def my_function(x):
    return 2*x + 6

Es bastante posible analizar una cadena para crear automáticamente dicha función; diga que analiza 2x + 6 en una lista, [6, 2] (donde el índice de la lista corresponde a la potencia de x, entonces 6 * x ^ 0 + 2 * x ^ 1). Entonces:

def makePoly(arr):
    def fn(x):
        return sum(c*x**p for p,c in enumerate(arr))
    return fn

my_func = makePoly([6, 2])
my_func(3)    # returns 12

Luego, necesita otra función que conecte repetidamente un valor x en su función, observe la diferencia entre el resultado y lo que quiere encontrar, y modifique su valor x para (con suerte) minimizar la diferencia.

def dx(fn, x, delta=0.001):
    return (fn(x+delta) - fn(x))/delta

def solve(fn, value, x=0.5, maxtries=1000, maxerr=0.00001):
    for tries in xrange(maxtries):
        err = fn(x) - value
        if abs(err) < maxerr:
            return x
        slope = dx(fn, x)
        x -= err/slope
    raise ValueError(''no solution found'')

Aquí hay muchos problemas potenciales: encontrar un buen valor x inicial, asumiendo que la función realmente tiene una solución (es decir, no hay respuestas de valores reales para x ^ 2 + 2 = 0), que alcanzan los límites de precisión computacional. Pero en este caso, la función de minimización de errores es adecuada y obtenemos un buen resultado:

solve(my_func, 16)    # returns (x =) 5.000000000000496

Tenga en cuenta que esta solución no es absolutamente correcta. Si necesitas que sea perfecto, o si quieres intentar resolver familias de ecuaciones analíticamente, debes recurrir a una bestia más complicada: un solucionador simbólico.

Un solucionador simbólico, como Mathematica o Maple, es un sistema experto con muchas reglas incorporadas ("conocimiento") sobre álgebra, cálculo, etc. "sabe" que la derivada de pecado es cos, que la derivada de kx ^ p es kpx ^ (p-1), y así sucesivamente. Cuando le das una ecuación, trata de encontrar un camino, un conjunto de aplicaciones de reglas, desde donde está (la ecuación) hasta donde quieres estar (la forma más simple posible de la ecuación, que es la solución, con suerte). .

Tu ecuación de ejemplo es bastante simple; Una solución simbólica podría verse como:

=> LHS([6, 2]) RHS([16])

# rule: pull all coefficients into LHS
LHS, RHS = [lh-rh for lh,rh in izip_longest(LHS, RHS, 0)], [0]

=> LHS([-10,2]) RHS([0])

# rule: solve first-degree poly
if RHS==[0] and len(LHS)==2:
    LHS, RHS = [0,1], [-LHS[0]/LHS[1]]

=> LHS([0,1]) RHS([5])

Y ahí está tu solución: x = 5.

Espero que esto le dé el sabor de la idea; Los detalles de la implementación (encontrar un buen conjunto completo de reglas y decidir cuándo se debe aplicar cada regla) pueden consumir fácilmente muchos años de esfuerzo.

Answer 3

Python puede ser bueno, pero no es Dios ...

Hay algunas maneras diferentes de resolver ecuaciones. SymPy ya se ha mencionado, si está buscando soluciones analíticas.

Si está contento de tener una solución numérica, Numpy tiene algunas rutinas que pueden ayudar. Si solo estás interesado en soluciones para polinomios, numpy.roots funcionará. Específicamente para el caso que mencionaste:

>>> import numpy
>>> numpy.roots([2,-6])
array([3.0])

Para expresiones más complicadas, echa un vistazo a scipy.fsolve.

De cualquier manera, no puedes escapar usando una biblioteca.

Answer 4

Si solo desea resolver el conjunto extremadamente limitado de ecuaciones mx + c = y para el entero positivo m, c, y , entonces esto hará:

import re
def solve_linear_equation ( equ ):
    """
    Given an input string of the format "3x+2=6", solves for x.
    The format must be as shown - no whitespace, no decimal numbers,
    no negative numbers.
    """
    match = re.match(r"(/d+)x/+(/d+)=(/d+)", equ)
    m, c, y = match.groups()
    m, c, y = float(m), float(c), float(y) # Convert from strings to numbers
    x = (y-c)/m
    print ("x = %f" % x)

Algunas pruebas:

>>> solve_linear_equation("2x+4=12")
x = 4.000000
>>> solve_linear_equation("123x+456=789")
x = 2.707317
>>> 

Si quieres reconocer y resolver ecuaciones arbitrarias , como sin(x) + e^(i*pi*x) = 1 , necesitarás implementar algún tipo de motor de matemáticas simbólicas, similar a maxima , Mathematica , la solve() de MATLAB solve() o Caja de herramientas simbólica, etc. Como un principiante, esto está más allá de su conocimiento.

Answer 5

Usa una herramienta diferente. Algo como Wolfram Alpha , Maple , R , Octave , Matlab o cualquier otro paquete de software de álgebra.

Como principiante, probablemente no deberías intentar resolver un problema tan no trivial.