s1Eva_IIIT2007_T3_AN Factorar polinomio

P3(x) = 2×3 – 5×2 + 3x – 1

se obtuvo usando un graficador, 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 -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 -1)/(x-raiz1)
# SALIDA
pol2 = p2(xi)
plt.plot(xi,pol2)
plt.show()

s1Eva_IIIT2007_T2_AN 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):
    """
    rango de búsqueda [a,b]
    busca hasta que (a-b)=tolera and cambia<0):
        c = (a+b)/2
        fc = funcionx(c)
        cambia = np.sign(fa)*np.sign(fc)
        if (cambia<0):
            b=c
        else:
            a=c
        fa = funcionx(a)
        fb = funcionx(b)
        cambia = np.sign(fa)*np.sign(fb)
        tramo = abs(b-a)
    respuesta = c

    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)
plt.plot(kj,fxi)
plt.axhline(0)
plt.show()

s1Eva_IIIT2007_T1_AN Container: Refrigeradoras y Cocinas

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_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_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) && 1 && 6.85 \\ (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} && 1 - 1\frac{(4.2)^3}{(4.5)^3} && 7.25 - 6.85\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} && 1 -1\frac{(3.8)^3}{(4.5)^3} && 6.42 - 6.85\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} && 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_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.

s1Eva_IT2015_T4 lingotes metales

Se plantea que cada lingote debe aportar una proporción xi al lingote nuevo a ser fundido.

Se dispone de los compuestos de cada lingote por filas:

compuesto = np.array([[ 20, 50, 20, 10],
                      [ 30, 40, 10, 20],
                      [ 20, 40, 10, 30],
                      [ 50, 20, 20, 10]])
proporcion = np.array([ 27, 39.5, 14, 19.5])

El contenido final de cada componente basado en los aportes xi de cada lingote para cada componente.

Ejemplo para los 27 gramos de oro

20x_1 + 30x_2+ 20x_3 + 50x_4 = 27

se realiza el mismo procedimiento para los otros tipos de metal.

50x_1 + 40x_2+ 40x_3 + 20x_4 = 39.5 20x_1 + 10x_2+ 10x_3 + 20x_4 = 14 10x_1 + 20x_2+ 30x_3 + 10x_4 = 19.5

Las ecuaciones se escriben en la forma matricial Ax=B

\begin{bmatrix} 20 && 30&& 20 &&50 \\ 50 && 40 && 40 && 20 \\ 20 && 10 && 10 && 20 \\ 10 && 20 && 30 && 10 \end{bmatrix} = \begin{bmatrix} x_1 \\ x_2 \\x_3 \\ x_4 \end{bmatrix} = \begin{bmatrix} 27 \\ 39.5 \\ 14 \\ 19.5 \end{bmatrix}

Para resolver se plantea la matriz aumentada

\begin{bmatrix} 20 && 30&& 20 &&50 && 27\\ 50 && 40 && 40 && 20 && 39.5\\ 20 && 10 && 10 && 20 && 14 \\ 10 && 20 && 30 && 10 && 19.5 \end{bmatrix}

se pivotea por filas la matriz:

\begin{bmatrix} 50 && 40 && 40 && 20 && 39.5\\ 20 && 30&& 20 &&50 && 27\\ 10 && 20 && 30 && 10 && 19.5 \\ 20 && 10 && 10 && 20 && 14 \end{bmatrix}

Para eliminar hacia adelante:

\begin{bmatrix} 50 && 40 && 40 && 20 && 39.5 \\ 20 - 50\frac{20}{50} && 30-40\frac{20}{50} && 20-40\frac{20}{50} && 50-20\frac{20}{50} && 27-39.5\frac{20}{50}\\ 10 - 50\frac{10}{50} && 20-40\frac{10}{50} && 30-40\frac{10}{50} && 10-20\frac{10}{50} && 19.5-39.5\frac{10}{50} \\ 20 - 50\frac{20}{50} && 10-40\frac{20}{50} && 10-40\frac{20}{50} && 20-20\frac{20}{50} && 14-39.5\frac{20}{50} \end{bmatrix}

continuando con el desarrollo:

Elimina hacia adelante
[[50.  40.  40.  20.  39.5]
 [ 0.  14.   4.  42.  11.2]
 [ 0.  12.  22.   6.  11.6]
 [ 0.  -6.  -6.  12.  -1.8]]
Elimina hacia adelante
[[ 50.  40.  40.      20.  39.5]
 [  0.  14.   4.      42.  11.2]
 [  0.   0.  18.5714 -30.   2. ]
 [  0.   0.  -4.2857  30.   3. ]]
Elimina hacia adelante
[[ 50.  40.  40.      20.     39.5   ]
 [  0.  14.   4.      42.     11.2   ]
 [  0.   0.  18.5714 -30.      2.    ]
 [  0.   0.   0.      23.0769  3.4615]]
Elimina hacia adelante
[[ 50.  40.   40.      20.     39.5  ]
 [  0.  14.    4.      42.     11.2  ]
 [  0.   0.   18.5714 -30.      2.   ]
 [  0.   0.    0.      23.0769  3.4615]]
Elimina hacia atras
[[ 1.    0.    0.    0.    0.25]
 [ 0.    1.    0.    0.    0.25]
 [ 0.    0.    1.   -0.    0.35]
 [ 0.    0.    0.    1.    0.15]]
el vector solución X es:
[[0.25]
 [0.25]
 [0.35]
 [0.15]]
verificar que A.X = B
[[39.5]
 [27. ]
 [19.5]
 [14. ]]

Las proporciones de cada lingote a usar para el nuevo lingote que cumple con lo solicitado son: [0.25, 0.25, 0.35, 0.15]


Algoritmo en python usado para la solución es:

# 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
A = np.array([[ 50., 40, 40, 20],
              [ 20., 30, 20, 50],
              [ 10., 20, 30, 10],
              [ 20., 10, 10, 20]])
B1 = np.array([ 39.5, 27, 19.5, 14])

B = np.transpose([B1])

# 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]))

Tarea: Revisar sobre la última pregunta.

s1Eva_IT2015_T2 Salida cardiaca

Solución presentada como introducción al tema de interpolación y solución de sistemas de ecuaciones.
No realiza el literal c, no se desarrolla el tema de integrales.

Note que el desarrollo del tema permite aumentar el grado del polinomio de interpolación, lo que se afecta al tamaño del sistema de ecuaciones (matriz).

Los valores obtenidos con la solución propuesta son:

solución para X por Gauss-Seidel
[[-0.42175867]
 [ 0.15610893]
 [ 0.02736763]]
verifica que A.X = B:
[[ -7.02831455e-05]
 [  1.50012970e+00]
 [  3.20000000e+00]]
polinomio interpolación, con puntos:  3
0.0273676337623498*x**2 + 0.156108926206362*x - 0.421758670607596
>>>

La gráfica para observar los datos experimentales es:

La gráfica con polinomio de interpolación de grado 2, con tres puntos:

instrucciones del problema para la solución por partes en python:

# 1ra Evaluación I Término 2015
# Tema 2. Flujo de sangre en corazón
# Tarea: parte c), no se ha realizado el áre bajo curva
#        falta calcular salida cardiaca.
import numpy as np
import matplotlib.pyplot as plt

# Gráfica de datos experimentales:
t = np.array([2,6,9,12,15,18])
y = np.array([0,1.5,3.2,4.1,3.4,2.0])

# SALIDA
plt.plot(t,y)
plt.title('datos del experimento: t vs concentración ')
plt.show()

# Sistema de ecuaciones para aproximar a polinomio grado 2
# para grado dos usa tres puntos,
# por ejemplo usando el punto [ 2, 0] del experimento
# a + b*(2) + c*(2**2) =  0
A = np.array([[1,2,2**2],
              [1,6,6**2],
              [1,9,9**2]])
B = np.array([[0],
              [1.5],
              [3.2]])

tolera = 0.0001
X = np.zeros(len(B), dtype = float)

# usando numpy para solucion de matrices
# Xnp = np.linalg.solve(A,B)
# print('solución para A.X=B con numpy')
# print(Xnp)

# algoritmo Gauss-Seidel
iteramax=100
tamano = np.shape(A)
n = tamano[0]
m = tamano[1]
diferencia = np.ones(n, dtype=float)
errado = np.max(diferencia)

itera = 0
while (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]
        diferencia[i] = np.abs(nuevo-X[i])
        X[i] = nuevo
    errado = np.max(diferencia)
    itera = itera + 1
# Vector en columna
X =  np.transpose([X])
# No converge
if (itera>iteramax):
    X=0

Xgs = X

# Metodo numérico Gauss_Seidel
verifica = np.dot(A,Xgs)
print('solución para X por Gauss-Seidel')
print(Xgs)

# verificar resultado
print('verifica que A.X = B: ')
print(verifica)

# Observar interpolacion con polinomio creado
pt = lambda t: Xgs[0,0]+ Xgs[1,0]*t + Xgs[2,0]*t**2

ti = np.linspace(2,18,501)
pti = pt(ti)

plt.plot(ti,pti, label = 'interpolacion')
plt.plot(t,y,'*', label = 'datos experimento')
plt.title('interpolación con polinomio')
plt.legend()
plt.show()

# polinomio en sympy
import sympy as sp
x = sp.Symbol('x')
polinomio = 0
k = len(Xgs)
for i in range(0,k,1):
    polinomio = polinomio + Xgs[i,0]*x**i
print('polinomio interpolación, con puntos: ', k) 
print(polinomio)