s1Eva_IIT2008_T1 Distribuidores de productos

Ejercicio: 1Eva_IIT2008_T1 Distribuidores de productos

literal a

Siguiendo las instrucciones del enunciado, el promedio de precios del nodo A, se conforma de los precios en los nodos aledaños menos el costo de transporte.

precio en X1 para A = precio en nodoA – costo de transporteA

siguiendo el mismo procedimiento,

precio en X1 para A: (3.1-0.2)
precio de X1 para B: (2.8-0.3)
precio de X1 para C: (2.7-0.4)
precio de X1 para X2: (X2-0.1)
precio de X1 para X3: (X3-0.5)

x_1 = \frac{1}{5} \Big[ (3.1-0.2)+(2.8-0.3)+(2.7-0.4)+ +(x_2-0.1)+(x_3-0.5)\Big] x_1 = \frac{1}{5} \Big[ 2.9+2.5 +2.3+x_2+x_3-0.6\Big] x_1 = \frac{1}{5} (7.1+x_2+x_3) 5x_1 = 7.1+x_2+x_3 5x_1-x_2-x_3 = 7.1

Se continua con el mismo proceso para los siguientes nodos:

x_2 = \frac{1}{4} \Big[ (3.2-0.5)+(3.4-0.3) +(x_1-0.1)+(x_3-0.2)\Big] 4x_2 = (3.2-0.5)+(3.4-0.3) +(x_1-0.1)+(x_3-0.2) 4x_2 = 2.7+3.1 +x_1+x_3-0.3 -x_1+4x_2-x_3 = 5.5

Para X3

x_3 = \frac{1}{4} \Big[ (3.3-0.3)+(2.9-0.2) +(x_1-0.5)+(x_2-0.2)\Big] 4x_3 = 3.0+2.7+x_1+x_2-0.7 4x_3 = 5+x_1+x_2 -x_1-x_2+4x_3= 5

El sistema de ecuaciones se convierte en:

\begin{cases} 5x_1-x_2-x_3 = 7.1 \\ -x_1+4x_2-x_3 = 5.5 \\-x_1-x_2+4x_3= 5 \end{cases}

Para resolver se cambia a la forma Ax=B

\begin{bmatrix} 5 && -1 && -1 \\ -1 && 4 && -1 \\ -1 && -1 && 4 \end{bmatrix} . \begin{bmatrix} x_1 \\ x_2 \\ x_3 \end{bmatrix} = \begin{bmatrix} 7.1 \\ 5.5 \\5 \end{bmatrix}

En los métodos directos se usa la forma de matriz aumentada

\begin{bmatrix} 5 && -1 && -1 && 7.1 \\ -1 && 4 && -1 && 5.5 \\ -1 && -1 && 4 && 5 \end{bmatrix}

pivoteo: no es necesario, pues la matriz ya está ordenada de forma diagonalmente dominante.

Eliminación hacia adelante

i=0, f=0

\begin{bmatrix} 5 && -1 && -1 && 7.1 \\ -1-5\big(\frac{-1}{5}\big) && 4 -(-1)\big(\frac{-1}{5}\big) && -1 -(-1)\big(\frac{-1}{5}\big) && 5.5-7.1\big(\frac{-1}{5}\big) \\ -1-5\big(\frac{-1}{5}\big) && -1-(-1)1\big(\frac{-1}{5}\big) && 4-(-1)\big(\frac{-1}{5}\big) && 5-7.1\big(\frac{-1}{5}\big) \end{bmatrix} \begin{bmatrix} 5 && -1 && -1 && 7.1 \\ 0 && 3.8 && -1.2 && 6.92 \\ 0 && -1.2 && 3.8 && 6.42 \end{bmatrix}

Eliminación hacia adelante para i = 1, j=1

Elimina hacia adelante
[[ 5.         -1.         -1.          7.1       ]
 [ 0.          3.8        -1.2         6.92      ]
 [ 0.          0.          3.42105263  8.60526316]]

Eliminación hacia atrás, continuando el desarrollo de forma semejante a los pasos anteriores se obtiene:

Elimina hacia atrás
[[ 1.         -0.         -0.          2.44615385]
 [ 0.          1.         -0.          2.61538462]
 [ 0.          0.          1.          2.51538462]]
el vector solución X es:
[[2.44615385]
 [2.61538462]
 [2.51538462]]
verificar que A.X = B
[[7.1]
 [5.5]
 [5. ]]

literal b

Para el literal b se usa como referencia el número de condición:

>>> np.linalg.cond(A)
2.5274158815808474

El número de condición es cercano a 1, dado que la matriz A es diagonalmente dominante pues los valores mayores de la fila se encuentran en la diagonal. Como el número de condición es cercano a 1 el sistema converge usando métodos iterativos.

La selección del vector inicial para las iteraciones siguiendo el enunciado del problema, se evita el vector cero dado que el precio de un producto para una fabrica no puede ser cero. Se observa los valores de los precios, y se encuentra que el rango de existencia en los nodos es [ 2.7, 3.4] que restando el valor de transporte podrían ser un valor menor a 2.7. Por lo que un buen vector inicial será [2,2,2]


literal c

Se plantean las ecuaciones para el método de Jacobi a partir del sistema de ecuaciones, a partir del pivoteo por filas:

\begin{cases} 5x_1-x_2-x_3 = 7.1 \\ -x_1+4x_2-x_3 = 5.5 \\-x_1-x_2+4x_3= 5 \end{cases} x_1 = \frac{7.1 +x_2 + x_3}{5} x_2 = \frac{ 5.5 +x_1 + x_3}{4} x_3 = \frac{5 +x_1 + x_2}{4}

Si consideramos que el costo mínimo podría ser 2, el precio debería ser mayor x0 = [2,2,2]

itera =  0

x_1 = \frac{7.1 +(2) + (2)}{5} = 2.22 x_2 = \frac{ 5.5 +(2) + (2)}{4} = 2.375 x_3 = \frac{5 +(2) + (2)}{4} =2.25 errado = max|[2.22-2, 2.375-2, 2.25-2]| = max |[0.22, 0.375, 0.25]| = 0.375 X_1 = [2.22, 2.375, 2.25]|

itera = 1

x_1 = \frac{7.1 +(2.375) + (2.25)}{5} = 2.345 x_2 = \frac{ 5.5 +(2.22) + (2.25)}{4} = 2.4925 x_3 = \frac{5 +(2.22) + (2.375)}{4} =2.39875 errado = max|[2.345-2.22, 2.4925-2.375, 2.39875 - 2.25]| = 0.14874999999999972 X_2 = [2.345, 2.4925, 2.39875]

itera = 2

x_1 = \frac{7.1 +(2.4925) + (2.39875)}{5} = 2.39825 x_2 = \frac{ 5.5 +(2.345) + (2.39875)}{4} = 2.5609375 x_3 = \frac{5 +(2.345) + (2.4925)}{4} = 2.459375 errado = max|[2.39825 - 2.345, 2.5609375- 2.4925, 2.459375 - 2.39875]| = 0.06843749999999993 X_3 = [2.39825, 2.5609375, 2.459375 ]

El error disminuye entre iteraciones, por lo que el método converge.

Los datos de las iteraciones usando el algoritmo son:

Matriz aumentada
[[ 5.  -1.  -1.   7.1]
 [-1.   4.  -1.   5.5]
 [-1.  -1.   4.   5. ]]
Pivoteo parcial:
  Pivoteo por filas NO requerido
itera,[X],errado
0 [2. 2. 2.] 1.0
1 [2.22  2.375 2.25 ] 0.375
2 [2.345   2.4925  2.39875] 0.14874999999999972
3 [2.39825   2.5609375 2.459375 ] 0.06843749999999993
4 [2.4240625  2.58940625 2.48979687] 0.030421875000000043
5 [2.43584062 2.60346484 2.50336719] 0.014058593750000181
6 [2.44136641 2.60980195 2.50982637] 0.006459179687499983
7 [2.44392566 2.61279819 2.51279209] 0.0029962402343750583
8 [2.44511806 2.61417944 2.51418096] 0.001388874511718985
9 [2.44567208 2.61482476 2.51482437] 0.0006453167724607134
10 [2.44592983 2.61512411 2.51512421] 0.00029983517456066977
11 [2.44604966 2.61526351 2.51526348] 0.0001393951034542873
12 [2.4461054  2.61532829 2.51532829] 6.480845146183967e-05
numero de condición: 2.5274158815808474
respuesta con Jacobi
[2.4461054 2.61532829 2.51532829]

