Los resultados estáticos obtenidos a través de un método de solución son una fotografía, corresponden a la optimización de acuerdo a unos parámetros inalterables. Las preguntas que dan pie, tanto al análisis de sensibilidad como al análisis postóptimo son: ¿Qué pasaría si los valores de algunos parámetros cambian? ¿Cómo afecta esto a la solución óptima o la factibilidad del modelo? ¿Cómo afecta a las variables de decisión y/o la función objetivo?

Para responder a estas preguntas acudimos a los análisis complementarios: Sensibilidad y Postóptimo.

El análisis de sensibilidad determina las condiciones que mantendrán la solución actual sin cambios (desde el punto de vista geométrico, ya que es posible que la función objtivo y las variables de decisión cambien ante los cambios de los parámetros del modelo), mientras que el análisis postóptimo determina la nueva solución óptima cuando los datos del modelo cambian. Las tecnologías actuales, como Geogebra, han reducido la diferencia entre estos dos tipos de análisis, permitiendo una transición fluida desde el análisis de sensibilidad (indicadores lineales) hasta el análisis postóptimo mediante técnicas dinámicas.

Es importante destacar que, aunque el método gráfico es útil para comprender las relaciones en el sistema, existen otras herramientas más robustas, como la programación paramétrica con lenguajes de programación, que superan las limitaciones de la cantidad máxima de variables que puede manejar el método gráfico. Por lo tanto, el método gráfico puede ser una buena opción para visualizar los resultados, pero no es la herramienta más adecuada para un análisis exhaustivo y detallado de la sensibilidad.

Empezaremos por uno de los casos de análisis de sensibilidad más conocidos:

Cambios en el lado derecho de las restricciones

También conocido como «cambio en la disponibilidad de los recursos», este tipo de análisis de sensibilidad es técnicamente definido como «cambio en el lado derecho de las restricciones» y es uno de los más populares. Sin embargo, es importante destacar que las restricciones en un sistema no solo se relacionan con la disponibilidad de recursos, sino que también representan condiciones, relaciones y políticas que rigen al sistema en sí. Por lo tanto, denominar este tipo de análisis como «cambio en la disponibilidad de los recursos» puede generar ambigüedad y no reflejar completamente su alcance.

En palabras más sencillas: Vamos a explorar el impacto que tiene en los resultados del modelo de programación lineal, los cambios en el lado derecho de las restricciones. ¿Cambios en plural? Sí, lea la siguiente advertencia:

Los paradigmas de la enseñanza tradicional no paran ahí, también tenemos que:

Con el propósito de evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Investigación de Operaciones (9na edición), de Hamdy A. Taha (University of Arkansas, Fayetteville), (Ejemplo 3.6-1):

JOBCO fabrica dos productos en dos máquinas. Una unidad del producto 1 requiere 2 horas en la máquina 1, y 1 hora en la máquina 2. Una unidad del producto 2 requiere 1 hora en la máquina 1, y 3 horas en la máquina 2. Los ingresos por unidad de los productos 1 y 2 son de $30 y $20, respectivamente. El tiempo de procesamiento diario total disponible en cada máquina es de 8 horas.

Si x e y son las cantidades diarias de productos 1 y 2, respectivamente, el modelo se da como:

Zmax = 30x + 20y

Sujeto a:

2x + y <= 8 (Máquina 1)

x + 3y <= 8 (Máquina 2)

x, y >= 0 (No negatividad)

La solución de este modelo mediante método gráfico nos muestra lo siguiente:

Es decir que tenemos:

La pregunta que pretende responder este caso de análisis de sensibilidad es ¿Qué pasaría con estos resultados si cambia el lado derecho de algunas de sus restricciones? Propiamente, qué pasaría si aumenta o disminuye la disponibilidad de tiempo de alguna de las máquinas de acuerdo al caso planteado (máquina 1 / máquina 2).

Así que, vamos a formular específiamente la pregunta a resolver:

¿Qué pasaría con los resultados del modelo si el tiempo disponible de la máquina 1 aumenta en una hora?

Un cambio en la restricción supone un cambio en la representación gráfica de la misma, en consecuencia, debemos trazar la línea que representa la restricción ante este cambio de disponibilidad.

La representación gráfica de una línea requiere un mínimo de dos puntos. La representación gráfica de un punto requiere dos coordenadas; por lo tanto vamos a tabular las coordenadas necesarias (en la igualdad).

Así entonces, tenemos nuestras coordenadas:

Trazamos los puntos y la línea que representan a R1:

Trazar esta nueva restricción nos muestra que si desplazamos R1 hacia el lugar en el que se muestra R1′ (aumento de la disponibilidad del recurso), tendremos una nueva intersección óptima. Simplificando: El cambio en el lado derecho de esta restricción tendría un efecto sobre los resultados obtenidos inicialmente. ¿Cuál es este efecto? Para saberlo debemos hallar la nueva intersección.

Si usamos técnicas matemáticas, tendremos que recurrir a la solución de ecuaciones de 2 * 2. Se trata de encontrar la intersección entre R1′ y R2. Veamos el método de reducción / eliminación:

Si despejamos x = 3.8 en cualquiera de las restricciones tendremos el valor de y:

2(3.8) + y = 9

7.6 + y = 9

y = 9 – 7.6

y = 1.4

Por lo tanto tenemos las coordenadas del nuevo punto óptimo (3.8, 1.4):

Si evaluamos la función objetivo en este nuevo punto tendremos que:

Zmáx = 30(3.8) + 20(1.4)

Zmáx = 142

Podemos afirmar que un cambio en el lado derecho de la restricción 1 (tiempo disponible en horas de la máquina 1), tuvo un efecto en los resultados de la siguiente manera:

La diferencia en la función objetivo entre la solución nueva y la solución inicial ante un cambio unitario en el lado derecho de una restricción es un indicador lineal conocido como valor dual. En este caso, el valor dual es de 14 $/hora. Es decir, por cada hora que aumente la disponibilidad de la máquina 1, la utilidad se incrementará en $14. Del mismo modo funciona de manera inversa: Por cada hora que disminuya la disponibilidad de la máquina 1, la utilidad disminuirá en $14.

¿Este valor dual tiene validez ante cualquier cambio en este recurso? ¡No! Este indicador lineal tiene validez dentro de unos límites denominados límites de factibilidad.

¿Entonces es imposible calcular el impacto por fuera de los límites del valor dual? ¡No! La literatura invita a recalcular todo el modelo. Sin embargo, si utilizamos un software como Geogebra podemos calcular el impacto de un cambio por fuera de los límites de factibilidad:

Cambios en el lado derecho de las restricciones con Geogebra

Utilice los desplazadores para ver el impacto del cambio del lado derecho de las restricciones en los resultados del modelo.

De acuerdo a la representación gráfica de Geogebra vemos cómo podemos lograr conocer el impacto de cambios simultáneos en los lados derechos de las restricciones. También podemos validar el resutado obtenido manualmente, validar ese valor dual de $14 si aumentamos la disponibilidad de la máquina 1 a 9 horas y verificar, desde luego, que dicho impacto lineal no es ilimitado, ya que existen límites que abordaremos en un próximo post.

La entrada Cambios en el lado derecho de las restricciones (Método gráfico) se publicó primero en Ingenieria Industrial Online.

Casos especiales

Soluciones óptimas múltiples

En ocasiones, pueden existir múltiples soluciones que maximizan o minimizan la función objetivo de un modelo de programación lineal, es decir, múltiples soluciones óptimas. La elección de la solución en un contexto de aplicación práctico dependerá tanto de la sensibilidad de las restricciones activas como de los factores propios del sistema que no se consideran en un modelo matemático.

Por ejemplo, supongamos que tenemos el siguiente modelo de programación lineal:

La ebanistería «López S.A.S» ha recibido una gran cantidad de partes prefabricadas para la elaboración de mesas, pero no ha podido iniciar un plan de producción enfocado en ellas debido a la alta demanda de sus otros productos. Las mesas que se pueden elaborar con las partes prefabricadas son de dos modelos: A y B. Estas mesas solo requieren ser ensambladas y pintadas.

Esta semana se ha determinado dedicar 10 horas a ensamblar y 8 horas a pintar para elaborar la mayor cantidad de mesas posibles, teniendo en cuenta que cada mesa modelo A requiere 2 horas de ensamble y 1 hora de pintura, mientras que cada mesa modelo B requiere 1 hora de ensamble y 2 horas de pintura. Si el margen de utilidad es de $20000 por cada mesa modelo A y $10000 por cada mesa modelo B, determine el modelo de producción adecuado para esta semana.

Variables

x = Mesas modelo A a fabricar esta semana

y = Mesas modelo B a fabricar esta semana

Restricciones

2x + y <= 10        «Horas de ensamble»

x + 2y <= 8          «Horas de pintura»

x >= 0                  «No negatividad»

y >= 0                  «No negatividad»

Función objetivo

Zmax = 20000x + 10000y

Solución gráfica:

Como se puede observar, la región factible tiene dos vértices que maximizan la función Z: C(4,2) y D(6,0). Ambas soluciones son óptimas, ya que maximizan la función Z dentro de las restricciones del modelo. En este caso, la elección de la solución dependerá de factores propios del sistema que no se consideran en el modelo matemático, como por ejemplo la disponibilidad de recursos o el costo de producción; del mismo modo, sería conveniente evaluar la sensibilidad de las restricciones activas en cada vértice.

En este caso se da una condición particular, ya que los vértices son consecutivos. Esto implica que cada punto en el tramo que une a C y a D son soluciones óptimas.

Con la ayuda de GeoGebra, se puede mover la barra de desplazamiento que representa la utilidad y evaluar que la función objetivo alcanza el máximo de 100000 tanto en C como en D, así como en cualquier punto del tramo CD. Esto demuestra que en este caso existen múltiples soluciones óptimas y que cualquier punto en el tramo CD es una solución válida.

Solución óptima no acotada

Otra de las variantes que presentan los modelos de programación lineal es la solución óptima no acotada, es decir, problemas con infinitas soluciones óptimas. Dada la naturaleza finita de las restricciones en los contextos reales, estos problemas suelen deberse a un mal planteamiento de las restricciones, pero en el mundo académico es común evaluar este tipo de problemas.

Por ejemplo, supongamos que tenemos el siguiente modelo de programación lineal:

La compañía comercializadora de bebidas energéticas «WILD» está promocionando dos nuevas bebidas: la tipo A y la tipo B. Dado que se encuentran en promoción, se puede asegurar el cubrimiento de cualquier cantidad de demanda. Sin embargo, la empresa debe tener en cuenta dos políticas:

1. La cantidad de bebidas tipo A que se vendan no puede ser menor que la de tipo B.

2. Se deben vender por lo menos 1500 bebidas de cualquier tipo.

Estas políticas pueden ser representadas mediante restricciones en un modelo de programación lineal, que nos permitirá determinar la cantidad óptima de bebidas tipo A y B a vender en promoción.

El precio de venta de ambas bebidas es de $1800 por unidad

Variables

x = Bebidas tipo A a vender en promoción

y = Bebidas tipo B a vender en promoción

Restricciones

x >= y                     «Políticas de ventas»

x + y >= 1500          «Horas de pintura»

x >= 0                      «No negatividad»

y >= 0                      «No negatividad»

Función objetivo

Zmax = 1800x + 1800y

Solución gráfica:

Como se puede observar, la región factible no está acotada, lo que significa que el conjunto de posibles soluciones factibles es infinito. En consecuencia, la solución óptima tiende a infinito, lo que hace que el modelo no tenga solución.

En este caso, el problema planteado tiene un mal planteamiento de las restricciones, lo que ha llevado a una solución no acotada. Para solucionar este problema, es necesario ajustar las restricciones del modelo para que la región factible sea acotada y tenga una solución óptima finita.

Solución inviable o infactible

La solución infactible es un caso común en la programación lineal, y corresponde a aquellos casos en los que no existen soluciones que cumplan con todas las restricciones del modelo. Las restricciones acotan el sistema y establecen límites para alcanzar el objetivo del modelo. Cuando estas restricciones no se pueden cumplir en su totalidad, la solución es infactible.

En contexto de aplicación práctica, este caso es más común de lo que parece, y se da en escenarios en los que se plantean proporciones de oferta y demanda inviables en el modelo.

Por ejemplo, supongamos que tenemos el siguiente modelo de programación lineal:

La compañía de galletas «CAROLA» desea planificar la producción de galletas que deberá entregar a su cliente en dos semanas. Según el contrato, la empresa se compromete a entregar al menos 300 cajas de galletas, cualquiera sea su tipo (presentación D, presentación N o una combinación de ambas).

La producción de cada caja de galletas presentación D requiere 2 horas de elaboración y 3 horas de horneado, mientras que la producción de cada caja de presentación N requiere 3 horas de elaboración y 1 hora de horneado. La empresa cuenta con 550 horas para elaboración y 480 horas de horneado en las próximas dos semanas.

El margen de utilidad de cada caja de galletas presentación D es de $8500, y el margen de utilidad de cada caja de presentación N es de $8100. Para maximizar las utilidades, la empresa debe utilizar un modelo de programación lineal que le permita determinar el plan de producción adecuado.

Variables

x = Cajas de galletas de presentación D a producir en dos semanas

y = Cajas de galletas de presentación N a producir en dos semanas

Restricciones

2x + 3y <= 550               «Horas de elaboración»

3x + y <= 480                 «Horas de horneado»

x + y >= 300                   «Demanda según el contrato»

x >= 0                             «No negatividad»

y >= 0                             «No negatividad»

Función objetivo

Zmax = 8500x + 8100y

Solución gráfica:

La gráfica muestra el área sombreada que se delimita a partir de la representación de las restricciones que corresponden a los recursos de producción. Se puede apreciar cómo no existe una intersección entre las restricciones de capacidad y la restricción de demanda (sombreada de azul), lo que indica que no existen soluciones que cumplan con todas las restricciones del modelo. En este caso, se trata de una solución infactible.

Restricciones redundantes

Existen en los modelos de programación lineal un tipo de restricciones que no tienen ningún efecto en la determinación del conjunto solución (ni en la solución óptima). Estas restricciones se conocen como redundantes, ya que no afectan la solución del modelo.

En algunos casos, las restricciones redundantes pueden ser útiles para el análisis de sensibilidad, ya que nos permiten evaluar cómo cambia la solución óptima ante cambios en los valores de las restricciones. En lugar de eliminar estas restricciones, se pueden dejar en el modelo y marcar como inactivas. De esta manera, no afectan la solución óptima del modelo, pero se pueden utilizar para el análisis de sensibilidad.

Por ejemplo, supongamos que tenemos el siguiente modelo de programación lineal:

La compañía «CONGELADORES MAJO» se encuentra en la necesidad de planificar su producción semanal de congeladores tipo A y B. Cada uno de ellos requiere pasar por tres operaciones: Ensamblaje, pintura y control de calidad. Los congeladores tipo A requieren 2 horas de ensamblaje, 3 kg de pintura y 4 horas de control de calidad; los congeladores tipo B requieren 3 horas de ensamblaje, 6 kg de pintura y 5 horas de control de calidad. La compañía cuenta con un margen contributivo de $102000 y $98000 por cada congelador tipo A y B respectivamente. La disponibilidad semanal de recursos se encuentra limitada a 300 horas de ensamblaje, 840 kg de pintura y 450 horas de control de calidad. A partir de esta información, se debe determinar la cantidad de unidades a producir semanalmente de cada referencia, con el fin de maximizar las utilidades.

Variables

x = Congeladores tipo A a producir semanalmente

y = Congeladores tipo B a producir semanalmente

Restricciones

2x + 3y <= 300               «Horas de ensamblaje»

3x + 5y <= 840                «Kg de pintura»

4x + 5y <= 450                «Horas de control de calidad»

x >= 0                             «No negatividad»

y >= 0                             «No negatividad»

Función objetivo

Zmax = 102000x + 98000y

Solución gráfica:

La gráfica muestra cómo las restricciones 1 y 2 (Horas de ensamblaje y Kg de pintura) no determinan el conjunto solución. La solución se encuentra en el vértice C(112.5, 0), con una utilidad de $11475000.

Sin embargo, denominar las restricciones que no determinan el área de factibilidad ni el punto óptimo, como redundantes o sobrantes (o excluirlas del modelo), quizá no sea la manera correcta; preferiblemente denominar estas restricciones como inactivas. Supongamos que nos encontramos en un escenario en el cual evaluamos la posibilidad de aumentar la capacidad de la restricción 3 (horas de control de calidad); es fundamental reconocer los límites en los cuales dicho incremento de capacidad activaría las restricciones 1 y 2.

En resumen, los casos especiales en programación lineal pueden darse por una mala formulación de las restricciones, la presencia de soluciones infactibles o infinitas. Es importante considerar siempre todas las restricciones del modelo y utilizar el análisis de sensibilidad para evaluar su efecto en la solución óptima.

¡Si te ha gustado este artículo sobre casos especiales en programación lineal, ¡compartelo con tus contactos!

La entrada Casos especiales de programación lineal (Método Gráfico) se publicó primero en Ingenieria Industrial Online.

Quienes se adentren en los conceptos de la investigación de operaciones, propiamente en los conceptos de la programación lineal, deben considerar que existe algo más allá de la solución óptima. En investigación de operaciones, la solución de un modelo matemático establece una base para la toma de decisiones; sin embargo, puede considerarse como esencial el análisis de los resultados obtenidos.

Los resultados de un modelo de programación lineal pueden ofrecer mucha información adicional, inputs del análisis de resultados. Existen a grandes rasgos, dos tipos de análisis complementarios en PL:

En este artículo abordaremos el análisis de sensibilidad.

El análisis de sensibilidad en programación lineal corresponde al examen detallado de los límites dentro de los cuales los parámetros del modelo (recursos, utilidad o costo), pueden cambiar sin que esto afecte a la solución óptima y a la capacidad de calcular el impacto que tienen dichos cambios sobre la misma. Es decir, a partir de los resultados obtenidos de un modelo, podemos establecer una solución óptima y tenemos un rango en el cual podemos medir el impacto de los cambios en la disponibilidad de los recursos y los cambios en los coeficientes de la función objetivo. El análisis de dichas variaciones y el cálculo de los límites dentro de los cuales estas son válidas, es lo que se conoce como análisis de sensibilidad. Todo el análisis que se encuentre fuera de ese rango requeriría recalcular el modelo.

Como tal, constituye una herramienta importante en el análisis de los resultados obtenidos, sobre todo, en dos casos en particular:

