RESOLVER ACTIVIDADES Y EJERCICIOS DE
PENALIZACION M DEL LAB 02
Gonzalez Polar Ampuero Alessio
Alessio.gonzalezpolar@ucsm.edu.pe
Universidad Católica de Santa María
Arequipa, Perú
Resumen- En este informe se realizarán los ejercicios propuestos en la primera guía, donde se
resolverán solamente los ejercicios que contengan dos variables, el cual será realizado usando
el metodo grafico explicado en clase.
I.INTRODUCCION
El algoritmo Simplex es un método numérico desarrollado para encontrar la solución óptima en
problemas de programación lineal, donde se busca maximizar o minimizar una función lineal
sujeta a restricciones lineales. El Simplex se basa en moverse a lo largo de las aristas de un polítopo
(un conjunto convexo de soluciones factibles) para encontrar la solución óptima. Sin embargo, el
Simplex clásico tiene limitaciones cuando no existe una solución factible inicial, o cuando las
restricciones de igualdad no cumplen la condición de ser linealmente independientes.
Aquí es donde entra en juego la penalización M. La penalización M es una técnica que se utiliza
para convertir un problema de programación lineal no factible en un problema factible. La idea
principal es agregar una cantidad ficticia (penalización) a la función objetivo que penaliza las
desviaciones con respecto a las restricciones. Esto "penaliza" las soluciones no factibles y permite
al algoritmo encontrar una solución factible antes de buscar la óptima.
El método Simplex con penalización M combina estos dos conceptos al incorporar la penalización
M en el algoritmo Simplex para resolver problemas no factibles inicialmente. A medida que el
algoritmo avanza, ajusta la penalización M de manera dinámica para acercarse gradualmente a una
solución factible. Una vez que se encuentra una solución factible, se elimina la penalización M y
se procede a buscar la solución óptima como en el Simplex clásico.
El informe consta de dos partes, la primera sección la cual reflejará todos los ejercicios resueltos
que contengan penalización M [1] y por último tendrá la sección de conclusiones y referencias.
II.
EJERCICIOS RESUELTOS
1. Implementar en Python, Java o C++ una función que capture la función objetivo
maximizada, las restricciones del tipo AX <= B y cree una matriz equivalente para la tabla
del método Simplex.
import numpy as np
def crear_matriz_simplex(funcion_objetivo, restricciones):
# Obtener el número de variables y restricciones
num_variables = len(funcion_objetivo)
num_restricciones = len(restricciones)
# Matriz de la tabla Simplex
matriz_simplex = np.zeros((num_restricciones + 1, num_variables +
num_restricciones + 1))
# Configurar la fila de la función objetivo
matriz_simplex[0, :num_variables] = -funcion_objetivo
matriz_simplex[0, -1] = 1 # Columna para el valor de la función
objetivo
# Configurar las filas de las restricciones
for i in range(num_restricciones):
matriz_simplex[i + 1, :num_variables] =
restricciones[i][:num_variables]
matriz_simplex[i + 1, num_variables + i] = 1 # Variable de
holgura
matriz_simplex[i + 1, -1] = restricciones[i][-1] # Lado
derecho de la restricción
return matriz_simplex
# Ejemplo
funcion_objetivo = [3, 2] # Maximizar 3x1 + 2x2
restricciones = [
[2, 1, 10], # 2x1 + x2 <= 10
[1, 1, 6],
# x1 + x2 <= 6
]
matriz_simplex = crear_matriz_simplex(funcion_objetivo, restricciones)
print(matriz_simplex)
2. Implementar en Python, Java o C++ una función que calcule cual es la fila y columna
pivote.
import numpy as np
def encontrar_pivote(matriz_simplex):
# Obtener dimensiones de la matriz
num_filas, num_columnas = matriz_simplex.shape
# Encontrar la columna pivote (variable de entrada)
columna_pivote = np.argmin(matriz_simplex[0, :-1])
# Inicializar una lista para almacenar los cocientes
cocientes = []
# Calcular los cocientes para cada fila
for i in range(1, num_filas):
if matriz_simplex[i, columna_pivote] > 0:
cociente = matriz_simplex[i, -1] / matriz_simplex[i,
columna_pivote]
cocientes.append(cociente)
else:
cocientes.append(np.inf) # Evitar divisiones por cero
# Encontrar la fila pivote (variable de salida) usando el cociente
mínimo
fila_pivote = np.argmin(cocientes) + 1 # Sumamos 1 para ajustar
el índice de la fila
return fila_pivote, columna_pivote
# Ejemplo de uso con una matriz de prueba
matriz_simplex_prueba = np.array([
[1, -1, 1, 0, 0, 3],
[3, 2, 0, 1, 0, 12],
[2, 1, 0, 0, 1, 10],
[-4, -3, 0, 0, 0, 0]
])
fila_pivote, columna_pivote = encontrar_pivote(matriz_simplex_prueba)
print("Fila pivote:", fila_pivote)
print("Columna pivote:", columna_pivote)
3. Implementar en Python, Java o C++ una función que tome como entrada una fila pivote y
transforme su pivote al valor 1.
import numpy as np
def pivotar_fila(matriz, fila_pivote):
num_filas, num_columnas = matriz.shape
pivote = matriz[fila_pivote, fila_pivote]
la fila pivote
# Valor del pivote en
# Convertir el pivote a número de punto flotante
pivote = float(pivote)
# Dividir toda la fila pivote por el valor del pivote para hacerlo
igual a 1
matriz[fila_pivote, :] /= pivote
# Actualizar las otras filas
for i in range(num_filas):
if i != fila_pivote:
factor = matriz[i, fila_pivote] # Factor para hacer 0 en
la columna del pivote
matriz[i, :] -= factor * matriz[fila_pivote, :]
# Ejemplo de uso con una matriz de prueba
matriz_prueba = np.array([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
], dtype=float) # Convertir la matriz a números de punto flotante
fila_pivote = 1
pivote
# Por ejemplo, seleccionamos la fila 1 como fila
print("Matriz original:")
print(matriz_prueba)
pivotar_fila(matriz_prueba, fila_pivote)
print("\nMatriz después de pivotar la fila:")
print(matriz_prueba)
4. Implementar en Python, Java o C++ una función que tome como entrada una fila no pivote
y transforme su valor en columna pivote a 0.
import numpy as np
def hacer_cero_columna_pivote(matriz, fila_no_pivote, columna_pivote):
# Obtener dimensiones de la matriz
num_filas, num_columnas = matriz.shape
# Calcular el factor necesario para hacer 0 en la columna pivote
factor = matriz[fila_no_pivote, columna_pivote]
# Actualizar la fila no pivote
matriz[fila_no_pivote, :] -= factor * matriz[columna_pivote, :]
# Matriz de prueba
matriz_prueba = np.array([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
], dtype=float) # Convertir la matriz a números de punto flotante
fila_no_pivote = 2
no pivote
columna_pivote = 1
# Por ejemplo, seleccionamos la fila 2 como fila
#lo mismo pero 1 como fila no pivote
print("Matriz original:")
print(matriz_prueba)
hacer_cero_columna_pivote(matriz_prueba, fila_no_pivote,
columna_pivote)
print("\nMatriz después de hacer cero la columna pivote:")
print(matriz_prueba)
5. Resolver los problemas que contengan penalización M
EJERCICIO 4.11
𝑚𝑖𝑛𝑖𝑚𝑖𝑐𝑒𝑠𝑒: 𝑍 = 𝑋 + 2𝑌
con las condiciones:
𝑋 + 3𝑌 ≥ 11
2𝑋 + 𝑌 ≥ 9
con: X, Xy no negativas
Aplicábamos el uso de variables artificiales
𝑋 + 3𝑌 + 𝑠1 ≥ 11
2𝑋 + 𝑌 + 𝑠2 ≥ 9
Despejamos las variables artificiales
𝑠1 = 11 − 𝑋 − 3𝑌 + 𝑑1
𝑠2 = 9 − 2𝑋 − 𝑌 + 𝑑2
Juntamos los datos despejados en la función objetivo quedando de la siguiente manera:
𝑍 − 𝑋 − 2𝑌 − 𝑀(11 − 𝑋 − 3𝑌 + 𝑑1) − 𝑀(9 − 2𝑋 − 𝑌 + 𝑑2) = 0
Factorizamos la función objetivo quedando de la siguiente manera
𝑍 − 𝑋 − 2𝑌 − 𝑀(11 − 𝑋 − 3𝑌 + 𝑑1) − 𝑀(9 − 2𝑋 − 𝑌 + 𝑑2) = 0
Creamos la tabla simplex inicial con la penalización M
Z
1
0
0
X
-10M
1
2
Y
-8M
3
1
D1
-M
0
-1
D2
-M
-1
0
R1
0
1
0
R2
0
0
1
BETA
0
11
9
Ubicamos la columna y fila pivote
Z
1
0
0
X
-10M
1
2
Y
-8M
3
1
D1
-M
0
-1
D2
-M
-1
0
R1
0
1
0
R2
0
0
1
BETA
0
11
9
/1 = 11
/2 = 6
R2
0
0
1
R2
0
0
1/2
BETA
0
11
9
BETA
0
11
9/2
R2
0
0
1/2
R2
5M
-1/2
1/2
BETA
0
11
9/2
BETA
45
13/2
9/2
Como el elemento pivote es 2 es necesario convertirlo
Z
1
0
0
Z
1
0
0
1/2(F3)
X
-10M
1
2
X
-10M
1
1
Y
-8M
3
1
Y
-8M
3
1/2
D1
-M
0
-1
D1
-M
0
-1/2
D2
-M
-1
0
D2
-M
-1
0
R1
0
1
0
R1
0
1
0
Ahora se convierte en 0 los valores que están en la columna pivote
Z
10M(F3)+(F1) 1
F3(-1) +(F2)
0
0
Z
1
0
0
X
-10M
1
1
X
0
0
1
Y
-8M
3
1/2
Y
-3M
5/2
1/2
D1
-M
0
-1/2
D1
-6M
1/2
-1/2
D2
-M
-1
0
D2
-M
-1
0
R1
0
1
0
R1
0
1
0
Como todavía existen valores positivos en la función objetivo se vuelve a buscar cual es
la columna y fila pivote
Z
1
0
0
X
0
0
1
Y
-3M
5/2
1/2
D1
-6M
1/2
-1/2
D2
-M
-1
0
R1
0
1
0
R2
5M
-1/2
1/2
BETA
45
13/2
9/2
/1/2 = 13
/-1/2 = -9
Convertimos en 1 el elemento pivote
F2(2/1)
Z
1
0
0
Z
1
0
0
X
0
0
1
X
0
0
1
Y
-3M
5/2
1/2
Y
-3M
5
1/2
D1
-6M
1/2
-1/2
D1
-6M
1
-1/2
D2
-M
-1
0
D2
-M
-2
0
R1
0
1
0
R1
0
2
0
R2
5M
-1/2
1/2
R2
5M
-1
1/2
BETA
45
13/2
9/2
BETA
45
13
9/2
R2
5M
-1
1/2
R2
0
-1
0
BETA
45
13
9/2
BETA
-195/2
13
11
Convertimos los valores de la columna pivote en 0, saliendo lo siguiente
Z
F2(-1/6)*(F1) 1
0
F2(1/2) +(F3) 0
Z
1
0
0
X
0
0
1
X
0
0
1
Y
-3M
5
1/2
Y
-5M/2
5
1
D1
-6M
1
-1/2
D1
M
1
0
D2
-M
-2
0
D2
-M/3
-2
-2
R1
0
2
0
R1
0
2
2
EJERCICIO 4.14
𝑚𝑖𝑛𝑖𝑚𝑖𝑐𝑒𝑠𝑒: 𝑍 = 14𝑥 + 13𝑦 + 11𝑤 + 13𝑣 + 13𝑠 + 12𝑝
con las condiciones:
𝑥 + 𝑦 + 𝑤 = 1200
𝑣 + 𝑠 + 𝑝 = 1000
𝑥 + 𝑣 = 1000
𝑦 + 𝑠 = 700
𝑤 + 𝑝 = 500
con: todas las variables no negativas
Despejamos las variables artificiales
𝑠1 = 𝑥 + 𝑦 + 𝑤 + 1200
𝑠2 = 𝑣 + 𝑠 + 𝑝 + 1000
𝑠3 = 𝑥 + 𝑣 + 1000
𝑠4 = 𝑦 + 𝑠 + 700
𝑠5 = 𝑤 + 𝑝 + 500
Juntamos los datos despejados en la función objetivo quedando de la siguiente manera:
𝑍 − 14𝑋 − 13𝑌 − 11𝑊 − 13𝑉 − 13𝑆 − 12𝑃 − 𝑀(1200 + 𝑋 + 𝑌 + 𝑊)
− 𝑀(1000 + 𝑉 + 𝑆 + 𝑃) − 𝑀(1000 + 𝑋 + 𝑉) − 𝑀(700 + 𝑌 + 𝑆) − 𝑀(500
+ 𝑊 + 𝑃)
Factorizamos la función objetivo quedando de la siguiente manera
Z -X(1200M)-Y(1000M)-W(1000M)-V(700)-S(500M)-P(14M) = 0
Creamos la tabla simplex inicial con la penalización M
Z
1
0
0
0
0
0
X
1200M
1
0
1
0
0
Y
1000M
1
0
0
1
0
W
1000M
1
0
0
0
1
V
700M
0
1
1
0
0
S
500M
0
1
0
1
0
P
14M
0
1
0
0
1
s1
0
1
0
0
0
0
s2
0
0
1
0
0
0
s3
0
0
0
1
0
0
s4
0
0
0
0
1
0
s5
0
0
0
0
0
1
BETA
0
1200
1000
1000
700
500
Ubicamos la columna y fila pivote
Z
1
0
0
0
0
0
X
-1200M
1
0
1
0
0
Y
-1000M
1
0
0
1
0
W
-1000M
1
0
0
0
1
V
-700M
0
1
1
0
0
S
-500M
0
1
0
1
0
P
-14M
0
1
0
0
1
s1
0
1
0
0
0
0
s2
0
0
1
0
0
0
s3
0
0
0
1
0
0
s4
0
0
0
0
1
0
s5
0
0
0
0
0
1
BETA
0
1200
1000
1000
700
500
/0 = 0
/1 = 1000
/0 = 0
/0 = 0
/1= 500
s5
0
0
0
0
0
1
s5
0
0
0
0
0
1
BETA
0
1200
1000
1000
700
500
BETA
0
1200
0
1000
700
500
Como el elemento pivote es 1, no es necesario convertirlo
Z
F6(-1/14)*(F1) 1
0
(0)F6(F3)
0
0
0
0
Z
1
0
0
0
0
0
X
1200M
1
0
1
0
0
X
-600/7M
1
0
1
0
0
Y
1000M
1
0
0
1
0
Y
-500/7M
1
0
0
1
0
W
1000M
1
0
0
0
1
W
-500/7M
1
0
0
0
1
V
700M
0
1
1
0
0
V
-50M
0
0
1
0
0
S
500M
0
1
0
1
0
S
-250/7M
0
0
0
1
0
P
14M
0
1
0
0
1
P
M
0
0
0
0
1
s1
0
1
0
0
0
0
s1
0
1
0
0
0
0
s2
0
0
1
0
0
0
s2
0
0
0
0
0
0
s3
0
0
0
1
0
0
s3
0
0
0
1
0
0
s4
0
0
0
0
1
0
s4
0
0
0
0
1
0
CUESTIONARIO
1. ¿Qué es el Método Simplex?
El Método Simplex es un algoritmo utilizado para resolver problemas de programación
lineal, una técnica matemática que se emplea para encontrar la mejor solución posible en
situaciones en las que se busca maximizar o minimizar una función lineal sujeta a un
conjunto de restricciones lineales.
2. Describe los pasos del Método Simplex
• Formulación del problema de programación lineal:
• Crear la tabla Simplex inicial
• Evaluar la solución actual (pivote)
• Selección de la variable de salida
• Actualizar la tabla Simplex
• Repetir el proceso
• Solución óptima
3. ¿Qué opinas sobre el Método Simplex?
El Método Simplex es ampliamente reconocido como uno de los algoritmos más
efectivos y poderosos para resolver problemas de programación lineal.
III.
CONCLUSIONES
1. La principal ventaja de la penalización M es su capacidad para abordar problemas de
programación lineal que no tienen una solución factible inicial. Al agregar penalizaciones
a las restricciones y a la función objetivo, el algoritmo puede comenzar su búsqueda incluso
en situaciones donde no hay soluciones factibles.
2. El método Simplex con penalización M está diseñado para buscar soluciones factibles a
medida que avanza. La penalización incentiva al algoritmo a ajustar gradualmente las
variables de decisión y las restricciones para acercarse a una solución factible. Esto es
particularmente útil en problemas con restricciones no linealmente independientes.
IV.
REFERENCIAS
[1] TÉCNICAS DE LAS VARIABLES ARTIFICIALES. (s.f.). Instituto Tecnológico de La
Laguna. http://www.itlalaguna.edu.mx/2014/Oferta%20Educativa/Ingenierias/Industrial/Plan
%201997-2004/Invoperaciones1/u2c.html