Algoritmo en Python

# 1Eva_IIT2008_T1 Distribuidores de productos
# Método de Jacobi
import numpy as np

def jacobi(A,B,tolera,X0,iteramax=100, vertabla=False):
    ''' Método de Jacobi, tolerancia, vector inicial X0
        para mostrar iteraciones: vertabla=True
    '''
    A = np.array(A, dtype=float)
    B = np.array(B, dtype=float)
    X0 = np.array(X0, dtype=float)
    tamano = np.shape(A)
    n = tamano[0]
    m = tamano[1]
    diferencia = np.ones(n, dtype=float)
    errado = np.max(diferencia)
    X = np.copy(X0)
    xnuevo = np.copy(X0)

    itera = 0
    if vertabla==True:
        print('itera,[X],errado')
        print(itera, xnuevo, errado)
    while not(errado<=tolera or itera>iteramax):
        
        for i in range(0,n,1):
            nuevo = B[i]
            for j in range(0,m,1):
                if (i!=j): # excepto diagonal de A
                    nuevo = nuevo-A[i,j]*X[j]
            nuevo = nuevo/A[i,i]
            xnuevo[i] = nuevo
        diferencia = np.abs(xnuevo-X)
        errado = np.max(diferencia)
        X = np.copy(xnuevo)
        itera = itera + 1
        if vertabla==True:
            print(itera, xnuevo, errado)
    # No converge
    if (itera>iteramax):
        X=itera
        print('iteramax superado, No converge')
    return(X)

def pivoteafila(A,B,vertabla=False):
    '''
    Pivotea parcial por filas, entrega matriz aumentada AB
    Si hay ceros en diagonal es matriz singular,
    Tarea: Revisar si diagonal tiene ceros
    '''
    A = np.array(A,dtype=float)
    B = np.array(B,dtype=float)
    # Matriz aumentada
    nB = len(np.shape(B))
    if nB == 1:
        B = np.transpose([B])
    AB  = np.concatenate((A,B),axis=1)
    
    if vertabla==True:
        print('Matriz aumentada')
        print(AB)
        print('Pivoteo parcial:')
    
    # Pivoteo por filas AB
    tamano = np.shape(AB)
    n = tamano[0]
    m = tamano[1]
    
    # Para cada fila en AB
    pivoteado = 0
    for i in range(0,n-1,1):
        # columna desde diagonal i en adelante
        columna = np.abs(AB[i:,i])
        dondemax = np.argmax(columna)
        
        # dondemax no es en diagonal
        if (dondemax != 0):
            # intercambia filas
            temporal = np.copy(AB[i,:])
            AB[i,:] = AB[dondemax+i,:]
            AB[dondemax+i,:] = temporal

            pivoteado = pivoteado + 1
            if vertabla==True:
                print(' ',pivoteado, 'intercambiar filas: ',i,'y', dondemax)
    if vertabla==True:
        if pivoteado==0:
            print('  Pivoteo por filas NO requerido')
        else:
            print('AB')
    return(AB)


# INGRESO
A = [[  5, -1, -1],
     [ -1,  4, -1],
     [ -1, -1,  4]]
B = [7.1, 5.5,5]
X0  = [2,2,2]

tolera = 0.0001
iteramax = 100

# PROCEDIMIENTO
# numero de condicion
ncond = np.linalg.cond(A)
# Pivoteo parcial por filas
AB = pivoteafila(A,B,vertabla=True)
n = len(A)
A = AB[:,:n]
B = AB[:,n]

respuesta = jacobi(A,B,tolera,X0,vertabla=True)

# SALIDA
print('numero de condición:', ncond)
print('respuesta con Jacobi')
print(respuesta)

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.

s1Eva_IT2008_T1 Raíz de funcion(f)

Ejercicio: 1Eva_IT2008_T1 Raíz de funcion(f)

Pasos a Seguir usando: BISECCION

  1. Plantear la fórmula estandarizada f(x) = 0
  2. Seleccionar el rango de análisis [a,b] donde exista cambio de signo.
  3. Calcular el número de iteraciones para llegar a la raíz con el error tolerado
  4. Calcular la raíz:
    4.1 Solución manual en papel: Realizar la tabla que muestre las iteraciones del método:
    4.2 Solución usando el algoritmo: Usar el algoritmo para encontrar la raiz.

1. Plantear la fórmula estandarizada f(x) = 0

\sqrt{f} . ln \Big( R\frac{\sqrt{f}}{2.51} \Big) - 1.1513 = 0

La función depende de la variable f, por lo que por facilidad de trabajo se cambiará a x para no ser confundida con una función f(x).
El valor de R también se reemplaza con R=5000 como indica el problema.
El error tolerado para el problema es de 0.00001

\sqrt{x} . ln \Big( 5000\frac{\sqrt{x}}{2.51} \Big) - 1.1513 = 0

2. Seleccionar el rango de análisis [a,b] donde exista cambio de signo

La función tiene un logaritmo, por lo que no será posible iniciar con cero, sin o con  valor un poco mayor a=0.01. Para el límite superior se escoge para prueba b=2. y se valida el cambio de signo en la función.

>>> import numpy as np
>>> fx = lambda x: np.sqrt(x)*np.log((5000/2.51)*np.sqrt(x))-1.1513
>>> fx(0.01)
-0.62186746547214999
>>> fx(2)
10.082482845673042

validando el rango por cambio de signo en la función [0.01 ,2]

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

error = 0.00001

\frac{|2-0.01|}{2^n} = 0.001 1.99/0.00001 = 2^n log(1.99/0.00001) = nlog(2) n = \frac{log(1.99/0.00001)}{log(2)} = 17.6 n = 18

4. Calcular la raíz:

Usando el algoritmo se encuentra que la raiz está en:

raiz:  0.0373930168152
f(raiz) =  -2.25294254252e-06

Primeras iteraciones de la tabla resultante:

 
a,b,c, fa, fb, fc, error
[[  1.00000000e-02   2.00000000e+00   1.00500000e+00  -6.21867465e-01
    6.46707903e+00   6.46707903e+00   1.99000000e+00]
 [  1.00000000e-02   1.00500000e+00   5.07500000e-01  -6.21867465e-01
    4.01907320e+00   4.01907320e+00   9.95000000e-01]
 [  1.00000000e-02   5.07500000e-01   2.58750000e-01  -6.21867465e-01
    2.36921961e+00   2.36921961e+00   4.97500000e-01]
 [  1.00000000e-02   2.58750000e-01   1.34375000e-01  -6.21867465e-01
    1.26563722e+00   1.26563722e+00   2.48750000e-01]
 [  1.00000000e-02   1.34375000e-01   7.21875000e-02  -6.21867465e-01
    5.36709904e-01   5.36709904e-01   1.24375000e-01]
 [  1.00000000e-02   7.21875000e-02   4.10937500e-02  -6.21867465e-01
    6.51903790e-02   6.51903790e-02   6.21875000e-02]
...

el número de iteraciones es filas-1 de la tabla

>>> len(tabla)
19

con lo que se comprueba los resultados.

s1Eva_IIIT2007_T3 Factorar polinomio

Ejercicio: 1Eva_IIIT2007_T3 Factorar polinomio

Para factorar el polinomio:

P_3(x) = 2 x^3 - 5 x^2 + 3 x - 0.1

Se realiza la gráfica para observar los intervalos de búsqueda de raíces.factorar polinomio 01

Para la solución con Newton-Raphson se plantea f(x)=0

2x^3-5x^2 + 3x - 0.1 = 0 f(x) = 2x^3-5x^2 + 3x - 0.1 f'(x) =6x^2-10x + 3 x_{i+1} = x_i -\frac{f(x_i)}{f'(x_i)}

Para la primera raíz a la izquierda, se usa x0 = 0

itera = 0

f(0) = 2(0)^3-5(0)^2 + 3(0) - 0.1 = - 0.1 f'(0) =6(0)^2-10(0) + 3 = 3 x_{1} = 0 -\frac{- 0.1}{3} = 0.03333 error = |0.03333 -0| = 0.03333

itera = 1

f(0.0333) = 2(0.0333)^3-5(0.0333)^2 + 3(0.0333) - 0.1 = -0.0054815 f'(0.0333) =6(0.0333)^2-10(0.0333) + 3 = 2.6733 x_{2} = 0.0333 -\frac{-0.0054815}{2.6733} = 0.035384 error = |0.035384 - 0.03333| = 0.0020504

itera = 2