1. La sensibilidad de la solución óptima ante los cambios de la disponibilidad de los recursos (lado derecho de las restricciones). Es decir, cuáles serían los límites dentro de los cuáles los resultados del modelo me permiten calcular el impacto que tiene sobre la solución óptima, el aumento o la disminución de la disponibilidad de un recurso.
2. La sensibilidad de la solución óptima ante los cambios en la utilidad unitaria o el costo unitario (coeficientes de las variables de la función objetivo). Es decir, cuáles serían los límites dentro de los cuáles los resultados del modelo me permiten calcular el impacto que tiene sobre la solución óptima, el aumento o la disminución de la utilidad unitaria o el costo unitario asociada a las variables que forman parte de la función objetivo.

Análisis de sensibilidad gráfica, caso 1: Cambios en el lado derecho (Disponibilidad de recursos)

Con el propósito de evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Investigación de Operaciones (9na edición), de Hamdy A. Taha (University of Arkansas, Fayetteville), (Ejemplo 3.6-1):

JOBCO fabrica dos productos en dos máquinas. Una unidad del producto 1 requiere 2 horas en la máquina 1, y 1 hora en la máquina 2. Una unidad del producto 2 requiere 1 hora en la máquina 1, y 3 horas en la máquina 2. Los ingresos por unidad de los productos 1 y 2 son de $30 y $20, respectivamente. El tiempo de procesamiento diario total disponible en cada máquina es de 8 horas.

Si x1 y x2 son las cantidades diarias de productos 1 y 2, respectivamente, el modelo se da como:

Zmax = 30x1 + 20x2

Sujeto a:

2x1 + x2 <= 8 (Máquina 1)

x1 + 3x2 <= 8 (Máquina 2)

x1, x2 >= 0 (No negatividad)

La forma en la que abordamos la solución gráfica de un modelo de programación lineal mediante Python, está ampliamente documentada. El código en Python que resuelve mediante método gráfico el problema anterior, lo presentamos a continuación:

# Caso JOBCO: Investigación de Operaciones (9na edición), de Hamdy A. Taha 
# (University of Arkansas, Fayetteville), (Ejemplo 3.6-1)
# Autor del código en Python: Bryan Salazar López, Ing. M.Sc. (2021)

#Librerías necesarias
import matplotlib.pyplot as plt
import numpy as np
from shapely.geometry import LineString

#Ecuaciones e intervalos (Para tabular)
x = np.arange(-20, 20, 5)
y = np.arange(-20, 20, 5)
y1 = 8 - (2 * x)
y2 = (8 - x) / 3
y3 = 0 * x
x1 = 0 * y
z = (-30 * x) / 20

#Identificadores para las líneas
primera_linea = LineString(np.column_stack((x, y1)))
segunda_linea = LineString(np.column_stack((x, y2)))
tercera_linea = LineString(np.column_stack((x, y3)))
cuarta_linea = LineString(np.column_stack((x1, y)))
quinta_linea = LineString(np.column_stack((x, z)))

#Graficando las líneas
plt.plot(x, y1, '-', linewidth=2, color='b')
plt.plot(x, y2, '-', linewidth=2, color='g')
plt.plot(x, y3, '-', linewidth=2, color='r')
plt.plot(x1, y, '-', linewidth=2, color='y')
plt.plot(x, z, ':', linewidth=1, color='k')


#Generando las intersecciones (vértices)
primera_interseccion = cuarta_linea.intersection(segunda_linea)
segunda_interseccion = primera_linea.intersection(segunda_linea)
tercera_interseccion = primera_linea.intersection(tercera_linea)
cuarta_interseccion = tercera_linea.intersection(cuarta_linea)
quinta_interseccion = cuarta_linea.intersection(primera_linea)
sexta_interseccion = segunda_linea.intersection(tercera_linea)

#Graficando los vértices
plt.plot(*primera_interseccion.xy, 'o', color='k')
plt.plot(*segunda_interseccion.xy, 'o', color='k')
plt.plot(*tercera_interseccion.xy, 'o', color='k')
plt.plot(*cuarta_interseccion.xy, 'o', color='k')
plt.plot(*quinta_interseccion.xy, 'o', color='silver')
plt.plot(*sexta_interseccion.xy, 'o', color='silver')

#Identificando los valores de las coordenadas x y y de cada vértice
xi1m, yi1m = primera_interseccion.xy
xi2m, yi2m = segunda_interseccion.xy
xi3m, yi3m = tercera_interseccion.xy
xi4m, yi4m = cuarta_interseccion.xy
xi5m, yi5m = quinta_interseccion.xy
xi6m, yi6m = sexta_interseccion.xy

#Cambiamos el formato de matriz a float
xi1 = np.float64(np.array(xi1m))
xi2 = np.float64(np.array(xi2m))
xi3 = np.float64(np.array(xi3m))
xi4 = np.float64(np.array(xi4m))
xi5 = np.float64(np.array(xi5m))
xi6 = np.float64(np.array(xi6m))
yi1 = np.float64(np.array(yi1m))
yi2 = np.float64(np.array(yi2m))
yi3 = np.float64(np.array(yi3m))
yi4 = np.float64(np.array(yi4m))
yi5 = np.float64(np.array(yi5m))
yi6 = np.float64(np.array(yi6m))

#literales de las intersecciones (nombres en el gráfico)
plt.annotate(' A', (xi4, yi4))
plt.annotate(' B', (xi1, yi1))
plt.annotate(' C', (xi2, yi2))
plt.annotate(' D', (xi3, yi3))
plt.annotate(' E', (xi5, yi5))
plt.annotate(' F', (xi6, yi6))

#Evaluando la función objetivo en cada vértice
FOi1 = (xi1 * 30) + (yi1 * 20)
FOi2 = (xi2 * 30) + (yi2 * 20)
FOi3 = (xi3 * 30) + (yi3 * 20)
FOi4 = (xi4 * 30) + (yi4 * 20)

#Calculando el mejor resultado (Maximizar)
ZMAX = max(FOi1, FOi2, FOi3, FOi4)

#Imprimiendo la solución óptima en la consola
print('\n SOLUCIÓN ÓPTIMA')
print('Solución óptima: {} '.format(ZMAX))

#Ordenando las coordenadas de los vértices (Las coordenadas x en m y las coordenadas y en n)
m = [xi1, xi2, xi3, xi4]
n = [yi1, yi2, yi3, yi4]

#Graficando el polígono solución a partir de las coordenadas de los vértices (importante el orden según las manecillas)
plt.fill(m, n, color='silver')

#Identificando el índice del vértice de la mejor solución
dict1 = {0:FOi1, 1:FOi2, 2:FOi3, 3:FOi4}
posicion = max(dict1, key=dict1.get)

#Obteniendo las coordenadas del vértice de la mejor solución de acuerdo al índice del paso anterior
XMAX = m[posicion]
YMAX = n[posicion]

#Imprimiendo las coordenadas del vértice de la mejor solución (variables de decisión)
print('\n VARIABLES DE DECISIÓN')
print('Cantidad de producto X1 a producir: {} unidades'.format(XMAX))
print('Cantidad de producto X2 a producir: {} unidades'.format(YMAX))

#Configuraciones adicionales del gráfico
plt.grid()
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('JOBCO')

plt.show()

Al ejecutar este código, de acuerdo a las instrucciones que pueden encontrar en el artículo de introducción al método gráfico mediante Python, obtendrán:

Así mismo, el siguiente resultado en la consola:

Así entonces, tenemos establecido el código base sobre el cual abordaremos este primer caso de análisis de sensibilidad: cambios en el lado derecho (disponibilidad de recursos).

La pregunta que pretende responder este caso de análisis de sensibilidad es ¿Qué pasaría con la función objetivo si cambia la disponibilidad de alguno de los recursos del problema? El cual corresponde a un planteamiento muy lógico de análisis, puesto que nos ampliaría la información relevante para la toma de decisiones.

Acercando este interrogante a nuestro problema de ejemplo, la cuestión podría ser: ¿Qué pasaría con los ingresos totales si la máquina 1 cambia su capacidad?

Pensemos por un momento cómo podemos abordar este planteamiento de manera gráfica, pensemos por un momento cómo podemos utilizar nuestro código base para abordar este caso.

Y bien, se nos puede ocurrir en primer lugar, graficar la nueva línea que represente la nueva función de disponibilidad de la máquina 1. Recordemos que si la restricción base es la siguiente:

2x1 + x2 <= 8 (Máquina 1)

Un incremento en la capacidad (variación), por ejemplo, se representaría mediante la siguiente inecuación:

2x1 + x2 <= 8 + 1

Esto quiere decir que, la nueva disponibilidad de la máquina 1 pasará de 8 horas a 9 horas. Y nuestro razonamiento nos indica que esta función, tendrá una representación distinta a la anterior, por ende sería de mucha utilidad graficarla. Veamos el código para adicionar en Python:

#Ecuaciones e intervalos (Para tabular)
x = np.arange(-20, 20, 5)
y = np.arange(-20, 20, 5)
y1 = 8 - (2 * x)
y2 = (8 - x) / 3
y3 = 0 * x
x1 = 0 * y
z = (-30 * x) / 20
y1v = (8 + 1) - (2 * x) #Variación en la máquina 1 (8 + 1)

#Identificadores para las líneas
primera_linea = LineString(np.column_stack((x, y1)))
segunda_linea = LineString(np.column_stack((x, y2)))
tercera_linea = LineString(np.column_stack((x, y3)))
cuarta_linea = LineString(np.column_stack((x1, y)))
quinta_linea = LineString(np.column_stack((x, z)))
sexta_linea = LineString(np.column_stack((x, y1v))) #Nueva línea

#Graficando las líneas
plt.plot(x, y1, '-', linewidth=2, color='b')
plt.plot(x, y2, '-', linewidth=2, color='g')
plt.plot(x, y3, '-', linewidth=2, color='r')
plt.plot(x1, y, '-', linewidth=2, color='y')
#plt.plot(x, z, ':', linewidth=1, color='k') #Podemos ocultar esta línea (FO)
plt.plot(x, y1v, ':', linewidth=1, color='b') #Nueva línea

Podemos observar cómo agregamos tan solo 3 líneas de código, mediante la inclusión de la variable y1v (variación de la ecuación de la máquina 1).

La ecuación con la cual se representa la restricción de la máquina 1 corresponde a la siguiente:

y1 = 8 – (2 * x)

Por ende, lo que hacemos es aumentar la capacidad de la máquina 1 (8) a una nueva capacidad (9 = 8 + 1):

y1v = (8 + 1) – (2 * x)

Las dos líneas de código adicionales graficarán esta nueva ecuación.

Al ejecutar nuestro código tendremos:

En este caso, podemos observar cómo una variación en la disponibilidad del recurso 1 (máquina 1), se representa con una línea recta (línea azul punteada) que conserva la misma pendiente de la restricción 1 (línea azul continua), que se mueve paralela a ella, y que en consecuencia, genera una nueva intersección solución (intersección con la restricción 2 – línea verde).

En este nuevo vértice solución se encuentra un nuevo punto óptimo, es decir, una coordenada diferente en la cual al evaluar la función objetivo, tendremos la respuesta al interrogante planteado: ¿Qué pasaría con los ingresos totales si la máquina 1 cambia su capacidad?

En consecuencia, utilizaremos nuestro código para:

El siguiente fragmento muestra detalladamente las adiciones al código base:

#Generando las intersecciones (vértices)
primera_interseccion = cuarta_linea.intersection(segunda_linea)
segunda_interseccion = primera_linea.intersection(segunda_linea)
tercera_interseccion = primera_linea.intersection(tercera_linea)
cuarta_interseccion = tercera_linea.intersection(cuarta_linea)
quinta_interseccion = cuarta_linea.intersection(primera_linea)
sexta_interseccion = segunda_linea.intersection(tercera_linea)
septima_interseccion = sexta_linea.intersection(segunda_linea) #Nuevo vértice

#Graficando los vértices
plt.plot(*primera_interseccion.xy, 'o', color='k')
plt.plot(*segunda_interseccion.xy, 'o', color='k')
plt.plot(*tercera_interseccion.xy, 'o', color='k')
plt.plot(*cuarta_interseccion.xy, 'o', color='k')
plt.plot(*quinta_interseccion.xy, 'o', color='silver')
plt.plot(*sexta_interseccion.xy, 'o', color='silver')
plt.plot(*septima_interseccion.xy, 'o', color='k') #Graficar nuevo vértice

#Identificando los valores de las coordenadas x y y de cada vértice
xi1m, yi1m = primera_interseccion.xy
xi2m, yi2m = segunda_interseccion.xy
xi3m, yi3m = tercera_interseccion.xy
xi4m, yi4m = cuarta_interseccion.xy
xi5m, yi5m = quinta_interseccion.xy
xi6m, yi6m = sexta_interseccion.xy
xi7m, yi7m = septima_interseccion.xy #Coordenadas del nuevo vértice

#Cambiamos el formato de matriz a float
xi1 = np.float64(np.array(xi1m))
xi2 = np.float64(np.array(xi2m))
xi3 = np.float64(np.array(xi3m))
xi4 = np.float64(np.array(xi4m))
xi5 = np.float64(np.array(xi5m))
xi6 = np.float64(np.array(xi6m))
xi7 = np.float64(np.array(xi7m)) #Nueva coordenada en x
yi1 = np.float64(np.array(yi1m))
yi2 = np.float64(np.array(yi2m))
yi3 = np.float64(np.array(yi3m))
yi4 = np.float64(np.array(yi4m))
yi5 = np.float64(np.array(yi5m))
yi6 = np.float64(np.array(yi6m))
yi7 = np.float64(np.array(yi7m)) #Nueva coordenada en y

#literales de las intersecciones (nombres en el gráfico)
plt.annotate(' A', (xi4, yi4))
plt.annotate(' B', (xi1, yi1))
plt.annotate(' C', (xi2, yi2))
plt.annotate(' D', (xi3, yi3))
plt.annotate(' E', (xi5, yi5))
plt.annotate(' F', (xi6, yi6)) 
plt.annotate(' G', (xi7, yi7)) #Nombrar el nuevo vértice como G

#Evaluando la función objetivo en cada vértice
FOi1 = (xi1 * 30) + (yi1 * 20)
FOi2 = (xi2 * 30) + (yi2 * 20)
FOi3 = (xi3 * 30) + (yi3 * 20)
FOi4 = (xi4 * 30) + (yi4 * 20)
FOi4 = (xi7 * 30) + (yi7 * 20) #Calcular la FO en el nuevo vértice

#Imprimiendo la solución óptima en la consola
print('\n SOLUCIÓN ÓPTIMA')
print('Solución óptima: {} '.format(ZMAX))
print('Función objetivo en punto G: {} '.format(FOi7)) #Mostrar la FO en el punto G

Lo que realizamos es muy sencillo, es decir, ya que tenemos una nueva línea, realizamos los mismos procedimientos para identificar y graficar el nuevo vértice generado. Al ejecutar el código obtendremos lo siguiente:

La figura 5 ilustra el cambio de la solución óptima cuando se cambia la capacidad de la máquina 1. Si la capacidad diaria se incrementa de 8 a 9 horas, el nuevo óptimo se moverá al punto G. Los resultados que se pueden apreciar en la consola, nos permiten conocer que el valor de la función objetivo evaluada en el punto G (z en G) equivale a 142,0. Es decir, un valor superior a 128,0 (z en C).

Con los datos obtenidos podemos establecer en este caso la tasa de cambio en la función objetivo a consecuencia del cambio de la capacidad de la máquina 1 de 8 a 9 horas. Esta tasa de cambio se denomina de diversas formas: valor unitario de un recurso (Taha); precio dual (múltiples solucionadores); shadow price (precio sombra).

Esta tasa representa el impacto del incremento unitario en la capacidad de un recurso en la función objetivo; se calcula de la siguiente manera:

En nuestro ejemplo se calculará así:

Esto indica que: Un incremento unitario en la capacidad de la máquina 1, aumentará el ingreso en $14,0. O lo que es igual: Una reducción unitaria en la capacidad de la máquina 1, reducirá el ingreso en $14,0.

En lo que concierne a nuestro código e Python, es sencillo, resulta que nosotros ya tenemos la función objetivo evaluada en cada uno de los vértices del gráfico. Así entonces, será cuestión de crear una nueva variable que represente el precio dual y la operación correspondiente:

#Precio dual (Restricción 1)
Dual1 = (FOi7 - ZMAX) #Calculamos el precio dual para la restricción 1

print('\n ANÁLISIS DE SENSIBILIDAD')
print('Precio dual de la máquina 1: {} $/h'.format(Dual1)) #Imprimimos el precio dual 1

Recordemos que la función objetivo del punto G (z en G) se representa por la variable FOi7 (función objetivo en la intersección 7). La operación efectúa la diferencia entre este valor y la función objetivo en el vértice óptimo base (ZMAX).

Al ejecutar el código obtendremos lo siguiente en la consola de Windows:

Ahora bien, debemos recordar que hemos hecho énfasis en que el análisis de sensibilidad del caso 1 (cambios en el lado derecho de las restricciones – capacidad de los recursos), precisa de unos límites dentro de los cuáles los resultados del modelo me permiten calcular el impacto que tiene sobre la solución óptima. Es decir, para nuestro caso en particular: los límites dentro de los cuales el precio dual para la máquina 1 es 14$/h. Dicho de otra manera, estamos en condiciones de calcular el impacto de una variación en la máquina 1 en los ingresos totales, pero, ¿Hasta cuándo esa proyección es válida? Y sí, existen unos límites dentro de los cuales nuestra proyección, tasa o precio dual es válido, por fuera de ellos, sería necesario recalcular.

Revisemos nuevamente la figura 4:

Veamos cómo la línea que representa los cambios en la capacidad de la máquina 1 (recurso) se mueve paralela a sí misma, y bien puede hacerlo sobre el segmento de la línea que representa la capacidad de la máquina 2 (línea verde, o algebraicamente: línea BF, desde el punto B hasta el punto F). Esa es básicamente la clave para determinar los límites de validez de nuestro precio dual, mejor conocidos como intervalos de factibilidad. Pero ¿Cuál es la clave? Sí, la ecuación de la máquina 1 puede moverse para formar una intersección con la línea verde (a medida que cambie su capacidad) entre B y F, de manera que en estos vértices se encuentran los límites. Y para ser directos, la idea consiste en calcular la capacidad de la máquina 1 en cada uno de estos vértices. ¿Cómo lo hacemos? Veamos:

La ecuación que representa la capacidad de la máquina 1 está dada por:

