s1Eva_IIT2008_T1_MN Bacterias contaminantes

Ejercicio: 1Eva_IIT2008_T1_MN Bacterias contaminantes

a.  Planteamiento del problema

estandarizar la fórmula a la forma f(x) = 0

c = 70 e^{-1.5t} + 25 e^{-0.075t}

el valor que debe tomar c = 9, por lo que la función a desarrollar se convierte en:

9 = 70 e^{-1.5t} + 25 e^{-0.075t}

y la que se usará en el algoritmo de búsqueda de raices es:

70 e^{-1.5t} + 25 e^{-0.075t} -9 = 0 f(t) = 70 e^{-1.5t} + 25 e^{-0.075t} -9 = 0

b. Intervalo de búsqueda [a,b]

Como la variable t representa el tiempo, se inicia el análisis con cero por la izquierda o un poco mayor. a=0

Para verificar que existe raíz se evalúa f(a) y f(b) buscando valores donde se presenten cambios de signo.

La función depende de tiempo, por lo que a = 0, y b seleccionar un valor mayor.

Para el caso de b,  si fuesen minutos, se pueden probar con valores considerando el tiempo que duraría un «experimento» en el laboratorio durante una clase. Por ejemplo 60 minutos, 30 minutos, etc, para obtener un punto «b» donde se garantice un cambio de signo f(a) y f(b)

Para el ejemplo, se prueba con b = 15

a = 0
b = 15
f(a) = f(0) = 70*e0 + 25 e0 -9 = 86
f(b) = f(15) = 70*e-1.5*15. + 25 e-0.075*15 -9 = - 0.0036

c. Número de iteraciones

Calcular el número de iteraciones para llegar a la raíz con el error tolerado

error = 0.001

\frac{|15-0|}{2^n} = 0.001 15/0.001 = 2^n log(15/0.001) = nlog(2) n = \frac{log(15/0.001)}{log(2)} = 13.87 n = 14

Verificando la selección usando una gráfica, usando 50 tramos entre [a,b] o 51 muestras en el intervalo.

bacteriasLago02


d. iteraciones

Se encuentra la derivada f'(t) y se aplica el algoritmo Newton-Raphson con valor inicial cero.

f(t) = 70 e^{-1.5t} + 25 e^{-0.075t} -9 = 0 f'(t) = 70(-1.5) e^{-1.5t} + 25(-0.075) e^{-0.075t}

itera = 0 , t0=0

f(0) = 70 e^{-1.5(0)} + 25 e^{-0.075(0)} -9 = 86 f'(0) = 70(-1.5) e^{-1.5(0)} + 25(-0.075) e^{-0.075(0)} =-106.875 t_1 = 0 - \frac{86}{-106.875} = 0.8047 errado = |0.8047- 0| = 0.8047

itera = 1

f(0.8047) = 70 e^{-1.5(0.8047)} + 25 e^{-0.075(0.8047)} -9 = 35.472 f'(0.8047) = 70(-1.5) e^{-1.5(0.8047)} + 25(-0.075) e^{-0.075(0.8047)} = -33.1694 x_2 = 0.8047 - \frac{35.472}{-33.1694} = 1.8741 errado = |1.8741-0.8047| = 1.0694

itera = 2

f(1.8741) = 70 e^{-1.5(1.8741)} + 25 e^{-0.075(1.8741)} -9 = 16.93146 f'(1.8741) = 70(-1.5) e^{-1.5(1.8741)} + 25(-0.075) e^{-0.075(1.8741)} = -7.9434 t_1 = 1.8741 - \frac{16.9314}{-7.9434} = 4.0056 errado = |4.0056 -1.8741| = 2.1315

Se observa que el valor del error crece en cada iteración, por lo que si solo se hacen tres iteraciones, se concluye que el método No converge.
Sin embargo con el algoritmo se observa que el método luego comienza a disminuir, por lo que se calcula hasta la iteración 7, obteniendo un error de 10-6 y una raíz en 13.62.

El resultado final se lo encuentra al usar el algoritmo:

método de Newton-Raphson
i ['xi', 'fi', 'dfi', 'xnuevo', 'tramo']
0 [   0.       86.     -106.875     0.8047    0.8047]
1 [  0.8047  35.472  -33.1694   1.8741   1.0694]
2 [ 1.8741 16.9314 -7.9434  4.0056  2.1315]
3 [ 4.0056  9.6848 -1.6465  9.8875  5.8819]
4 [ 9.8875  2.9093 -0.8932 13.1445  3.257 ]
5 [13.1445  0.3282 -0.6996 13.6136  0.4691]
6 [ 1.3614e+01  5.7056e-03 -6.7543e-01  1.3622e+01  8.4474e-03]
7 [ 1.3622e+01  1.8070e-06 -6.7500e-01  1.3622e+01  2.6771e-06]
raiz en:  13.622016772385326

Se usa el algoritmo en Python para encontrar el valor. El algoritmo Newton-Raphson mostrado es más pequeño que por ejemplo la bisección, pero requiere realizar un trabajo previo para encontrar la derivada de la función.

# 1Eva_IIT2008_T1_MN Bacterias contaminantes
# Método de Newton-Raphson
import numpy as np

def newton_raphson(fx,dfx,xi, tolera, iteramax=100, vertabla=False, precision=4):
    '''
    fx y dfx en forma numérica lambda
    xi es el punto inicial de búsqueda
    '''
    itera=0
    tramo = abs(2*tolera)
    if vertabla==True:
        print('método de Newton-Raphson')
        print('i', ['xi','fi','dfi', 'xnuevo', 'tramo'])
        np.set_printoptions(precision)
    while (tramo>=tolera):
        fi = fx(xi)
        dfi = dfx(xi)
        xnuevo = xi - fi/dfi
        tramo = abs(xnuevo-xi)
        if vertabla==True:
            print(itera,np.array([xi,fi,dfi,xnuevo,tramo]))
        xi = xnuevo
        itera = itera + 1

    if itera>=iteramax:
        xi = np.nan
        print('itera: ',itera, 'No converge,se alcanzó el máximo de iteraciones')

    return(xi)


# PROGRAMA ---------------------------------
fx = lambda t: 70*(np.e**(-1.5*t)) +25*(np.e**(-0.075*t))-9
dfx = lambda t: -70*1.5*(np.e**(-1.5*t)) -25*0.075*(np.e**(-0.075*t))

# INGRESO
x0 = 0
tolera = 0.001

# PROCEDIMIENTO
raiz = newton_raphson(fx, dfx, x0, tolera, vertabla=True)

# SALIDA
print('raiz en: ', raiz)

# GRAFICA
import matplotlib.pyplot as plt
a = 0
b = 15
muestras = 21

xi = np.linspace(a,b,muestras)
fi = fx(xi)
plt.plot(xi,fi, label='f(x)')
plt.axhline(0)
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid()
plt.legend()
plt.show()

Tarea: Para el problema, realice varios métodos y compare el número de iteraciones y el trabajo realizado al plantear el problema al implementar cada uno.