f(0.035384) = 2(0.035384)^3-5(0.035384)^2 + 3(0.035384) - 0.1 = -0.000020163 f'(0.035384) =6(0.035384)^2-10(0.035384) + 3 = 2.6537 x_{3} = 0.0333 -\frac{-0.000020163}{2.6537} = 0.035391 error = |0.035391 - 0.035384| = 0.0000075982

como el error es del orden de 10-6 que es menor que tolera de 10-5 se considera la raíz encontrada.

raíz en: 0.03539136103889022

los resultados con el algoritmo son:

i ['xi', 'fi', 'dfi', 'xnuevo', 'tramo']
0 [ 0.     -0.1     3.      0.0333  0.0333]
1 [ 3.3333e-02 -5.4815e-03  2.6733e+00  3.5384e-02  2.0504e-03]
2 [ 3.5384e-02 -2.0163e-05  2.6537e+00  3.5391e-02  7.5982e-06]
raíz en:  0.03539136103889022

para raíz cerca de 1

i ['xi', 'fi', 'dfi', 'xnuevo', 'tramo']
0 [ 1.  -0.1 -1.   0.9  0.1]
1 [ 0.9    0.008 -1.14   0.907  0.007]
2 [ 9.0702e-01  2.0390e-05 -1.1341e+00  9.0704e-01  1.7979e-05]
raíz en:  0.9070355226186211

para raíz cercana a 1.5

i ['xi', 'fi', 'dfi', 'xnuevo', 'tramo']
0 [ 1.5    -0.1     1.5     1.5667  0.0667]
1 [1.5667 0.0184 2.06   1.5577 0.0089]
2 [1.5577e+00 3.4849e-04 1.9820e+00 1.5576e+00 1.7583e-04]
3 [1.5576e+00 1.3436e-07 1.9805e+00 1.5576e+00 6.7843e-08]
raíz en:  1.557573116112315

Instrucciones en Python

# 1ra Eval III Término 2007
# Tema 3. Factorar polinomio
import numpy as np
import matplotlib.pyplot as plt

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)

# Literal a)
fx = lambda x: 2*x**3 - 5*x**2 + 3*x -0.1
dfx = lambda x: 6*x**2 - 10*x +3
# Literal b)
#fx =  lambda x: (2*x**3 - 5*x**2 + 3*x -0.1)/(x-0.03539136103889022)
#dfx = lambda x: (6*x**2 - 10*x + 3)/(x - 0.0353913610388902) - (2*x**3 - 5*x**2 + 3*x - 0.1)/(x - 0.0353913610388902)**2

x0 = 0
tolera = 0.0001

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

# SALIDA
print('raíz en: ', respuesta)

# simplificando el polinomio
import sympy as sym
x = sym.Symbol('x')
p = 2*x**3 - 5*x**2 + 3*x -0.1
Q2 = p/(x-respuesta)
dQ2 = sym.diff(Q2,x,1)
print('Q2')
print(Q2)
print('dQ2')
print(dQ2)


