s1Eva_IIIT2007_T3 Factorar polinomio

Ejercicio: 1Eva_IIIT2007_T3 Factorar polinomio

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

la gráfica se obtuvo con Python, con lo que se puede observar la primera raíz…

# 1ra Eval III Término 2007
# Tema 3. Factorar polinomio
import numpy as np
import matplotlib.pyplot as plt
def newtonraphson(funcionx, fxderiva, c, tolera):
    tramo = abs(2*tolera)
    while (tramo>=tolera):
        xnuevo = c - funcionx(c)/fxderiva(c)
        tramo = abs(xnuevo-c)
        c = xnuevo
    return(c)

# Literal a)
p3 = lambda x: 2*x**3 - 5*x**2 + 3*x -0.1
dp3 = lambda x: 6*x**2 - 10*x +3
a = 0
b = 2
pasos = 100
c = 2
tolera = 0.0001

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

raiz1 = newtonraphson(p3, dp3, c, tolera)

# SALIDA
print('primera raiz: ',raiz1)
plt.plot(xi,p_i)
plt.axhline(0)
plt.show()

para el literal b)
se añade:

# Literal b)
# PROCEDIMIENTO
p2 =  lambda x: (2*x**3 - 5*x**2 + 3*x -0.1)/(x-raiz1)
# SALIDA
pol2 = p2(xi)
plt.plot(xi,pol2)
plt.show()

s1Eva_IIIT2007_T2_AN Función Cobb-Douglas

Ejercicio: 1Eva_IIIT2007_T2 Función Cobb-Douglas

usando los algoritmos para encontrar los polinomios de lagrange y búsqueda de raíz por la bisección, se obtiene:

 **** literal a:
Polinomio de Lagrange
[0, 6.16333333333368e-5*x**3 - 0.00527800000000012*x**2 + 0.254746666666668*x + 11.0, 0.00010365*x**3 - 0.008876*x**2 + 0.428425*x + 18.4997, 0.000140483333333337*x**3 - 0.0120304999999998*x**2 + 0.580686666666667*x + 25.0746]
Puntos f[25]:
[0, 15.0329375000000, 25.2823562500000, 34.2677562500002]
Polinoio con f[25]:
0.000586583333333373*x**3 - 0.0415150937500013*x**2 + 1.85978635416668*x
Estimado de [la,ka]:
29.7130898437501
 **** Literal b
La raiz se encuentra en:  25.3295898438

Revisar el algoritmo por partes: literal a y literal b.

# Interpolacion de Lagrange
import numpy as np
import matplotlib.pyplot as plt
import sympy as sp

def lagrange(xi,fi):
    n = len(xi)
    x = sp.Symbol('x')
    # Polinomio
    polinomio = 0
    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*fi[i]
    # Expande el polinomio
    px = polinomio.expand()
    return(px)

