s1Eva_2024PAOII_T3 matriz de distribución de energía por sectores

Ejercicio: s1Eva_2024PAOII_T3 matriz de distribución de energía por sectores

:

Fuente\Consumidor Industrial Comercial Transporte Residencial
Hidroeléctrica 0.7 0.19 0.1 0.01
Gas Natural 0.12 0.18 0.68 0.02
Petróleos-combustible 0.2 0.38 0.4 0.02
Eólica 0.11 0.23 0.15 0.51

total de fuente de generación para la tabla es: [1500,400,600,200]

literal a Planteamiento

Considerando que el factor de la tabla es el factor de consumo por tipo de cliente, para encontrar las cantidades por tipo cliente que se puedan atender con la capacidad de cada «fuente de generación», se plantea:

0.7x+0.19y+0.1z+0.01w = 1500 0.12x+0.18y+0.68z+0.02w = 400 0.2x+0.38y+0.4z+0.04w = 600 0.11x+0.23y+0.15z+0.51w =200

literal b. Matriz aumentada y Pivoteo parcial por filas

\begin{bmatrix} 0.7 & 0.19& 0.1 & 0.01 &1500 \\ 0.12 & 0.18 & 0.68 & 0.02 & 400 \\0.2 & 0.38 & 0.4 & 0.02 & 600 \\0.11 & 0.23& 0.15 & 0.51 & 200 \end{bmatrix}

Revisando la primera columna j=0,  el mayor valor ya se encuentra en la posición de la diagonal i=0, por lo que no hay cambio de filas

Para la segunda columna j=1, desde la posición de la diagonal i=1, el mayor valor se encuentra en i=2, por lo que intercambian las filas.

\begin{bmatrix} 0.7 & 0.19& 0.1 & 0.01 &1500\\0.2 & 0.38 & 0.4 & 0.02 & 600 \\ 0.12 & 0.18 & 0.68 & 0.02 & 400 \\ 0.11 & 0.23& 0.15 & 0.51 & 200 \end{bmatrix}

Al observar la tercera columna j=2, desde la diagonal i=2, el valor mayor ya se encuentra en la posición de la diagonal, no hay cambio de filas. Para la última fila no se tiene otra fila para comparar, con lo que el pivoteo se terminó.

literal c. Método de Jacobi

A partir de la matriz del literal anterior, las expresiones quedan:

0.7x+0.19y+0.1z+0.01w = 1500 0.2x+0.38y+0.4z+0.04w = 600 0.12x+0.18y+0.68z+0.02w = 400 0.11x+0.23y+0.15z+0.51w =200

y despejar una incógnita de cada ecuación se convierte en:

x = \frac{1}{0.7} \Big( 1500 - (+0.19y+0.1z+0.01w) \Big) y = \frac{1}{0.38} \Big( 600 - (0.2x +0.4z+0.04w) \Big) z = \frac{1}{0.68} \Big(400-(0.12x+0.18y+0.02w)\Big) w =\frac{1}{0.51} \Big(200-(0.11x+0.23y+0.15z) \Big)

literal d. iteraciones

En el literal c, se sugiere iniciar con el vector X0 = [100,100,100,100].

Como la unidad de medida en las incógnitas es número de clientes, la tolerancia puede ajustarse a 0.1.

itera = 0

X0 = [100,100,100,100]

x = \frac{1}{0.7} \Big( 1500 - (+0.19(100)+0.1(100)+0.01(100)) \Big) = 2100 y = \frac{1}{0.38} \Big( 600 - (0.2(100) +0.4(100)+0.04(100)) \Big) = 1415.7 z = \frac{1}{0.68} \Big(400-(0.12(100)+0.18(100)+0.02(100))\Big) = 541.17 w =\frac{1}{0.51} \Big(200-(0.11(100)+0.23(100)+0.15(100)) \Big) =296.1 errado = max| [ 2100-100, 1415.7-100, 541.17-100, 296.1-100] | errado = max| [ 2000, 1315.7,441.17,196.1] | = 2000

itera = 1

X0 = [ 2100, 1415.7, 541.1, 296.1 ]