# grafica
a = 0
b = 2
muestras = 21
xi = np.linspace(a,b, muestras)
fi = fx(xi)
plt.plot(xi,fi, label='P(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('P3(x)')
plt.axhline(0)
plt.grid()
plt.show()

literal b

Obtenga el polinomio cociente Q2(x), a partir de P3(x) = (x – r1)Q2(x)

Se simplifica el polinomio realizando la división:

Q_2(x) = \frac{2 x^3 - 5 x^2 + 3 x - 0.1}{x-0.03539136103889022} Q'_2(x) = \frac{ 6 x^2 - 10 x + 3}{x - 0.0353913610388902} - \frac{2 x^3 - 5 x^2 + 3 x - 0.1}{(x - 0.0353913610388902)^2}

Se reutiliza el algoritmo usando las nuevas expresiones

# Literal b)
# PROCEDIMIENTO
fx =  lambda x: (2*x**3 - 5*x**2 + 3*x -0.1)/(x-raiz1)
dfx = lambda x: (6*x**2 - 10*x + 3)/(x - 0.0353913610388902) - (2*x**3 - 5*x**2 + 3*x - 0.1)/(x - 0.0353913610388902)**2

la derivada se puede obtener usando la librería Sympy, con las instrucciones:

# simplificando el polinomio
import sympy as sym
x = sym.Symbol('x')
p = 2*x**3 - 5*x**2 + 3*x -0.1
Q2 = p/(x-respuesta)
dQ2 = sym.diff(Q2,x,1)
print('Q2')
print(Q2)
print('dQ2')
print(dQ2)

Usando los resultados de Q2(x) y actualizando las expresiones para f(x) y f'(x) se obtienen los siguientes resultados, que verifican las raíces encontradas en el literal a.

i ['xi', 'fi', 'dfi', 'xnuevo', 'tramo']
0 [ 0.      2.8255 -4.9292  0.5732  0.5732]
1 [ 0.5732  0.6572 -2.6363  0.8225  0.2493]
2 [ 0.8225  0.1243 -1.6392  0.8983  0.0758]
3 [ 0.8983  0.0115 -1.336   0.9069  0.0086]
4 [ 9.0692e-01  1.4809e-04 -1.3015e+00  9.0704e-01  1.1379e-04]
5 [ 9.0704e-01  2.5894e-08 -1.3011e+00  9.0704e-01  1.9902e-08]
raíz en:  0.9070355227446406

La gráfica obtenida para Q2(x) es:

factorar polinomio Q2(x)


literal c

La otra raíz cercana a 1.5 se calcula a partir de Q2(x) usando el algoritmo.

i ['xi', 'fi', 'dfi', 'xnuevo', 'tramo']
0 [ 1.5    -0.0683  1.0708  1.5638  0.0638]
1 [1.5638 0.0081 1.3258 1.5576 0.0061]
2 [1.5576e+00 7.5234e-05 1.3013e+00 1.5576e+00 5.7814e-05]
raíz en:  1.5575731212503858

literal d

El polinomio:

P_3(x) = 2 x^3 - 5 x^2 + 3 x - 0.1

se expresa también formado como parte de sus raíces:

P_3(x) = (x - 0.0353913)(x - 0.907035 )(x -1.557573 )

s1Eva_IIIT2007_T2 Función Cobb-Douglas

Ejercicio: 1Eva_IIIT2007_T2 Función Cobb-Douglas

[ a1 interpola filas ] [a2 interpola punto Y] [ b1 interpola columnas ] [ b2 raíz Newton-Raphson]  [ Algoritmo ]
..


literal a.1 Interpola tabla por filas

Se usa la tabla para plantear los polinomios usando los datos de cada fila. Se evalúa el polinomio con el valor de K=25 (en miles) para completar los datos de la columna K=25

 L\K (miles $) 10 20 25 30 40
0 0 0 0 0
10 11.0000 13.0813 14.4768 15.5563
20 18.4997 22.0000 24.3470 26.1626
25 Y
30 25.0746 29.8189 33.0000 35.4608

Para la fila L=0 no es necesario realizar un polinomio, pues se observa que para 0 trabajadores la producción es nula, no existe producción p(K)=0  y pK(25)=0.

Para la fila L=10, se disponen de 4 puntos, por lo que se plantea un polinomio de grado 3:

P_{L10}(K) = 11\frac{(K-20)(K-30)(K-40)}{(10-20)(10-30)(10-40)} + + 13.0813\frac{(K-10)(K-30)(K-40)}{(20-10)(20-30)(20-40)} + + 14.4768\frac{(K-10)(K-20)(K-40)}{(30-10)(30-20)(30-40)} + + 15.5563\frac{(k-10)(k-20)(k-30)}{(40-10)(40-20)(40-30)}

Con el algoritmo se simplifica la expresión:

P_{L10}(K) =0.0000616335 K^3 - 0.0071269*K^2 + 0.378796 K + 7.8630

Se evalúa el polinomio con K=25

P_{L10}(K) =0.0000616335 (25)^3 - 0.0071269*(25)^2 + 0.378796 (25) + 7.8630 P_{L10}(25) = 13.84166

Se observan los resultados encontrados en la primera gráfica:

Cobb Douglas

Se continua el ejercicio usando los algoritmos para encontrar los polinomios de Lagrange obteniendo:

 **** literal a:
Polinomio de Lagrange por fila de L
fila: 0 , li[fila]: 0  , polinomio pk :
0
 pk[25]: 0
___
fila: 1 , li[fila]: 10  , polinomio pk :
                     3                        2                               
6.16333333333342e-5*K  - 0.00712699999999999*K  + 0.378796666666668*K + 7.86309999999999
 pk[25]: 13.8416625000000
___
fila: 2 , li[fila]: 20  , polinomio pk :
                      3              2                                
0.000103649999999999*K  - 0.0119855*K  + 0.637039999999995*K + 13.2242
 pk[25]: 23.2787937499999
___
fila: 3 , li[fila]: 30  , polinomio pk :
                     3                       2                                
0.00014048333333333*K  - 0.0162449999999998*K  + 0.863441666666663*K + 17.9242
 pk[25]: 31.5521687500000
___
 Datos para el polinomio de L
li:
[ 0 10 20 30]
k_buscado:
[0, 13.8416625000000, 23.2787937499999, 31.5521687500000]

[ a1 interpola filas ] [a2 interpola punto Y] [ b1 interpola columnas ] [ b2 raíz Newton-Raphson]  [ Algoritmo ]

..


literal a.2 Interpola un punto en Y con K=25

Con los datos obtenidos se genera el siguiente polinomio P(L), que corresponde a la parte derecha de la gráfica mostrada.

P_{k=25}(L) = 0\frac{(L-10)(L-20)(L-30)}{(0-10)(0-20)(0-30)} + + 13.84166\frac{(L-0)(L-20)(L-30)}{(10-0)(10-20)(10-30)} + + 23.27879\frac{(L-0)(L-10)(L-30)}{(20-0)(20-10)(20-30)} + + 31.55216\frac{(L-0)(L-10)(L-20)}{(30-0)(30-10)(30-20)}

simplificando con el algoritmo se tiene:

P_{k=25}(L) = 00.00054012 L^3 - 0.038226 L^2 + 1.71241 L

evaluando el polinomio con L=25

P_{k=25}(L) = 00.00054012 (25)^3 - 0.038226 (25)^2 + 1.71241 (25) P_{k=25}(L) = 27.358402

Con los datos obtenidos se realiza la gráfica en 3D marcando los puntos calculados con los polinomios.

Cobb Douglas Y[L,K]

[ a1 interpola filas ] [a2 interpola punto Y] [ b1 interpola columnas ] [ b2 raíz Newton-Raphson]  [ Algoritmo ]

..


literal b.1 Interpola tabla por columnas

 L\K (miles $) 10 20 K=? 30 40
0 0 0 0 0
10 11.0000 13.0813 14.4768 15.5563
20 18.4997 22.0000 24.3470 26.1626
25 Y=30
30 25.0746 29.8189 33.0000 35.4608

Se repite el ejercicio del literal a, con el mismo algoritmo para no rescribir todo por las filas por columnas. En el algoritmo se intercambian las filas por columnas y se transpone la matriz.

# INGRESO 

...
# Se intercambian los valores de fila columna para repetir el algoritmo
# obteniendo Y(L=25,k)
M = np.transpose(M)
kj = [0, 10, 20, 30]
li = [10, 20, 30, 40]

l_busca = 25 # trabajadores
k_busca = 25 # inversión en miles de $

Se ajustan las etiquetas de las gráficas y se obtiene el polinomio a usar, que es la producción Y(k) para un capital K dado:

Y(K) = P_{L=25}(K) = 
0.000121812500000016*K**3 - 0.0140857812500013*K**2 +
 0.748676562500027*K + 15.5417812499999
Y(K) = 0.00012181 K^3 - 0.014085 K^2 + 0.74867 K + 15.54178

[ a1 interpola filas ] [a2 interpola punto Y] [ b1 interpola columnas ] [ b2 raíz Newton-Raphson]  [ Algoritmo ]

..


literal b.2 raíz con Newton-Raphson

Para el algoritmo de Newton- Raphson, el ejercicio se plantea igualando el polinomio al valor buscado de producción Y=30. Se escribe luego la expresión en como f(x)=0 y f'(x):.

0.00012181 K^3 - 0.014085 K^2 + 0.74867 K + 15.54178 = 30 f(K) = 0.00012181 K^3 - 0.014085 K^2 + 0.74867 K + 15.54178 - 30 f'(K) = 0.0001218(3) K^2 - 0.014085(2) K+ 0.74867 f'(K) = 0.00036543 K^2 - 0.02817 K+ 0.74867

Usando la gráfica se inicia con K0=30, por ser el valor mas cercano de los puntos conocidos a Y=30, se obtienen los siguientes resultados:

itera = 0

f(30) = 0.00012181 (30)^3 - 0.014085 (30)^2 + 0.74867 (30) + + 15.54178 - 30 = -1.3862 f'(30) = 0.00036543 (30)^2 - 0.02817 (30)+ 0.74867 = 0.2325 K_{1} = 30 -\frac{-1.3862}{0.2325} = 35.963 errado = |35.963 -30| = 5.963

itera = 1

f(35.963) = 0.00012181 (35.963)^3 - 0.014085 (35.963)^2 + + 0.74867 (35.963) + 15.54178 - 30 = -0.0854 f'(35.963) = 0.00036543 (35.963)^2 - 0.02817 (35.963) + 0.74867 = 0.2082 K_{2} = 35.963 -\frac{-0.0854}{0.2082} = 36.3734 errado = |36.3734 -35.963| = 0.4104

itera = 2

f( 36.3734) = 0.00012181 ( 36.3734)^3 - 0.014085 ( 36.3734)^2 + + 0.74867 ( 36.3734) + 15.54178 - 30 = -0.00016955 f'( 36.3734) = 0.00036543 ( 36.3734)^2 - 0.02817 ( 36.3734)+ + 0.74867 = 0.20751 K_{3} = 36.3734 -\frac{-0.00016955}{0.20751} = 36.374 errado = |36.374 - 36.3734| = 0.00081705

Se observa que el error disminuye en cada iteración, por lo que el método converge.

Se sigue con las iteraciones usando el algoritmo:

método de Newton-Raphson
i ['xi', 'fi', 'dfi', 'xnuevo', 'tramo']
0 [30.     -1.3862  0.2325 35.963   5.963 ]
1 [35.963  -0.0854  0.2082 36.3734  0.4104]
2 [ 3.6373e+01 -1.6955e-04  2.0751e-01  3.6374e+01  8.1705e-04]
3 [ 3.6374e+01 -3.8858e-08  2.0751e-01  3.6374e+01  1.8726e-07]
raíz en:  36.3742052500759

Se encuentra la raíz en 36.3741, que corresponde a una inversión K un poco mas de 36 mil dólares para una producción Y de 30 mil unidades.

Cobb Douglas K para Y-30[ a1 interpola filas ] [a2 interpola punto Y] [ b1 interpola columnas ] [ b2 raíz Newton-Raphson]  [ Algoritmo ]

..


Instrucciones en Python. literal a

#1Eva_IIIT2007_T2 Función Cobb-Douglas
# Interpolacion de Lagrange
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym

def interpola_lagrange(xi,yi):
    '''
    Interpolación con método de Lagrange
    resultado: polinomio en forma simbólica
    '''
    # PROCEDIMIENTO
    n = len(xi)
    x=sym.Symbol('x')
    # Polinomio
    polinomio = 0*x # inicializa con cero
    for i in range(0,n,1):
        # Termino de Lagrange
        termino = 1
        for j  in range(0,n,1):
            if (j!=i):
                termino = termino*(x-xi[j])/(xi[i]-xi[j])
        polinomio = polinomio + termino*yi[i]
    # Expande el polinomio
    polinomio = polinomio.expand()
    return(polinomio)

# INGRESO
M = [[ 0,       0,       0,       0     ],
     [11.0000, 13.0813, 14.4768, 15.5563],
     [18.4997, 22.0000, 24.3470, 26.1626],
     [25.0746, 29.8189, 33.0000, 35.4608]]
li = [0, 10, 20, 30]
kj = [10, 20, 30, 40]

l_busca = 25 # trabajadores
k_busca = 25 # inversion en miles de $

# PROCEDIMIENTO
M = np.array(M)
tamano = np.shape(M)
n = tamano[0]
m = tamano[1]
x,K,L = sym.symbols('x,K,L')

# Literal a.1 Interpola polinomio pk
# por fila de trabajadores L
# evalua en k_busca, inversiones en miles
poli_fila = []
pk_columna =[]
for fila in range(0,n,1):
    pk = interpola_lagrange(kj,M[fila,:])
    pk = pk.subs(x,K)
    poli_fila.append(pk)
    pk_busca = poli_fila[fila].subs(K,k_busca)
    pk_columna.append(pk_busca)

# Interpola un polinomio en columna de inversiones pk_columna
# evalua en l_busca
pkl_busca = interpola_lagrange(li,pk_columna)
pkl_busca = pkl_busca.subs(x,L)
Ykl_busca = pkl_busca.subs(L,l_busca)

# SALIDA
np.set_printoptions(precision=4)
print(' **** literal a:')
print('___ Polinomio por fila de trabajadores L')
for fila in range(0,n,1):
    print(fila,', L['+str(fila)+']=',li[fila], ', pk(K) :')
    print(poli_fila[fila])
    print(' pk['+str(k_busca)+']:',pk_columna[fila])
    print('___')
print('\n Datos para el polinomio de L')
print('     Li: ',li)
print('k_busca: ',pk_columna)
print('Polinomio p(L):')
print(pkl_busca)
print('Y[l_busca,k_busca]: ',Ykl_busca)

# Grafica de P(k) por cada L
muestras = 20
xk = np.linspace(min(kj),max(kj),muestras)

plt.subplot(121)
for fila in range(0,n,1):
    pk = poli_fila[fila]
    if pk.has(K):
        pk_lambda = sym.lambdify(K,pk)
        pkx = pk_lambda(xk)
    else:
        nk = len(xk)
        pkx = np.ones(nk)*float(pk)
    plt.plot(xk,pkx, label='pk(K);li='+str(li[fila]))
    plt.plot(k_busca,pk_columna[fila],'o')
plt.ylabel('p(K)')
plt.xlabel('K inversiones en miles')
plt.axvline(k_busca, linestyle ='dashed')
plt.title('Polinomios pk(K)')
plt.legend()

# Grafica de p(L) en k_busca 
xl = np.linspace(min(li),max(li),muestras)
pl_lambda = sym.lambdify(L,pkl_busca)
plx = pl_lambda(xl)

plt.subplot(122)
plt.plot(xl,plx, label='p(L)')
plt.plot(li,pk_columna,'o', label='[li,pk(K)]')
plt.axvline(l_busca, linestyle ='dashed')
plt.plot(l_busca,Ykl_busca,'o')
plt.ylabel('p(L)')
plt.xlabel('L trabajadores')
plt.title('Polinomio pl(L)')
plt.legend()
# plt.show()

# Grafica 3D
from mpl_toolkits.mplot3d import axes3d
X, Y = np.meshgrid(kj,li)
figura = plt.figure()
ax = figura.add_subplot(111, projection = '3d')
ax.plot_wireframe(X,Y,M)
ax.plot(k_busca,l_busca,Ykl_busca,'o',label='(25,25,Y)')
ax.plot(k_busca*np.ones(len(li)),li,pk_columna,'o')
ax.set_xlabel('K inversion')
ax.set_ylabel('L trabajadores')
ax.set_zlabel('Y producción')
ax.set_title('Cobb-Douglas')
plt.show()

[ a1 interpola filas ] [a2 interpola punto Y] [ b1 interpola columnas ] [ b2 raíz Newton-Raphson]  [ Algoritmo ]

Instrucciones en Python. literal b

#1Eva_IIIT2007_T2 Función Cobb-Douglas
# Interpolacion de Lagrange # Newton-Raphson
import numpy as np
import matplotlib.pyplot as plt

def newton_raphson(fx,dfx,xi, tolera, iteramax=100, vertabla=False, precision=4):
    '''
    funciónx y fxderiva en forma numérica lambda
    xi es el punto inicial de búsqueda
    '''
    itera=0
    tramo = abs(2*tolera)
    if vertabla==True:
        print('i', ['xi','fi','dfi', 'xnuevo', 'tramo'])
        np.set_printoptions(precision)
    while (tramo>=tolera and itera<iteramax):
        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)

