El problema a discutir en este post y en el siguiente es el de resolver la ecuación f(x)=0, donde f(x) es una función de cualquier naturaleza, por ejm: f(x)=x^5-3×4+x^2-3=0, o f(x)=arctan(x)+sen(x)-2=0.

Diversos métodos se han propuestos para este tipo de problemas. Aquí discutiremos, el método gráfico, el de Newton Raphson y el de la Biseccion.

METODO GRAFICO

Consiste en hacer una gráfica de la curva y=f(x) en el sistema de coordenadas (x,y). Luego se escoge el/o  los puntos por donde corta el eje X.

Ejemplo: Hallar las raíces de la ecuación: f(x)=x^3 +7*x^2 -60=0

Solución en Python:

```python
import numpy as np
import matplotlib.pyplot as plt

# definición de la función
def f(x): return x**3+7*x**2-60
#f=lambda: x**3+7*x**2-60
#definición del intervalo
x = np.arange(-3.0,3.0,0.2)
plt.plot(x,f(x)) # Plot with specified
plt.plot(x,0*x)
plt.show() # Show plot on screen

Salida:

Puede observarse que la curva (color azul) corta a el eje X (color naranja ) en el punto x=2.4, luego esta es la solución aproximada por el método gráfico

METODO DE NEWTON RAPHSON

El método de Newton- Raphson es un método iterativo que comienza con una aproximación inicial x0 (la cual suele tomarse del resultado del método gráfico) y una formula a iterar:

x(n+1)=f(x(n))/f'(x(n))

donde f’ es la derivada de f. Se realizan las iteraciones hasta un numero máximo: N, o hasta alcanzar un grado de tolerancial: tol (lo que ocurra primero) previamente definidos.

Vamos a ejemplificar con la misma función anterior

f(x)= x^3 +7*x^2 -60. En este caso f'(x)=3x^2+14x y

podemos tomar x0=2.4 como valor Valor inicial y dejamos al usuario que introduzca la tolerancia y el valor maximo de iteraciones a trves del comando input

Programa en Python

```python
import numpy as np
#import matplotlib.pyplot as plt

# definición de la función
def f(x): return x**3+7*x**2-60
def df(x): return 3*x**2+14*x
x0=2.4 # Valor inicial
n=input("numero de interaciones = ?")
n=int(n)

maxe=input("tolerancia = ?")
maxe=float(tol)
print("\n")
for i in range(n):
    x=x0-f(x0)/df(x0)
    err=np.abs(x-x0)
    print("solución parcial para i = ",i+1)
    print(" x0, x : ",x0,x)
    if err < tol :
        print("\n","Convergencia alcanzada")
        print(" solución = ",x)
        print(" Numero de iteraciones = ",i+1)
        break
    else: 
        x0=x
    
Salida

```

    numero de interaciones = ?10
    tolerancia = ?.000000001
    
    
    solución parcial para i =  1
     x0, x :  2.4 2.5150943396226415
    solución parcial para i =  2
     x0, x :  2.5150943396226415 2.511594922905926
    solución parcial para i =  3
     x0, x :  2.511594922905926 2.511591630458341
    solución parcial para i =  4
     x0, x :  2.511591630458341 2.511591630455428
    
     Convergencia alcanzada
     solución =  2.511591630455428
     Numero de iteraciones =  4
       

METODO DE LA BISECCION

Es un algoritmo de búsqueda de raíces que trabaja dividiendo el intervalo a la mitad y seleccionando el subintervalo que tiene la raíz. Es un método sencillo de comprender, ya que es muy intuitivo. Se basa en el siguiente teorema
Teorema de BOLZANO
Sea y = f(x) continua en un intervalo [a,b] y supongamos que
f(x) tenga signos opuestos en a y b es decir f(a)*f(b)<0
Entonces debe existir r en [a,b] tal que tal que f(r)=0,
es decir, debe haber por lo menos una raíz en el intervalo.

Ejemplo: considere la función y= x^3+7*x-60. (Ver grafico)

Se realiza un estudio preliminar( el gráfico ayuda en esto) para seleccionar 2 puntos, a y b, tal que sus imágenes tengan signos diferentes, es decir, f (a)*f (b) <0. En esta caso, observando la gráfica podemos visualizar que entre  a=2 y b=3 hay un cambio de signo de f(x). Por lo tanto según el teorema de Bolzano existe una raiz  de f(x) entre a=2 y b=3

def f(x): return x3+7*x**2-60
a=2;b=3;n=30;tol=0.01 # valores iniciales
import numpy as np
import matplotlib.pyplot as plt
plt.plot(x,f(x))
plt.plot(x,0*x)
xvieja=0
for i in range(n):
    xm=(a+b)/2
    print(xvieja)
    err=np.abs(xm-xvieja)
    print("\n"," solucion parcial iteracion",i)
    print("raiz,error",xm,err)
    print("imagenes f(a),f(b),f(xm)",f(a),f(b), f(xm))
    if err<tol:
       print("\n","convergencia alcanzada")
       print("numero de iteraciones",i)
       print("Raiz= ",xm)
       break
    else:
       if f(a)*f(xm)> 0 :
          a=xm
          print("cambia a, a=xm ")
          if f(a)*f(xm)< 0 :
             b=xm
             print("cambia  b,  b=xm")