2x1 + x2 <= 8 horas (máquina 1)

Por ende, si retiramos el valor de la capacidad del recurso (8 horas), obtendremos la ecuación de la utilización o el uso del recurso:

2x1 + x2 = Utilización o uso de la máquina 1

Ahora, teniendo la ecuación de la restricción 1 (máquina 1), podemos evaluar cuál sería su utilización en los vértices B y F. Así encontraríamos los límites de validez para esta restricción (intervalos de factibilidad para nuestro precio dual = 14$/h). Dicho de otro modo, encontraríamos la capacidad mínima y máxima de la máquina 1, para que una variación unitaria en la disponibilidad de la misma (máquina 1), represente una variación de 14$ en la función objetivo. Por fuera de ese intervalo, no podemos asegurar de ninguna manera que el precio dual es de 14$/h, sería necesario recalcular.

Volvamos a la determinación de los límites. Ya tenemos la ecuación de la restricción (la verdad, siempre la hemos tenido), ahora la evaluaremos en los puntos B y F. Para ello es preciso conocer las coordenadas de cada uno de estos puntos. En Python podemos utilizar el siguiente fragmento:

#Intervalos de factibilidad
IFmin1 = (2 * xi2) + yi2
IFmax1 = (2 * xi6) + yi6

print('Límite mínimo de factibilidad (PD máquina 1): {} h'.format(IFmin1))
print('Límite máximo de factibilidad (PD máquina 1): {} h'.format(IFmax1))

Veamos: El punto B según nuestro código, corresponde a la segunda intersección, por ende sus coordenadas están definidas por las variables xi1 y yi1. Así entonces, evaluamos la capacidad de la máquina 1 en estas coordenadas y tenemos el límite mínimo de factibilidad para el precio dual de la máquina 1 (IFmin1).

Así mismo, el punto F según nuestro código, corresponde a la sexta intersección, por ende sus coordenadas están definidas por las variables xi6 y yi6. Así entonces, evaluamos la capacidad de la máquina 1 en estas coordenadas y tenemos el límite mínimo de factibilidad para el precio dual de la máquina 1 (IFmax1).

Al ejecutar el código obtendremos lo siguiente en la consola de Windows:

Podemos efectuar nosotros mismos los cálculos correspondientes:

El punto B tiene la siguientes coordenadas (x = 0, y = 2,67)

Evaluando estas coordenadas en la ecuación de la máquina 1, tenemos:

2(0)+ (2,67) = Límite mínimo de factibilidad (máquina 1)

2(0)+ (2,67) = 2,67 horas

El punto F tiene la siguientes coordenadas (x = 8, y = 0)

Evaluando estas coordenadas en la ecuación de la máquina 1, tenemos:

2(8)+ (0) = Límite máximo de factibilidad (máquina 1)

2(8)+ (0) = 16 horas

Ya efectuamos los procedimientos de manera manual y mediante Python. La conclusión es que el precio dual de $14/h permanece válido en el intervalo:

2,67 h <= Capacidad de la máquina 1 <= 16 h

Los cambios que se encuentren fuera de esos intervalos de factibilidad producen un precio dual diferente, y por lo tanto, precisan nuevos cálculos.

En nuestro código, incluiremos las líneas que permitan llegar al precio dual y a los intervalos de factibilidad de la máquina 2. Al ejecutarlo, obtendremos lo siguiente:

La conclusión es que el precio dual de $2/h permanece válido en el intervalo:

4 h <= Capacidad de la máquina 2 <= 24 h

Los precios duales y los intervalos de factibilidad amplían la base que ofrece la solución óptima para la toma de decisiones. Taha propone una serie de preguntas alrededor de este caso (ejercicio 3.6-1), que pueden ser abordadas gracias al análisis de sensibilidad.

Pregunta 1: Si JOBCO puede incrementar la capacidad de ambas máquinas, ¿Cuál máquina tendrá la prioridad?

Respuesta: De acuerdo a los precios duales para las máquinas 1 y 2, cada hora adicional de la máquina 1 incrementa el ingreso total en $14; mientras tanto, cada hora adicional de la máquina 2 incrementa el ingreso total en $2. Por lo tanto, la máquina 1 debe tener la prioridad.

Pregunta 2: Se sugiere incrementar las capacidades de las máquinas 1 y 2 al costo adicional de $10/h para cada máquina. ¿Es esto aconsejable?

Respuesta: De acuerdo a los precios duales para las máquinas 1 y 2.  Los ingresos netos adicionales por hora serían de la siguiente manera:

Máquina 1:

14$/h (Precio dual máquina 1) – 10$/h (Costo para aumentar capacidad) = 4 $/h (Ingreso neto)

Máquina 2:

2$/h (Precio dual máquina 2) – 10$/h (Costo para aumentar capacidad) = – 8 $/h (Ingreso neto)

Por consiguiente, solo la máquina 1 debe considerarse para el incremento de capacidad.

Pregunta 3: Si la capacidad de la máquina 1 se incrementa de 8 a 13 horas, ¿Cómo impactará este incremento al ingreso óptimo?

Respuesta: Lo primero que debe evaluarse es que la nueva capacidad de la máquina 1 se encuentre dentro del intervalo de factibilidad (2,67 h – 16 h). Ya que sí se encuentra en dicho intervalo (13 h), el siguiente paso consiste en calcular el cambio en la disponibilidad:

Cambio en la capacidad = 13 (Nueva capacidad) – 8 (Capacidad inicial)

Cambio en la capacidad = 5 horas

Por ende, multiplicamos dicho cambio por la tasa de cambio del ingreso (precio dual):

Cambio en el ingreso = Precio dual  * Cambio en la capacidad

Cambio en el ingreso = 14 $/h * (5 horas)

Cambio en el ingreso = 70 $

Nuevo ingreso = Ingreso base (Solución óptima) + Cambio en el ingreso

Nuevo ingreso = $ 128 + $ 70

Nuevo ingreso = $ 198

En el caso de que la nueva capacidad de la máquina se encuentre por fuera del intervalo de factibilidad para dicho recurso, no se dispondría de información suficiente para llegar a una conclusión válida.

A continuación, dejamos a disposición el código completo del análisis de sensibilidad gráfica desarrollado en Python:

# Caso 1: Investigación de Operaciones (9na edición), de Hamdy A. Taha 
# (University of Arkansas, Fayetteville), (Ejemplo 3.6-1)
# Autor del código en Python: Bryan Salazar López, Ing. M.Sc. (2021)

#Librerías necesarias
import matplotlib.pyplot as plt
import numpy as np
from shapely.geometry import LineString

#Ecuaciones e intervalos (Para tabular)
x = np.arange(-20, 20, 5)
y = np.arange(-20, 20, 5)
y1 = 8 - (2 * x)
y2 = (8 - x) / 3
y3 = 0 * x
x1 = 0 * y
z = (-30 * x) / 20
y1v = (8 + 1) - (2 * x) #Variación en la máquina 1 (8 + 1)
y2v = ((8 + 1) - x) / 3 #Variación en la máquina 2 (8 + 1)

#Identificadores para las líneas
primera_linea = LineString(np.column_stack((x, y1)))
segunda_linea = LineString(np.column_stack((x, y2)))
tercera_linea = LineString(np.column_stack((x, y3)))
cuarta_linea = LineString(np.column_stack((x1, y)))
quinta_linea = LineString(np.column_stack((x, z)))
sexta_linea = LineString(np.column_stack((x, y1v))) #Nueva línea Máquina 1 (M1)
septima_linea = LineString(np.column_stack((x, y2v))) #Nueva línea Máquina 2 (M2)

#Graficando las líneas
plt.plot(x, y1, '-', linewidth=2, color='b')
plt.plot(x, y2, '-', linewidth=2, color='g')
plt.plot(x, y3, '-', linewidth=2, color='r')
plt.plot(x1, y, '-', linewidth=2, color='y')
#plt.plot(x, z, ':', linewidth=1, color='k')
plt.plot(x, y1v, ':', linewidth=1, color='b') #Nueva línea M1
plt.plot(x, y2v, ':', linewidth=1, color='g') #Nueva línea M2


#Generando las intersecciones (vértices)
primera_interseccion = cuarta_linea.intersection(segunda_linea)
segunda_interseccion = primera_linea.intersection(segunda_linea)
tercera_interseccion = primera_linea.intersection(tercera_linea)
cuarta_interseccion = tercera_linea.intersection(cuarta_linea)
quinta_interseccion = cuarta_linea.intersection(primera_linea)
sexta_interseccion = segunda_linea.intersection(tercera_linea)
septima_interseccion = sexta_linea.intersection(segunda_linea) #Nuevo vértice M1
octava_interseccion = septima_linea.intersection(primera_linea) #Nuevo vértice M2

#Graficando los vértices
plt.plot(*primera_interseccion.xy, 'o', color='k')
plt.plot(*segunda_interseccion.xy, 'o', color='k')
plt.plot(*tercera_interseccion.xy, 'o', color='k')
plt.plot(*cuarta_interseccion.xy, 'o', color='k')
plt.plot(*quinta_interseccion.xy, 'o', color='silver')
plt.plot(*sexta_interseccion.xy, 'o', color='silver')
plt.plot(*septima_interseccion.xy, 'o', color='k') #Graficar nuevo vértice M1
plt.plot(*octava_interseccion.xy, 'o', color='k') #Graficar nuevo vértice M2

#Identificando los valores de las coordenadas x y y de cada vértice
xi1m, yi1m = primera_interseccion.xy
xi2m, yi2m = segunda_interseccion.xy
xi3m, yi3m = tercera_interseccion.xy
xi4m, yi4m = cuarta_interseccion.xy
xi5m, yi5m = quinta_interseccion.xy
xi6m, yi6m = sexta_interseccion.xy
xi7m, yi7m = septima_interseccion.xy #Coordenadas del nuevo vértice M1
xi8m, yi8m = octava_interseccion.xy #Coordenadas del nuevo vértice M2

#Cambiamos el formato de matriz a float
xi1 = np.float64(np.array(xi1m))
xi2 = np.float64(np.array(xi2m))
xi3 = np.float64(np.array(xi3m))
xi4 = np.float64(np.array(xi4m))
xi5 = np.float64(np.array(xi5m))
xi6 = np.float64(np.array(xi6m))
xi7 = np.float64(np.array(xi7m)) #Nueva coordenada en x (Máquina 1)
xi8 = np.float64(np.array(xi8m)) #Nueva coordenada en x (Máquina 2)
yi1 = np.float64(np.array(yi1m))
yi2 = np.float64(np.array(yi2m))
yi3 = np.float64(np.array(yi3m))
yi4 = np.float64(np.array(yi4m))
yi5 = np.float64(np.array(yi5m))
yi6 = np.float64(np.array(yi6m))
yi7 = np.float64(np.array(yi7m)) #Nueva coordenada en y (Máquina 1)
yi8 = np.float64(np.array(yi8m)) #Nueva coordenada en y (Máquina 2)

#literales de las intersecciones (nombres en el gráfico)
plt.annotate(' A', (xi4, yi4))
plt.annotate(' B', (xi1, yi1))
plt.annotate(' C', (xi2, yi2))
plt.annotate(' D', (xi3, yi3))
plt.annotate(' E', (xi5, yi5))
plt.annotate(' F', (xi6, yi6)) 
plt.annotate(' G', (xi7, yi7)) #Nombrar el nuevo vértice como G
plt.annotate(' H', (xi8, yi8)) #Nombrar el nuevo vértice como H

#Evaluando la función objetivo en cada vértice
FOi1 = (xi1 * 30) + (yi1 * 20)
FOi2 = (xi2 * 30) + (yi2 * 20)
FOi3 = (xi3 * 30) + (yi3 * 20)
FOi4 = (xi4 * 30) + (yi4 * 20)
FOi7 = (xi7 * 30) + (yi7 * 20) #Calcular la FO en el nuevo vértice G
FOi8 = (xi8 * 30) + (yi8 * 20) #Calcular la FO en el nuevo vértice H

#Calculando el mejor resultado (Maximizar)
ZMAX = max(FOi1, FOi2, FOi3, FOi4)

#Imprimiendo la solución óptima en la consola
print('\n SOLUCIÓN ÓPTIMA')
print('Solución óptima: {} '.format(ZMAX))
print('Función objetivo en punto G: {} '.format(FOi7))
print('Función objetivo en punto H: {} '.format(FOi8))

#Ordenando las coordenadas de los vértices (Las coordenadas x en m y las coordenadas y en n)
m = [xi1, xi2, xi3, xi4]
n = [yi1, yi2, yi3, yi4]

#Graficando el polígono solución a partir de las coordenadas de los vértices (importante el orden según las manecillas)
plt.fill(m, n, color='silver')

#Identificando el índice del vértice de la mejor solución
dict1 = {0:FOi1, 1:FOi2, 2:FOi3, 3:FOi4}
posicion = max(dict1, key=dict1.get)

#Obteniendo las coordenadas del vértice de la mejor solución de acuerdo al índice del paso anterior
XMAX = m[posicion]
YMAX = n[posicion]

#Imprimiendo las coordenadas del vértice de la mejor solución (variables de decisión)
print('\n VARIABLES DE DECISIÓN')
print('Cantidad de producto X1 a producir: {} unidades'.format(XMAX))
print('Cantidad de producto X2 a producir: {} unidades'.format(YMAX))

#Precio dual (Restricción 1)
Dual1 = (FOi7 - ZMAX) #Calculamos el precio dual para la restricción 1
Dual2 = (FOi8 - ZMAX) #Calculamos el precio dual para la restricción 1

#Imprimir los precios duales
print('\n ANÁLISIS DE SENSIBILIDAD')
print('Precio dual de la máquina 1: {} $/h'.format(Dual1)) #Imprimimos el precio dual 1
print('Precio dual de la máquina 2: {} $/h'.format(Dual2)) #Imprimimos el precio dual 2

#Intervalos de factibilidad (Máquina 1)
IFmin1 = (2 * xi1) + yi1
IFmax1 = (2 * xi6) + yi6

#Intervalos de factibilidad (Máquina 2)
IFmin2 = xi3 + (3 * yi3)
IFmax2 = xi5 + (3 * yi5)

#Imprimir los intervalos de factibilidad
print('\n INTERVALOS DE FACTIBILIDAD')
print('Límite mínimo de factibilidad (PD máquina 1): {} h'.format(IFmin1))
print('Límite máximo de factibilidad (PD máquina 1): {} h'.format(IFmax1))
print('Límite mínimo de factibilidad (PD máquina 2): {} h'.format(IFmin2))
print('Límite máximo de factibilidad (PD máquina 2): {} h'.format(IFmax2))


#Configuraciones adicionales del gráfico
plt.grid()
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('JOBCO')

plt.show()

En el próximo artículo desarrollaremos el segundo caso de análisis de sensibilidad: cambios en la utilidad unitaria o el costo unitario.

La entrada Análisis de sensibilidad gráfica mediante el uso de Python (Caso 1) se publicó primero en Ingenieria Industrial Online.

Tal como lo mencionamos en el artículo en el que abordamos inicialmente los pasos de resolución gráfica de los modelos de programación lineal; dada la limitación en la cantidad de variables que puede soportar el método gráfico (2 variables), y dada la forma manual de resolución del mismo, este es difícilmente útil en la práctica.

¿Por qué debería aprender a solucionar gráficamente un modelo de PL?

La solución gráfica de los modelos de programación lineal, puede proporcionar una perspectiva que permita un entendimiento más amplio de los métodos generales de resolución (método simplex o solucionadores). Del mismo modo, permite una mayor comprensión de los diversos elementos que componen un modelo de PL (dado su componente visual), siendo especialmente útil en el aprendizaje de diferentes tópicos como pueden ser: tipos de solución, tipos de restricciones y análisis de sensibilidad.

¿Solo puedo solucionar gráficamente un modelo de PL de manera manual?

Si bien hemos reconocido las bondades del aprendizaje de la solución gráfica, razón por la cual su enseñanza perdura en la academia; también hemos de reconocer que la naturaleza manual de sus cálculos y procedimientos gráficos, pueden hacer tedioso su aprendizaje.

Ahora bien, es preciso considerar que gran parte de los programas solucionadores de modelos PL cuentan con algún módulo gráfico interactivo (TORA, WinQSB, por ejemplo), que puede remplazar los procedimientos manuales. Así entonces, existen otras alternativas a los procedimientos y cálculos manuales, que permiten lograr un acercamiento más ágil al método de solución gráfica de PL.

Solución gráfica de programación lineal mediante Python

Ya hemos justificado de manera suficiente la permanencia del método gráfico en los programas de enseñanza de Investigación de Operaciones; sin embargo, es necesario reconocer la posibilidad actual de integrar diversas disciplinas a través de los procesos de aprendizaje que enriquezcan la formación en la materia.

El objetivo de este artículo consiste precisamente en abordar el método gráfico como alternativa de solución de modelos de programación lineal, al tiempo que generamos un código en Python (programación), que nos permita automatizar procedimientos gráficos y cálculos.

El propósito de integrar un lenguaje de programación como lo es Python, consiste en acercar a las personas a la posibilidad de integrar métodos tradicionales de la investigación de operaciones con herramientas tecnológicas vigentes. ¿Por qué Python? Porque es gratuito; está respaldado por los desarrollos de una gran comunidad (casi que existe una línea de código desarrollado para cada requerimiento); sus aplicaciones no se limitan a un área en concreto, y por lo tanto podemos integrar diversos desarrollos a nuestros métodos.

En síntesis, queremos aportar nuevas propuestas en la enseñanza de la investigación de operaciones a través de la programación.

Requisitos técnicos

Los requisitos técnicos varían de acuerdo a si queremos ejecutar los códigos en nuestro equipo, o si queremos utilizar un entorno colaborativo (recomendado).

Requisitos en nuestro equipo

Requisitos en un entorno colaborativo

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

Librerías necesarias

Con la instalación de los programas, o el uso de un entorno colaborativo, ya estamos listos para empezar a programar, sin embargo, cada desarrollo, por pequeño que este sea, tiene sus particularidades; y existen herramientas (librerías) que nos facilitan considerablemente nuestros desarrollos, de acuerdo a nuestras necesidades. Para colocarlo en perspectiva, piense en se teléfono celular, tenemos diferentes apps, cada una de ellas nos facilita algunas tareas, de acuerdo a nuestras necesidades; pues bien, así funcionan las librerías en Python.

El desarrollo que queremos lograr requiere de las siguientes librerías:

