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()