# INGRESO , Datos de prueba
M = np.array([[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 = np.array([0, 10, 20, 30])
kj = np.array([10, 20, 30, 40])

la = 25
ka = 25

# PROCEDIMIENTO
tamano = np.shape(M)
n = tamano[0]
m = tamano[1]
x = sp.Symbol('x')
poli = []
for i in range(0,n,1):
    xi = li
    fi = M[i,:]
    p = lagrange(xi,fi)
    poli.append(p)
# literal a, evalua en la
f_la =[]
for i in range(0,n,1):
    puntola = poli[i].subs(x,la)
    f_la.append(puntola)
poli_la = lagrange(li,f_la)
# literal a, evalua en ka
puntolaka = poli_la.subs(x,ka)

# SALIDA
print(' **** literal a:')
print('Polinomio de Lagrange')
print(poli)
print('Puntos f['+str(la)+']:')
print(f_la)
print('Polinoio con f['+str(ka)+']:')
print(poli_la)
print('Estimado de [la,ka]:')
print(puntolaka)


# ------------------------------------
# literal b, usa f_ka con resultado 30

def biseccion(funcionx,a,b,tolera,iteramax = 20):
    '''
    Algoritmo de Bisección
    Los valores de [a,b] son seleccionados
    desde la gráfica de la función
    error = tolera
    '''
    fa = funcionx(a)
    fb = funcionx(b)

    itera = 0
    tramo = np.abs(b-a)
    while (tramo>=tolera and itera<=iteramax):
        c = (a+b)/2
        fc = funcionx(c)
        cambia = np.sign(fa)*np.sign(fc)
        if (cambia<0):
            b = c
            fb = fc
        else:
            a = c
            fa = fc
        tramo = np.abs(b-a)
        itera = itera + 1
    respuesta = c
    # Valida respuesta
    if (i>=iteramax):
        respuesta = np.nan
    return(respuesta)


# INGRESO
a = kj[0]
b = kj[m-1]
tolera = 0.01

# PROCEDIMIENTO
# Busca raiz
fx = sp.lambdify(x,poli_la - 30)
fxi = fx(kj)

raiz = biseccion(fx,a,b,tolera)

# SALIDA
print(' **** Literal b')
print('La raiz se encuentra en: ',raiz)

# GRAFICA
plt.plot(kj,fxi)
plt.axhline(0)
plt.show()

s1Eva_IIIT2007_T1_AN Container: Refrigeradoras y Cocinas

Ejercicio: 1Eva_IIIT2007_T1 Container: Cocinas y Refrigeradoras

x: cantidad de refrigeradoras
y: cantidad de cocinas

ecuaciones:

200 x + 100  y = 1000
  2 x + 1.05 y =   10.4

literal a)
Nota: se han omitido los pasos para la solución del sistema, usando la función gauss desarrollada en python.

Si las matrices son:
A = np.array([[200, 100],
              [2,1.05]])

B = np.array([[1000],
              [10.4]])

el vector solución X es:
[ 1.  8.]
verificar que A.X sea igual a B
[ 1000.     10.4]

literal b)

>>> 
el vector solución X es:
[ 3.  4.]
verificar que A.X sea igual a B
[ 1000.     10.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

s1Eva_IT2017_T2 Tanque esférico-volumen

Ejercicio: 1Eva_IT2017_T2 Tanque esférico-volumen

a. Planteamiento del problema

V = \frac{\pi h^{2} (3r-h)}{3}

Si r=1 m y V=0.75 m3,

0.75 = \frac{\pi h^{2} (3(1)-h)}{3} 0.75 -\frac{\pi h^{2} (3(1)-h)}{3} = 0 f(h) = 0.75 -\frac{\pi h^{2} (3-h)}{3} = 0.75 -\frac{\pi}{3}(h^{2} (3)-h^{2}h) = 0.75 -\frac{\pi}{3}(3 h^{2} - h^{3}) f(h) = 0.75 -\pi h^{2} + \frac{\pi}{3}h^{3}

b. Intervalo de búsqueda de raíz

El tanque vacio tiene h=0 y completamente lleno h= 2r = 2(1) = 2, por lo que el intevalo tiene como extremos:

[0,2]

Verificando que exista cambio de signo en la función:

f(0) = 0.75 -\pi (0)^{2} + \frac{\pi}{3}(0)^{3} = 0.75 f(2) = 0.75 -\pi (2)^{2} + \frac{\pi}{3}(2)^{3}= -3.4387

y verificando al usar la gráfica dentro del intervalo:

Tolerancia

Se indica en el enunciado como 0.01 que es la medición mínima a observar con un flexómetro.

tolera = 0.01


c. Método de Newton-Raphson
d. Método de Punto Fijo


c. Método de Newton-Raphson

El método de Newton-Raphson requiere la derivada de la función:

x_{i+1} = x_i -\frac{f(x_i)}{f'(x_i)} f(h) = 0.75 -\pi h^{2} + \frac{\pi}{3}h^{3} f'(h) = -2\pi h + \pi h^{2}

Tomando como punto inicial de búsqueda el extremo izquierdo del intervalo, genera una división para cero. Por lo que se mueve un poco a la derecha, algo más cercano a la raiz, viendo la gráfica por ejemplo 0.1

x0 = 0.1

iteración 1

i =0

f(0.1) = 0.75 -\pi (0.1)^{2} + \frac{\pi}{3}(0.1)^{3} =0.7196 f'(0.1) = -2\pi (0.1) + \pi (0.1)^{2} = -0.5969 x_{1} = x_0 -\frac{0.7496 }{-0.0625} = 1.3056 tramo = |x_{1}-x_{0}| = |0.1-1.3056 | = 1.2056

iteración 2

i =1

f(1.3056) = 0.75 -\pi (1.3056)^{2} + \frac{\pi}{3}(1.3056)^{3} = -2.2746 f'(1.3056) = -2\pi (1.3056) + \pi (1.3056)^{2} =-2.8481 x_{1} = x_0 -\frac{-2.2746}{-2.8481} = 0.5069 tramo = |x_{2}-x_{1}|=|0.5069-1.3056|=0.7987

iteración 3

i =2

f(0.5069) = 0.75 -\pi (0.5069)^{2} + \frac{\pi}{3}(0.5069)^{3} = 0.0789 f'(0.5069) = -2\pi (0.5069) + \pi (0.5069)^{2} =-2.3780 x_{1} = x_0 -\frac{0.0789}{-2.3780} = 0.5401 tramo = |x_{3}-x_{2}| =|0.5401 - 0.5069| = 0.0332

Observe que el tramo disminuye en cada iteración , por lo que el método converge, si se siguen haciendo las operaciones se tiene que:

 [ xi, xnuevo, tramo]
[[1.00000000e-01 1.30560920e+00 1.20560920e+00]
 [1.30560920e+00 5.06991599e-01 7.98617601e-01]
 [5.06991599e-01 5.40192334e-01 3.32007350e-02]
 [5.40192334e-01 5.39518667e-01 6.73667593e-04]]
raiz 0.5395186666699257

Instrucciones en Python

para Método de Newton-Raphson

# 1Eva_IT2017_T2 Tanque esférico-volumen
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
fx = lambda h: 0.75 - np.pi*(h**2)+(np.pi/3)*h**3
dfx = lambda h: -2*np.pi*h+np.pi*(h**2)

# Parámetros de método
a = 0
b = 2
tolera = 0.01
x0 = 0.1
iteramax = 100

# parametros de gráfica
La = a
Lb = b
muestras = 21

# PROCEDIMIENTO
# Newton-Raphson
tabla = []
tramo = abs(2*tolera)
xi = x0
while (tramo>=tolera):
    xnuevo = xi - fx(xi)/dfx(xi)
    tramo = abs(xnuevo-xi)
    tabla.append([xi,xnuevo,tramo])
    xi = xnuevo
tabla = np.array(tabla)

# calcula para grafica
hi = np.linspace(La,Lb,muestras)
fi = fx(hi)
gi = dfx(hi)

# SALIDA
print(' [ xi, xnuevo, tramo]')
print(tabla)
print('raiz', xnuevo)
plt.plot(hi,fi)
plt.plot(xi,fx(xi),'ro')
plt.axhline(0, color='green')
plt.xlabel('h')
plt.ylabel('V')
plt.title('Método Newton-Raphson')
plt.show()

Planteo con Punto Fijo


d. Método de Punto Fijo

Del planteamiento del problema en el literal a, se tiene que:

0.75 = \frac{\pi h^{2} (3(1)-h)}{3}

de donde se despeja una h:

\frac{3(0.75)}{\pi (3(1)-h) } = h^{2} h = \sqrt{\frac{3*0.75}{\pi (3-h) }} h = \sqrt{\frac{2.25}{\pi (3-h) }}

con lo que se obtienen las expresiones a usar en el método

identidad = h g(h) = \sqrt{\frac{2.25}{\pi (3-h) }}

El punto inicial de búsqueda debe encontrarse en el intervalo, se toma el mismo valor que x0 en el método de Newton-Raphson

x0 = 0.10

Iteracion 1

x_0= 0.10 g(0.10) = \sqrt{\frac{2.25}{\pi (3-(0.10) }}= 0.4969 tramo= |0.4969-0.10| = 0.3869

Iteracion 2

x_1= 0.4969 g(0.4969) = \sqrt{\frac{2.25}{\pi (3-(0.4969 ) }}= 0.5349 tramo= |0.5349- 0.4969| = 0.038

Iteracion 3

x_2 =0.5349 g(0.5349) = \sqrt{\frac{2.25}{\pi (3-(0.5349) }}= 0.5390 tramo= |0.5390 - 0.5349| = 0.0041

con lo que se cumple el criterio de tolerancia, y se obtiene la raiz de:

raiz = 0.5390

Tabla de resultados, donde se observa que el tramo o error en cada iteración disminuye, por lo que el método converge.

 [i,xi,xi+1,tramo]
[[1.         0.1        0.4969553  0.3969553 ]
 [2.         0.4969553  0.5349116  0.03795631]
 [3.         0.5349116  0.53901404 0.00410243]]
raiz 0.5390140355891347
>>> 

Instrucciones en Python

para Método de Punto-Fijo, recordamos que el método puede diverger, por lo que se añade el parámetro iteramax

# 1Eva_IT2017_T2 Tanque esférico-volumen
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
fx = lambda h: h
gx = lambda h: np.sqrt(2.25/(np.pi*(3-h)))

a = 0.1
b = 2
tolera = 0.01
iteramax = 100

La = a
Lb = b
muestras = 21

# PROCEDIMIENTO
# Punto Fijo
tabla = []
i = 1 # iteración
b = gx(a)
tramo = abs(b-a)
while not(tramo<=tolera or i>=iteramax):
    tabla.append([i,a,b,tramo])
    a = b
    b = gx(a)
    tramo = abs(b-a)
    i = i+1
tabla.append([i,a,b,tramo])
respuesta = b

# Validar respuesta
if (i>=iteramax):
    respuesta = np.nan
tabla = np.array(tabla)

# calcula para grafica
hi = np.linspace(La,Lb,muestras)
fi = fx(hi)
gi = gx(hi)

# SALIDA
print(' [i, xi, xi+1, tramo]')
print(tabla)
print('raiz', respuesta)
plt.plot(hi,fi, label = 'identidad', color='green')
plt.plot(hi,gi, label = 'g(h)', color = 'orange')
plt.plot(b,gx(b),'ro')
plt.axhline(0, color='green')
plt.xlabel('h')
plt.ylabel('V')
plt.title('Método Punto Fijo')
plt.legend()
plt.axhline(0, color='green')
plt.show()

Otra forma de probar la convergencia es que |g'(x)|<1 que se observa en la una gráfica adicional, lo que limita aún más el intervalo de búsqueda.

Desarrollo en la siguiente clase.


s1Eva_IIT2008_T3_MN Ganancia en inversión

Ejercicio: 1Eva_IIT2008_T3_MN Ganancia en inversión

Se usan para cada par ordenado, punto, la evaluación del polinomio para generar las ecuaciones:

[[3.2, 5.12],
 [3.8, 6.42],
 [4.2, 7.25],
 [4.5, 6.85]]

modelo propuesto:

f(x) = a_1 x^3 + a_2 x^2 + a_3 x + a_4

usando los datos

a_1 (3.2)^3 + a_2 (3.2)^2 + a_3 (3.2) + a_4 = 5.12 a_1 (3.8)^3 + a_2 (3.8)^2 + a_3 (3.8) + a_4 = 6.42 a_1 (4.2)^3 + a_2 (4.2)^2 + a_3 (4.2) + a_4 = 7.25 a_1 (4.5)^3 + a_2 (4.5)^2 + a_3 (4.5) + a_4 = 6.85

Se convierte a la forma Ax=B
\begin{bmatrix} (3.2)^3 && (3.2)^2 && (3.2) && 1 \\ (3.8)^3 && (3.8)^2 && (3.8) && 1 \\ (4.2)^3 && (4.2)^2 && (4.2) && 1 \\ (4.5)^3 && (4.5)^2 && (4.5) && 1 \end{bmatrix} . \begin{bmatrix} a_1 \\ a_2 \\ a_3 \\ a_4 \end{bmatrix} = \begin{bmatrix} 5.12 \\ 6.42 \\ 7.25 \\6.85 \end{bmatrix}

Se crea la matriz aumentada

\begin{bmatrix} (3.2)^3 && (3.2)^2 && (3.2) && 1 && 5.12\\ (3.8)^3 && (3.8)^2 && (3.8) && 1 && 6.42 \\ (4.2)^3 && (4.2)^2 && (4.2) && 1 && 7.25 \\ (4.5)^3 && (4.5)^2 && (4.5) && 1 && 6.85 \end{bmatrix}

Se pivotea por filas:

\begin{bmatrix} (4.5)^3 && (4.5)^2 && (4.5) && 1 && 6.85 \\ (4.2)^3 && (4.2)^2 && (4.2) && 1 && 7.25 \\ (3.8)^3 && (3.8)^2 && (3.8) && 1 && 6.42 \\ (3.2)^3 && (3.2)^2 && (3.2) && 1 && 5.12 \end{bmatrix}

Como se pide un método directo, se inicia con el algoritmo de eliminación hacia adelante

\begin{bmatrix} (4.5)^3 && (4.5)^2 && (4.5) \\ (4.2)^3 - (4.5)^3\frac{(4.2)^3}{(4.5)^3} && (4.2)^2 - (4.5)^2\frac{(4.2)^3}{(4.5)^3} && (4.2) - (4.5)\frac{(4.2)^3}{(4.5)^3} \\ (3.8)^3 - (4.5)^3\frac{(3.8)^3}{(4.5)^3} && (3.8)^2 - (4.5)^2\frac{(3.8)^3}{(4.5)^3} && (3.8) -(4.5)\frac{(3.8)^3}{(4.5)^3} \\ (3.2)^3 - (4.5)^3\frac{(3.2)^3}{(4.5)^3} && (3.2)^2 -(4.5)^2\frac{(3.2)^3}{(4.5)^3} && (3.2) - (4.5)\frac{(3.2)^3}{(4.5)^3} \end{bmatrix}

continua a la derecha de la matriz:

\begin{bmatrix} 1 && 6.85 \\ 1 - 1\frac{(4.2)^3}{(4.5)^3} && 7.25 - 6.85\frac{(4.2)^3}{(4.5)^3} \\ 1 -1\frac{(3.8)^3}{(4.5)^3} && 6.42 - 6.85\frac{(3.8)^3}{(4.5)^3}\\1 -1\frac{(3.2)^3}{(4.5)^3} && 5.12-6.85\frac{(3.2)^3}{(4.5)^3} \end{bmatrix}
[[91.125  20.25   4.5    1.     6.85 ]
 [ 0.      1.176  0.541  0.186  1.680]
 [ 0.      2.246  1.090  0.397  2.295]
 [ 0.      2.958  1.581  0.640  2.656]]
Elimina hacia adelante
[[91.125  20.250  4.500  1.000  6.850]
 [ 0.      1.176  0.541  0.186  1.680]
 [ 0.      0.     0.056  0.040 -0.915]
 [ 0.      0.     0.220  0.170 -1.571]]
Elimina hacia adelante
[[91.125  20.250  4.500  1.000  6.850]
 [ 0.      1.176  0.541  0.186  1.680]
 [ 0.      0.000  0.056  0.040 -0.915]
 [ 0.      0.000  0.000  0.010  2.006]]
Elimina hacia adelante
[[91.125  20.250  4.500  1.000  6.850]
 [ 0.      1.176  0.541  0.186  1.680]
 [ 0.      0.     0.056  0.040 -0.915]
 [ 0.      0.     0.     0.010  2.006]]
Elimina hacia atras
[[1. 0. 0. 0.   -3.67490842]
 [0. 1. 0. 0.   41.06730769]
 [0. 0. 1. 0. -149.92086081]
 [0. 0. 0. 1.  184.75692308]]
el vector solución X es:
[[  -3.67490842]
 [  41.06730769]
 [-149.92086081]
 [ 184.75692308]]

verificar que A.X = B
[[6.85]
 [7.25]
 [6.42]
 [5.12]]

con lo que el polinomio buscado es:

f(x) = -3.67490842 x^3 + 41.06730769 x^2 + -149.92086081 x + 184.75692308

que genera la siguiente gráfica:

para encontrar la cantidad necesaria a invertir y obtener 6.0 de ganancia en f(x):

6.0 = -3.67490842 x^3 + 41.06730769 x^2 + -149.92086081 x + 184.75692308

que para usar en el algoritmo se realiza se reordena como g(x) = 0

-3.67490842 x^3 + 41.06730769 x^2 +

-149.92086081 x + 184.75692308 - 6.0 = 0
y se aplica la búsqueda de raices en el rango [a, b] que de la gráfica se estima en [3.2, 3.8]

La ejecución del algoritmo de búsqueda queda como tarea.


Algoritmo en python para obtener la gráfica y respuesta a la matriz:

# Método de Gauss-Jordan ,
# Recibe las matrices A,B
# presenta solucion X que cumple: A.X=B
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
puntos = np.array([[3.2, 5.12],
                   [3.8, 6.42],
                   [4.2, 7.25],
                   [4.5, 6.85]])

A = np.array([[4.5**3 , 4.5**2 , 4.5 , 1],
              [4.2**3 , 4.2**2 , 4.2 , 1],
              [3.8**3 , 3.8**2 , 3.8 , 1],
              [3.2**3 , 3.2**2 , 3.2, 1]])

B = np.array([[6.85],
              [7.25],
              [6.42],
              [5.12]])

# PROCEDIMIENTO
casicero = 1e-15 # 0
AB = np.concatenate((A,B),axis=1)
tamano = np.shape(AB)
n = tamano[0]
m = tamano[1]

print('matriz aumentada: ')
print(AB)
# Gauss elimina hacia adelante
# tarea: verificar términos cero
for i in range(0,n,1):
    pivote = AB[i,i]
    adelante = i+1 
    for k in range(adelante,n,1):
        if (np.abs(pivote)>=casicero):
            factor = AB[k,i]/pivote
            AB[k,:] = AB[k,:] - factor*AB[i,:]
    print('Elimina hacia adelante')
    print(AB)

# Gauss-Jordan elimina hacia atras
ultfila = n-1
ultcolumna = m-1
for i in range(ultfila,0-1,-1):
    # Normaliza a 1 elemento diagonal
    AB[i,:] = AB[i,:]/AB[i,i]
    pivote = AB[i,i] # uno
    # arriba de la fila i
    atras = i-1 
    for k in range(atras,0-1,-1):
        if (np.abs(AB[k,i])>=casicero):
            factor = pivote/AB[k,i]
            AB[k,:] = AB[k,:]*factor - AB[i,:]
        else:
            factor= 'division para cero'
print('Elimina hacia atras')
print(AB)

X = AB[:,ultcolumna]

# Verifica resultado
verifica = np.dot(A,X)

# SALIDA
print('el vector solución X es:')
print(np.transpose([X]))

print('verificar que A.X = B')
print(np.transpose([verifica]))

# Revisa polinomio
a = np.min(puntos[:,0])
b = np.max(puntos[:,0])
muestras = 51

px = lambda x: X[0]*x**3 + X[1]*x**2 +X[2]*x + X[3]
xi = np.linspace(a,b,muestras)
pxi = px(xi)

# gráfica
plt.plot(xi,pxi)
plt.plot(puntos[:,0],puntos[:,1],'ro')
plt.show()

s1Eva_IIT2008_T1 Distribuidores de productos

Ejercicio: 1Eva_IIT2008_T1 Distribuidores de productos

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 resolve se convierte 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
1ra Iteración

\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
2da Iteración

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

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

Elimina hacia atras
[[ 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. ]]

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]

Queda como tarea las iteraciones por un método Jacobi.

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_IT2009_T2 Materiales y Productos 3×4

Ejercicio: 1Eva_IT2009_T2 Materiales y Productos 3×4

1. Plantear el sistema de ecuaciones

0.2 x0 + 0.5 x1 + 0.4 x2 + 0.2 x3 = 10
0.3 x0 +  0  x1 + 0.5 x2 + 0.6 x3 = 12
0.4 x0 + 0.5 x1 + 0.1 x2 + 0.2 x3 = 15

Observe que hay más incógnitas que ecuaciones.

Para equiparar las ecuaciones con el número de incógnitas, podriamos suponer que uno de los productos NO se fabricará. por ejempo el producto x3 que podría hacerse igual a cero. Supone que la variable libre es x3 .

Para mantener la forma de las ecuaciones para otros valores de x3, se pasa la variable y su coeficiente a la derecha.

0.2 x0 + 0.5 x1 + 0.4 x2 = 10 - 0.2 x3 
0.3 x0 +  0  x1 + 0.5 x2 = 12 - 0.6 x3 
0.4 x0 + 0.5 x1 + 0.1 x2 = 15 - 0.2 x3 

Para analizar el ejercicio, se supondrá que el valor de x3 = 0, lo que permite usar el modelo del problema como A.X=B .En caso de que x3 sea diferente de cero,  el vector B modifica, y se puede proceder con el sistema de ecuaciones.

2. Convertir a la forma matricial AX = B

Siendo así, suponiendo que x3 = 0, el ejercicio se puede desarrollar usando:

A = np.array([[0.2, 0.5, 0.4],
              [0.3, 0.0, 0.5],
              [0.4, 0.5, 0.1]])
B = np.array([[10],
              [12],
              [15]])

que luego armar el algoritmo y su ejecución, obtendría una solución semejante:

array([[ 32.10526316],
       [  3.36842105],
       [  4.73684211]])

Nota: Para desarrollar, se recomienda seguir los pasos indicados en:

http://blog.espol.edu.ec/analisisnumerico/unidad-03-y-04-sistema-de-ecuaciones-pasos/

Encontrada la solución, modifique el algoritmo para calcular B en función de x3, pregunte el valor al inicio, y vuelva a calcular.

x3 = float(input('cantidad a producir de cuarto producto: ')

Observe el rango para x3, por ejemplo que debe ser mayor o igual que cero, pues no hay producción negativa. De producir solamente ése un producto, el valor máximo de unidades a obtener no superaría lo posible con la cantidad de materiales disponible.

Ejemplo:

x3 = 1
B3 = np.array([[0.2],
	       [0.6],
	       [0.2]])
Bnuevo = B - x3*B3

>>> Bnuevo
array([[  9.8],
       [ 11.4],
       [ 14.8]])

Y se vuelve a generar el sistema A.X=Bnuevo

Observación: Algunos productos se fabrican por unidades, no necesesariamente por peso o volumen. ¿comentarios al respecto?

 

s1Eva_IIT2011_T2 Sistema de Ecuaciones, diagonal dominante

Ejercicio: 1Eva_IIT2011_T2 Sistema de Ecuaciones, diagonal dominante

1. Desarrollo analítico

1.1 Solución iterativa usando el médodo de Jacobi

El sistema de ecuaciones

\begin{cases} -2x+5y+9z=1\\7x+y+z=6\\-3x+7y-z=-26\end{cases}

cambia a su forma matricial AX=B

\begin{bmatrix} -2 & 5 & 9 \\ 7 & 1 & 1 \\ -3 & 7 &-1 \end{bmatrix} \begin{bmatrix} x_0 \\ x_1 \\ x_2 \end{bmatrix} = \begin{bmatrix} 1 \\ 6 \\ -26 \end{bmatrix}

para usarla en el algoritmo se intercambian filas, pivoteo, buscando hacerla diagonal dominante:

\begin{bmatrix} 7 & 1 & 1 \\ -3 & 7 &-1\\ -2 & 5 & 9 \end{bmatrix} \begin{bmatrix} x_0 \\ x_1 \\ x_2 \end{bmatrix} = \begin{bmatrix} 6 \\ -26 \\1 \end{bmatrix}

las ecuaciones para el algoritmo se obtienen despejando una variable diferente en cada ecuación.

\begin{cases}x=(6-y-z)/(7)\\y=(-26+3x+z)/(7)\\z=(1+2x-5y)/(9)\end{cases}

Dado el vector inicial X(0) = [0, 0, 0], y una tolerancia de 0.0001, e desarrollan al menos 3 iteraciones:

Nota. El super índice entre paréntesis denota el número de la iteración. El subíndice denota el elemento del vector. El error se verifica para éste ejercicio como el mayor valor de la diferencia entre iteraciones consecutivas. Analogía al video del acople entre las aeronaves. Si una coordenada aún no es la correcta …. menor a lo tolerado, pues NO hay acople…

Iteración 1

\begin{cases}x=(6-(0)-(0))/(7)\\y=(-26+3(0)+(0))/(7)\\z=(1+2(0)-5(0))/(9)\end{cases}
X(1) = [6/7, -26/7, 1/9] 
    = [0.8571, -3,7142, 0.1111]
diferencia(1) = |X(1) - X(0)|
             = |[0.8571,-3,7142,0.1111] - [0,0,0]|
             = |[0.8571,-3,7142,0.1111]|
errado(1) = maximo|[0.8571,-3,7142,0.1111]|
         = 26/7 ≅ 3.71, 
error es más alto que lo tolerado

Iteración 2

\begin{cases}x=(6-(-26/7)-(1/9))/(7)\\y=(-26+3(6/7)+(1/9))/(7)\\z=(1+2(6/7)-5(-26/7))/(9)\end{cases}
X(2) = [1.3718, -3.3310 ,  2,3650]
diferencia(2) = |X(2) - X(1)|
             = |[1.3718, -3.3310 , 2,3650] - [0.8571, -3,7142, 0.1111]| 
             = |[0.5146, 0.3832, 2.2539]|
errado(2) ≅ 2.2538, 
el error disminuye, pero es más alto que lo tolerado

Iteración 3

\begin{cases}x=(6-(-3.3310)-( 2,3650))/(7)\\y=(-26+3x+z)/(7)\\z=(1+2x-5y)/(9)\end{cases}
X(3) = [0.9951, -2.7884, 2.2665]
diferencia(3) = |[0.9951, -2.7884, 2.2665] - [1.3718, -3.3310 ,  2,3650]|
             = |[-0.3767, 0.5425, -0.0985]|
errado(3) ≅ 0.5425, 
el error disminuye, pero es más alto que lo tolerado

Observación: Si el error disminuye en cada iteración, se puede intuir que se converge a la solución. Se puede continuar con la 4ta iteración…


2. Solución numérica usando Python

Usando el algoritmo desarrollado en clase se obtiene la respuesta con 13 iteraciones:

Xi, errado
[ 0.85714286 -3.71428571  0.11111111] 3.71428571429
[ 1.37188209 -3.33106576  2.36507937] 2.25396825397
[ 0.99514091 -2.78846777  2.26656589] 0.542597991578
[ 0.93170027 -2.96400162  1.8814023 ] 0.385163589245
[ 1.0117999  -3.04621384  1.96482318] 0.0834208883016
[ 1.01162724 -2.99996816  2.02829656] 0.0634733731283
[ 0.99595309 -2.99097453  2.00256614] 0.0257304176216
[ 0.99834406 -3.0013678   1.99408654] 0.0103932672897
[ 1.00104018 -3.00155447  2.0003919 ] 0.00630536414945
[ 1.00016608 -2.99949822  2.00109475] 0.00205624814582
[ 0.99977193 -2.99977243  1.99975814] 0.00133660433338
[ 1.00000204 -3.0001323   1.99982289] 0.000359867509479
[ 1.0000442  -3.00002443  2.00007395] 0.000251063280064
[ 0.99999292 -2.99997049  2.00002339] 5.39347670632e-05
iteraciones:  13

La gráfica muestra las coordenadas de las aproximaciones, observe el espiral que se va cerrando desde el punto inicial en verde al punto final en rojo.

Tarea: convierta el algoritmo a una función, así es más sencillo usar en otros ejercicios.
Se debe controlar el número de iteraciones para verificar la convergencia con iteramax.
NO es necesario almacenar los valores de los puntos, solo el último valor y el contador itera permite determinar si el sistema converge.

# 1ra Evaluación II Término 2011
# Tema 2. Sistema ecuaciones Jacobi
import numpy as np

# INGRESO
A = np.array([[ 7.0, 1, 1],
              [-3.0, 7,-1],
              [-2.0, 5, 9]])

B = np.array([6.0, -26.0, 1.0])

X = np.array([0.0, 0.0,  0.0],dtype=float)
tolera = 0.0001
iteramax = 100

# PROCEDIMIENTO
tamano = np.shape(A)
n = tamano[0]
m = tamano[1]
Xi1 = np.zeros(n, dtype=float)
errado = 2*tolera
itera = 0
while not(errado<=tolera or itera>=iteramax):
    i = 0
    while not(i>=n):
        j = 0
        nuevo = B [i]
        while not(j>=m):
            if (i!=j):
                nuevo = nuevo - A[i,j]*X[j]
            j = j+1
        Xi1[i] = nuevo/A[i,i]
        i = i+1
    diferencia = np.abs(X - Xi1)
    errado = np.max(diferencia)
    X = np.copy(Xi1)
    itera = itera +1
    print(Xi1, errado)

# SALIDA
print('iteraciones: ', itera-1)

Tarea: Realice las modificaciones necesarias para usar el algoritmo de Gauss-Seidel. Luego compare resultados.


Revisión de resultados

Si se usan las ecuaciones sin cambiar a diagonal dominante, como fueron presentadas en el enunciado, el algoritmo Jacobi NO converge, el error aumenta, y muy rápido como para observar la espiral hacia afuera en una gráfica.

Xi, errado
[ -0.5   6.   26. ] 26.0
[ 131.5  -16.5   69.5] 132.0
[ 271. -984. -484.] 967.5
[-4638.5 -1407.  -7675. ] 7191.0
[-38055.5  40150.5   4092.5] 41557.5
[ 118792.  262302.  395246.] 391153.5
[ 2434361.5 -1226784.   1479764. ] 2315569.5
[  3591977.5 -18520288.5 -15890546.5] 17370310.5
....

s1Eva_IT2011_T3_MN Precios unitarios en factura, k

Ejercicio: 1Eva_IT2011_T3_MN Precios unitarios en factura, k

Las ecuaciones basadas en las sumas de cantidad.preciounitario representan el valor pagado en cada factura.

Siendo Xi el precio unitario de cada material:

2x_1 + 5x_2 + 4x_3 = 35 3x_1 + 9x_2 + 8x_3 = k 5x_1 + 3x_2 + x_3 = 17

se escriben en la forma matricial Ax=B

\begin{bmatrix} 2 && 5 && 4 \\ 3 && 9 && 8 \\ 5 && 3 && 1 \end{bmatrix}.\begin{bmatrix} x_1 \\ x_2 \\ x_3 \end{bmatrix}=\begin{bmatrix} 35 \\ k \\ 17 \end{bmatrix}

luego se escribe la matriz aumentada:

\begin{bmatrix} 2 && 5 && 4 && 35\\ 3 && 9 && 8 && k\\ 5 && 3 && 1 && 17\end{bmatrix}

se pivotea por filas buscando tener una matriz diagonal dominante,

\begin{bmatrix} 5 && 3 && 1 && 17 \\ 3 && 9 && 8 && k\\ 2 && 5 && 4 && 35\\\end{bmatrix}

Luego se usa el procedimiento de eliminación hacia adelante,

\begin{bmatrix} 5 && 3 && 1 && 17 \\ 3-5\frac{3}{5} && 9-3\frac{3}{5} && 8-1\frac{3}{5} && k-17\frac{3}{5} \\ 2-5\frac{2}{5} && 5-3\frac{2}{5} && 4-1\frac{2}{5} && 35-17\frac{2}{5} \end{bmatrix} \begin{bmatrix} 5 && 3 && 1 && 17 \\ 0 && \frac{36}{5} && \frac{37}{5} && k-\frac{51}{5} \\ 0 && \frac{19}{5} && \frac{18}{5} && \frac{141}{5} \end{bmatrix} \begin{bmatrix} 5 && 3 && 1 && 17 \\ 0 && 36 && 37 && 5k-51 \\ 0 && 19 && 18 && 141 \end{bmatrix} \begin{bmatrix} 5 && 3 && 1 && 17 \\ 0 && 36 && 37 && 5k-51 \\ 0 && 19-36\frac{19}{36} && 18-37\frac{19}{36} && 141-(5k-51)\frac{19}{36} \end{bmatrix} \begin{bmatrix} 5 && 3 && 1 && 17 \\ 0 && 36 && 37 && 5k-51 \\ 0 && 0 && \frac{-55}{36} && \frac{6045-5k}{36} \end{bmatrix}

multiplicando la última fila por 36,

\begin{bmatrix} 5 && 3 && 1 && 17 \\ 0 && 36 && 37 && 5k-51 \\ 0 && 0 && -55 && 6045-5k \end{bmatrix}

con lo que se pueden obtener cada precio unitario en función de k.
Como variante, se continua siguiendo el procedimieno de Gauss, dejando como tarea el uso de Gauss-Jordan

-55x_3 = 6045-5k x_3 = -\frac{6045-5k}{55} 36 x_2 + 37 x_3 = 5k-51 x_2 = \frac{1}{36}(5k-51 - 37 x_3) x_2 = \frac{1}{36} \Big( 5k-51 - 37 \big(-\frac{6045-5k}{55}\big) \Big) 5x_1 + 3 x_2 +x_3 = 17 x_1 = \frac{1}{5} \Big[ 17 - 3 x_2 - x_3 \Big] x_1 = \frac{1}{5} \Big[17-3\frac{1}{36} \Big( 5k-21 - 37 \big(-\frac{6045-5k}{55}\big) \Big) - \Big( -\frac{6045-5k}{55} \Big) \Big]

para luego simplificar las expresiones (tarea).

En el literal c se indica que el valor de k es 65, con lo que se requiere sustituir en la solución el valor de K para encontrar los precios unitarios.

\begin{bmatrix} 5 && 3 && 1 && 17 \\ 3 && 9 && 8 && 65\\ 2 && 5 && 4 && 35\\\end{bmatrix}

Se encuentra que:

el vector solución X es:

[[-0.18181818]
 [ 5.18181818]
 [ 2.36363636]]

Lo que muestra que debe existir un error en el planteamiento del enunciado, considerando que los precios NO deberían ser negativos como sucede con el primer precio unitario de la respuesta.

que es lo que suponemos ser trata de corregir en el literal d, al indicar que se cambie en la matriz el valor de 5 por 5.1. Los resultados en éste caso son más coherentes con el enunciado. Todas las soluciones son positivas.

A = np.array([[ 5.1, 3  , 1],
              [ 3. , 9  , 8],
              [ 2. , 5.1, 4]])
B1 = np.array([ 17, 65, 35])

el vector solución X es:
[[0.33596838]
 [3.88669302]
 [3.62648221]]

El error relativo de los precios encontrados entre las ecuaciones planteadas es:

diferencia = [0.335968-0.181818,
              3.886693-5.181818, 
              3.626482-2.363636]
           = [0.154150, -1.295125, 1.262845]
error(dolares) = max|diferencia| = 1.295125
Por las magnitudes de los precios, el error se aprecia
usando el error relativo referenciado 
al mayor valor de la nueva solución
error relativo = 1.295125/3.886693 = 0.333220
es decir de aproximadamente 33%

Para revisar otra causa del error se analiza el número de condición de la matriz:

>>> A
array([[5.1, 3. , 1. ],
       [3. , 9. , 8. ],
       [2. , 5.1, 4. ]])
>>> np.linalg.cond(A)
60.28297696795716

El número de condición resulta lejano a 1, por lo que para éste problema:
pequeños cambios en la matriz de entrada producen grandes cambios en los resultados.

por ejemplo: un 0.1/5= 0.02 que es un 2% de variación en la entrada produce un cambio del 33% en el resultado.