# INGRESO
y_busca = 30
fx  = lambda K: 0.0001218125*K**3 - 0.0140857812500013*K**2 + 0.748676562500027*K + 15.5417812499999 -y_busca
dfx = lambda K: 0.00036543*K**2 - 0.02817*K + 0.748676562500027

x0 = 30
tolera = 0.00001
muestras = 20

# PROCEDIMIENTO
respuesta = newton_raphson(fx,dfx,x0, tolera, vertabla=True)
# SALIDA
print('raíz en: ', respuesta)

# Grafica
xl = np.linspace(0,40,muestras)
plx = fx(xl)
plt.plot(xl,plx, label='Y(k)')
plt.axhline(0,linestyle='dotted')
plt.ylabel('f(K)')
plt.xlabel('K inversiones en miles')
plt.title('f(K) = Y(K)-'+str(y_busca))
plt.show()

[ a1 interpola filas ] [a2 interpola punto Y] [ b1 interpola columnas ] [ b2 raíz Newton-Raphson]  [ Algoritmo ]

s1Eva_IIIT2007_T1_AN Container: Refrigeradoras y Cocinas

Ejercicio: 1Eva_IIIT2007_T1 Container: Cocinas y Refrigeradoras

literal a

Considerando  como  x la cantidad de refrigeradoras, y cantidad de cocinas, las ecuaciones a plantear son:

\begin{cases} 200 x + 100 y = 1000 \\ 2 x + 1.05 y = 10.4 \end{cases}

La forma matricial del ejercicio se convierte a:

\begin{pmatrix} 200 & 100 \\ 2 & 1.05\end{pmatrix} \begin{pmatrix}x \\ y \end{pmatrix} = \begin{pmatrix} 1000 \\10.4 \end{pmatrix}

la matriz aumentada es

\begin{pmatrix} 200 & 100 & 1000\\ 2 & 1.05 & 10.4\end{pmatrix}

Para el pivoteo parcial por filas, dado que el mayor valor de la primera columna se encuentra en la diagonal, no se requiere y la matriz aumentada se mantiene igual.

Para el proceso de eliminación hacia adelante, se incia con el pivote=200

factor = \frac{2}{200} = 0.01

que se aplica a la segunda fila

         [ 200.  100.     1000  ]
-(2/200)*[   2.    1.05     10.4]
_________________________________
       = [   0.     0.05     0.4]

con lo que la matriz queda:

\begin{pmatrix} 200 & 100 & 1000\\ 0 & 0.05 & 0.4\end{pmatrix}

Se aplica sustitución hacia atrás, desde la última fila:

0.05 y = 0.4 y = \frac{0.4}{0.05 } = 8

para la primera fila:

200 x+100(8)=1000 200 x=1000-100 (8) x=\frac{1000 - 100 (8)}{200} = 1

siendo la respuesta [1,8]

Con el algoritmo se obtiene:

Matriz aumentada
[[ 200.    100.   1000.  ]
 [   2.      1.05   10.4 ]]
Pivoteo parcial:
  Pivoteo por filas NO requerido
Elimina hacia adelante:
  factor:  0.01  para fila:  1
[[2.e+02 1.e+02 1.e+03]
 [0.e+00 5.e-02 4.e-01]]
solución: 
[1. 8.]
>>>

literal b

Matriz aumentada
[[ 200.   100.  1000. ]
 [   2.     1.1   10.4]]
Pivoteo parcial:
  Pivoteo por filas NO requerido
Elimina hacia adelante:
 fila 0 pivote:  200
   factor:  0.01  para fila:  1
[[2.e+02 1.e+02 1.e+03]
 [0.e+00 1.e-01 4.e-01]]
solución: 
[3. 4.]
>>> 

literal c

Observación: el pequeño cambio de volumen de la cocina no es consistente con los resultados.

El asunto es que la forma de la refrigeradora o cocina no se adapta al volumen disponible, pues son objetos rígidos. Por lo que el sistema de ecuaciones estaría mal planteado.
Las ecuaciones tendrían sentido si esta diseñando el mejor «tamaño» para que entren la mayor cantidad dentro de un container, sin embargo los tamaños de las refrigeradoras y cocinas se encuentran estandarizados.

Revisamos el número de condición, que resulta ser del orden de 104, lo que confirma que el sistema está mal condicionado.

Usando la el valor de 1.05

>>> C = np.concatenate((A,B),axis=1)
>>> C
array([[  200. ,   100. ,  1000.  ],
       [    2. ,     1.05,    10.4]])
>>> np.linalg.cond(C)
12926.000640466344

Algoritmo en Python

# 1Eva_IIIT2007_T1 Container: Cocinas y Refrigeradoras
import numpy as np