Instalar una librería en Python es muy sencillo, de ahí la importancia de contar con pip (paquetes de instalación). Pip nos permite instalar cualquier librería con un comando escrito en la Lista de comandos de Windows (CMD). Recuerde que si utiliza un entorno colaborativo, este incluye gran parte de las librerías necesarias.

Para instalar Numpy tan solo debemos escribir el siguiente comando en la lista de comandos: pip install numpy

Damos ENTER y veremos lo siguiente:

Así de sencillo es instalar una librería en Python.

Para instalar Matplotlib tan solo debemos escribir el siguiente comando en la lista de comandos: pip install matplotlib

Para instalar Shapely tan solo debemos escribir el siguiente comando en la lista de comandos: pip install Shapely

Así de sencillo es instalar librerías en Python. Con estas librerías estamos listos para crear nuestro desarrollo.

El problema

Un autobús que hace el recorrido Cali-Buga, ofrece asientos para fumadores al precio de 10.000 pesos y a no fumadores al precio de 6.000 pesos. Al no fumador se le deja llevar 50 Kg. de peso y al fumador 20 Kg. Si el autobús tiene 90 asientos y admite un equipaje de hasta 3.000 Kg. ¿Cuál ha de ser la oferta de asientos de la compañía para cada tipo de pasajeros, con la finalidad de optimizar el beneficio? Además, debe considerarse que por políticas de la empresa, deben ofrecerse cómo mínimo 10 asientos para pasajeros no fumadores.

Modelamiento mediante programación lineal

Variables

x: Cantidad de asientos reservados a fumadores.

y: Cantidad de asientos reservados a no fumadores.

Restricciones

20x + 50y <= 3000 (Equipaje permitido)

x + y <= 90 (Cantidad de asientos disponibles)

y >= 10 (Política de asientos mínimos para no fumadores)

y >= 0 (No negatividad)

x >= 0 (No negatividad)

Función objetivo 

z = 10000x + 6000y  (Maximizar)

Método gráfico mediante Python

Paso 1: Importar las librerías

El siguiente fragmento de código importa las librerías necesarias para nuestro desarrollo:

#Librerías necesarias
import matplotlib.pyplot as plt
import numpy as np
from shapely.geometry import LineString

Paso 2: Ecuaciones e intervalos

Para poder graficar las restricciones (paso esencial del método gráfico), es necesario representar las ecuaciones por medio de líneas en nuestra gráfica. Cada restricción estará representada por una línea recta. El paso que antecede trazar una línea recta consiste en la determinación de un mínimo de dos puntos que al unirse la conformen.

Cada punto en el plano cartesiano se encuentra conformado por una coordenada en x y una coordenada en y (en el caso que así definamos llamar a la abscisa y a la ordenada). Recordemos que a partir del modelo algebraico inicial, nuestras restricciones se encuentran representadas por ecuaciones. Así entonces, la tarea consiste en, a partir de una ecuación, obtener un conjunto mínimo de dos coordenadas.

Manualmente este proceso se realiza tabulando, es decir, despejando el valor de una de las variables de la ecuación, a partir de la asignación arbitraria de un valor a la variable restante.

La tarea que tenemos mediante la programación en Python consistirá entonces en automatizar este proceso.

Lo primero que debemos hacer es despejar cada una de las inecuaciones convertidas en ecuaciones del problema, para eso, en nuestro caso, vamos a despejar en función de y:

Por ejemplo, para nuestra primera restricción:

20x + 50y <= 3000 (Inecuación)

20x + 50y = 3000 (Ecuación)

y = (3000 – 20x) / 50 (Despejamos y)

y1 = (3000 – 20x) / 50 (Asignamos un identificador único a y)

Repetimos el procedimiento para nuestra segunda restricción:

x + y <= 90 (Inecuación)

x + y = 90 (Ecuación)

y = 90 – x (Despejamos y)

y2 = 90 – x (Asignamos un identificador único a y)

En el caso de la tercera restricción:

y >= 10 (Inecuación)

y = 10 (Ecuación)

En este caso, dado que la intención es graficar, es fundamental que cada ecuación contenga las dos variables. Dado que en la ecuación original la variable x no hace parte, podemos incluirla multiplicándola por 0. Es decir, para todos los valores que tome x la ecuación permanecerá inalterable.

y = 10 + (0 * x) (Ecuación, y ya se encuentra despejada)

y3 = 10 + (0 * x) (Asignamos un identificador único a y)

En el caso de la cuarta restricción:

y >= 0 (Inecuación)

y = 0 (Ecuación)

En este caso, dado que la intención es graficar, es fundamental que cada ecuación contenga las dos variables. Dado que en la ecuación original la variable x no hace parte, podemos incluirla multiplicándola por 0. Es decir, para todos los valores que tome x la ecuación permanecerá inalterable.

y = 0 * x (Ecuación, y ya se encuentra despejada)

y4 = 0 * x (Asignamos un identificador único a y)

Todas las ecuaciones anteriores tienen algo en común: Se encuentran despejadas para obtener el valor de y a partir de x, de manera que necesitamos alguna función que nos permita asignar diferentes valores a x en un rango dado. Para eso utilizaremos la función np.arange.

x = np.arange(-100, 150, 50)

Esta función permite asignar a x diferentes valores de acuerdo a unos argumentos dados (valor mínimo, valor máximo, intervalo o paso). Es decir que de acuerdo a la anterior línea de código, a la variable x le serán asignados diversos valores desde el valor -100 hasta el valor 150 con intervalos de 50. Así entonces, tomará los siguientes valores:

Dado que las ecuaciones que pretenden hallar y1, y2, y3 y y4 son dependientes de x, tomarán sus valores respectivos de acuerdo a los resultados de cada ecuación, para cada valor de x:

La última de nuestras restricciones (quinta restricción), está dada en función de hallar x a partir y, de manera que efectuamos la misma tarea en un sentido inverso:

x >= 0 (Inecuación)

x = 0 (Ecuación)

En este caso, dado que la intención es graficar, es fundamental que cada ecuación contenga las dos variables. Dado que en la ecuación original la variable y no hace parte, podemos incluirla multiplicándola por 0. Es decir, para todos los valores que tome y la ecuación permanecerá inalterable.

x = 0 * y (Ecuación, x ya se encuentra despejada)

x1 = 0 * y (Asignamos un identificador único a x)

En este caso, ya que requerimos que y tome diversos valores, utilizaremos la función np.arange.

y = np.arange(-100, 150, 50)

Esta función permite asignar a y diferentes valores de acuerdo a unos argumentos dados (valor mínimo, valor máximo, intervalo o paso). Es decir que de acuerdo a la anterior línea de código, a la variable y le serán asignados diversos valores desde el valor -100 hasta el valor 150 con intervalos de 50. Así entonces, tomará los siguientes valores:

Dada que nuestra quinta restricción pretende hallar x1 a partir de los valores de y, tendríamos lo siguiente:

Por último, consideramos la inclusión de la función objetivo, para ello:

10000x + 6000y = 0 (Ecuación)

y = (- 10000x) / 6000 (Despejamos y)

y5 = (- 10000x) / 6000 (Asignamos un identificador único a y)

En este caso, la función que ya asignamos a x (np.arange), nos prestará los valores necesarios para tabular y5.

Lo que hicimos hasta ahora consiste en explicar con alto grado de detalle la función de cada una las líneas del código que utilizaremos en Python. Todo lo anterior queda reducido al siguiente fragmento:

#Ecuaciones e intervalos (Para tabular)
x = np.arange(-100, 150, 50)
y1 = (3000 - (20 * x))/ 50
y2 = 90 - x
y3 = 10 + (0 * x)
y4 = 0 * x
y5 = (-10000 * x) / 6000
y = np.arange(-100, 150, 50)
x1 = 0 * y

Paso 3: Tabular coordenadas e identificar las líneas

En el paso anterior desarrollamos unas líneas de código que representan los cálculos correspondientes a cada una de las ecuaciones del modelo. Si bien con fines prácticos mostramos la forma en que se tabularían los datos, es hasta este paso en que la información se organiza en tablas (propiamente matrices de dos columnas: x y y). La información se organiza a partir de una instancia básica de la librería Numpy, tal como se explicará a continuación:

np.column_stack((x, y1))

Esta instancia tomará los valores del paso 1 y los tabulará en una matriz 2D (dos columnas). En este ejemplo:

El siguiente paso consiste en, a partir de una instancia básica de la librería Shapely, generar la línea correspondiente a cada ecuación de acuerdo al tabulado generado, tal como se aprecia a continuación:

LineString(np.column_stack((x, y1)))

LineString es una instancia de la librería Shapely que permite unir cada punto (coordenada), de manera que genera una línea. Ahora bien, cada línea de código deberá corresponder o asociarse a una variable única que nos permitirá identificar cada una de las líneas, por ejemplo:

primera_línea = LineString(np.column_stack((x, y1)))

Realizamos el mismo procedimiento para cada una de las líneas, siendo cuidadosos al momento de asignar las variables asociadas a cada una de las líneas:

#Identificadores para las líneas
primera_linea = LineString(np.column_stack((x, y1)))
segunda_linea = LineString(np.column_stack((x, y2)))
tercera_linea = LineString(np.column_stack((x, y3)))
cuarta_linea = LineString(np.column_stack((x1, y)))
quinta_linea = LineString(np.column_stack((x, y4)))
sexta_linea = LineString(np.column_stack((x, y5)))

Podemos observar como cada conjunto de variables corresponde estrictamente a cada una de las líneas asociadas a cada ecuación en particular.

Paso 4: Graficar las líneas

En este paso vamos a utilizar la librería Matplotlib para graficar nuestras líneas (ecuaciones).

Tipos de línea

Estilo de línea
–
– –
:
: –

El argumento linewidth determinará el grosor de la línea. Debemos considerar asignar las mismas variables que en el paso anterior.

#Graficando las líneas
plt.plot(x, y1, '-', linewidth=2, color='b')
plt.plot(x, y2, '-', linewidth=2, color='g')
plt.plot(x, y3, '-', linewidth=2, color='r')
plt.plot(x1, y, '-', linewidth=2, color='y')
plt.plot(x, y4, '-', linewidth=2, color='k')
plt.plot(x, z, ':', linewidth=1, color='k')

Ya en este paso tenemos lo suficiente para esbozar nuestras líneas, sin embargo es necesario crear algunas configuraciones generales de nuestra gráfica, y aunque estas líneas de código van al cierre, nos adelantaremos para ir conociendo la evolución parcial de nuestro desarrollo.

#Configuraciones adicionales del gráfico
plt.grid()
plt.xlabel('Asientos para fumadores')
plt.ylabel('Asientos para no fumadores')
plt.title('Método Gráfico')

plt.show()

Estos ajustes permiten asignar los títulos de los ejes, así como el título general del gráfico, así mismo especifica la función que permite que el resultado del código se muestre como imagen.

En este paso queremos ejecutar el código parcial. Nosotros utilizaremos Google Colaboratory, puedes ver la ejecución en nuestro cuaderno: Método Gráfico.

De manera que, de acuerdo al código ejecutado, nuestro programa es capaz de esbozar gráficamente cada una de nuestras ecuaciones sobre el plano cartesiano. Ya que incluso tenemos una representación de la función objetivo (línea punteada), e infiriendo el polígono factible (de acuerdo a la naturaleza de las restricciones: <= o >=), podemos geométricamente establecer cual es el vértice solución.

Ahora bien, podemos identificar que en la gráfica se pueden apreciar algunos polígonos, pero: ¿Cuál es nuestro polígono factible? Bien, para eso debemos considerar la naturaleza de las restricciones; en cuyo caso, cada línea trazada dividirá el cuadrante solución en dos semiplanos: uno a cada lado de la línea trazada. Solo una de estas dos mitades satisface cada desigualdad, de manera que debemos considerar si cada restricción es «menor o igual», «mayor o igual», o en su defecto «igual». Por ejemplo:

En la anterior gráfica (Figura 5) podemos observar la línea que representa la segunda restricción. Así mismo, podemos observar el concepto de semiplanos: A y B (Uno a cada lado de la línea trazada). Como se trata de una restricción «menor o igual» (líneas hacia abajo y hacia la izquierda); solo la mitad A satisface la desigualdad.

En este caso representamos con flechas el lado, es decir la mitad que divide cada línea trazada, en el cual se encuentran los valores que satisfacen cada restricción. Las restricciones «menores o igual» apuntarán sus flechas hacia abajo y/o a la izquierda; los «mayores o igual» apuntarán sus flechas hacia arriba y/o a la derecha. Así entonces encontramos con suma facilidad nuestro polígono factible (zona gris).

Paso 5: Determinar y graficar las intersecciones

Algunos textos, como por ejemplo Investigación de Operaciones de Taha, consideran que los dos pasos fundamentales de la solución gráfica consisten en: determinar el espacio de soluciones factibles y determinar la solución óptima entre todos los puntos localizados en el espacio de soluciones.

Consideremos que el área gris de la Figura 6 corresponde al polígono o espacio de soluciones factibles. Todos los puntos (coordenadas en x, y) que se encuentran en este espacio, satisfacen al mismo tiempo todas las restricciones del modelo. Los puntos que se encuentra fuera, satisfacen algunas o ninguna de las restricciones.

Ahora bien, la cantidad de puntos dentro del espacio de soluciones factibles es sumamente grande, sin embargo, hemos de recordar que este método se rige bajo criterios de optimización. En nuestro ejemplo, este criterio es: maximizar. Recordemos que en programación lineal, la solución óptima siempre está asociada con un punto de esquina o vértice del polígono factible. Y que estos vértices se generan en cada punto de intersección de dos o más líneas, es decir, en el punto en que se igualan dos o más ecuaciones.

Lo anterior es sumamente importante, ya que para efectos de nuestro desarrollo en Python, podemos utilizar alguna función básica que, dadas las líneas, nos represente las intersecciones. En la práctica, determinar el punto de intersección de dos líneas requiere de la solución de un sistema de ecuaciones de 2 x 2, ya sea por el método de sustitución, igualación, eliminación, etc.

En nuestro caso, vamos a utilizar la función intersection() de Python. Lo que debemos hacer es determinar que intersecciones queremos determinar y graficar. Por ejemplo:

Si queremos determinar la intersección de la línea amarilla (cuarta línea, así la nombramos en el paso anterior) y la línea azul (primera línea), debemos escribir el siguiente código:

primera_interseccion = cuarta_linea.intersection(primera_linea)

Esta línea de código creará una variable llamada primera_interseccion que estará definida por la intersección entre la cuarta línea y la primera línea. El siguiente fragmento creará las intersecciones restantes del polígono solución (consideramos que el orden es importante, así que las creamos de acuerdo a las manecillas del reloj).

#Generando las intersecciones (vértices)
primera_interseccion = cuarta_linea.intersection(primera_linea)
segunda_interseccion = primera_linea.intersection(segunda_linea)
tercera_interseccion = segunda_linea.intersection(tercera_linea)
cuarta_interseccion = tercera_linea.intersection(cuarta_linea)

El espacio de soluciones factibles tienen cuatro intersecciones, de acuerdo al código anterior quedan definidas de acuerdo a los nombres que le asignamos a las variables. Ahora, el paso siguiente consiste en graficar dichas restricciones.

Acá pueden encontrar el listado con los tipos de marcadores (símbolos) que pueden utilizar: marcadores pyplot. Nosotros utilizaremos un marcador en círculo (representado así en el código: «o»).

#Graficando los vértices
plt.plot(*primera_interseccion.xy, 'o', color='k')
plt.plot(*segunda_interseccion.xy, 'o', color='k')
plt.plot(*tercera_interseccion.xy, 'o', color='k')
plt.plot(*cuarta_interseccion.xy, 'o', color='k')

Así entonces, podemos ejecutar nuestro código (Método Gráfico) nuevamente y veremos:

Como podemos observar en la Figura 7, hemos logrado graficar los vértices del polígono factible.

Ahora es cuando debemos preguntarnos: ¿Qué más necesitamos? Pues bien, si bien gráficamente podemos determinar el vértice solución (basta con trasladar paralelamente la línea punteada hasta cada vértice e identificar en cual de ellos la línea no corta el polígono solución); sería importante determinar el valor de las coordenadas en cada uno de los vértices, ya que con ello podemos evaluar la ecuación de la función objetivo para cada punto de esquina.

Lo que necesitamos es el valor numérico de cada punto, y la verdad, ya lo tenemos dentro de nuestras variables; lo que debemos hacer es imprimirlo en la consola de Windows, para eso podemos utilizar el siguiente fragmento:

#Imprimiendo las coordenadas de los vértices en la consola
print('\n COORDENADAS DE LAS INTERSECCIONES')
print('Coordenadas de la primera intersección: {} '.format(primera_interseccion))
print('Coordenadas de la segunda intersección: {} '.format(segunda_interseccion))
print('Coordenadas de la tercera intersección: {} '.format(tercera_interseccion))
print('Coordenadas de la cuarta intersección: {} '.format(cuarta_interseccion))

Bien podíamos utilizar tan solo la función print() en su versión más simple, por ejemplo:

print(primera_interseccion)

Esto serviría para obtener el punto de la primera intersección con sus dos coordenadas (x, y). Sin embargo, hemos utilizado algún texto que identifique con precisión la información que estamos generando. En este caso utilizamos un poco de texto, dentro de las llaves {} el programa introducirá el valor de cada variable. Esta es una cuestión accesoria y de estilo, siéntanse libres de explorar con el código. Ejecutamos (Método Gráfico) y, junto a la imagen, tendremos el siguiente resultado:

De esta manera hemos obtenido los valores de los puntos de cada vértice.

Paso 6: Determinar la solución óptima

Básicamente el objetivo de la solución gráfica se logra en este paso, es decir, hallar la solución óptima en términos de la función objetivo y los valores de las variables de decisión. Con un poco de lógica podemos inferir que en el punto en el que estamos, esta es una cuestión sencilla. Lo único que debemos hacer es, de acuerdo a los valores de cada vértice, evaluar la ecuación de la función objetivo en cada uno de ellos, de manera que podamos determinar cual es el mejor resultado (de acuerdo al criterio de optimización, en este caso: maximizar).

Ya que nos encontramos trabajando en Python, es necesario aclarar que el valor de los vértices obtenidos corresponde a un formato de tipo point (punto), y que básicamente, no es posible operar cada una de las variables (x, y) que contiene sin antes extraerlas. Por esa razón, lo siguiente que debemos hacer es extraer el valor de cada variable contenida en cada punto de manera independiente:

#Identificando los valores de las coordenadas (x, y) de cada vértice
xi1m, yi1m = primera_interseccion.xy
xi2m, yi2m = segunda_interseccion.xy
xi3m, yi3m = tercera_interseccion.xy
xi4m, yi4m = cuarta_interseccion.xy

El anterior código acaba de generar un total de 8 variables, cada una de ellas contendrá la información correspondiente a la proyección de cada eje sobre cada punto, por ejemplo: xi1m contendrá la información correspondiente al valor que tienen el punto de la primera intersección sobre el eje x. Es decir, acabamos de extraer las variables x y y de cada uno de los puntos de intersección.

Sin embargo, ese valor extraído se encuentra en un formato de matriz y contiene más información que la que necesitamos, de hecho por eso le colocamos la letra m, para reconocer que es una matriz. Lo que debemos hacer es cambiar el formato de los valores extraídos. Formas existen muchas, nosotros utilizaremos la siguiente:

#Cambiamos el formato de la variable de matriz a real
xi1 = np.float64(np.array(xi1m))
xi2 = np.float64(np.array(xi2m))
xi3 = np.float64(np.array(xi3m))
xi4 = np.float64(np.array(xi4m))
yi1 = np.float64(np.array(yi1m))
yi2 = np.float64(np.array(yi2m))
yi3 = np.float64(np.array(yi3m))
yi4 = np.float64(np.array(yi4m))

float 64 es un formato que corresponde a números reales, es decir: números que pueden ser positivos o negativos con decimales. En este punto tenemos las variables correspondientes a cada uno de los valores de los vértices en los ejes x y y. Lo siguiente será evaluar la ecuación objetivo en cada uno de los vértices, es decir, en las coordenadas de cada intersección. Por ejemplo:

FOi1 = (xi1 * 10000) + (yi1 * 6000)

Creamos la variable FOi1, es decir: La función objetivo en la intersección 1 (vértice 1). La cual multiplicará los coeficientes de la ecuación objetivo por el valor de la variable xi1 y yi1, es decir, las coordenadas x y y en el vértice 1. En este caso, y ya que conocemos estos valores (los hemos impreso en la consola), generaría el siguiente resultado:

FOi1 = (0 * 10000) + (60 * 6000)

FOi1 = 360000

Lo que equivale a decir que el resultado de la función objetivo en el vértice 1 es igual a 360.000. Así entonces, generamos el fragmento de código de estas ecuaciones y variables, así como las funciones que permitan que estos valores se impriman en la consola:

#Evaluando la función objetivo en cada vértice
FOi1 = (xi1 * 10000) + (yi1 * 6000)
FOi2 = (xi2 * 10000) + (yi2 * 6000)
FOi3 = (xi3 * 10000) + (yi3 * 6000)
FOi4 = (xi4 * 10000) + (yi4 * 6000)

#Imprimiendo las evaluaciones de la FO en cada vértice (Consola)
print('\n EVALUACIÓN DE LA FO EN LOS VÉRTICES')
print('Función objetivo en la intersección 1: {} pesos'.format(FOi1))
print('Función objetivo en la intersección 2: {} pesos'.format(FOi2))
print('Función objetivo en la intersección 3: {} pesos'.format(FOi3))
print('Función objetivo en la intersección 4: {} pesos'.format(FOi4))

Ejecutamos nuestro código (Método Gráfico), y tendremos, además de la gráfica, el siguiente resultado:

A esta altura debemos suponer que estamos muy cerca de lograr que nuestro desarrollo determine, según el criterio de optimización, la solución óptima. Ya que tenemos los valores de la función objetivo en cada uno de los vértices, será cuestión de determinar su valor máximo o mínimo, según se el caso. En nuestro problema, requerimos determinar el valor máximo; para eso utilizamos una función básica de Python:

ZMAX = max(FOi1, FOi2, FOi3, FOi4)

Creamos la variable ZMAX, es decir: La variable que contendrá el valor máximo entre las variables que contienen los valores de la función objetivo en cada vértice. Así entonces obtendremos de una muy sencilla, nuestra solución óptima. El siguiente código creará la variable y la función que permitirá que se imprima dicho resultado en la consola:

#Calculando el mejor resultado (Maximizar)
ZMAX = max(FOi1, FOi2, FOi3, FOi4)

#Imprimiendo la solución óptima en la consola
print('\n SOLUCIÓN ÓPTIMA')
print('Solución óptima: {} pesos'.format(ZMAX))

Ejecutamos nuestro código (Método Gráfico) y tendremos, además de la gráfica, el siguiente resultado:

En este punto nuestro desarrollo permite que obtengamos, además de la gráfica, la solución óptima. ¿Qué más podemos necesitar? Pues bien, necesitamos como mínimo imprimir el valor de las variables de decisión, es decir, el valor de las coordenadas x y y en el vértice donde se encuentra la solución óptima (punto óptimo). En Python pueden existir muchas alternativas para obtener esta información, nosotros utilizaremos el concepto de directorio.

Lo primero que vamos a hacer es organizar la información, es decir, crear un vector que almacene los valores de cada variable (sea x o y) en todos los vértices, por ejemplo:

m = [xi1, xi2, xi3, xi4]

El vector m contendrá los valores (ordenados) de las variables x en cada uno de los vértices, empezando por el vértice 1 y finalizando en el vértice 4. Lo mismo realizamos con las variables y.

n = [yi1, yi2, yi3, yi4]

En este punto, y con la información tal cual como tenemos organizada, podemos realizar un pequeño aporte al gráfico: rellenar nuestro polígono solución. Para eso, utilizamos una función llamada fill, y nuestros vectores recién creados:

plt.fill(m, n, color=’silver’)

Esta función utiliza los vectores m y n para crear un relleno en el gráfico al desplazarse por los puntos de los vectores (coordenadas), en sentido de las manecillas del reloj. Es decir, iniciará en el vértice 1 y finalizará en el vértice 4. Además, hemos especificado que el color de este relleno sea silver:

#Ordenando las coordenadas de los vértices (Las coordenadas x en m y las coordenadas y en n)
m = [xi1, xi2, xi3, xi4]
n = [yi1, yi2, yi3, yi4]

#Graficando el polígono solución a partir de las coordenadas de los vértices 
plt.fill(m, n, color='silver')

Ejecutamos nuestro código (Método Gráfico) y tendremos la siguiente gráfica:

Ahora podemos apreciar el espacio de soluciones factibles desde la gráfica que nos exporta el programa.

Volvamos a nuestro directorio. Lo que vamos a hacer es crear un arreglo con las variables que contienen los resultados de las funciones objetivo (FOi1, FOi2, FOi3 y FOi4), y a cada uno le asignaremos un índice de acuerdo a su orden (ya veremos para qué). Por ejemplo:

dict1 = {0:FOi1, 1:FOi2, 2:FOi3, 3:FOi4}

Así entonces, a cada variable le asignamos un número inicia en 0 y finaliza en 3 (ya veremos para qué). La variable dict hace referencia a nuestro directorio, y dentro de él se encuentra el arreglo con nuestros índices.

Lo siguiente que haremos es extraer el índice, no la variable de este arreglo, de acuerdo al mayor valor de la variable, no del índice. Es decir, una función que evalúe las variables de las funciones objetivo, y en lugar de devolvernos dicho valor, nos traiga el índice que tiene al lado. Nosotros de antemano conocemos que el mayor valor es el de FOi3, por esta razón, la función debe arrojarnos como respuesta el índice 2 (2:FOi3). ¿Por qué no iniciamos desde 1 y sí desde 0? En Python, las posiciones dentro de un arreglo inician desde 0.

La siguiente función nos traerá el índice de acuerdo al mayor valor de la variable:

posicion = max(dict1, key=dict1.get)

Creamos la variable posicion y en ella se almacenará el índice asociado al mayor valor de la variable del arreglo. ¿Y esto para qué nos sirve? Pues bien, recuerdan que tenemos un par de vectores donde se almacenan las variables x y y de cada uno de los vértices (y que hicimos énfasis en ordenarlos). Con la variable posicion podemos acceder a la variable específica dentro de estos vectores, es decir, a la posición en la que se encuentra cada una de las variables asociadas al vértice solución. ¿Podemos plantearlo de una manera más sencilla? Vamos a intentarlo:

Según de la manera ordenada en la que hemos venido trabajando el código, podemos inferir que si la función objetivo solución se encuentra en la variable FOi3 sus coordenadas serán xi3 y y13. Así entonces, si tenemos la posición de la función objetivo dentro de un arreglo (dict1), esa misma posición corresponderá a la de cada variable dentro del vector que la contenga (el vector m contiene las variables x de los vértices, mientras el vector n contiene las variables y de los vértices).

Así entonces, el valor de las coordenadas del vértice solución la obtenemos de la siguiente forma:

XMAX = m[posicion] YMAX = n[posicion]

La variable XMAX tomará el valor de la variable x que se encuentra en el vector m en la posición de la variable posicion. Es decir, corresponderá al valor de la variable x en el vértice solución. Veamos:

#Identificando el índice del vértice de la mejor solución
dict1 = {0:FOi1, 1:FOi2, 2:FOi3, 3:FOi4}
posicion = max(dict1, key=dict1.get)

#Obteniendo las coordenadas del vértice de la mejor solución de acuerdo al índice
XMAX = m[posicion]
YMAX = n[posicion]

#Imprimiendo las coordenadas del vértice de la mejor solución (variables de decisión)
print('\n VARIABLES DE DECISIÓN')
print('Cantidad de asientos a reservar para fumadores: {} '.format(XMAX))
print('Cantidad de asientos a reservar para no fumadores: {} '.format(YMAX))

En el anterior fragmento, bien pudimos utilizar la función print(XMAX) de una manera sencilla. Sin embargo, le dimos un formato que permitiera darle un nombre a las variables de acuerdo al problema (variables de decisión).

Ejecutamos nuestro código y tendremos, además de la gráfica, el siguiente resultado en la consola:

En este punto podemos decir que nuestro código tiene la capacidad de esbozar una solución gráfica del problema de programación lineal. Al mismo tiempo nos permite obtener información básica relevante.

Podemos hacer algunos ajustes accesorios, todos a elección del desarrollador. En este caso, vamos a agregar un par de líneas de código que permitan adicionar al gráfico un par de anotaciones con las coordenadas del vértice solución y el valor la solución óptima. Veamos:

#Generando las anotaciones de las coordenadas y solución óptima en el gráfico
plt.annotate('  X: {0} / Y: {1} (Coordenadas)'.format(XMAX, YMAX), (XMAX, YMAX))
plt.annotate('  Solución óptima: {}'.format(ZMAX), (XMAX, YMAX+3))

Ejecutamos nuestro código (Método Gráfico) y tendremos la siguiente gráfica:

También podemos eliminar las líneas rectas, para ello anteponemos # en la línea que ordena imprimir cada una de las ecuaciones. Ejecutamos (Método Gráfico) y tendremos:

Así entonces, hemos finalizado con la construcción de nuestro código para efectuar una solución gráfica de un modelo de programación lineal. Este puede, con ligeras modificaciones, ajustarse a cualquier problema susceptible de ser solucionado mediante método gráfico.

El código completo de nuestro desarrollo lo presentamos a continuación. También puedes ver el cuaderno de este módulo en nuestro Colaboratory: Método Gráfico.

#Autor: Bryan Salazar López, Ing. M.Sc. (2021)
#Librerías necesarias
import matplotlib.pyplot as plt
import numpy as np
from shapely.geometry import LineString

#Ecuaciones e intervalos (Para tabular)
x = np.arange(-100, 150, 50)
y = np.arange(-100, 150, 50)
y1 = (3000 - (20 * x))/ 50
y2 = 90 - x
y3 = 10 + (0 * x)
x1 = 0 * y
y4 = 0 * x
z = (-10000 * x) / 6000

#Identificadores para las líneas
primera_linea = LineString(np.column_stack((x, y1)))
segunda_linea = LineString(np.column_stack((x, y2)))
tercera_linea = LineString(np.column_stack((x, y3)))
cuarta_linea = LineString(np.column_stack((x1, y)))
quinta_linea = LineString(np.column_stack((x, y4)))
sexta_linea = LineString(np.column_stack((x, z)))

#Graficando las líneas
plt.plot(x, y1, '-', linewidth=2, color='b')
plt.plot(x, y2, '-', linewidth=2, color='g')
plt.plot(x, y3, '-', linewidth=2, color='r')
plt.plot(x1, y, '-', linewidth=2, color='y')
plt.plot(x, y4, '-', linewidth=2, color='k')
plt.plot(x, z, ':', linewidth=1, color='k')

#Generando las intersecciones (vértices)
primera_interseccion = cuarta_linea.intersection(primera_linea)
segunda_interseccion = primera_linea.intersection(segunda_linea)
tercera_interseccion = segunda_linea.intersection(tercera_linea)
cuarta_interseccion = tercera_linea.intersection(cuarta_linea)

#Graficando los vértices
plt.plot(*primera_interseccion.xy, 'o')
plt.plot(*segunda_interseccion.xy, 'o')
plt.plot(*tercera_interseccion.xy, 'o')
plt.plot(*cuarta_interseccion.xy, 'o')

#Imprimiendo las coordenadas de los vértices en la consola
print('\n COORDENADAS DE LAS INTERSECCIONES')
print('Coordenadas de la primera intersección: {} '.format(primera_interseccion))
print('Coordenadas de la segunda intersección: {} '.format(segunda_interseccion))
print('Coordenadas de la tercera intersección: {} '.format(tercera_interseccion))
print('Coordenadas de la cuarta intersección: {} '.format(cuarta_interseccion))

#Identificando los valores de las coordenadas x y y de cada vértice
xi1m, yi1m = primera_interseccion.xy
xi2m, yi2m = segunda_interseccion.xy
xi3m, yi3m = tercera_interseccion.xy
xi4m, yi4m = cuarta_interseccion.xy

#Cambiamos el formato de matriz a float
xi1 = np.float64(np.array(xi1m))
xi2 = np.float64(np.array(xi2m))
xi3 = np.float64(np.array(xi3m))
xi4 = np.float64(np.array(xi4m))
yi1 = np.float64(np.array(yi1m))
yi2 = np.float64(np.array(yi2m))
yi3 = np.float64(np.array(yi3m))
yi4 = np.float64(np.array(yi4m))

#Evaluando la función objetivo en cada vértice
FOi1 = (xi1 * 10000) + (yi1 * 6000)
FOi2 = (xi2 * 10000) + (yi2 * 6000)
FOi3 = (xi3 * 10000) + (yi3 * 6000)
FOi4 = (xi4 * 10000) + (yi4 * 6000)

#Imprimiendo las evaluaciones de la FO en cada vértice (Consola)
print('\n EVALUACIÓN DE LA FO EN LOS VÉRTICES')
print('Función objetivo en la intersección 1: {} pesos'.format(FOi1))
print('Función objetivo en la intersección 2: {} pesos'.format(FOi2))
print('Función objetivo en la intersección 3: {} pesos'.format(FOi3))
print('Función objetivo en la intersección 4: {} pesos'.format(FOi4))

#Calculando el mejor resultado (Maximizar)
ZMAX = max(FOi1, FOi2, FOi3, FOi4)

#Imprimiendo la solución óptima en la consola
print('\n SOLUCIÓN ÓPTIMA')
print('Solución óptima: {} pesos'.format(ZMAX))

#Ordenando las coordenadas de los vértices (Las coordenadas x en m y las coordenadas y en n)
m = [xi1, xi2, xi3, xi4]
n = [yi1, yi2, yi3, yi4]

#Graficando el polígono solución a partir de las coordenadas de los vértices 
plt.fill(m, n, color='silver')

#Identificando el índice del vértice de la mejor solución
dict1 = {0:FOi1, 1:FOi2, 2:FOi3, 3:FOi4}
posicion = max(dict1, key=dict1.get)

#Obteniendo las coordenadas del vértice de la mejor solución de acuerdo al índice
XMAX = m[posicion]
YMAX = n[posicion]

#Imprimiendo las coordenadas del vértice de la mejor solución (variables de decisión)
print('\n VARIABLES DE DECISIÓN')
print('Cantidad de asientos a reservar para fumadores: {} '.format(XMAX))
print('Cantidad de asientos a reservar para no fumadores: {} '.format(YMAX))

#Generando las anotaciones de las coordenadas y solución óptima en el gráfico
plt.annotate('  X: {0} / Y: {1} (Coordenadas)'.format(XMAX, YMAX), (XMAX, YMAX))
plt.annotate('  Solución óptima: {}'.format(ZMAX), (XMAX, YMAX+3))


#Configuraciones adicionales del gráfico
plt.grid()
plt.xlabel('Asientos para fumadores')
plt.ylabel('Asientos para no fumadores')
plt.title('Método Gráfico')

plt.show()

En artículos posteriores abordaremos Análisis de sensibilidad en la solución gráfica mediante Python, y evaluaremos la pertinencia de la misma.

La entrada Método gráfico de la programación lineal mediante el uso de Python se publicó primero en Ingenieria Industrial Online.

En artículos anteriores hemos mencionado la diferencia existente entre programación lineal (PL) y programación lineal entera (PLE). Recordamos entonces que, cuando un modelo presenta todas sus variables enteras, se denomina puro. En caso contrario, cuando utiliza una combinación de variables enteras y continuas, se denomina mixto, constituyendo un modelo de programación lineal mixta.

En materia de optimización lineal, la programación lineal mixta, lógicamente, aborda la mayor cantidad de casos de aplicación práctica. En la medida en que se consideren la mayor cantidad de variables que representen mediante un modelo de optimización, la realidad; es potencialmente adecuado, hacer uso de modelos de programación mixta.

Por ejemplo, pensemos en la producción de televisores, es posible que en un modelo lineal queramos representar por medio de una variable entera, la cantidad de unidades producidas; ahora bien, también es posible que queramos representar por medio de una variable continua, el tiempo empleado en la fabricación. En este escenario, requerimos de programación lineal mixta.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools para abordar problemas de programación lineal mixta (optimización lineal mixta). 

OR-Tools proporciona una herramienta principal para resolver este tipo de problemas de optimización:

El problema

En el artículo de introducción (programación lineal), abordamos un caso descrito en el libro Applied Mathematical Programming, de Bradley, Hax, and Magnanti (Addison-Wesley, 1977), del MIT (Cápitulo 2 página 50). Con fines prácticos, hemos adaptado dicho problema, incorporando nuevas restricciones y modificando algunos datos del modelo original, con el propósito de evidenciar la diferencia en los resultados obtenidos por medio del uso de variables continuas, enteras y mixtas.

