s1Eva2007TIII_T1_AN Container: Refrigeradoras y Cocinas

Ejercicio: 1Eva2007TIII_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 10⁴, 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)