def pivoteafila(A,B,vertabla=False):
    '''
    Pivotea parcial por filas
    Si hay ceros en diagonal es matriz singular,
    Tarea: Revisar si diagonal tiene ceros
    '''
    A = np.array(A,dtype=float)
    B = np.array(B,dtype=float)
    # Matriz aumentada
    nB = len(np.shape(B))
    if nB == 1:
        B = np.transpose([B])
    AB  = np.concatenate((A,B),axis=1)
    
    if vertabla==True:
        print('Matriz aumentada')
        print(AB)
        print('Pivoteo parcial:')
    
    # Pivoteo por filas AB
    tamano = np.shape(AB)
    n = tamano[0]
    m = tamano[1]
    
    # Para cada fila en AB
    pivoteado = 0
    for i in range(0,n-1,1):
        # columna desde diagonal i en adelante
        columna = np.abs(AB[i:,i])
        dondemax = np.argmax(columna)
        
        # dondemax no es en diagonal
        if (dondemax != 0):
            # intercambia filas
            temporal = np.copy(AB[i,:])
            AB[i,:] = AB[dondemax+i,:]
            AB[dondemax+i,:] = temporal

            pivoteado = pivoteado + 1
            if vertabla==True:
                print(' ',pivoteado, 'intercambiar filas: ',i,'y', dondemax)
    if vertabla==True:
        if pivoteado==0:
            print('  Pivoteo por filas NO requerido')
        else:
            print(AB)
    return(AB)

def gauss_eliminaAdelante(AB,vertabla=False, casicero = 1e-15):
    ''' Gauss elimina hacia adelante
    tarea: verificar términos cero
    '''
    tamano = np.shape(AB)
    n = tamano[0]
    m = tamano[1]
    if vertabla==True:
        print('Elimina hacia adelante:')
    for i in range(0,n,1):
        pivote = AB[i,i]
        adelante = i+1
        if vertabla==True:
            print(' fila',i,'pivote: ', pivote)
        for k in range(adelante,n,1):
            if (np.abs(pivote)>=casicero):
                factor = AB[k,i]/pivote
                AB[k,:] = AB[k,:] - factor*AB[i,:]
                if vertabla==True:
                    print('   factor: ',factor,' para fila: ',k)
            else:
                print('  pivote:', pivote,'en fila:',i,
                      'genera division para cero')
    if vertabla==True:
        print(AB)
    return(AB)

def gauss_sustituyeAtras(AB,vertabla=False, casicero = 1e-15):
    ''' Gauss sustituye hacia atras
    '''
    tamano = np.shape(AB)
    n = tamano[0]
    m = tamano[1]
    # Sustitución hacia atras
    X = np.zeros(n,dtype=float) 
    ultfila = n-1
    ultcolumna = m-1
    for i in range(ultfila,0-1,-1):
        suma = 0
        for j in range(i+1,ultcolumna,1):
            suma = suma + AB[i,j]*X[j]
        X[i] = (AB[i,ultcolumna]-suma)/AB[i,i]
    return(X)

# INGRESO
A = [[200, 100   ],
     [  2,   1.05]]

B = [1000, 10.4]

# PROCEDIMIENTO
AB = pivoteafila(A,B,vertabla=True)

AB = gauss_eliminaAdelante(AB,vertabla=True)

X = gauss_sustituyeAtras(AB,vertabla=True)

# SALIDA
print('solución: ')
print(X)

s1Eva_IIT2007_T3 Interpolación inversa, encontrar xi para fi dado

Ejercicio: 1Eva_IIT2007_T3 Interpolación inversa

Para determinar el valor de x, usando interpolación inversa.interpola inversa

f(0.50) = 1.648
f(0.65) = 1.915
f( x  ) = 2.117
f(0.80) = 2.225
f(0.95) = 2.5857

Para el algoritmo se intercambian las variables previo a usarlo.

fi = [0.50 , 0.65 , 0.80,  0.95   ]
xi = [1.648, 1.915, 2.225, 2.5857 ]

Luego se evalúa en el punto buscado, en éste caso: fi=2.117, obteniendo que x es: 0.750321134121361

Para obtener el polinomio se usa el método de Lagrange:

término 1

L_{0} (x) = \frac{(x-1.915)(x-2.225)(x-2.5857)}{(1.648-1.915)(1.648-2.225)(1.648-2.5857)}

término 2

L_{1} (x) = \frac{(x-1.648)(x-2.225)(x-2.5857)}{(1.915-1.648)(1.915-2.225)(1.915-2.5857)}

término 3

L_{2} (x) = \frac{(x-1.648)(x-1.915)(x-2.5857)}{(2.225-1.648)(2.225-1.915)(2.225-2.5857)}

término 4

L_{3} (x) = \frac{(x-1.648)(x-1.915)(x-2.225)}{(2.5857-1.648)(2.5857-1.915)(2.5857-2.225)}

se construye el polinomio usando la fórmula para fn(x) para cada valor fi,

p_3(x) = 0.5 L_{0} (x) + 0.65 L_{1} (x) + 0.8 L_{2} (x) + 0.95 L_{3} (x) p_3(x) = 0.5 \frac{(x-1.915)(x-2.225)(x-2.5857)}{-0.14446112} + +0.65 \frac{(x-1.648)(x-2.225)(x-2.5857)}{0.05551384 } + + 0.8 \frac{(x-1.648)(x-1.915)(x-2.5857)}{-0.06451841} + +0.95 \frac{(x-1.648)(x-1.915)(x-2.225)}{0.22684978} p_3(x) = 0.03588 x^3 - 0.34275 x^2 + 1.44073 x - 1.10404

A partir del resultado del algoritmo se puede evaluar p(2.117)

    valores de fi:  [0.5  0.65 0.8  0.95]
divisores en L(i):  [-0.14446112  0.05551384 -0.06451841  0.22684978]

Polinomio de Lagrange, expresiones
-3.46113878334255*(x - 2.5857)*(x - 2.225)*(x - 1.915) 
+ 11.7087921085767*(x - 2.5857)*(x - 2.225)*(x - 1.648) 
- 12.3995618056856*(x - 2.5857)*(x - 1.915)*(x - 1.648) 
+ 4.18779332775953*(x - 2.225)*(x - 1.915)*(x - 1.648)

Polinomio de Lagrange: 
0.0358848473081546*x**3 - 0.342756582990933*x**2 
+ 1.44073214117569*x - 1.10404634485234
>>> polisimple.subs(x,2.117)
0.750321134121178
>>> polisimple
0.0358848473081546*x**3 - 0.342756582990933*x**2 
+ 1.44073214117569*x - 1.10404634485234
>>> 

Algoritmo en Python

# 1Eva_IIT2007_T3 Interpolación inversa
# Interpolacion de Lagrange
# divisoresL solo para mostrar valores
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym

# INGRESO , Datos de prueba
fi = [0.50 , 0.65 , 0.80,  0.95   ]
xi = [1.648, 1.915, 2.225, 2.5857 ]

# PROCEDIMIENTO
xi = np.array(xi,dtype=float)
fi = np.array(fi,dtype=float)
# Polinomio de Lagrange
n = len(xi)
x = sym.Symbol('x')
polinomio = 0
divisorL = np.zeros(n, dtype = float)
for i in range(0,n,1):
    
    # Termino de Lagrange
    numerador = 1
    denominador = 1
    for j  in range(0,n,1):
        if (j!=i):
            numerador = numerador*(x-xi[j])
            denominador = denominador*(xi[i]-xi[j])
    terminoLi = numerador/denominador

    polinomio = polinomio + terminoLi*fi[i]
    divisorL[i] = denominador

# simplifica el polinomio
polisimple = polinomio.expand()

# Salida
print('    valores de fi: ',fi)
print('divisores en L(i): ',divisorL)
print()
print('Polinomio de Lagrange, expresiones')
print(polinomio)
print()
print('Polinomio de Lagrange: ')
print(polisimple)

para revisar con la gráfica, se añaden las líneas,

# GRAFICA
polinomio = sym.lambdify(x,polisimple)
y = np.linspace(1,3,100)
pyi= polinomio(y)
plt.plot(pyi,y,label='p(x)')
plt.plot(fi,xi,'o')
plt.axhline(2.117,linestyle='dashed',
            label='f(x)=2.117', color='green')
plt.legend()
plt.xlabel('x')
plt.ylabel('f(x)')
plt.show()

s1Eva_IIT2007_T2 Aplicar Gauss-Seidel 6×6

Ejercicio: 1Eva_IIT2007_T2 Aplicar Gauss-Seidel 6×6

1. Desarrollo Analítico