El propietario de una tienda que produce remolques para automóviles desea determinar la mejor combinación para sus tres productos: remolques de plataforma plana, remolques económicos y remolques de lujo. Su taller se limita a trabajar 24 días al mes en el trabajo de los metales y 60 días al mes en el trabajo de la madera para estos productos.

Existe un contrato vigente, mediante el cual, el propietario deberá entregar como mínimo 4 remolques tipo económico cada mes.

La siguiente tabla indica los datos de producción de los remolques.

Modelamiento del problema

Sean las variables de decisión del problema:

x₀ = Número de remolques de plataforma plana producidos por mes

x₁ = Número de remolques económicos producidos por mes

x₂ = Número de remolques de lujo producidos por mes

Suponiendo que los costos de la capacidad de trabajo en metal y madera sean fijos, el problema se convierte en un problema de maximización:

Zmax = 6x₀ + 14x₁ + 13x₂

Sujeto a las siguientes restricciones de capacidad:

0,6x₀ + 2x₁ + x₂ <= 24,

x₀ + 2x₁ + 4x₂ <= 60,

Sujeto a la siguiente restricción de demanda mínima (contrato)

x₁ >= 4

Sujeto a las siguientes restricciones de no-negatividad:

x₀ >= 0,

x₁ >= 0,

x₂ >= 0,

Podemos, del mismo modo, establecer un par de variables que correspondan a las horas ociosas para las dos tareas establecidas (metal y madera):

x₃ = Número de horas ociosas en el trabajo en metal al mes,

x₄ = Número de horas ociosas en el trabajo en madera al mes,

Reescribimos las restricciones (adicionando las variables de horas ociosas). Podemos observar que las inecuaciones ahora serán igualdades, para que de esta forma ahora podamos tener información relacionada a los recursos. En otras palabras, lo que se utiliza (horas productivas) + lo que sobre (horas ociosas) = tiempo disponible:

0,6x₀ + 2x₁ + x₂ + x₃ = 24,

x₀ + 2x₁ + 4x₂ + x₄ = 60,

x₀ >= 0,

x₁ >= 0,

x₂ >= 0,

x₃ >= 0,

x₄ >= 0,

Así entonces, tenemos el problema completamente modelado.

Resolución del modelo mediante Google OR-Tools

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, en esta ocasión, haremos uso del lenguaje de programación Python.

Paso 1: Importar la librería

El siguiente fragmento de código importa las librerías necesarias:

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

Paso 2: Declarar el solucionador

El siguiente fragmento de código declara el solucionador SCIP (Solving Constraint Integer Programs), un solucionador de código abierto disponible que permite resolver problemas lineales mixtos (Google OR-Tools posee múltiples solucionadores):

solver = pywraplp.Solver.CreateSolver('SCIP')

Paso 3: Crear las variables del modelo

El siguiente fragmento de código permite crear las variables del modelo. La sintaxis permite declarar la naturaleza de cada una de las variables y el rango de valores permitidos (restricciones de no-negatividad).

    x0 = solver.IntVar(0, solver.infinity(), 'x0')
    x1 = solver.IntVar(0, solver.infinity(), 'x1')
    x2 = solver.IntVar(0, solver.infinity(), 'x2')
    x3 = solver.NumVar(0, solver.infinity(), 'x3')
    x4 = solver.NumVar(0, solver.infinity(), 'x4')

A partir de la declaración de estas variables, el modelo corresponde a un problema de programación lineal mixta.

Paso 4: Definir las restricciones del modelo

El siguiente fragmento de código define las restricciones del modelo:

    # Restricción 0: 0.6x0 + 2x1 + x2 + x3 = 24. (horas metales)
    solver.Add(0.6 * x0 + 2 * x1 + x2 + x3 == 24.0)

    # Restricción 1: x0 + 2x1 + 4x2 + x4 = 60. (horas madera)
    solver.Add(x0 + 2 * x1 + 4 *x2 + x4 == 60.0)

    # Restricción 3: x1 >= 4. (demanda mínima)
    solver.Add(x1 >= 4.0)

Paso 5: Definir la función objetivo del modelo

El siguiente fragmento de código define la función objetivo del modelo:

    # Función objetivo (max): 6x0 + 14x1 + 13x2
    solver.Maximize(6 * x0 + 14 * x1 + 13 * x2)

Paso 6: Invocar el solucionador

El siguiente fragmento de código sirve para invocar el solucionador del modelo:

status = solver.Solve()

Paso 7: Definir las salidas del solucionador

    if status == pywraplp.Solver.OPTIMAL:
        print('Solución:')
        print('Valor objetivo =', solver.Objective().Value())
        print('Número de remolques de plataforma plana producidos por mes =', x0.solution_value())
        print('Número de remolques económicos producidos por mes =', x1.solution_value())
        print('Número de remolques de lujo producidos por mes =', x2.solution_value())
        print('Número de horas ociosas en el trabajo en metal al mes =', x3.solution_value())
        print('Número de horas ociosas en el trabajo en madera al mes =', x4.solution_value())
    else:
      if status == solver.FEASIBLE:
        print('Se encontró una solución potencialmente subóptima.')
      else:
        print('El problema no tiene solución óptima.')

    # Información avanzada del solucionador

    print('\nUso avanzado:')
    print('Problema resuelto en %f milisegundos' % solver.wall_time())
    print('Problema resuelto en %d iteraciones' % solver.iterations())

Es posible que el desarrollo de los siete pasos anteriores demande algún grado de complejidad subyacente del uso de un lenguaje de programación; sin embargo, es preciso mencionar que, el modelo anterior queda perfectamente configurado, y puede replicarse con modificaciones menores en múltiples problemas de optimización lineal.

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo, así mismo debemos contar con la última versión del comando pip y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

El código completo de nuestro desarrollo lo presentamos a continuación. También puedes ver el cuaderno de este módulo en nuestro Colaboratory: Programación Lineal Mixta.

#Adaptado de: Bradley, Hax, and Magnanti, 'Applied Mathematical Programming', Chapter 2
#Nuevo caso y modelo: Salazar, ingenieriaindustrialonline.com (Programación lineal mixta)

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

def LinearProgrammingExample():
    solver = pywraplp.Solver.CreateSolver('SCIP')

    x0 = solver.IntVar(0, solver.infinity(), 'x0')
    x1 = solver.IntVar(0, solver.infinity(), 'x1')
    x2 = solver.IntVar(0, solver.infinity(), 'x2')
    x3 = solver.NumVar(0, solver.infinity(), 'x3')
    x4 = solver.NumVar(0, solver.infinity(), 'x4')

    print('Número de variables =', solver.NumVariables())

    # Restricción 0: 0.5x0 + 2x1 + x2 + x3 = 24.
    solver.Add(0.6 * x0 + 2 * x1 + x2 + x3 == 24.0)

    # Restricción 1: x0 + 2x1 + 4x2 + x4 = 60.
    solver.Add(x0 + 2 * x1 + 4 *x2 + x4 == 60.0)

    # Restricción 3: x1 >= 4.
    solver.Add(x1 >= 4.0)

    print('Número de restricciones =', solver.NumConstraints())

    # Función objetivo (max): 6x0 + 14x1 + 13x2
    solver.Maximize(6 * x0 + 14 * x1 + 13 * x2)

    # Declarar el solucionador.
    status = solver.Solve()

    # Declarar las salidas del solucionador
    if status == pywraplp.Solver.OPTIMAL:
        print('Solución:')
        print('Valor objetivo =', solver.Objective().Value())
        print('Número de remolques de plataforma plana producidos por mes =', x0.solution_value())
        print('Número de remolques económicos producidos por mes =', x1.solution_value())
        print('Número de remolques de lujo producidos por mes =', x2.solution_value())
        print('Número de horas ociosas en el trabajo en metal al mes =', x3.solution_value())
        print('Número de horas ociosas en el trabajo en madera al mes =', x4.solution_value())
    else:
      if status == solver.FEASIBLE:
        print('Se encontró una solución potencialmente subóptima.')
      else:
        print('El problema no tiene solución óptima.')

    # Información avanzada del solucionador

    print('\nUso avanzado:')
    print('Problema resuelto en %f milisegundos' % solver.wall_time())
    print('Problema resuelto en %d iteraciones' % solver.iterations())

LinearProgrammingExample()

Al ejecutar nuestro desarrollo en Colaboratory, tenemos:

Hemos modificado la naturaleza de las variables con el objetivo de mostrar los resultados a partir de tres escenarios: variables mixtas, enteras y continuas:

El anterior, es un problema lineal que representa un caso sencillo, sin embargo, los resultados obtenidos presentan variaciones menores de acuerdo a la naturaleza de las variables consideradas.

Sin embargo, en modelos robustos, estas variaciones pueden ser considerables y determinantes. Por tal razón, la programación lineal mixta ofrece la posibilidad de modelar variables cuya naturaleza refleje con precisión la realidad que se pretende representar.

Ahora bien, el modelo de optimización lineal mixta y el script del solucionador quedaron desarrollados en un lenguaje de programación estándar y ampliamente utilizado. Desde luego, las posibilidades de integrar datos de entrada y procesar los datos de salidas son interesantes. Por ejemplo, es posible desarrollar un script mediante el cual el código ya desarrollado tome los datos de entrada desde un archivo de Excel, o desde un servidor externo.

También, es posible desarrollar una interfaz amigable desde la cual se ingrese la información; o vincular los datos de salida con algún modelo o documento determinado.

La entrada Programación lineal mixta con Google OR-Tools se publicó primero en Ingenieria Industrial Online.

Ahora bien, existen innumerables casos de aplicación práctica en los cuales las soluciones fraccionarias no se ajustan a la realidad y debemos considerar el uso de variables enteras, así entonces, tendremos un modelo de programación lineal entera (PLE). Por ejemplo, pensemos en la producción de lápices, es posible que queramos determinar la producción en términos de unidades de producto, no tanto así de fracciones.

Es preciso mencionar que, cuando un modelo presenta todas sus variables enteras, se denomina puro. En caso contrario, cuando utiliza una combinación de variables enteras y continuas, se denomina mixto, y se abordará mediante programación lineal mixta.

Ciertamente, en la práctica, los solucionadores de modelos de optimización han abordado la naturaleza de las variables brindando relativa facilidad; es decir, podemos cambiar el tipo de variable entre continua y entera de una manera muy sencilla, sin que esto afecte considerablemente el modelo.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools para abordar problemas de programación lineal entera (optimización lineal entera). 

OR-Tools proporciona dos herramientas principales para resolver este tipo de problemas de optimización:

El problema

Con el propósito de evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Investigación de Operaciones (9na edición), de Hamdy A. Taha (University of Arkansas, Fayetteville), (Conjunto de problemas 9.1A – Problema 3).

Suponga que tiene 7 botellas de vino llenas, 7 a la mitad y 7 vacías. Le gustaría dividir las 21 botellas entre tres individuos de modo que cada uno reciba exactamente 7. Además, cada individuo debe recibir la misma cantidad de vino. Exprese el problema como restricciones del PLE, y halle una solución. TAHA

Modelamiento del problema

El problema plantea un caso de asignación, en el cual debemos determinar la cantidad de botellas de cada tipo (llenas, medias y vacías), asignadas a cada uno de un conjunto de 3 individuos (1, 2 y 3). Por lo tanto, las variables de decisión se definirán de la siguiente manera:

x_ij = Cantidad de botellas de tipo i asignadas al individuo j

i = {0 = Llena; 1 = Media; 2 = Vacía}

j = {0 = Individuo 1; 1 = individuo 2; 2 = individuo 3}

Donde todos los x_ij son enteros no negativos. (Ya que queremos determinar cantidad de botellas, es decir que las variables de decisión no están formuladas en función del contenido).

Este modelo puede abordar las restricciones de volumen de líquido (contenido igual para todos los individuos), por medio de coeficientes de contenido, o, definiendo que el contenido corresponde a una variable, la cual debe declararse de igual forma. Ya que el contenido que se encuentra en una botella llena, por ejemplo, es el mismo sea asignado a cualquier individuo, la manera más simple de abordarlo es por medio de coeficientes.

En la formulación del modelo de Python lo abordaremos por medio de variables con fines prácticos.

La función objetivo es artificial, dado que el modelo no pretende maximizar o minimizar algún factor. Por lo tanto podemos utilizar cualquier coeficiente, por ejemplo cero.

Zmax = 0x₀₀ + 0x₀₁  +  0x₀₂  + 0x₁₀ + 0x₁₁  +  0x₁₂  + 0x₂₀ + 0x₂₁  +  0x₂₂  

Sujeto a las siguientes restricciones:

x₀₀ + x₀₁  +  x₀₂  = 7

x₁₀ + x₁₁  +  x₁₂  = 7

x₂₀ + x₂₁  +  x₂₂  = 7

Las anteriores restricciones limitan la disponibilidad de botellas de cada tipo. Es decir, por ejemplo, la sumatoria de botellas llenas enviadas a los individuos 1, 2 y 3 deberá ser igual a 7; así mismo para el restante tipo de botellas.

x₀₀ + x₁₀  +  x₂₀  = 7

x₀₁ + x₁₁  +  x₂₁  = 7

x₀₂ + x₁₂  +  x₂₂  = 7

Las anteriores restricciones indican que cada individuo deberá recibir exactamente 7 botellas sin importar el tipo de las mismas. Es decir, por ejemplo, la sumatoria de botellas tipo 0, 1 y 2 enviadas al individuo 0, deberá ser igual a 7; así mismo para los individuos restantes.

Respecto a las restricciones de contenido, que limitarán el modelo para que cada individuo reciba la misma cantidad de vino, podemos realizar una operación previa, en la cual determinemos la cantidad total de vino disponible.

Vino disponible = 1( 7 botellas llenas) + 0,5( 7 botellas medias)

Vino disponible = 10,5 

Así entonces, para que a cada individuo le corresponda la misma cantidad de vino en la distribución de botellas, deberá dividirse el vino disponible entre el total de individuos.

Vino para cada individuo = (10,5 / 3) = 3,5

Así entonces, las restricciones de equidad en la distribución (contenido) serán las siguientes:

x₀₀ + 0,5x₁₀   = 3,5

x₀₁ + 0,5x₁₁  = 3,5

x₀₂ + 0,5x₁₂  = 3,5

Así entonces, tenemos el problema completamente modelado.

Resolución del modelo mediante Google OR-Tools

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, en esta ocasión, haremos uso del lenguaje de programación Python.

Paso 1: Importar la librería

El siguiente fragmento de código importa las librerías necesarias:

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

Paso 2: Declarar el solucionador

El siguiente fragmento de código declara el solucionador SCIP (Solving Constraint Integer Programs), un solucionador de código abierto disponible (Google OR-Tools posee múltiples solucionadores):

solver = pywraplp.Solver.CreateSolver('SCIP')

Paso 3: Crear la data del modelo

El siguiente fragmento de código crea la data del modelo. En este caso, la matriz de contenido de las botellas distribuidas a los 3 individuos (matriz 3 x 3).

# Crear la data del modelo de asignación
contenido = [
    [  1,   1,   1],
    [0.5, 0.5, 0.5],
    [  0,   0,   0],
]
num_botellas = len(contenido)
num_individuos = len(contenido[0])

Paso 4: Crear las variables del modelo

El siguiente fragmento crea las variables del modelo mediante un bucle (Hace uso número de botellas y el número de individuos), definiendo las variables x [i, j]. Así mismo, se declara el rango de valores que pueden tomar las variables, del mismo modo su naturaleza: variables enteras (solver.IntVar). Esta declaración sustituye las restricciones de no-negatividad (0, solver.infinity()), es decir, mayores a cero.

  x = {}
  for i in range(num_botellas):
      for j in range(num_individuos):
          x[i, j] = solver.IntVar(0, solver.infinity(), '')

Paso 5: Definir las restricciones del modelo

El siguiente fragmento de código define las restricciones del modelo mediante bucles:

# Restricciones de disponibilidad de botellas de cada tipo = 7
# Para cada i (tipo de botella), suma sus posibles variaciones de j (individuos)
# Por ejemplo, siendo i = 0, sumará X00 + X01 + X02, esta sumatoria
# deberá ser igual a 7 (botellas disponibles de cada tipo)
  for i in range(num_botellas):
      solver.Add(solver.Sum([x[i, j] for j in range(num_individuos)]) == 7)
# Restricciones de cantidad de botellas asignadas a cada individuo
# Para cada j (individuo), suma sus posibles variaciones de i (tipos de botella)
# Por ejemplo, siendo j = 0, sumará X00 + X10 + X20, esta sumatoria
# deberá ser igual a 7 (botellas asignadas a un individuo sin importar el tipo)
  for j in range(num_individuos):
      solver.Add(solver.Sum([x[i, j] for i in range(num_botellas)]) == 7)
# Restricciones de equidad en la distribución (utiliza la matriz de contenido)
# Para cada j (individuo), suma los productos de las posibles
# variaciones de i (tipo de botella) por sus coeficientes de contenido
# Por ejemplo, siendo j = 0 y C[i][j] equivalente al contenido
# de una botella tipo i entregado a un individuo tipo j
# sumará (C00 * X00) + (C10 * X10) + (C20 * X20), los valores de C[i][j]
# los tomará de la matriz de contenido. Esta sumatoria
# deberá ser igual a 3,5 (distribución equitativa por individuo)
  for j in range(num_individuos):
      solver.Add(solver.Sum([contenido[i][j] * x[i, j] for i in range(num_botellas)]) == 3.5)

Paso 6: Definir la función objetivo del modelo

El siguiente fragmento de código define la función objetivo del modelo. Consideremos que no es importante el criterio de la función, tampoco existe un costo asociado a las variables de decisión. Sin embargo, formularemos una función objetivo basada en bucles (utilizando la matriz de contenido), la cual quizá puede ser de utilidad en modelamientos futuros. Los coeficientes de las variables de decisión se basarán en la matriz de contenido (contenido[i][j]).

# Función objetivo
  objective_terms = []
  for i in range(num_botellas):
      for j in range(num_individuos):
          objective_terms.append(contenido[i][j] * x[i, j])
  solver.Maximize(solver.Sum(objective_terms))

Paso 7: Invocar el solucionador

El siguiente fragmento de código sirve para invocar el solucionador del modelo:

status = solver.Solve()

Paso 8: Definir las salidas del solucionador

