python 2.7 - transpuesta - Resuelve una ecuación usando un solucionador numérico de python en números.

transpuesta de una matriz en python numpy

Question

Tengo una ecuación, como sigue:

R - ((1.0 - np.exp(-tau))/(1.0 - np.exp(-a*tau))) = 0 .

Quiero resolver para tau en esta ecuación usando un solucionador numérico disponible dentro de numpy. ¿Cuál es la mejor manera de hacer esto?

Los valores de R y a en esta ecuación varían para diferentes implementaciones de esta fórmula, pero se fijan en valores particulares cuando se va a resolver para tau.

Answer 1

En la notación matemática convencional, tu ecuación es

La función SciPy fsolve busca un punto en el que una expresión dada sea igual a cero (un "cero" o "raíz" de la expresión). Deberá proporcionar a fsolve una suposición inicial que esté "cerca" de su solución deseada. Una buena manera de encontrar una conjetura inicial es trazar la expresión y buscar el cruce por cero.

#!/usr/bin/python
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import fsolve
# Define the expression whose roots we want to find
a = 0.5
R = 1.6
func = lambda tau : R - ((1.0 - np.exp(-tau))/(1.0 - np.exp(-a*tau)))
# Plot it
tau = np.linspace(-0.5, 1.5, 201)
plt.plot(tau, func(tau))
plt.xlabel("tau")
plt.ylabel("expression value")
plt.grid()
plt.show()
# Use the numerical solver to find the roots
tau_initial_guess = 0.5
tau_solution = fsolve(func, tau_initial_guess)
print "The solution is tau = %f" % tau_solution
print "at which the value of the expression is %f" % func(tau_solution)

Answer 2

Puedes reescribir la ecuación como

• Para enteros ay no R cero, obtendrá soluciones en el espacio complejo;
• Hay soluciones analíticas para a=0,1,...4 (ver here );

Por lo tanto, en general, puede tener una, varias o ninguna solución y algunas o todas pueden ser valores complejos. Puedes lanzar fácilmente scipy.root a esta ecuación, pero ningún método numérico garantiza encontrar todas las soluciones.

Para resolver en el espacio complejo:

import numpy as np
from scipy.optimize import root
def poly(xs, R, a):
x = complex(*xs)
err = R * x - x + 1 - R
return [err.real, err.imag]
root(poly, x0=[0, 0], args=(1.2, 6))