– Verificar que la matriz es diagonal dominante

No es necesario realizar el pivoteo por filas, ya la matriz tiene la diagonal dominante.

A = [[7.63, 0.30, 0.15,  0.50, 0.34, 0.84],
     [0.38, 6.40, 0.70,  0.90, 0.29, 0.57],
     [0.83, 0.19, 8.33,  0.82, 0.34, 0.37],
     [0.50, 0.68, 0.86, 10.21, 0.53, 0.70],
     [0.71, 0.30, 0.85,  0.82, 5.95, 0.55],
     [0.43, 0.54, 0.59,  0.66, 0.31, 9.25]]

B = [ -9.44, 25.27, -48.01, 19.76, -23.63, 62.59]

– revisar el número de condición

cond(A) = || A||.||A-1||

El número de condición no es «muy alto»,  los valores de la diagonal son los mayores en toda la fila, por lo que el sistema converge.

>>> np.linalg.cond(A)
2.04518539662910119

– realizar iteraciones con las expresiones:

x_0 = \Big(-9.44 -0.3 x_1 -0.15x_2 -0.50 x_3 -0.34 x_4 -0.84 x_5\Big)\frac{1}{7.63} x_1 = \Big( 25.27 -0.38 x_0 -0.70 x_2 -0.90 x_3 -0.29 x_4 -0.57 x_5 \Big) \frac{1}{6.40} x_2 = \Big(-48.01 -0.83x_0 -0.19 x_1 -0.82x_3 -0.34x_4 -0.37x_5 \Big)\frac{1}{8.33} x_3 = \Big(19.76 -0.50 x_0 -0.68 x_1 -0.86 x_2 -0.53 x_4 -0.70x_5 \Big)\frac{1}{10.21} x_4 = \Big( -23.63 - 0.71 x_0 -0.30 x_1 -0.85 x_2 -0.82 x_3 -0.55x_5 \Big)\frac{1}{5.95} x_5 = \Big( 62.59 - 0.43x_0 -0.54x_1 - 0.59 x_2 -0.66 x_3 -0.31 x_4 \Big)\frac{1}{9.25}

Dado que no se establece en el enunciado el vector inicial, se usará el vector cero. La tolerancia requerida es 10-5
X0 = [ 0. 0. 0. 0. 0. 0.] = [x0,x1,x2,x3,x4,x5]

iteración 0

x_0 = \Big(-9.44 -0.3 (0) -0.15(0) -0.50 (0) -0.34(0) -0.84 (0)\Big)\frac{1}{7.63} = -1.23722 x_1 = \Big( 25.27 -0.38 (-1.23722) -0.70 (0) -0.90 (0) -0.29 (0) -0.57 (0) \Big) \frac{1}{6.40} = 4.0219 x_2 = \Big(-48.01 -0.83 (-1.23722) -0.19 (4.0219) -0.82(0) -0.34(0) -0.37(0) \Big)\frac{1}{8.33} = -5.73196 x_3 = \Big( 19.76 -0.50 (-1.23722) -0.68 (4.0219) -0.86 (-5.73196) -0.53 (0) -0.70(0) \Big)\frac{1}{10.21} = 2.21089 x_4 = \Big( -23.63 - 0.71 (-1.23722) -0.30 (4.0219) -0.85 (-5.73196) -0.82 (2.21089) -0.55(0) \Big)\frac{1}{5.95} = -3.51242 x_5 = \Big( 62.59 - 0.43(-1.23722) -0.54(4.0219) - 0.59 (-5.73196) -0.66 (2.21089) -0.31 (-3.51242) \Big)\frac{1}{9.25} = 6.91478 X_1 = [-1.23722, 4.0219, -5.73196, 2.21089, -3.51242, 6.91478 ] diferencia = X1 - [0,0,0,0,0,0] errado = max(|diferencia|) = 6.91478

iteración 1

x_0 = \Big(-9.44 -0.3 (4.0219) -0.15(4.0219) -0.50 (2.21089) -0.34 (-3.51242) -0.84(6.91478) \Big)\frac{1}{7.63} = -2.0323 x_1 = \Big( 25.27 -0.38 (-2.0323) -0.70 ( -5.73196) -0.90 (2.21089) -0.29 (-3.51242) -0.57 (6.91478) \Big) \frac{1}{6.40} = 3.92844 x_2 = \Big(-48.01 -0.83(-2.0323) -0.19 (3.92844) -0.82(2.21089) -0.34(-3.51242) -0.37(6.91478) \Big)\frac{1}{8.33} = -6.03203 x_3 = \Big(19.76 -0.50 (-2.0323) -0.68 (3.92844) -0.86 (-6.03203) -0.53 (-3.51242) -0.70(6.91478) \Big)\frac{1}{10.21} = 1.98958 x_4 = \Big( -23.63 - 0.71 (-2.0323) -0.30 (3.92844) -0.85 (-6.03203) -0.82 (1.98958) -0.55(6.91478) \Big)\frac{1}{5.95} = -3.97865 x_5 = \Big( 62.59 - 0.43(-2.0323) -0.54(3.92844) - 0.59 (-6.03203) -0.66 (1.98958) -0.31 (-3.97865) \Big)\frac{1}{9.25} = 7.00775 X_2 = [-2.0323, 3.92844, -6.03203, 1.98958, -3.97865, 7.00775] diferencia = X2 - [-1.23722, 4.0219, -5.73196, 2.21089, -3.51242, 6.91478 ] errado = max(|diferencia|) = 0.79507

iteración 2

Desarrollar como tarea.


2. Algoritmo en Python

La tabla de aproximaciones sucesivas para el vector X es:

Pivoteo por filas NO requerido
Iteraciones Gauss-Seidel
itera,[X],[errado]
0 [0. 0. 0. 0. 0. 0.] [1.]
1 [-1.23722  4.0219  -5.73196  2.21089 -3.51242  6.91478] [6.91478]
2 [-2.0323   3.92844 -6.03203  1.98958 -3.97865  7.00775] [0.79507]
3 [-1.99768  4.00317 -6.00049  1.99808 -4.00082  6.9999 ] [0.07473]
4 [-1.99994  4.00037 -5.99979  2.      -4.00005  6.99996] [0.00281]
5 [-2.00001  3.99998 -6.       2.00001 -4.       7.     ] [0.00038]
6 [-2.  4. -6.  2. -4.  7.] [1.60155e-05]
7 [-2.  4. -6.  2. -4.  7.] [1.74554e-06]
Matriz aumentada y pivoteada:
[[  7.63   0.3    0.15   0.5    0.34   0.84  -9.44]
 [  0.38   6.4    0.7    0.9    0.29   0.57  25.27]
 [  0.83   0.19   8.33   0.82   0.34   0.37 -48.01]
 [  0.5    0.68   0.86  10.21   0.53   0.7   19.76]
 [  0.71   0.3    0.85   0.82   5.95   0.55 -23.63]
 [  0.43   0.54   0.59   0.66   0.31   9.25  62.59]]
Vector Xi: 
[-2.  4. -6.  2. -4.  7.]
>>> 

el gráfico de los iteraciones vs errores es:

Gauss-Seidel errado_1EIIT2007T2

La tabla obtiene aplicando la función de Gauss-Seidel, tomando como vector inicial el vector de ceros.

Tarea: X=TX+C

Instrucciones en Python

# 1Eva_IIT2007_T2 Aplicar Gauss-Seidel
# Algoritmo Gauss-Seidel
import numpy as np

def pivoteafila(A,B,vertabla=False):
    '''
    Pivotea parcial por filas
    Si hay ceros en diagonal es matriz singular,
    Tarea: Revisar si diagonal tiene ceros
    '''
    # Matriz aumentada
    nB = len(np.shape(B))
    if nB == 1:
        B = np.transpose([B])
    AB  = np.concatenate((A,B),axis=1)
    M = np.copy(AB)
    
    # Pivoteo por filas AB
    tamano = np.shape(M)
    n = tamano[0]
    m = tamano[1]
    
    # Para cada fila en AB
    pivoteado = 0
    for i in range(0,n-1,1):
        # columna desde diagonal i en adelante
        columna = np.abs(M[i:,i])
        dondemax = np.argmax(columna)
        
        # dondemax no es en diagonal
        if (dondemax != 0):
            # intercambia filas
            temporal = np.copy(M[i,:])
            M[i,:] = M[dondemax+i,:]
            M[dondemax+i,:] = temporal

            pivoteado = pivoteado + 1
            if vertabla==True:
                print(pivoteado, 'intercambiar: ',i,dondemax)
    if vertabla==True and pivoteado==0:
        print('Pivoteo por filas NO requerido')
    return(M)