x = \frac{1}{0.7} \Big( 1500 - (+0.19(1415.7)+0.1(541.1)+0.01(296.1)) \Big) = 1677.0 y = \frac{1}{0.38} \Big( 600 - (0.2(2100) +0.4(541.1)+0.04( 296.1)) \Big) = -111.55 z = \frac{1}{0.68} \Big(400-(0.12(2100)+0.18(1415.7)+0.02(541.1))\Big) = -165.82 w =\frac{1}{0.51} \Big(200-(0.11( 2100)+0.23( 1415.7)+0.15(541.1)) \Big) =-858.44 errado = max| [ 1677.0 - 2100,-111.55 -1415.7, -165.82- 541.17, -858.44- 296.1] | errado = max| [ -423, -1527.25 ,-706.99 ,-1154.54] | = 1527.25

itera = 2

tarea..

literal e. convergencia y revisión de resultados obtenidos

Para el asunto de convergencia, el error disminuye entre iteraciones, por lo que el método es convergente.

Analizando los resultados desde la segunda iteración, se obtienen valores negativos, lo que no es acorde al concepto del problema. Se continuarán con las iteraciones siguientes y se observará el resultado para dar mayor «opinión» sobre lo obtenido.

literal f Número de condición

Número de condición = 5.77 que al ser «bajo y cercano a 1» se considera que el método converge.

Resultados con el algoritmo

Iteraciones Jacobi
itera,[X],errado
0 [100. 100. 100. 100.] 1.0
1 [2100.      1415.78947  541.17647  296.07843] 2000.0
2 [1677.03081 -111.55831 -165.82893 -858.44716] 1527.3477812177503
3 [2209.09063  916.03777  347.06727  129.52816] 1027.5960799832396
4 [1842.78688   44.11685  -47.89447 -599.50735] 871.9209205662409
5 [2146.28903  691.02779  268.99219  -11.1162 ] 646.9109334007268
...
40 [2022.87519  383.13614  137.36642 -257.41944] 0.11802984805018468
41 [2022.91669  383.22837  137.41009 -257.33833] 0.09223623893257127
numero de condición: 5.7772167744910625
respuesta X: 
[2022.91669  383.22837  137.41009 -257.33833]
iterado, incluyendo X0:  42

El resultado muestra que los clientes residenciales serán -257 según las ecuaciones planteadas. Lo que se interpreta según lo presentado por los estudiantes:

1. energía insuficiente: causa por los apagones diarios en el país en éstos días.

2. Se requiere mejorar el planteamiento, pues la respuesta no debe contener valores negativos según el concepto planteado en el ejercicio.

Se considerarán ambas válidas para la evaluación al observar que el resultado numérico es correcto, pero no es acorde al ejercicio.

 

Instrucciones en Python

# 1Eva_2024PAOII_T3 matriz de distribución de energía por sectores
import numpy as np

#INGRESO
A= [[0.7,0.19,0.1,0.01],
    [0.12,0.18,0.68,0.02],
    [0.2,0.38,0.4,0.02],
    [0.11,0.23,0.15,0.51]]

B = [1500,400,600,200]

# PROCEDIMIENTO
A = np.array(A,dtype=float)
B = np.transpose([np.array(B)])

X0 = [100,100,100,100]
tolera = 0.1
iteramax = 100
verdecimal = 5

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

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

        itera = itera + 1
        if vertabla==True:
            print(itera, xnuevo, errado)

    # No converge
    if (itera>iteramax):
        X=itera
        print('iteramax superado, No converge')
    return(X,tabla)

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

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

# PROGRAMA Búsqueda de solucion  --------


# PROCEDIMIENTO
AB = pivoteafila(A,B,vertabla=True)
# separa matriz aumentada en A y B
[n,m] = np.shape(AB)
A = AB[:,:m-1]
B = AB[:,m-1]

[X, puntos] = jacobi(A,B,X0,tolera,vertabla=True,precision=verdecimal)
iterado = len(puntos)

# numero de condicion
ncond = np.linalg.cond(A)

# SALIDA
print('numero de condición:', ncond)
print('respuesta X: ')
print(X)
print('iterado, incluyendo X0: ', iterado)