# Configura los parámetros de impresión, las salidas del modelo
botellas_ind0 = 0
botellas_ind1 = 0
botellas_ind2 = 0  
if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
      print('Puntaje total = ', solver.Objective().Value(), '\n')
      for i in range(num_botellas):
          for j in range(num_individuos):
              # Test if x[i,j] is 1 (con tolerancia de punto flotante)
              if x[i, j].solution_value() > 0.5:
                print('Botellas del tipo %d asignadas al individuo %d.  Cantidad = %d' %
                          (i, j, x[i, j].solution_value()))
      for i in range(num_botellas):
          botellas_ind0 = x[i, 0].solution_value() + botellas_ind0
      for i in range(num_botellas):
          botellas_ind1 = x[i, 1].solution_value() + botellas_ind1
      for i in range(num_botellas):
          botellas_ind2 = x[i, 2].solution_value() + botellas_ind2
  print('Número de botellas asignadas al individuo 0:', botellas_ind0)
  print('Número de botellas asignadas al individuo 1:', botellas_ind1)
  print('Número de botellas asignadas al individuo 2:', botellas_ind2)

En este caso, configuramos las salidas del solucionador. Nos deberá indicar la cantidad de botellas de cada tipo que deberán ser distribuidas a cada individuo. El valor de la función objetivo (contenido total), nos servirá para verificar la solución (10,5).

Como información adicional, hemos configurado algunas impresiones (arbitrarias) para que nos detalle la cantidad de botellas que le deberán ser asignadas a cada individuo.

Es posible que el desarrollo de los ocho pasos anteriores demande algún grado de complejidad subyacente del uso de un lenguaje de programación; sin embargo, es preciso mencionar que, el modelo anterior queda perfectamente configurado, y puede replicarse con modificaciones menores en múltiples problemas de optimización lineal.

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo, así mismo debemos contar con la última versión del comando pip y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

El código completo de nuestro desarrollo lo presentamos a continuación. También puedes ver el cuaderno de este módulo en nuestro Colaboratory: Programación Lineal Entera.

# Caso: Investigación de Operaciones (9na edición), de Hamdy A. Taha 
# (University of Arkansas, Fayetteville), (Conjunto de problemas 9.1A - Problema 3)
# Modelo: MSc. Ing. Bryan Salazar López

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

# Declarar el solucionador que abordará el modelo
solver = pywraplp.Solver.CreateSolver('SCIP')

# Data del modelo

contenido = [ 
    [  1,   1,   1], 
    [0.5, 0.5, 0.5],
    [  0,   0,   0],      
] 
num_botellas = len(contenido)
num_individuos = len(contenido[0])


def main():

# Variables del modelo
  x = {}
  for i in range(num_botellas):
      for j in range(num_individuos):
          x[i, j] = solver.IntVar(0, solver.infinity(), '')

  # Las sumatoria de botellas de cada tipo es igual a 7
  # Cada curso podrá tener un máximo de n estudiantes
  for i in range(num_botellas):
      solver.Add(solver.Sum([x[i, j] for j in range(num_individuos)]) == 7)
  for j in range(num_individuos):
      solver.Add(solver.Sum([x[i, j] for i in range(num_botellas)]) == 7)
  for j in range(num_individuos):
      solver.Add(solver.Sum([contenido[i][j] * x[i, j] for i in range(num_botellas)]) == 3.5)



  # Función objetivo con criterio de optimización: minimizar
  objective_terms = []
  for i in range(num_botellas):
      for j in range(num_individuos):
          objective_terms.append(contenido[i][j] * x[i, j])
  solver.Maximize(solver.Sum(objective_terms))

  # Invoca el solucionador
  status = solver.Solve()

  # Configura los parámetros de impresión, las salidas del modelo
  botellas_ind0 = 0
  botellas_ind1 = 0
  botellas_ind2 = 0
  if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
      print('Contenido total = ', solver.Objective().Value(), '\n')
      for i in range(num_botellas):
          for j in range(num_individuos):
              # Test if x[i,j] is 1 (con tolerancia de punto flotante)
              if x[i, j].solution_value() > 0.5:
                print('Botellas del tipo %d asignadas al individuo %d.  Cantidad = %d' %
                          (i, j, x[i, j].solution_value()))
      for i in range(num_botellas):
          botellas_ind0 = x[i, 0].solution_value() + botellas_ind0
      for i in range(num_botellas):
          botellas_ind1 = x[i, 1].solution_value() + botellas_ind1
      for i in range(num_botellas):
          botellas_ind2 = x[i, 2].solution_value() + botellas_ind2
  print('Número de botellas asignadas al individuo 0:', botellas_ind0)
  print('Número de botellas asignadas al individuo 1:', botellas_ind1)
  print('Número de botellas asignadas al individuo 2:', botellas_ind2)



if __name__ == '__main__':
  main()

Al ejecutar nuestro desarrollo en Colaboratory, tenemos:

De esta manera se ha hallado una solución óptima al modelo formulado. Esta misma respuesta se encuentra consignada en el libro Investigación de Operaciones de TAHA:

Ahora bien, el modelo de optimización lineal y el script del solucionador quedaron desarrollados en un lenguaje de programación estándar y ampliamente utilizado. Desde luego, las posibilidades de integrar datos de entrada y procesar los datos de salidas son interesantes. Por ejemplo, es posible desarrollar un script mediante el cual el código ya desarrollado tome los datos de entrada desde un archivo de Excel, o desde un servidor externo.

También, es posible desarrollar una interfaz amigable desde la cual se ingrese la información; o vincular los datos de salida con algún modelo o documento determinado.

En próximos artículos abordaremos algunos modelos que incorporen la combinación de tipos de variables (continuas y enteras): programación lineal mixta.

La entrada Programación lineal entera con Google OR-Tools se publicó primero en Ingenieria Industrial Online.

Un factor importante al abordar optimización lineal es la eficiencia del modelamiento. En el artículo introductorio a problemas de programación lineal mediante Google OR-Tools, abordamos con fines prácticos, un ejemplo con pocas variables y restricciones.

Cuando el número de variables y restricciones aumenta, se hace necesario contar con herramientas que permitan modelar eficientemente bajo estas condiciones. Una herramienta importante, considerando el modelamiento en lenguajes de programación, consiste en el uso de bucles sobre matrices, que permitan automatizar la definición de variables y restricciones; es decir, pasar de la definición individual de variables a una definición automatizada apoyándose en el uso de matrices.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools para abordar problemas de programación lineal (optimización lineal) usando matrices para la definición de las variables y restricciones del modelo. 

El problema

En el artículo de introducción, abordamos un caso descrito en el libro Applied Mathematical Programming, de Bradley, Hax, and Magnanti (Addison-Wesley, 1977), del MIT (Cápitulo 2 página 50). Con fines prácticos, hemos adaptado dicho modelo, incorporando nuevos procesos al sistema, que impliquen nuevas variables y restricciones:

El propietario de una tienda que produce remolques para automóviles desea determinar la mejor combinación para sus tres productos: remolques de plataforma plana, remolques económicos y remolques de lujo. Su taller se limita a trabajar 24 días al mes en el trabajo de los metales, 60 días al mes en el trabajo de la madera, 40 días al mes en el trabajo de pintura, 50 días al mes en el trabajo de montaje y 45 días al mes en el trabajo de acabados para estos productos. La siguiente tabla indica los datos de producción de los remolques.

Tabla 1

Podemos observar, que respecto al problema original, se han incorporado tres procesos más, lo cual implica la adición de nuevas variables y nuevas restricciones.

Modelamiento del problema

Sean las variables de decisión del problema:

x₀ = Número de remolques de plataforma plana producidos por mes

x₁ = Número de remolques económicos producidos por mes

x₂ = Número de remolques de lujo producidos por mes

Suponiendo que los costos de la capacidad de trabajo en metal, madera, pintura, montaje y acabados sean fijos, el problema se convierte en un problema de maximización:

Zmax = 6x₀ + 14x₁ + 13x₂

Sujeto a las siguientes restricciones de capacidad:

0,5x₀ + 2x₁ + x₂ <= 24,

x₀ + 2x₁ + 4x₂ <= 60,

1,5x₀ + 0,5x₁ + 2x₂ <= 40,

1x₀ + 1,5x₁ + 1,5x₂ <= 50,

0,5x₀ + 1x₁ + 1,5x₂ <= 45,

Sujeto a las siguientes restricciones de no-negatividad:

x₀ >= 0,

x₁ >= 0,

x₂ >= 0,

Podemos, del mismo modo, establecer un conjunto de variables que correspondan a las horas ociosas para cada uno de los procesos del sistema (metal, madera, pintura, montaje y acabados):

x₃ = Número de horas ociosas en el trabajo en metal al mes,

x₄ = Número de horas ociosas en el trabajo en madera al mes,

x₅ = Número de horas ociosas en el trabajo en pintura al mes,

x₆ = Número de horas ociosas en el trabajo en montaje al mes,

x₇ = Número de horas ociosas en el trabajo en acabados al mes,

Reescribimos las restricciones (adicionando las variables de horas ociosas). Podemos observar que las inecuaciones ahora serán igualdades, para que de esta forma ahora podamos tener información relacionada a los recursos. En otras palabras, lo que se utiliza (horas productivas) + lo que sobre (horas ociosas) = tiempo disponible:

0,5x₀ + 2x₁ + x₂ + x₃ = 24,

x₀ + 2x₁ + 4x₂ + x₄ = 60,

1,5x₀ + 0,5x₁ + 2x₂ + x₅ = 40,

1x₀ + 1,5x₁ + 1,5x₂ + x₆ = 50,

0,5x₀ + 1x₁ + 1,5x₂ + x₇ = 45,

x₀ >= 0,

x₁ >= 0,

x₂ >= 0,

x₃ >= 0,

x₄ >= 0,

x₅ >= 0,

x₆ >= 0,

x₇ >= 0,

Así entonces, tenemos el problema completamente modelado.

Resolución del modelo mediante Google OR-Tools

Tal como lo hemos mencionado, el objetivo de este artículo es abordar un problema de optimización lineal utilizando matrices para la definición de variables. De tal manera que detallaremos nuevamente cada uno de los pasos utilizados en el modelamiento.

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, así entonces, haremos uso del lenguaje de programación Python.

Paso 1: Importar la librería

El siguiente fragmento de código importa las librerías necesarias:

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

Paso 2: Crear la data del modelo (matrices)

Es recomendable previamente disponer las restricciones por medio de un tabulado que nos permita observar las matrices con claridad. En este caso, la matriz en la cual se relacionan los coeficientes de las restricciones (considerando las variables de horas ociosas), se puede apreciar en la tabla 2. 

Tabla 2

Podemos observar que, en la matriz de entrada de los coeficientes de las restricciones incorporaremos todas las variables, incluso las que no forman parte de la ecuación (incluidas con coeficiente 0), esto para conservar un orden de la matriz.

def create_data_model():
  """Almacena la data de entrada del modelo"""
  data = {}
  data['restriccion_coef'] = [
      [0.5,   2,   1,   1,   0,   0,   0,   0],
      [  1,   2,   4,   0,   1,   0,   0,   0],
      [1.5, 0.5,   2,   0,   0,   1,   0,   0],
      [  1, 1.5, 1.5,   0,   0,   0,   1,   0],
      [0.5,   1, 1.5,   0,   0,   0,   0,   1],
  ]
  data['limites'] = [24, 60, 40, 50, 45]
  data['obj_coef'] = [6, 14, 13, 0, 0, 0, 0, 0]
  data['num_vars'] = 8
  data['num_restricciones'] = 5
  return data

Paso 3: Declarar el solucionador y crear las variables del modelo

Haciendo uso de las matrices definidas previamente, el siguiente fragmento de código automatiza la creación de las variables por medio de un bucle:

def main():
  data = create_data_model()
  # Declara el solucionador GLOP
  solver = pywraplp.Solver.CreateSolver('GLOP')
  # Crea las variables por medio de un bucle tomando las matrices (data).
  infinity = solver.infinity()
  x = {}
  for j in range(data['num_vars']):
    x[j] = solver.IntVar(0, infinity, 'x[%i]' % j)
  print('Número de variables =', solver.NumVariables())

Por medio del fragmento anterior se definen cada una de las variables (enteras), y se establecen los límites de cada una de ellas (0, infinity = desde cero hasta el infinito), es decir, hace las veces de restricciones de no-negatividad.

Paso 4: Definir las restricciones del modelo

Haciendo uso de las matrices definidas previamente, el siguiente fragmento de código automatiza la definición de las restricciones por medio de un bucle:

  for i in range(data['num_restricciones']):
    constraint = solver.RowConstraint(data['limites'][i], data['limites'][i], '')
    for j in range(data['num_vars']):
      constraint.SetCoefficient(x[j], data['restriccion_coef'][i][j])
  print('Número de restricciones =', solver.NumConstraints())

Usando el método RowConstraint creamos las restricciones de manera automatizada para el modelo. Los signos de las inecuaciones o igualdades (límites) se expresan dentro del método. Citaremos algunos ejemplos:

La expresión data[‘limites][i] toma el valor correspondiente al límite asociado a la fila de cada restricción (fila i) desde la matriz límites. Así entonces, y tomando como ejemplo la primera restricción (fila 0, es decir i =0), lo que expresaría el código en cada caso sería:

Paso 5: Definir la función objetivo del modelo

Haciendo uso de las matrices definidas previamente, el siguiente fragmento de código automatiza la definición de la función objetivo por medio de un bucle (maximizar):

  objective = solver.Objective()
  for j in range(data['num_vars']):
    objective.SetCoefficient(x[j], data['obj_coef'][j])
  objective.SetMaximization()

Paso 6: Invocar el solucionador

El siguiente fragmento de código sirve para invocar el solucionador del modelo:

status = solver.Solve()

Paso 7: Definir las salidas del solucionador

De acuerdo a los bucles definidos, las variables toman los nombres base siguiendo el formato x[i]; de manera que por medio del siguiente código, renombraremos las variables para una mejor comprensión de las salidas del solucionador.

    print('Valor objetivo =', solver.Objective().Value())
    print('Solución:')
    print('Remolques de plataforma plana producidos por mes =', x[0].solution_value())
    print('Remolques económicos producidos por mes =', x[1].solution_value())
    print('Remolques de lujo producidos por mes =', x[2].solution_value())
    print('Horas ociosas en el trabajo en metal al mes =', x[3].solution_value())
    print('Horas ociosas en el trabajo en madera al mes =', x[4].solution_value())
    print('Horas ociosas en el trabajo en pintura al mes =', x[5].solution_value())
    print('Horas ociosas en el trabajo en montaje al mes =', x[6].solution_value())
    print('Horas ociosas en el trabajo en acabados al mes =', x[7].solution_value())
    print()
    print('Problema resuelto en %f milisegundos' % solver.wall_time())
    print('Problema resuelto en %d iteraciones' % solver.iterations())
    
  else:
    print('El problema no tiene solución óptima.')

Es posible que el desarrollo de los siete pasos anteriores demande algún grado de complejidad subyacente del uso de un lenguaje de programación; sin embargo, es preciso mencionar que, el modelo anterior queda perfectamente configurado, y puede replicarse con modificaciones menores en múltiples problemas de optimización lineal. Ahora bien, haciendo el uso de matrices, se puede mejorar considerablemente la eficiencia del modelamiento.

¿Cómo ejecutar el modelo?

Lo primero que debemos considerar, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo, así mismo debemos contar con la última versión del comando pip y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico, por ejemplo: Sublime Text.

En este caso, haremos uso del editor Sublime Text, al cual llevaremos íntegramente el código completo del programa:

#Caso desde: Bradley, Hax, and Magnanti, 
#'Applied Mathematical Programming', Chapter 2
#Nuevos procesos adicionados por Salazar (2021)

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

def create_data_model(): 
  """Almacena la data de entrada del modelo""" 
  data = {} 
  data['restriccion_coef'] = [ 
      [0.5,   2,   1,   1,   0,   0,   0,   0], 
      [  1,   2,   4,   0,   1,   0,   0,   0], 
      [1.5, 0.5,   2,   0,   0,   1,   0,   0], 
      [  1, 1.5, 1.5,   0,   0,   0,   1,   0], 
      [0.5,   1, 1.5,   0,   0,   0,   0,   1],
  ] 
  data['limites'] = [24, 60, 40, 50, 45] 
  data['obj_coef'] = [6, 14, 13, 0, 0, 0, 0, 0] 
  data['num_vars'] = 8 
  data['num_restricciones'] = 5 
  return data

def main():
  data = create_data_model()
  # Declara el solucionador GLOP
  solver = pywraplp.Solver.CreateSolver('GLOP')
  # Crea las variables por medio de un bucle tomando las matrices (data).
  infinity = solver.infinity()
  x = {}
  for j in range(data['num_vars']):
    x[j] = solver.IntVar(0, infinity, 'x[%i]' % j)
  print('Número de variables =', solver.NumVariables())

  # Definir las restricciones por medio de un bucle tomando las matrices (data).
  for i in range(data['num_restricciones']):
    constraint = solver.RowConstraint(data['limites'][i], data['limites'][i], '')
    for j in range(data['num_vars']):
      constraint.SetCoefficient(x[j], data['restriccion_coef'][i][j])
  print('Número de restricciones =', solver.NumConstraints())

  # Define la función objetivo por medio de un bucle tomando las matrices (data).
  objective = solver.Objective()
  for j in range(data['num_vars']):
    objective.SetCoefficient(x[j], data['obj_coef'][j])
  objective.SetMaximization()
  # In Python, you can also set the objective as follows.
  # obj_expr = [data['obj_coeffs'][j] * x[j] for j in range(data['num_vars'])]
  # solver.Maximize(solver.Sum(obj_expr))

  status = solver.Solve()

  if status == pywraplp.Solver.OPTIMAL:
    print('Valor objetivo =', solver.Objective().Value())
    print('Solución:')
    print('Remolques de plataforma plana producidos por mes =', x[0].solution_value())
    print('Remolques económicos producidos por mes =', x[1].solution_value())
    print('Remolques de lujo producidos por mes =', x[2].solution_value())
    print('Horas ociosas en el trabajo en metal al mes =', x[3].solution_value())
    print('Horas ociosas en el trabajo en madera al mes =', x[4].solution_value())
    print('Horas ociosas en el trabajo en pintura al mes =', x[5].solution_value())
    print('Horas ociosas en el trabajo en montaje al mes =', x[6].solution_value())
    print('Horas ociosas en el trabajo en acabados al mes =', x[7].solution_value())
    print()
    print('Problema resuelto en %f milisegundos' % solver.wall_time())
    print('Problema resuelto en %d iteraciones' % solver.iterations())
    
  else:
    print('El problema no tiene solución óptima.')