def gauss_seidel(A,B,tolera,X0, iteramax=100, vertabla=False, precision=5):
    ''' Método de Gauss Seidel, tolerancia, vector inicial X0
        para mostrar iteraciones: vertabla=True
    '''
    tamano = np.shape(A)
    n = tamano[0]
    m = tamano[1]
    diferencia = 2*tolera*np.ones(n, dtype=float)
    errado = np.max(diferencia)
    X = np.copy(X0)

    itera = 0
    if vertabla==True:
        print('Iteraciones Gauss-Seidel')
        print('itera,[X],[errado]')
        np.set_printoptions(precision)
        print(itera, X, np.array([errado]))
    while (errado>tolera and itera<iteramax):
        for i in range(0,n,1):
            xi = B[i]
            for j in range(0,m,1):
                if (i!=j):
                    xi = xi-A[i,j]*X[j]
            xi = xi/A[i,i]
            diferencia[i] = np.abs(xi-X[i])
            X[i] = xi
        errado = np.max(diferencia)
        itera = itera + 1
        if vertabla==True:
            print(itera, X, np.array([errado]))        
    
    if (itera>iteramax): # No converge
        X = itera
        print('iteramax superado, No converge')
    return(X)

# Programa de prueba #######
# INGRESO
A = np.array([[7.63, 0.30, 0.15,  0.50, 0.34, 0.84],
              [0.38, 6.40, 0.70,  0.90, 0.29, 0.57],
              [0.83, 0.19, 8.33,  0.82, 0.34, 0.37],
              [0.50, 0.68, 0.86, 10.21, 0.53, 0.70],
              [0.71, 0.30, 0.85,  0.82, 5.95, 0.55],
              [0.43, 0.54, 0.59,  0.66, 0.31, 9.25]])

B = np.array([-9.44,25.27,-48.01,19.76,-23.63,62.59])

tolera = 0.00001
X = np.zeros(len(A), dtype=float)

# PROCEDIMIENTO
n = len(A)
A = np.array(A,dtype=float)
B = np.array(B,dtype=float)


AB = pivoteafila(A,B, vertabla=True)
A = AB[:,:n]
B = AB[:,n]
respuesta = gauss_seidel(A,B, tolera, X, vertabla=True)

# SALIDA
print('Matriz aumentada y pivoteada:')
print(AB)
print('Vector Xi: ')
print(respuesta)

En el caso de la norma infinito, para la matriz A, se puede usar el algoritmo desarrollado en clase.
Como valor para verificar su algoritmo, se obtuvo:

>>> np.linalg.norm(A, np.inf)
13.479999999999999

Tarea: incluir la norma infinito para T

s1Eva_IIT2007_T1 Distribución binomial acumulada

Ejercicio: 1Eva_IIT2007_T1 Distribución binomial acumulada

Dado F=0.4, dado que n=5 y k=1

F = \sum_{t=0}^{k} \binom{n}{t} p^t (1-p)^{n-t}

La fórmula para el ejercicio se convierte en:

F = \Bigg( \begin{array}{c} 5 \\ 0 \end{array} \Bigg) p ^0 (1-p)^{(5-0)} + \Bigg( \begin{array}{c} 5 \\ 1 \end{array} \Bigg) p ^1 (1-p)^{(5-1)} = 0.4

Los valores de las combinatorias se calculan como:

>>> import scipy.special as sts
>>> sts.comb(5,0,repetition=False)
1.0
>>> sts.comb(5,1,repetition=False)
5.0
>>> 
(1-p)^{5} + 5p (1-p)^{4} = 0.4

La expresión para el ejercicio se convierte en:

f(p) = (1-p)^{5} + 5p (1-p)^{4} - 0.4

como referencia se revisa la gráfica para f(p)

f(p) = (1-p)^5 + 5p(1-p)^4 - 0.4 = (1-p)^4 (1 - p + 5p) - 0.4 = (1-p)^4 (1 + 4p) - 0.4 = (1-p)^2 (1-p)^2 (1 + 4p) - 0.4 = (1-2p+p^2) (1-2p+p^2) (1 + 4p) - 0.4 = (1 - 4p + 6p^2 - 4p^3 +p^4 ) (1 + 4p) - 0.4 = 1 - 10p^2 + 20p^3 + 15p^4 + 4p^5 - 0.4 f(p) = 0.6 - 10p^2 + 20p^3 + 15p^4 + 4p^5

y su derivada:

f'(p) = - 20p + 60p^2 + 60p^3 +20p^4

con lo que se puede desarrollar el método Newton-Raphson.

Verificando el polinomio  obtenido a partir de la expresión inicial usando Sympy:

>>> import sympy as sp
>>> p = sp.Symbol('p')
>>> poli = (1-p)**5 + 5*p*((1-p)**4) - 0.4
>>> pol = poli.expand()
>>> pol
4*p**5 - 15*p**4 + 20*p**3 - 10*p**2 + 0.6
>>> pol.diff(p,1)
20*p**4 - 60*p**3 + 60*p**2 - 20*p

A partir de la gráfica, un punto inicial cercano a la raíz es X0 = 0.2

itera = 0

f(0.2) = 0.6 - 10(0.2)^2 + 20(0.2)^3 + 15(0.2)^4 + 4(0.2)^5 = 0.3373 f'(0.2) = - 20(0.2) + 60(0.2)^2 + 60(0.2)^3 +20(0.2)^4 = -2.048 x_1 = 0.2 -\frac{0.3373}{-2.048} = 0.3647 errado = |0.2 - 0.36469| = 0.1647

itera = 1

f(0.36469) = 0.6 - 10(0.36469)^2 + 20(0.36469)^3 + 15(0.36469)^4 + 4(0.36469)^5 = 0.0005566 f'(0.36469) = - 20(0.36469) + 60(0.36469)^2 + 60(0.36469)^3 +20(0.36469)^4 = -1.8703 x_1 = 0.36469 -\frac{0.0005566}{-1.8703} = 0.36499 errado = |0.36469 - 0.36499| = 0.000297

itera = 3

f(0.36499) = 0.6 - 10(0.36499)^2 + 20(0.36499)^3 + 15(0.36499)^4 + 4(0.36499)^5 = 1.6412291237166698e-07 f'(0.36499) = - 20(0.36499) + 60(0.36499)^2 + 60(0.36499)^3 +20(0.36499)^4 = -1.869204616112814 x_1 = 0.36469 -\frac{1.6412291237166698e-07}{ -1.8692} = 0.36499 errado = |0.36499 - 0.36499| = 8.7804e-08

verificar con raíz: 0.3649852264049102

Instrucciones para la gráfica

# 1ra Eval II Término 2007
# Tema 1. Distribución binomial acumulada
import numpy as np
import matplotlib.pyplot as plt
import scipy.special as sts

fp = lambda p: (1-p)**5 + 5*p*((1-p)**4) - 0.4

a = 0
b = 1
pasos = 100

# PROCEDIMIENTO
xi = np.linspace(a,b,pasos+1)
p_i = fp(xi)

# SALIDA
plt.plot(xi,p_i)
plt.axhline(0)
plt.show()

Algoritmo en Python

el resultado usando el algoritmo es:

i ['xi', 'fi', 'dfi', 'xnuevo', 'tramo']
0 [ 0.2     0.3373 -2.048   0.3647  0.1647]
1 [ 3.6469e-01  5.5668e-04 -1.8703e+00  3.6499e-01  2.9764e-04]
2 [ 3.6499e-01  1.6412e-07 -1.8692e+00  3.6499e-01  8.7804e-08]
raiz en:  0.3649852264049102

con error de: 8.780360960525257e-08

Instrucciones en Python para Newton-Raphson

# 1Eva_IIT2007_T1 Distribución binomial acumulada
# Método de Newton-Raphson

import numpy as np
import matplotlib.pyplot as plt

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)

# INGRESO
fx  = lambda p: 4*p**5 - 15*p**4 + 20*p**3 - 10*p**2 + 0.6
dfx = lambda p: 20*p**4 - 60*p**3 + 60*p**2 - 20*p

x0 = 0.2
tolera = 0.0000001

# PROCEDIMIENTO
respuesta = newton_raphson(fx,dfx,x0, tolera, vertabla=True)
# SALIDA
print('raiz en: ', respuesta)

# GRAFICA
a = 0
b = 1
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()