if __name__ == '__main__':
  main()

Es necesario que el editor esté configurado de acuerdo a la sintaxis de Python y el archivo se guarde como tal, con la extensión .py.

Lo siguiente será ejecutar el código, para eso podemos utilizar la consola del sistema (símbolo del sistema) o CMD. En ella, debemos dirigirnos hacia el directorio en el cual se encuentre nuestro archivo .py y ejecutarlo de la siguiente manera:

python Nombre del archivo.py

En nuestro caso, hemos guardado el modelo como PL_matrix.py, así que de esa manera lo ejecutamos desde la consola del sistema:

Y bien, tenemos la solución a este problema de programación lineal en 5 milisegundos (varía de acuerdo a las especificaciones del equipo) y en 4 iteraciones.

Dada la adición de variables de holgura o exceso, podemos identificar que existen dos restricciones redundantes: Horas montaje y horas de acabados.

Ahora bien, el modelo de optimización lineal y el script del solucionador quedaron desarrollados en un lenguaje de programación estándar y ampliamente utilizado. Desde luego, las posibilidades de integrar datos de entrada y procesar los datos de salidas son interesantes. Por ejemplo, es posible desarrollar un script mediante el cual el código ya desarrollado tome las matrices de entrada desde un archivo de Excel, o desde archivo csv.

Podemos observar que las variables que forman parte de la solución toman valores continuos, y dado el caso práctico, no es ajustado a la realidad mencionar que se producirán 9,99 remolques de lujo. De manera que, en próximos artículos abordaremos la solución de problemas de programación lineal entera y mixta (optimización lineal entera y mixta MIP), ya que Google OR-Tools cuenta con un solucionador específico para abordar este tipo de modelos.

La entrada Uso de matrices para definir un modelo de programación lineal en Google OR-Tools se publicó primero en Ingenieria Industrial Online.

Tal como lo hemos mencionado en artículos anteriores (programación lineal); la optimización lineal, es el nombre con el que se conoce al cálculo de la mejor solución a un problema modelado como un conjunto de restricciones lineales y una función objetivo también lineal.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools para abordar problemas de programación lineal (optimización lineal). 

El problema

Con el propósito de evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Applied Mathematical Programming, de Bradley, Hax, and Magnanti (Addison-Wesley, 1977), del MIT (Cápitulo 2 página 50).

El propietario de una tienda que produce remolques para automóviles desea determinar la mejor combinación para sus tres productos: remolques de plataforma plana, remolques económicos y remolques de lujo. Su taller se limita a trabajar 24 días al mes en el trabajo de los metales y 60 días al mes en el trabajo de la madera para estos productos. La siguiente tabla indica los datos de producción de los remolques.

Modelamiento del problema

Sean las variables de decisión del problema:

x₀ = Número de remolques de plataforma plana producidos por mes

x₁ = Número de remolques económicos producidos por mes

x₂ = Número de remolques de lujo producidos por mes

Suponiendo que los costos de la capacidad de trabajo en metal y madera sean fijos, el problema se convierte en un problema de maximización:

Zmax = 6x₀ + 14x₁ + 13x₂

Sujeto a las siguientes restricciones de capacidad:

0,5x₀ + 2x₁ + x₂ <= 24,

x₀ + 2x₁ + 4x₂ <= 60,

Sujeto a las siguientes restricciones de no-negatividad:

x₀ >= 0,

x₁ >= 0,

x₂ >= 0,

Podemos, del mismo modo, establecer un par de variables que correspondan a las horas ociosas para las dos tareas establecidas (metal y madera):

x₃ = Número de horas ociosas en el trabajo en metal al mes,

x₄ = Número de horas ociosas en el trabajo en madera al mes,

Reescribimos las restricciones (adicionando las variables de horas ociosas). Podemos observar que las inecuaciones ahora serán igualdades, para que de esta forma ahora podamos tener información relacionada a los recursos. En otras palabras, lo que se utiliza (horas productivas) + lo que sobre (horas ociosas) = tiempo disponible:

0,5x₀ + 2x₁ + x₂ + x₃ = 24,

x₀ + 2x₁ + 4x₂ + x₄ = 60,

x₀ >= 0,

x₁ >= 0,

x₂ >= 0,

x₃ >= 0,

x₄ >= 0,

Así entonces, tenemos el problema completamente modelado.

Resolución del modelo mediante Google OR-Tools

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, así entonces, haremos uso del lenguaje de programación Python.

Paso 1: Importar la librería

El siguiente fragmento de código importa las librerías necesarias:

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

Paso 2: Declarar el solucionador

El siguiente fragmento de código declara el solucionador GLOP (Google OR-Tools posee múltiples solucionadores):

solver = pywraplp.Solver.CreateSolver('GLOP')

Paso 3: Crear las variables del modelo

El siguiente fragmento crea las variables del modelo, así mismo indica el tipo de variables correspondientes y su rango de valores. Así entonces, desde la creación de las variables se pueden abordar las restricciones de no-negatividad (entre 0 e infinito):

x0 = solver.NumVar(0, solver.infinity(), 'x0')
x1 = solver.NumVar(0, solver.infinity(), 'x1')
x2 = solver.NumVar(0, solver.infinity(), 'x2')
x3 = solver.NumVar(0, solver.infinity(), 'x3')
x4 = solver.NumVar(0, solver.infinity(), 'x4')

print('Número de variables =', solver.NumVariables())

Paso 4: Definir las restricciones del modelo

El siguiente fragmento de código define las restricciones del modelo:

# Restricción 0: 0.5x0 + 2x1 + x2 + x3 = 24.
solver.Add(0.5 * x0 + 2 * x1 + x2 + x3 == 24.0)

# Restricción 1: x0 + 2x1 + 4x2 + x4 = 60.
solver.Add(x0 + 2 * x1 + 4 *x2 + x4 == 60.0)

print('Número de restricciones =', solver.NumConstraints())

Paso 5: Definir la función objetivo del modelo

El siguiente fragmento de código define la función objetivo del modelo (maximizar):

# Función objetivo (max): 6x0 + 14x1 + 13x2
solver.Maximize(6 * x0 + 14 * x1 + 13 * x2)

Paso 6: Invocar el solucionador

El siguiente fragmento de código sirve para invocar el solucionador del modelo:

status = solver.Solve()

Paso 7: Definir las salidas del solucionador

if status == pywraplp.Solver.OPTIMAL:
    print('Solución:')
    print('Valor objetivo =', solver.Objective().Value())
    print('Número de remolques de plataforma plana producidos por mes =', x0.solution_value())
    print('Número de remolques económicos producidos por mes =', x1.solution_value())
    print('Número de remolques de lujo producidos por mes =', x2.solution_value())
    print('Número de horas ociosas en el trabajo en metal al mes =', x3.solution_value())
    print('Número de horas ociosas en el trabajo en madera al mes =', x4.solution_value())
else:
    print('El problema no tiene solución óptima.')

Es posible que el desarrollo de los siete pasos anteriores demande algún grado de complejidad subyacente del uso de un lenguaje de programación; sin embargo, es preciso mencionar que, el modelo anterior queda perfectamente configurado, y puede replicarse con modificaciones menores en múltiples problemas de optimización lineal.

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo, así mismo debemos contar con la última versión del comando pip y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

El código completo de nuestro desarrollo lo presentamos a continuación. También puedes ver el cuaderno de este módulo en nuestro Colaboratory: Programación Lineal.

#Desde: Bradley, Hax, and Magnanti, 'Applied Mathematical Programming', Chapter 2

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

def LinearProgrammingExample():
    solver = pywraplp.Solver.CreateSolver('GLOP')

    x0 = solver.NumVar(0, solver.infinity(), 'x0')
    x1 = solver.NumVar(0, solver.infinity(), 'x1')
    x2 = solver.NumVar(0, solver.infinity(), 'x2')
    x3 = solver.NumVar(0, solver.infinity(), 'x3')
    x4 = solver.NumVar(0, solver.infinity(), 'x4')

    print('Número de variables =', solver.NumVariables())

    # Restricción 0: 0.5x0 + 2x1 + x2 + x3 = 24.
    solver.Add(0.5 * x0 + 2 * x1 + x2 + x3 == 24.0)

    # Restricción 1: x0 + 2x1 + 4x2 + x4 = 60.
    solver.Add(x0 + 2 * x1 + 4 *x2 + x4 == 60.0)

    print('Número de restricciones =', solver.NumConstraints())

    # Función objetivo (max): 6x0 + 14x1 + 13x2
    solver.Maximize(6 * x0 + 14 * x1 + 13 * x2)

    # Declarar el solucionador.
    status = solver.Solve()

    # Declarar las salidas del solucionador
    if status == pywraplp.Solver.OPTIMAL:
        print('Solución:')
        print('Valor objetivo =', solver.Objective().Value())
        print('Número de remolques de plataforma plana producidos por mes =', x0.solution_value())
        print('Número de remolques económicos producidos por mes =', x1.solution_value())
        print('Número de remolques de lujo producidos por mes =', x2.solution_value())
        print('Número de horas ociosas en el trabajo en metal al mes =', x3.solution_value())
        print('Número de horas ociosas en el trabajo en madera al mes =', x4.solution_value())
    else:
      if status == solver.FEASIBLE:
        print('Se encontró una solución potencialmente subóptima.')
      else:
        print('El problema no tiene solución óptima.')

    # Información avanzada del solucionador

    print('\nUso avanzado:')
    print('Problema resuelto en %f milisegundos' % solver.wall_time())
    print('Problema resuelto en %d iteraciones' % solver.iterations())

LinearProgrammingExample()

Al ejecutar nuestro desarrollo en Colaboratory, tenemos:

Podemos observar que se ha obtenido la misma respuesta que se encuentra consignada en el libro Applied Mathematical Programming (Página 51).

Ahora bien, el modelo de optimización lineal y el script del solucionador quedaron desarrollados en un lenguaje de programación estándar y ampliamente utilizado. Desde luego, las posibilidades de integrar datos de entrada y procesar los datos de salidas son interesantes. Por ejemplo, es posible desarrollar un script mediante el cual el código ya desarrollado tome los datos de entrada desde un archivo de Excel, o desde un servidor externo.

También, es posible desarrollar una interfaz amigable desde la cual se ingrese la información; o vincular los datos de salida con algún modelo o documento determinado.

En próximos artículos abordaremos algunos scripts haciendo uso de las librerías de Google OR-Tools que nos permitan utilizar bucles de matrices, con el objetivo de automatizar el proceso de definición de variables y restricciones, mejorando la eficiencia del modelamiento.

La entrada Programación lineal en Google OR-Tools se publicó primero en Ingenieria Industrial Online.

Google OR-Tools es un paquete de software portable de código abierto para resolución de problemas de optimización. Así mismo, cuenta con metaheurísticas que buscan encontrar la mejor solución a un problema entre un conjunto de posibles soluciones. Or-Tools es una herramienta potente, diseñada para abordar los problemas más difíciles del mundo en el enrutamiento de vehículos, los flujos, la programación de números enteros y lineales y la programación de restricciones.

Una de las ventajas potenciales de Google Or-Tools consiste en que, a pesar de estar desarrollado en lenguaje C++, permite el modelamiento de problemas en múltiples lenguajes de programación, del mismo modo, cuenta con múltiples solucionadores específicos para resolverlos, algunos comerciales y algunos de código abierto.

Fuente: Google OR-Tools

Centrémonos en la posibilidad de modelar un problema de optimización en un lenguaje de programación, puesto que las oportunidades son cada vez más interesantes. En la academia, la enseñanza de la investigación de operaciones, el proceso de modelamiento y el mundo de los solucionadores, es tan a menudo, atomizado, que carece de practicidad.

La obtención, el procesamiento y la disposición de un volumen considerable de datos, su convergencia en un modelo de optimización y su eventual integración hacia un solucionador, son procesos complejos, que implican con regularidad la reunión de herramientas poco compatibles.

Google Or-Tools, al permitir el modelamiento en diversos lenguajes de programación, ofrece un sinfín de posibilidades de integración entre herramientas de obtención y tratamiento de información; así mismo, ofrece posibilidades ilimitadas de desarrollo de soluciones, como por ejemplo interfaces de usuario amigables, o integración con sistemas de integración de recursos, app’s, plataformas webs, dispositivos con un sistema de conexión a internet de las cosas (IoT), y mucho más.

Suponga, por ejemplo, que quiere desarrollar un modelo que le permita mejorar la eficiencia del proceso de recogida de paquetes, un típico problema de distribución y recolección de última milla, abordado dentro de la investigación de operaciones como un problema VRP (Vehicle Routing Problem). En su versión básica, requerirá de un conjunto de nodos y el costo que representa el arco que une a cada par (origen y destino). Sin embargo, asumamos que el criterio de optimización está basado en la distancia entre nodos, y, además, que se pretende, dado el volumen de datos requeridos, integrar una interfaz de programación externa que le permita obtener los tiempos entre nodos desde una plataforma como Google Maps.

Por otro lado, la flota de vehículos disponibles tiene una capacidad limitada (CVRP), y la información relacionada al número de vehículos y su capacidad volumétrica, se encuentra actualizada todos los días en archivo csv accesible desde el servidor de la empresa.

La información relacionada con los destinos, o puntos de entrega, así mismo la dimensión volumétrica de los paquetes se puede obtener desde una solución desarrollada a la medida por la compañía, la cual mantiene la información actualizada en tiempo real y exporta diariamente estos datos en formato xls.

Pretender integrar los datos de entrada, que a su vez son salidas desde plataformas diferentes, en formatos diferentes; algunos de ellos, información en tiempo real; procesar y organizar dicha información, integrarlos en un modelo de optimización y luego ejecutar un solucionador, haciendo uso de las herramientas típicas como Solver, Storm, Tora, WinQSB, Crystall Ball, etc., resultaría sumamente complejo, y en algunos casos imposible.

Sin embargo, haciendo uso, por ejemplo, de un lenguaje de programación como Python, es posible desarrollar un código (script) que automatice las solicitudes hacia una API de Google Maps (HTML), decodifique sus respuestas (JSON), permitiendo disponer de la información relacionada con la distancia más probable para una hora de programación de salida de la flota en particular.

Así mismo, es posible ejecutar un script básico que extraiga la información contenida en un archivo csv y un archivo xls. Posteriormente, y haciendo uso de las librerías de enrutamiento de Google Or-Tools, toda esta data puede integrarse en un modelo de programación basada en restricciones que ejecutará una metaheurística como solucionador.

Como resultado, diariamente es posible mediante la integración de información actualizada en tiempo real en múltiples plataformas, a través de múltiples servidores, poder ejecutar un modelo de programación basado en restricciones que me permita obtener las rutas más eficientes de acuerdo a la metaheurística y a los parámetros del solucionador.

Dicho de otro modo, es posible integrar al modelo y al solucionador cualquier desarrollo que se base en un lenguaje común, por ejemplo: Python.

¡Sí, las ventajas potenciales son asombrosas!

¿Qué tipo de modelos se pueden resolver mediante Google OR-Tools?

Google OR-Tools incluye solucionadores para:

¿Qué tan potente es el solucionador?

De acuerdo al MiniZinc Challenge 2020, competencia internacional de solucionadores de programación de restricciones, Google OR-Tools obtuvo tres medallas doradas en cuatro categorías de evaluación.

Fuente: MiniZinc Challenge (2020)

¿Cómo puedo instalar Google OR-Tools?

Con asombro descubrimos desde esta plataforma (Ingeniería Industrial Online), que en la actualidad muchas personas nos escriben solicitando información para instalar WinQSB en computadores de 64 bits. El asombro es aún mayor cuando descubrimos que algunas instituciones de formación aún utilizan WinQSB como solucionador de modelos de investigación de operaciones.

Pues bien, esas incompatibilidades tecnológicas, no solo se han sorteado con Google OR-Tools, existen además múltiples solucionadores perfectamente compatibles con gran parte de los sistemas operativos de la actualidad. Ahora bien, OR-Tools es compatible con sistemas Linux, Mac y Windows; sin embargo, su instalación varía de acuerdo al lenguaje de programación que quieran utilizar.

Una guía completa de instalación la pueden encontrar en el siguiente enlace:

Ventajas de ser un software de código abierto

Una de la mayores ventajas que presenta Google OR-Tools consiste en que es un software de código abierto, de tal manera que su modelo de desarrollo se basa en la colaboración. Esto representa un beneficio potencial, dado que cientos de personas, día a día, se encuentran formulando modelos de optimización en diversos lenguajes de programación.

Una evidencia de ello es la colaboración entorno a la formulación de problemas de enrutamiento de vehículos, ya que a través de las contribuciones que pueden observarse en GitHub o un su foro de discusión en Google Groups, se han desarrollado modelos para diversas variaciones del modelo base, dentro de las que podemos encontrar:

Y mucho más, como colaboraciones a problemas de optimización específicos, integraciones con API’s desarrolladas por Google, como Distance Matrix API de Google Maps.

¿Los requerimientos técnicos son un limitante para su uso?

De ninguna manera. Y le vamos a explicar la razón.

Si queremos utilizar Google OR Tools en nuestro ordenador, sí tenemos algunos requerimientos técnicos, ahora bien, todos gratuitos. Requerimos la instalación de Python, un entorno de desarrollo integrado (IDE), y de la instalación de su librería (or tools).

Sin embargo, para su aprendizaje y uso básico, podemos utilizar entornos virtuales, como por ejemplo: Colaboratory de Google. ¿En qué consiste?

Colaboratory, también llamado «Colab», te permite ejecutar y programar en Python en tu navegador con las siguientes ventajas:

Es decir, podemos utilizar toda la potencia de las máquinas de Google para ejecutar nuestros modelos… ¡Genial! 

De hecho, vamos a utilizar esta herramienta en cada modelo que desarrollemos en este portal, compartiremos nuestros códigos y esperamos que les sean de gran utilidad.

En próximos artículos desarrollaremos modelos de optimización y metaheurísticas haciendo uso de Google OR-Tools, de tal manera que de la mano descubran esta gran herramienta.

La entrada ¿Qué es y para qué sirve Google OR-Tools? se publicó primero en Ingenieria Industrial Online.

A continuación, presentamos la solución a una serie de ejercicios de programación lineal. Encontrarán diversas variaciones del problema básico, aplicadas en diversos contextos. Los invitamos también a repasar los conceptos relacionados con:

Problema No. 16

La entrada Ejercicios de programación lineal (cuarta parte) se publicó primero en Ingenieria Industrial Online.