Documentos de Académico
Documentos de Profesional
Documentos de Cultura
1 - Guía Del Ampl - Ind-273
1 - Guía Del Ampl - Ind-273
OPERATIVA
A mathematical
programming language
GIOPA
Autores
Jonatán Rojas Polo
Christian Cornejo Sánchez
Alessandro Gilardino Arias
Renzo Benavente Sotelo
Alexia Cáceres Cansaya
Pedro Muñante Chihuantito
Ingeniería
Industrial
i
RESUMEN
Esta guía básica pretende explicar el uso del software AMPL, el cual es ampliamente
reconocido a nivel mundial como uno de los mejores lenguajes de programación en modelos
matemáticos de optimización, y utilizado en las mejores universidades del mundo. Este
software es usado como solver en papers de investigación, en publicaciones indizadas, y son
ganadores de premios internacionales por su alta capacidad de procesamiento de datos.
El proyecto AMPL pretende mejorar las habilidades de modelación matemática, teniendo así
una educación transversal, interrelacionando el área de Investigación de Operaciones con
áreas Core de Ingeniería Industrial como las áreas de Producción y de Finanzas.
Con el uso de las guías pretendemos aprovechar 3 cursos pilares de ingeniería industrial. En
el curso de Investigación Operativa 1, se pretende fortalece el análisis, realización de modelos
matemáticos lineales y el uso del software. Posteriormente, en el ciclo siguiente, se pretende
aplicar modelos matemáticos para los sistemas de producción en el curso de Planeamiento y
Control de Operaciones, y finalmente en curso de Investigación Operativa 2 consolidaremos
el aprendizaje cuantitativo con la elaboración de papers aplicando modelación matemática
con solver’s proporcionados por AMPL.
http://ampl.com/
ii
DEDICATORIA
iii
ÍNDICE GENERAL
iv
2. IMPORTACIÓN Y EXPORTACIÓN DE DATOS USANDO EXCEL ............................... 46
2.1. Declaración de los nombres de las tablas en Excel .................................................. 47
2.2. Declaración de tablas en AMPL para lectura de datos vectoriales ........................ 50
2.3. Declaración de tablas en AMPL para lectura de datos matriciales ........................ 51
2.4. Declaración de tablas en AMPL para escritura de variables vectoriales ............... 52
2.5. Declaración de tablas en AMPL para escritura de variables matriciales ............... 52
2.6. Comandos read table y write table .............................................................................. 54
2.7. UTILIDAD DE UN ARCHIVO “.run” ............................................................................. 56
QUINTA GUÍA DE AMPL .................................................................................................................. 57
1. COMANDOS DE MODELADO LET, FIX Y UNFIX ........................................................... 57
1.1. El comando let................................................................................................................. 57
1.2. Los comandos fix y unfix ............................................................................................... 58
2. COMANDO FOR: ITERACION DE SENTENCIAS ........................................................... 60
3. COMANDO REPEAT: ITERAR RESPECTO A UNA CONDICION ................................ 61
SEXTA GUÍA DE AMPL .................................................................................................................... 66
1. DEFINICIÓN DE RANGOS DE VARIABLES USANDO PARÁMETROS ...................... 66
2. DECLARACIÓN DE VARIABLES COMO ENTERAS Y BINARIAS ............................... 67
Bibliografía ........................................................................................................................................... 74
v
INDICE DE TABLAS
vi
INDICE DE GRÁFICOS
Figura 1: Página web de software AMPL ......................................................................................... 1
Figura 2: Libro desarrollado por AMPL ............................................................................................. 1
Figura 3: Página web de software AMPL con licencia académica ............................................... 2
Figura 4: Documentación de la descarga AMPL - Students .......................................................... 2
Figura 5: ventana de instalación de AMPL ...................................................................................... 3
Figura 6: aceptar el Amplide. .............................................................................................................. 3
Figura 7: Interface del Amplide. ......................................................................................................... 3
Figura 8: Comando New ...................................................................................................................... 4
Figura 9: Comando New file ............................................................................................................... 5
Figura 10: archivos para modelar ...................................................................................................... 5
Figura 11: modelado en .mod y .dat .................................................................................................. 6
Figura 12: opciones de consola ......................................................................................................... 6
Figura 13: interrumpir proceso ........................................................................................................... 7
Figura 14: limpiar pantalla ................................................................................................................... 7
Figura 15: sintaxis del modelo .mod .................................................................................................. 8
Figura 16: Programación en la consola ............................................................................................ 8
Figura 17: Búsqueda de archivo ........................................................................................................ 9
Figura 18: Búsqueda de la solución .................................................................................................. 9
Figura 19: creación de un archivo run ............................................................................................. 45
Figura 20: selección de datos ........................................................................................................... 47
Figura 21: columna donde se exportarán los datos ...................................................................... 48
Figura 22: administrador de nombres ............................................................................................. 48
Figura 23: valores de varios parámetros ........................................................................................ 49
Figura 24: declarando la matriz tiempo ........................................................................................... 49
Figura 25: declarando el nombre de la matriz resultados ............................................................ 49
Figura 26: administrador de nombres ............................................................................................. 50
vii
JUSTIFICACIÓN
Actualmente es una herramienta que genera una ventaja competitiva sostenible en el tiempo,
es muy usada en empresas privadas o del sector público de grandes países. No obstante, en
esta área nosotros los latinoamericanos, nos caracterizamos por nuestra paupérrima
contribución en la investigación del desarrollo de modelos matemáticos complejos. Según
Scimago Journal & Country Rank, comenta que la investigación en el Perú relacionada a
Ciencia de la Administración e Investigación de Operaciones es casi nula, es decir durante los
años de 1996 al 2016 solo se publicó 62 papers en revistas indizadas (SCOPUS), mientras
que en ese mismo periodo en Chile se publicaron 709; Colombia, 337 y Argentina, 185.
viii
http://www.scimagojr.com/countryrank.php?category=1803®ion=Latin%20America
Objetivos
- Explicar al lector las técnicas de modelación matemática, entre ellos programación lineal,
programación entera y programación por metas para que sea capaz de formular modelos
matemáticos, resolverlos utilizando métodos matemáticos y herramientas
computacionales, y analizar los resultados obtenidos para tomar decisiones.
- El lector desarrollará competencias para la identificación, formulación y solución de
problemas de decisión en el ámbito de la administración de los recursos de producción.
Además, el alumno adquirirá una actitud favorable hacia el empleo de herramientas y
técnicas cuantitativas para plantear y resolver problemas de carácter táctico y estratégico
que se presentan en el ámbito del área de operaciones.
ix
PRIMERA GUÍA DE AMPL
Antes de leer esta guía, descargue la versión demo del software AMPLIDE que está
disponible en la página web de AMPL en la siguiente dirección electrónica
http://ampl.com/try-ampl/download-a-free-demo/. En la figura 1 se observa la página web de
AMPL.
En dicha página también encontrará el libro "AMPL: A Modeling Language for Mathematical
Programming", que es un documento con información completa sobre este software en caso
requiera más detalles. Ver figura 2.
1
Para la descarga del software, le recomendamos inicialmente trabajar con la versión
académica (DEMO). Diríjase a la pestaña de producto, luego AMPL y posteriormente
aplique la opción for students tal como se observa la figura 3.
Una vez que se encuentra en la página for students, de un clic en Demo Version, con lo
cual no dirige a la documentación de Free Demo Version Downloads, usted debe darle clic
en Download a Free Demo, con lo cual nos envía a la documentación de DOWNLOAD A
FREE DEMO, usted debe darle click en Windows (elija según su sistema operativo) con lo
cual nos dirije a la documentación de AMPL IDE download for Windows y finalmente podrá
elegir la versión de AMPL IDE, por ejemplo amplide.mswin64.zip.
2
1.2. Interfaz de usuario del software AMPLIDE
Para iniciar el software lo primero que debe de hacer es extraer los archivos que se
encuentran en el archivo comprimido que descargo de la página de AMPL e ingresar a dicha
carpeta. Cuando ingrese a la carpeta busque el archivo amplide.exe mostrado en la figura
5.
Para poder ingresar al software deberá hacer doble clic en el ícono amplide.exe. Tenga en
cuenta que no debe mover dicho ejecutable de la carpeta original donde se encuentra, ya
que en caso se modifique la ubicación el software arrojará el siguiente mensaje de error
mostrado en la figura 6.
Inicie AMPLIDE para Windows y observamos que la primera pantalla que muestra es como
la que se ilustra en la Figura 7.
Ventana de
comandos para
Solver y reporte
Ventana de modelado y de
Ventana de dirección de pantalla
almacenamiento de datos
de archivos
3
El software AMPLIDE tiene 3 componentes principales:
● Archivos “.mod”: Son los archivos donde se edita el modelo de optimización con el
lenguaje de programación AMPL, el cual se visualiza en la ventana de modelado.
● Archivos “.dat”: Son los archivos donde se ingresan los parámetros necesarios para
resolver el modelo de optimización.
● Archivos “.run”: Son archivos que facilitan dar ciertas órdenes a los archivos “.mod”.
El software AMPLIDE tiene varias opciones que pueden ser útiles para crear archivos,
guardarlos y ejecutarlos. A continuación, se exponen algunos de los comandos del menú
File:
COMANDO NEW
Este comando permite crear un nuevo archivo. Siga los pasos de la figura 8 File/New/File.
4
Al dar clic sobre File aparecerá la ventana que se muestra en la figura 9. Usted puede
elegir el tipo de archivo que desea crear dando clic sobre el menú desplegable File
Extension. En este caso vamos a crear un archivo “.mod” con el nombre “model_prueba”.
COMANDO SAVE
Cuando se hace alguna modificación en un archivo aparecerá un “*” al lado del nombre del
mismo. En la Figura 11, en la parte izquierda, se muestra el archivo “diet.mod” sin
modificaciones; y en la derecha, se muestra el mismo archivo “diet.mod” solo que con una
línea adicional.
5
Figura 11: modelado en .mod y .dat
Para grabar solo ese archivo se debe ir al menú File y seleccionar el comando Save.
Asimismo, el comando Save también se puede ejecutar rápidamente presionando “Ctrl + S”
o el siguiente ícono en la barra de herramientas:
El comando Save All graba todos los archivos que hayan sido modificados y que estén
abiertos en la ventana de modelado. Esto resulta muy útil debido a que se puede tener
numerosos archivos abiertos en simultáneo y evita estar grabando uno a uno.
Al igual que con el comando Save, se puede ejecutar ingresando al Menú File, presionando
Ctrl + Shft + S o desde la barra de herramientas presionando el siguiente ícono:
6
BOTÓN INTERRUPT
También se puede detener el proceso de cálculo del modelo matemático presionando Ctrl
+ C.
Para borrar el texto acumulado en la ventana de comandos se utiliza el botón clear console,
el cual tiene el siguiente ícono:
Para que se familiarice con el lenguaje de programación AMPL, en la presente sección resolveremos
un modelo de optimización con dos variables.
Ejemplo 1
Una empresa fabrica dos tipos de muebles, Premium y Clásico, cuyos márgenes de contribución a
utilidades por unidad son S/.450 y S/. 280 respectivamente. Estos productos están sujetos a una
demanda máxima de 60 unidades para el mueble Premium y 100 unidades para el mueble Clásico.
El taller de la empresa puede fabricar un mueble tipo Premium en 4.5 horas y un mueble tipo Clásico
en 2.5 horas. Se cuenta con una disponibilidad de 320 horas semanales y se desea maximizar las
ganancias de la empresa.
Para solucionar el presente problema haremos uso de las siguientes variables de decisión:
7
Tenga en cuenta:
#variables Para los nombres de los
var P;
var C;
archivos “.mod”, “.dat”,
sets, parámetros,
#Funcion objetivo variables, función
maximize Utilidad: 450*P + 280*C; objetivo y restricciones
se puede utilizar una
#Restricciones
subject to Tiempo_disponible: 4.5*P + 2.5*C <= 400;
sola palabra o dos
subject to DemandamaxP: 0 <= P <= 60; palabras unidas con el
subject to Demanda_max_C: 0 <= C <= 100; signo “_”.
Para escribir comentarios en los archivos de AMPL se debe utilizar el signo “#” al inicio de cada
línea donde se vaya a escribir un comentario y no es necesario colocar el signo “;” al final.
Para este ejemplo el archivo se guardó bajo el nombre de “Ejemplo1.mod” y se puede visualizar en
la ventana de archivos. A continuación trabajaremos con la ventana de comandos. Lo primero que
haremos será llamar al archivo con el siguiente código:
En la figura 16 se muestra dentro del mensaje que se mostró luego de ejecutar el comando solve
observamos que dice “MINOS 5.51”. Esto indica el nombre del solver usado y su versión. Seguido
de esto tenemos el estado al cual se llegó, en este caso se encontró la solución óptima al modelo
planteado en 2 iteraciones. Finalmente nos muestra el valor de la función objetivo, el cual es de S/.
43000 en este caso.
8
Cuidado:
Cuando vaya a cargar algún archivo debe asegurarse que usted se encuentra en la carpeta
donde creó el archivo en su ventana de archivos.
Si queremos obtener el valor que toman las variables en la solución óptima debemos escribir lo
siguiente:
ampl: display A, B;
En este caso la solución indica que se realizarán 33.33 unidades del producto P y 100 unidades del
producto C.
Como ha podido observar en este ejemplo, para declarar una variable se debe escribir antes de
esta, la palabra “var”. Para la función objetivo se usan las palabras “maximize” o “minimize”,
dependiendo del modelo, y seguido de esto un nombre que indique el objetivo, en este caso se
9
escribió “Utilidades”. Las restricciones deben empezar con “subject to” seguidas de un nombre que
represente lo que quieren restringir, en el ejemplo se utilizaron “Tiempo_disponible”,
“DemandamaxP” y “Demanda_max_C”.
En la ventana de comandos, para poder leer un archivo se utiliza el comando “model” seguido del
nombre del archivo y para resolverlo se debe escribir el comando “solve”. Para poder obtener el
valor de las variables se escribe el comando “display” seguido del nombre de las variables que desee
ver.
Finalmente, se utiliza el comando “reset” para resetear la memoria del software y debe ingresarse
siempre que desee resolver un nuevo modelo, como se muestra a continuación.
ampl: reset;
Ejemplo 2
La misma empresa del ejemplo anterior comenzará a producir también un nuevo mueble modelo
Trébol, que va a vender junto con los otros dos que ya tiene. El margen de contribución de este tipo
de mueble es de S/.300 y demora 3.2 horas producirlo en el taller. El tiempo disponible se ha
ampliado a 120 horas y la demanda máxima del mueble tipo Trébol es de 35.
Realice un modelo que optimice las utilidades de la empresa y responda las siguientes preguntas:
10
SEGUNDA GUÍA DE AMPL
En la primera guía se explicó cómo resolver modelos de optimización con el software AMPLIDE e
interactuar con un solver. Sin embargo, como tal vez usted se habrá dado cuenta, si un programa
lineal tuviese una gran cantidad de variables y restricciones, y si lo formulara de la manera que se
hizo en la primera guía, definitivamente tomaría mucho tiempo, e incluso es bastante probable que
cometa diversos errores.
Para ilustrar la dificultad descrita, refiérase al ejemplo 1 de la primera guía en donde se describió a
una empresa que producía solo dos productos y que deseaba maximizar sus ganancias, sujeto a
una restricción de tiempo disponible y a una demanda máxima de los productos que elabora.
Ahora aumentaremos la magnitud de ese modelo así: la empresa fabrica cinco tipos de muebles
que deben pasar por cuatro procesos. Asimismo, se tienen restricciones de materia prima y de
tiempo disponible. A continuación se presenta el ejemplo completo.
Una empresa fabrica cuatro tipos de muebles diferentes y cada uno pasa por una secuencia de tres
procesos distintos y en cada uno se agrega materia prima. La secuencia de los procesos para cada
producto es la misma y se identifica con proceso 1 al primero, proceso 2 al segundo y proceso 3 al
tercero.
Esta empresa desea determinar cuántas unidades de cada tipo de producto debe fabricar para
maximizar las utilidades, para tal fin, las variables de decisión son:
Pi ≤ DEMANDAMAXi ; i=1,2…20
Restricciones de tiempo:
i=1…20(TIEMPOij*Pi) ≤ RECURSOTj ; j=1,2…7
11
i=1…20(MPij*Pi) ≤ RECURSOMPj ; j=1,2…5
Rango de existencia:
Pi ≥ 0 ; i=1,2…20
A continuación, se muestra el código algebraico que debería escribir en el archivo “.mod” para
resolver el modelo.
Función Objetivo
maximizar = 250*P[1] + 80*P[2] + 150*P[3] + 100*P[4]
En cierta empresa manufacturera se fabrican 20 diferentes productos y cada uno pasa por una
secuencia de siete procesos distintos en donde la materia prima se agrega en los cinco primeros y
los dos últimos son de acabado de los productos. La secuencia de los procesos para cada producto
es la misma y se identifica con proceso 1 al primero, proceso 2 al segundo y así sucesivamente.
Los anexos al final de esta guía muestran una serie de datos que a continuación se describen:
El anexo 1 contiene los costos variables unitarios, los precios de venta, el margen de contribución,
la demanda máxima de los 20 productos según los estudios de mercado y la demanda mínima por
obligaciones contractuales. El anexo 2 presenta el tiempo unitario por kilogramo de cada producto
en cada proceso y la disponibilidad del recurso tiempo. El anexo 3 muestra los datos de la cantidad
de materia prima requerida también por kilogramo de cada producto en cada proceso así como la
disponibilidad del recurso materia prima.
Esta empresa desea determinar cuántos kilogramos de cada tipo de producto debe fabricar para
maximizar las utilidades, para tal fin, las variables de decisión son:
12
Función objetivo:
Maximizar i=1…20(MARGENi*Pi)
Restricciones:
Restricciones de demanda:
Pi ≥ DEMANDAMINi ; i=1,2…20
Pi ≤ DEMANDAMAXi ; i=1,2…20
Restricciones de tiempo:
i=1…20(TIEMPOij*Pi) ≤ RECURSOTj ; j=1,2…7
Rango de existencia:
Pi ≥ 0 ; i=1,2…20
Ahora, ¿sabe usted cuánto debería escribir si quisiera resolver este problema como lo hizo con el
ejemplo de la guía 1? A continuación, se muestra el código algebraico que debería escribir en el
archivo “.mod”.
Función Objetivo
MAXIMIZAR = 11 * P_1 + 15.75 * P_2 + 10.5 * P_3 + 10.75 * P_4 + 14.5 * P_5
+ 17.25 * P_6 + 13.5 * P_7 + 12 * P_8 + 16 * P_9 + 17 * P_10 + 20 * P_11
+ 22 * P_12 + 18.5 * P_13 + 17 * P_14 + 15.5 * P_15 + 19 * P_16 + 21.5 *
P_17 + 21.5 * P_18 + 15.5 * P_19 + 14.5 * P_20;
Restricciones de demanda;
P_1 >= 10;
P_2 >= 15;
P_3 >= 0;
P_4 >= 0;
P_5 >= 10;
P_6 >= 0;
P_7 >= 10;
P_8 >= 0;
P_9 >= 20;
P_10 >= 25;
P_11 >= 15;
P_12 >= 10;
P_13 >= 0;
P_14 >= 0;
P_15 >= 0;
P_16 >= 10;
P_17 >= 0;
P_18 >= 0;
P_19 >= 0;
P_20 >= 0;
P_1 <= 150;
P_2 <= 80;
13
P_3 <= 90;
P_4 <= 100;
P_5 <= 180;
P_6 <= 150;
P_7 <= 150;
P_8 <= 145;
P_9 <= 100;
P_10 <= 110;
P_11 <= 150;
P_12 <= 160;
P_13 <= 165;
P_14 <= 155;
P_15 <= 150;
P_16 <= 250;
P_17 <= 150;
P_18 <= 200;
P_19 <= 250;
P_20 <= 180;
!Restricciones de tiempo;
0.167 * P_1 + 0.2 * P_2 + 0.417 * P_3 + 0.2 * P_4 + 0.25 * P_5 + 0.283 *
P_6 + 0.317 * P_7 + 0.5 * P_8 + 0.333 * P_9 + 0.35 * P_10 + 0.333 * P_11
+ 0.367 * P_12 + 0.333 * P_13 + 0.25 * P_14 + 0.3 * P_15 + 0.283 * P_16 +
0.25 * P_17 + 0.267 * P_18 + 0.233 * P_19 + 0.2 * P_20 <= 900;
0.083 * P_1 + 0.067 * P_2 + 0.133 * P_3 + 0.15 * P_4 + 0.033 * P_5 + 0.033
* P_6 + 0.05 * P_7 + 0.067 * P_8 + 0.083 * P_9 + 0.1 * P_10 + 0.083 * P_11
+ 0.133 * P_12 + 0.167 * P_13 + 0.183 * P_14 + 0.083 * P_15 + 0.05 * P_16
+ 0.067 * P_17 + 0.033 * P_18 + 0.05 * P_19 + 0.033 * P_20 <= 250;
0.1 * P_1 + 0.067 * P_2 + 0.167 * P_3 + 0.183 * P_4 + 0.2 * P_5 + 0.217 *
P_6 + 0.133 * P_7 + 0.183 * P_8 + 0.233 * P_9 + 0.25 * P_10 + 0.167 * P_11
+ 0.217 * P_12 + 0.25 * P_13 + 0.233 * P_14 + 0.217 * P_15 + 0.2 * P_16 +
0.2 * P_17 + 0.183 * P_18 + 0.167 * P_19 + 0.15 * P_20 <=600;
0.067 * P_1 + 0.083 * P_2 + 0.067 * P_3 + 0.1 * P_4 + 0.1 * P_5 + 0.117 *
P_6 + 0.133 * P_7 + 0.15 * P_8 + 0.167 * P_9 + 0.183 * P_10 + 0.117 * P_11
+ 0.15 * P_12 + 0.1 * P_13 + 0.167 * P_14 + 0.067 * P_15 + 0.083 * P_16 +
0.067 * P_17 + 0.1 * P_18 + 0.117 * P_19 + 0.133 * P_20 <= 380;
0.05 * P_1 + 0.033 * P_2 + 0.067 * P_3 + 0.067 * P_4 + 0.067 * P_5 + 0.083
* P_6 + 0.117 * P_7 + 0.1 * P_8 + 0.133 * P_9 + 0.15 * P_10 + 0.083 * P_11
+ 0.117 * P_12 + 0.067 * P_13 + 0.133 * P_14 + 0.033 * P_15 + 0.05 * P_16
+ 0.05 * P_17 + 0.067 * P_18 + 0.083 * P_19 + 0.1 * P_20 <= 270;
0.1 * P_1 + 0.117 * P_2 + 0.117 * P_3 + 0.133 * P_4 + 0.133 * P_5 + 0.15
* P_6 + 0.15 * P_7 + 0.133 * P_8 + 0.167 * P_9 + 0.183 * P_10 + 0.167 *
P_11 + 0.183 * P_12 + 0.083 * P_13 + 0.1 * P_14 + 0.133 * P_15 + 0.15 *
P_16 + 0.133 * P_17 + 0.15 * P_18 + 0.167 * P_19 + 0.15 * P_20 <= 450;
0.083 * P_1 + 0.1 * P_2 + 0.05 * P_3 + 0.067 * P_4 + 0.117 * P_5 + 0.133
* P_6 + 0.117 * P_7 + 0.1 * P_8 + 0.083 * P_9 + 0.1 * P_10 + 0.117 * P_11
+ 0.117 * P_12 + 0.133 * P_13 + 0.117 * P_14 + 0.067 * P_15 + 0.05 * P_16
+ 0.033 * P_17 + 0.15 * P_18 + 0.133 * P_19 + 0.067 * P_20 <= 300;
14
0.2 * P_1 + 0.2 * P_2 + 0.3 * P_3 + 0.3 * P_4 + 0.3 * P_5 + 0.15 * P_6 +
0.3 * P_7 + 0.3 * P_8 + 0.3 * P_9 + 0.2 * P_10 + 0.15 * P_11 + 0.05 * P_12
+ 0.2 * P_13 + 0.25 * P_14 + 0.15 * P_15 + 0.05 * P_16 + 0.2 * P_17 + 0.25
* P_18 + 0.25 * P_19 + 0.2 * P_20 <= 650;
0.2 * P_1 + 0.1 * P_2 + 0.1 * P_3 + 0.2 * P_4 + 0.1 * P_5 + 0.2 * P_8 +
0.3 * P_9 + 0.2 * P_10 + 0.25 * P_11 + 0.2 * P_12 + 0.2 * P_13 + 0.3 *
P_14 + 0.3 * P_15 + 0.1 * P_16 + 0.25 * P_17 + 0.25 * P_18 + 0.2 * P_19 +
0.2 * P_20 <= 600;
0.1 * P_1 + 0.2 * P_2 + 0.1 * P_3 + 0.1 * P_4 + 0.1 * P_5 + 0.15 * P_6 +
0.1 * P_7 + 0.1 * P_9 + 0.1 * P_10 + 0.15 * P_11 + 0.15 * P_12 + 0.05 *
P_13 + 0.1 * P_15 + 0.2 * P_16 + 0.1 * P_17 + 0.1 * P_18 + 0.1 * P_19 +
0.15 * P_20 <= 350;
0.1 * P_1 + 0.2 * P_2 + 0.1 * P_3 + 0.1 * P_4 + 0.1 * P_5 + 0.2 * P_6 +
0.2 * P_7 + 0.1 * P_10 + 0.1 * P_11 + 0.15 * P_12 + 0.05 * P_13 + 0.2 *
P_14 + 0.1 * P_15 + 0.2 * P_16 + 0.05 * P_17 + 0.1 * P_18 + 0.1 * P_19 +
0.15 * P_20 <= 400;
Como pudo notar, escribir todo ese código, variable por variable, realmente tomaría mucho tiempo,
además de poder ingresar mal alguna línea, lo que generaría que su solución no sea correcta.
A continuación, explicará cómo debe ingresar este modelo con el lenguaje de modelado de AMPL
para que sea mucho más sencillo resolverlo. Pero, antes de empezar a ver el lenguaje de modelado,
vamos a reconocer los parámetros y las variables que tiene el ejemplo 1.
15
2. ESTRUCTURA DE UN MODELO EN AMPL
2.1. SET
SETS SIMPLES
Para declararlos use la palabra reservada set, seguida del nombre que usted elija. Así por
ejemplo, para declarar el set simple cuyo nombre es “Productos” siga la sintaxis siguiente:
set Productos
A continuación debe declarar el número de miembros tendrá dicho set, según el ejemplo 2, hay
20 productos, por lo que la dimensión (el tamaño del set) sería de 20 y debe ser declarado de
la siguiente manera:
Para declarar la dimensión del set se usó la sintaxis 1..20, ya que el número 1 va a representar
al producto 1, el número 2 al producto 2 y así sucesivamente.
Ahora usted declare en su archivo “.mod” los demás sets simples que sean necesarios para
formular el programa lineal del ejemplo 2.
SETS COMPUESTOS
Estos sets se componen de dos o más sets simples. Para declararlos use la palabra reservada
set, seguida del nombre que usted elija. Así por ejemplo, para declarar el set compuesto cuyo
nombre es “Martriz 1” siga la sintaxis siguiente:
set Matriz1
Y para declarar los sets simples que lo componen se debe seguir la siguiente sintaxis:
Ahora usted declare en su archivo “.mod” los demás sets compuestos que sean necesarios
formular el programa lineal del ejemplo 2.
2.2. Parámetros:
16
debe asociarlo a un set para tomar su dimensión de acuerdo a lo requerido. La siguiente
sentencia ilustra este caso:
Ahora usted declare en su archivo “.mod” los parámetros restantes para formular el programa
lineal del ejemplo 2.
2.3. Variables:
Para declararlos use la palabra reservada var, seguida del Tenga en cuenta:
En AMPL se tiene la opción de
nombre que usted elija y de un set previamente declarado.
declarar el rango de las variables
Así, por ejemplo, para declarar la variable de decisión P agregando “>100”, “<0”, “>=0” ó
del ejemplo 1 la sintaxis sería la siguiente: “<=500”, dependiendo de lo que se
necesite. La sintaxis que se debe
var P {Productos}; seguir puede ser cualquiera de las
siguientes:
Ahora usted declare en su archivo “.mod” el resto de var P {Productos}>=0;
var P {Productos}<=0;
variables que se necesitan para formular el programa var P {Productos}>=0, <200;
lineal del ejemplo 2.
En el ejemplo 2, la empresa desea maximizar las utilidades que se obtienen al vender los
productos. Para formular la función objetivo en AMPL, se escriba la palabra reservada
maximize y a continuación el nombre que usted elija para la función objetivo. En el ejemplo 2,
usaremos el nombre “Utilidades” para la función objetivo y la sentencia es la siguiente:
maximize Utilidades:
Para este caso, el nombre de la F.O. es “Utilidades”, pero si desea puede usar otro nombre.
Siempre es recomendable que guarde relación con lo que se quiere lograr en la F.O.
Maximizar i=1…20(MARGENi*Pi)
maximize Utilidades:
sum {i in Productos} Margen[i] * P[i];
En su archivo “.mod” ingrese la sentencia para la F.O. que se muestra en la línea anterior.
17
Datos importantes:
¿Y si quiero
saber si estoy Para saber si está ingresando bien el
ingresando bien código en sus archivos, cargue los
el código? archivos “.mod” y/o “.dat” en la ventana
de códigos del software AMPLIDE,
recuerde usar la palabra reset luego.
Si desea saber si la sentencia que ha
escrito genera el código algebraico que
desea debe usar el comando expand
seguido del nombre de la sentencia o
F.O.. Por ejemplo:
expand Utilidades;
2.5. Restricciones:
Para escribir la función objetivo se debe empezar escribiendo la palabra reservada “subject to”
y luego se le debe dar un nombre a la restricción, aunque puede usarse el nombre que desee
siempre es recomendable utilizar nombres que tengan relación con la restricción.
0.167 * P_1 + 0.2 * P_2 + 0.417 * P_3 + 0.2 * P_4 + 0.25 * P_5 + 0.283
* P_6 + 0.317 * P_7 + 0.5 * P_8 + 0.333 * P_9 + 0.35 * P_10 + 0.333 *
P_11 + 0.367 * P_12 + 0.333 * P_13 + 0.25 * P_14 + 0.3 * P_15 + 0.283
* P_16 + 0.25 * P_17 + 0.267 * P_18 + 0.233 * P_19 + 0.2 * P_20 <= 900
0.083 * P_1 + 0.067 * P_2 + 0.133 * P_3 + 0.15 * P_4 + 0.033 * P_5 +
0.033 * P_6 + 0.05 * P_7 + 0.067 * P_8 + 0.083 * P_9 + 0.1 * P_10 +
0.083 * P_11 + 0.133 * P_12 + 0.167 * P_13 + 0.183 * P_14 + 0.083 *
P_15 + 0.05 * P_16 + 0.067 * P_17 + 0.033 * P_18 + 0.05 * P_19 + 0.033
* P_20 <= 250
De ellas podemos notar que para el proceso 1, la suma de todo el tiempo que se utiliza en la
producción de todos los productos debe ser menor o igual a 900, en el caso del proceso 2 la
suma de todo el tiempo de producción de todos los productos debe ser menor o igual a 250, y
así sería para los demás procesos que faltan, esto significa que en nuestra restricción, luego del
nombre, debemos agregar una expresión que nos permita hacer la sumatoria para cada
proceso, esta sentencia se llama expresión indexada y a continuación se muestra cómo debe
escribirse:
Expresión
indexada
subject to Tp {j in Procesos}:
sum {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j];
18
Como pudo notar usamos el nombre “Tp” para la restricción de tiempos máximos disponibles
para cada proceso. La expresión indexada {j in Procesos} crea una restricción para
cada proceso y se podría traducir como “para cada j que pertenece a Procesos”.
Ahora cree las restricciones necesarias para cantidad máxima de Materia prima y para la
demanda máxima y mínima de cada producto.
Ahora que ya sabe cómo ingresar un modelo matemático en lenguaje AMPL en el archivo
“.mod”; a continuación, se muestra el código que debió haber ingresado en el archivo.
Revíselo y corrija los errores que pudo haber tenido. En nuestro caso, hemos utilizado como
índices las letras “i” y “j” pero si usted desea puede utilizar cualquier otra letra.
Datos importantes:
A veces se debe iterar usando dos índices. ¿Cómo escribo eso con el lenguaje de AMPL?
Se escribiría en la expresión indexada, que puede usarse tanto para iterar todas las restricciones
de una familia o en una función sum, en cualquiera de los dos casos, se debe escribir de la
siguiente manera:
var P {Productos};
maximize Utilidades:
sum {i in Productos} Margen[i] * P[i];
subject to Tp {j in Procesos}:
sum {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j];
19
subject to Minimo {i in Productos}:
P[i] >= Demandamin[i];
Ahora que ya hemos ingresado nuestro modelo y que aseguramos que no tiene errores, vamos
mencionar algunos errores frecuentes que se pueden presentar cuando ingresamos nuestro modelo
matemático en el archivo “.mod”.
• Los comentarios y las líneas que contienen los nombres de los sets terminan con el signo “;”.
Verifique si lo digitó.
• Los nombres de los sets primitivos invocados en los sets compuestos se
separan con comas y deben iniciar y terminar con los signos “{ }”, verifique que usó esos signos
y no “( )” o “[ ]”
• Se recomienda nombres para los sets que sean fáciles de recordar (se sugiere que tengan
relación con los datos a los que van a ser asignados) porque serán usados en el resto del
programa y usted deberá invocarlos exactamente igual a como los definió en la zona de sets.
• No olvide usar exactamente los nombres declarados para cada set y parámetro ya que AMPL
distingue entre mayúsculas y minúsculas.
• Los sets que se van a asignar a un parámetro deben ingresarse entre “{ }”.
maximize Utilidades:
sum {i in Productos} PV[i] * P[i] - Costo[i] * P[i];
AMPL devolverá un error de sintaxis ya que AMPL solo reconocerá PV[i] * P[i] como parte de
la función sum.
Para que AMPL arroje errores puede escribir la sentencia de tres formas:
maximize Utilidades:
sum {i in Productos} (PV[i] * P[i] - Costo[i] * P[i]);
maximize Utilidades:
sum {i in Productos} (PV[i] - Costo[i]) * P[i];
20
maximize Utilidades:
sum {i in Productos} PV[i] * P[i] - sum {i in Productos}
Costo[i] * P[i];
Si hubiera tenido el signo “+” después de la función sum habría ocurrido el mismo error que se
menciona un par de líneas arriba.
• Si desea más información sobre la declaración de sets con el lenguaje de AMPL puede leer los
capítulos 5 y 6 del libro The AMPL Book.
• Si desea tener más información sobre como declarar las variables e ingresar la función objetivo
y restricciones de un modelo en AMPL puede leer el capítulo 8 del libro The AMPL Book.
En vista que no tenemos un parámetro escalar en el ejemplo 2, supongamos que tenemos que el
tiempo total disponible para todos los procesos es de 1000 horas, y utilizaremos el nombre
Tiempo_total para ese parámetro. Para ingresar el valor de dicho parámetro se debe usar la
siguiente sintaxis:
CUIDADO:
Como ya vimos en esta sección, hay varias palabras reservadas que utiliza AMPL para
definir funciones y otros comandos, estas deben ser escritas siempre de la misma forma
ya que en caso las escribiéramos con mayúsculas AMPL no las reconocería, las palabras
que hemos usado son las siguientes:
21
Ingreso de datos vectoriales:
Los datos vectoriales son los que tienen “m” filas, pero solo una columna, de este tipo de datos
tenemos varios en el ejemplo 2, margen, demanda mínima, demanda máxima, recurso de materia
prima y tiempo máximo disponible.
param Margen:=
1 11
2 15.75
3 10.5
4 10.75 Este signo es el de asignación, y se
5 14.5 utiliza siempre que se desea asignar
un valor a un parámetro.
6 17.25
7 13.5
8 12
9 16
10 17
11 20
12 22
13 18.5
14 17
15 15.5
16 19
17 21.5
18 21.5
19 15.5
20 14.5;
Ahora usted ingrese los valores de los demás parámetros Tenga en cuenta:
vectoriales. Para datos matriciales, se
coloca en la primera fila el
nombre del parámetro al que se
Ingreso de datos matriciales:
le van asignar los datos, y
recién desde la segunda fila se
Para mostrar cómo se deben ingresar los datos de una matriz de dos comienzan a colocar los
dimensiones, utilizaremos el parámetro Tiempo e ingresaremos sus índices.
datos.
param Tiempo:
1 2 3 4 5 6 7 :=
1 0.167 0.083 0.100 0.067 0.050 0.100 0.083
2 0.200 0.067 0.067 0.083 0.033 0.117 0.100
3 0.417 0.133 0.167 0.067 0.067 0.117 0.050
4 0.200 0.150 0.183 0.100 0.067 0.133 0.067
5 0.250 0.033 0.200 0.100 0.067 0.133 0.117
6 0.283 0.033 0.217 0.117 0.083 0.150 0.133
7 0.317 0.050 0.133 0.133 0.117 0.150 0.117
8 0.500 0.067 0.183 0.150 0.100 0.133 0.100
9 0.333 0.083 0.233 0.167 0.133 0.167 0.083
10 0.350 0.100 0.250 0.183 0.150 0.183 0.100
11 0.333 0.083 0.167 0.117 0.083 0.167 0.117
12 0.367 0.133 0.217 0.150 0.117 0.183 0.117
13 0.333 0.167 0.250 0.100 0.067 0.083 0.133
14 0.250 0.183 0.233 0.167 0.133 0.100 0.117
15 0.300 0.083 0.217 0.067 0.033 0.133 0.067
16 0.283 0.050 0.200 0.083 0.050 0.150 0.050
17 0.250 0.067 0.200 0.067 0.050 0.133 0.033
22
18 0.267 0.033 0.183 0.100 0.067 0.150 0.150
19 0.233 0.050 0.167 0.117 0.083 0.167 0.133
20 0.200 0.033 0.150 0.133 0.100 0.150 0.067;
Ahora usted ingrese los datos para los parámetros de cantidad máxima de recurso disponible.
En el ejemplo 2 no tenemos un caso con matrices de 3 dimensiones, por ello, suponga el siguiente
ejemplo 3:
Usted tiene una empresa donde hace 6 productos y tiene 3 máquinas para producir cualquiera de
los 6 productos, además, en su empresa se trabaja 3 turnos. Producir un producto en cada máquina
y en cada turno tiene costos diferentes; por ejemplo, el producto 1 en la maquina 1 en el turno 1
puede costar 10 UM mientras que el producto 1 en la máquina 2 en el turno 1 puede costar 12 UM.
Para poder crear y asignar los valores al parámetro Costo, primero crearemos los sets primitivos, el
set compuesto, el parámetro.
#Sets primitivos
set Turno; Tenga en cuenta:
set Maquinas; Podemos iterar en varios sets con
set Productos; los que no se ha creado un set
compuesto. Por ejemplo, si
#Sets compuestos tuviéramos que iterar una
set Matriz={Productos,Maquinas,Turno}; restricción en Productos y Turnos,
haríamos lo siguiente:
#Parametro de Costos subject to ¨Nombre¨ {i in
param Costo {Matriz}; Productos, k in Turnos}
Ahora, procederemos a asignar los valores al parámetro costo:
param Costo :=
[*,*,1]: 1 2 3 :=
1 13.0 10.0 12.0
2 13.0 13.0 13.0 No se coloca el signo “;” al final de cada tabla,
3 10.0 15.0 14.0 sino solo en la última
4 14.0 15.0 11.0
5 10.0 14.0 12.0
6 12.0 14.0 12.0
[*,*,2]: 1 2 3 :=
1 21.0 19.0 25.0
2 17.0 22.0 20.0
3 18.0 18.0 20.0
4 21.0 19.0 18.0
5 24.0 24.0 25.0
6 21.0 17.0 20.0
[*,*,3]: 1 2 3 :=
1 30.0 30.0 29.0
2 27.0 30.0 32.0 No se coloca el signo “;” al final de cada
3 31.0 27.0 32.0 tabla, sino solo en la última
4 32.0 32.0 27.0
5 28.0 29.0 29.0
6 31.0 29.0 27.0;
La primera tabla son los costos de producir un producto en cada máquina durante el primer turno,
la segunda tabla son los costos de producir un producto en cada máquina durante el segundo turno
y la tercera tabla son los costos de producir un producto en cada máquina durante el tercer turno.
23
ERRORES EN EL INGRESO DE LOS DATOS
Para tener más información sobre como ingresar los datos de los parámetros en un archivo “.dat”
puede ir al capítulo 9 del libro The AMPL Book.
AMPL puede comunicarse con diferentes solvers, los cuales tienen diferentes características y usos,
por lo que es importante saber cuál de ellos está utilizando al resolver un modelo.
Por defecto AMPLIDE está configurado para utilizar el software MINOS al resolver un modelo de
optimización. Por lo que si usted desea saber cuál es el solver que está utilizando para resolver un
modelo debe escribir el siguiente comando en la ventana de comandos:
Si usted ingresa este comando en su ventana de códigos, AMPLIDE le arrojará el siguiente mensaje,
donde se le mencionará cuál solver está utilizando:
Por ejemplo, si quisiéramos cambiar de solver y utilizar el cplex en vez del minos, deberíamos
ingresar el siguiente código:
24
5. COMO RESOLVER UN MODELO USANDO EL LENGUAJE AMPL Y LA INTERFAZ
AMPLIDE
Para resolver un modelo en lenguaje AMPL, primero debe cargar los archivos “.mod” y “.dat” y luego
usar el comando solve. Para los archivos que se han utilizado en esta guía se debería ingresar el
siguiente código en la ventana de comandos:
ampl: solve;
Esto significa que se obtuvo la solución óptima del problema teniendo como valor de la función
objetivo 50 289.23 y usando el solver MINOS en su versión 5.51.
Problema 1
La compañía CCS fabrica un producto de consumo masivo en cinco plantas y las vende a 10
clientes.
El precio que paga cada cliente por cada mil unidades, así como los costos de producción más el
costo de transporte de los productos desde cada planta hasta cada cliente, también por cada mil
unidades, se presenta en la tabla 2. Estos datos están anotados en el archivo cuyo nombre es
“Segunda guía de AMPL datos problema 2.xlsx” y está disponible en el campus virtual PUCP con el
propósito de que usted los pegue en el software AMPLIDE.
Los requerimientos de tiempo de mano de obra en cada planta para fabricar mil productos se
muestran en la tabla 3, asimismo, el tiempo total disponible de cada una de las cinco plantas suman
en total 60 000 horas; sin embargo, es posible comprar horas de mano de obra adicionales a 10
dólares la hora.
25
Tabla 3: requerimiento de tiempo por mil unidades
Horas por cada mil unidades
Planta 1 Planta 2 Planta 3 Planta 4 Planta 5
Producto 14 15 16 13.5 14
La cantidad de productos que se pueden fabricar como máximo en las cinco plantas es 750; 950; 1
000; 1 050 y 650, todas en miles de unidades, respectivamente; por otro lado, la demanda de
cada cliente es 400 mil unidades.
A continuación, se presenta las variables de decisión y algunas restricciones para este problema de
programación lineal cuyo objetivo es la maximización de las utilidades.
Variables de decisión
Restricciones
Restricciones de capacidad:
Para la planta 1:
X_1_1 + X_1_2 + X_1_3 + X_1_4 + X_1_5 + X_1_6 + X_1_7 + X_1_8 + X_1_9 + X_1_10
<= 750;
Que expresado como sumatoria es:
10
X1j ≤ 750
j=1
…
Restricciones de demanda:
Para el cliente 1:
X_1_1 + X_2_1 + X_3_1 + X_4_1 + X_5_1 >= 400;
Que expresado como sumatoria es:
5
Xi1 ≥ 400
i=1
…
Se pide:
a) Defina la variable de decisión MO y complete en términos algebraicos la función objetivo, las
restricciones de demanda, oferta y de tiempo que faltan y defina el rango de existencia de este
modelo. (Se recomienda usar sumatorias: ).
b) Formule el modelo en el lenguaje de modelado de AMPL. Indique claramente sus sets,
parámetros, variables, la función objetivo y las restricciones. Si requiere efectuar comentarios
para explicar mejor su modelo, anótelos.
c) Resuelva el modelo con el solver MINOS y CPLEX y conteste las siguientes preguntas:
26
▪ ¿Cuál es la utilidad óptima?
▪ ¿Qué clientes se atienden y qué cantidad desde cuál planta?
▪ ¿En qué plantas se usa el total de su capacidad en unidades?
▪ ¿La solución óptima del modelo sugiere adquirir horas adicionales?
Machinco elabora cuatro productos, los cuales requieren de tiempo en dos máquinas y de dos tipos
de mano de obra (calificada y no calificada). La cantidad de tiempo de máquina y de mano de obra
en horas necesarias para cada producto y los precios de venta se proporcionan en la tabla 4.
Se dispone todos los meses de 700 horas en la máquina 1 y 500 horas en la máquina 2. Machinco
puede comprar cada mes hasta 600 horas de mano de obra calificada a 8 dólares la hora, y hasta
650 horas de mano de obra no calificada a 6 dólares la hora.
1 11 4 8 7 300
2 7 6 5 8 260
3 6 5 4 7 220
4 5 4 6 4 180
Se pide:
a) Formule un modelo de programación lineal adecuado a esta situación.
b) Formule el modelo anterior en el lenguaje de modelado de AMPL y responda las siguientes
preguntas:
▪ ¿Cuál es la utilidad óptima que se podría lograr?
▪ ¿Cuántas unidades de cada tipo se produce?
▪ ¿Cuántas horas de mano de obra calificada y no calificada se adquieren?
27
Anexo 1
28
Anexo 2
Disponibilidad de
tiempo en horas
900 250 600 380 270 450 300
29
Anexo 3
30
TERCERA GUÍA DE AMPL
AMPL proporciona opciones que permiten analizar la sensibilidad de un modelo matemático y que
son útiles para poder variar algunos valores de parámetros, variables o de la función objetivo.
Precio dual
Holguras
Costo reducido
▪ Precio dual:
Representa la variación en la cantidad de la función objetivo como consecuencia de
modificar la cantidad de un recurso, se puede calcular como una ratio de contribución de un
aumento o disminución unitaria en la disponibilidad de un recurso sobre la función objetivo:
∆𝑓𝑢𝑛𝑐𝑖ó𝑛 𝑜𝑏𝑗𝑒𝑡𝑖𝑣𝑜
𝑃𝑟𝑒𝑐𝑖𝑜 𝑑𝑢𝑎𝑙 =
𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒𝑙 𝑟𝑒𝑐𝑢𝑟𝑠𝑜 𝑏𝑖
Algunos autores la denominan precio sombra. El signo de este indicador está en función del
tipo de restricción, es decir, si la restricción es “≤” utiliza una variable de holgura "+ hi", por
lo cual tiene un signo positivo; así también si la restricción es “≥” utiliza una variable de
excedente "-ei", por lo que tiene un signo negativo.
31
▪ Holgura / excedente:
La holgura o excedente se analiza en cada restricción (Slack or surplus). La holgura
representa la cantidad que no se usa de un recurso (sobrante), y el exceso representa la
cantidad adicional de uso mínimo de un recurso.
▪ Costo reducido:
La definición del costo reducido se basa en la explicación del análisis de sensibilidad de la
función objetivo. Se formaliza en la literatura de PL como:
Con la definición dada de costo reducido, podemos ver que una variable no rentable
(variable no básica, cuyo valor es cero) puede hacerse rentable de dos maneras:
En la mayoría de las situaciones, las condiciones del mercado dictan el precio por unidad y
puede ser difícil incrementarlo a voluntad. Por otra parte, una opción más viable es reducir
el consumo de recursos porque el fabricante puede reducir el costo si hace que el proceso
de producción sea más eficiente.
En el ejemplo 1 es importante saber cuántas horas se tienen disponibles en cada uno de los
procesos y cuánto costaría aumentar una hora a un proceso en caso sea necesario; por lo tanto, se
necesita conocer los precios sombra y las holguras. Para ello se usará el siguiente código: (El
nombre de la restricción es Tp)
32
Como puede notar, cuando la holgura es positiva el precio sombra es cero ya que aún hay tiempo
disponible en el proceso para seguir trabajando; pero para el caso del proceso 7, la holgura es igual
a 0 y por ello al aumentar en una hora el tiempo máximo disponible se obtendría 115.358 UM extra.
Para éste caso, cuando se aumentan horas al proceso 7 se aumenta la utilidad ya que el precio
sombra de dicha restricción es positivo; pero, también podría darse el caso que haya precios
sombras negativos, lo cual significa que para aumentar una unidad a la restricción se tendría una
disminución en el valor de la función objetivo igual al valor del precio sombra.
Para conocer el costo reducido de las variables se debe usar el siguiente código:
display P.rc;
Datos importantes:
CPLEX permite conocer el rango de valores de variación de los coeficientes de la F.O. Primero se debe
activar una opción del solver con el siguiente código:
33
AMPL indica que, como todos los valores de P son positivos, presentan costos reducidos iguales a
cero y por tanto no es necesario variar los coeficientes de la función objetivo pues las variables Pi
ya forman parte de la solución básica. Si desea más información sobre los comandos de análisis de
sensibilidad de AMPL puede consultar el capítulo 12 del libro The AMPL Book.
AMPL dispone de operadores lógicos para definir expresiones condicionales con el propósito de
aplicar ciertas condiciones a una familia de restricciones, a un grupo de variables en las restricciones
y a la función objetivo, entre otros casos.
= : Igual a
<> : Diferente de
< : Menor que
<= : Menor o igual a
> : Mayor a
>= : Mayor o igual a
Con el siguiente ejemplo se podrá entender mejor cómo funcionan estos operadores lógicos.
Ejemplo 1
Friedman S.A. desea determinar cuántas lanchas debe producir los próximos seis meses para
satisfacer a tiempo la demanda, que en el primer mes es 400 unidades, en el segundo 600 unidades,
en el tercero 750, en el cuarto 250, en el quinto 300 y en el sexto 450.
Para los cuatro primeros meses la capacidad normal de producción es 200 lanchas, y para los dos
últimos es hasta 300 lanchas. Cada unidad fabricada en tiempo normal cuesta 500 dólares el primer
mes y en los siguientes se estima que crezca en 25 dólares mensualmente. La empresa también
puede producir más lanchas haciendo trabajar horas extras a su personal a un costo de 550 dólares
el primer mes y cuyo incremento es 30 dólares mensualmente. Se sabe que el nivel de existencias
al inicio del primer mes es 20 lanchas.
La empresa decide al principio de cada mes cuántas lanchas hay que construir en dicho período
pero debe cumplirse las siguientes políticas:
▪ Necesariamente en los dos primeros meses la producción debe ser como mínimo 50 lanchas
en cada mes.
▪ La producción en tiempo extra de los dos primeros meses debe ser como máximo 350 lanchas
en cada mes.
▪ En los tres últimos meses la producción en tiempo normal más lo elaborado en tiempo extra no
debe superar las 550 unidades en cada mes.
La demanda se satisface al final de cada mes, luego de atenderla, las lanchas sobrantes se envían
a un almacén y se incurre en costos por almacenamiento cuyo importe es 15 dólares por cada lancha
guardada durante un mes.
El modelo de programación lineal que permite a Friedman programar su producción a costo mínimo
para el próximo semestre es el siguiente.
34
Variables de decisión:
Función objetivo:
Minimizar t=1…6(COSTNORMALt*PRODNORMALt + COSTEXTRAt*PRODEXTRAt) +
t=1…5(COSTOALMACEN*IFLANCHAt) + COSTOALMACEN*II
Restricciones:
Ecuaciones de inventario:
IFLANCHA1 = II + PRODNORMAL1 + PRODEXTRA1 – DEMANDA1
IFLANCHAt = IFLANCHAt-1 + PRODNORMALt + PRODEXTRAt – DEMANDAt;
t=2,3…6
Capacidad normal:
PRODNORMALt ≤ CAPNORMALt ; t=1,2…6
Producción mínima en los dos primeros meses:
PRODNORMALt ≥ PRODMIN; t=1,2
Producción máxima en tiempo extra en los dos primeros meses:
PRODEXTRAt ≤ PRODMAXTEX12; t=1,2
Producción máxima en los tres últimos meses:
PRODNORMALt + PRODEXTRAt ≤ PRODMAX; t=4,5,6
Rango de existencia:
PRODNORMALt ≥ 0 ; PRODEXTRAt ≥ 0 ; IFLANCHAt ≥ 0 ; t=1,2…6
Antes de empezar a escribir el ejercicio en lenguaje de AMPL vamos a reconocer los parámetros y
las variables del problema que se muestran en la tabla 5.
35
A continuación se le muestran los sets, parámetros y variables que se han declarado e ingresado al
archivo “Ejercicio1_guia3.mod”.
En la función objetivo del ejercicio 1, los costos de almacenamiento son considerados solo hasta el
mes 5, por lo que se debe usar operadores lógicos para escribir la F.O. A continuación se muestra
como se escribe dicha sentencia:
minimize Costo_total:
sum {i in Periodo} (COSTONORMAL[i] * PRODNORMAL[i] +
COSTOEXTRA[i] * PRODEXTRA[i]) + sum {i in Periodo:i<=5}
COSTOALMACEN*IFLANCHA[i]+COSTOALMACEN*II;
Use el comando expand para ver cuál es el código algebraico que genera dicha sentencia. Debe
tener en cuenta que no se considera el costo de mantener en almacén las lanchas del periodo 6. A
continuación se muestra el código generado por la sentencia.
minimize Costo_total:
500*PRODNORMAL[1] + 525*PRODNORMAL[2] + 550*PRODNORMAL[3] +
575*PRODNORMAL[4] + 600*PRODNORMAL[5] + 625*PRODNORMAL[6] +
550*PRODEXTRA[1] + 580*PRODEXTRA[2] + 610*PRODEXTRA[3] +
640*PRODEXTRA[4] + 670*PRODEXTRA[5] + 700*PRODEXTRA[6] +
15*IFLANCHA[1] + 15*IFLANCHA[2] + 15*IFLANCHA[3] + 15*IFLANCHA[4] +
15*IFLANCHA[5] + 300;
Note que al final de la expresión anterior hay una cifra igual a 300, esta es el resultado del producto
COSTOALMACEN*II; usualmente AMPL realiza las operaciones aritméticas de parámetros cuyos
valores son únicos.
36
2.2. Modelado de las restricciones con los operadores lógicos
Para las ecuaciones de inventario, debe tener en cuenta que para el mes 1 no se tiene inventario
final de un mes anterior, sino que se considera el inventario inicial. Para modelar dicha situación se
van a utilizar los operadores lógicos. A continuación se muestra cómo escribir las ecuaciones de
inventario con los operadores lógicos:
Este operador lógico se usa
para crear la ecuación de
inventarios solo para el mes 1
#Ecuaciones de inventario
subject to Produccion_mes1 {i in Periodo: i=1}:
IFLANCHA[i] = II + PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i];
Como puede notar, se han creado dos restricciones; por tanto, al usar el comando expand con la
restricción Produccion_mes1 se va a mostrar solo las ecuaciones para el mes 1.
Ahora, usted cree ingrese las sentencias para las restricciones que faltan. En el anexo 4 se muestra
como se han escrito las demás sentencias para que pueda ver si ha cometido algún error al utilizar
los operadores lógicos. En el anexo 5 se muestra el código algebraico generado por AMPL luego de
ingresar el modelo completo.
En ocasiones, algunos modelos necesitan que se usen dos o más operadores en una sola sentencia.
Para esto en AMPL se cuenta con los operadores lógicos and y or. Se va a usar el ejemplo 2 para
explicar su uso.
Ejemplo 2
Una empresa hace 3 tipos de productos, 1, 2 y 3 y desea obtener el plan de producción para los
siguientes dos meses de acuerdo a algunas condiciones de demanda en el mercado y las
limitaciones que tiene en su planta.
37
los productos 1 y 3 para ambos meses es de 500 y 650 respectivamente. El tiempo disponible por
para cada mes es de 200 horas y 270.
Archivo “Ejemplo2_guia3.mod”:
maximize Ganancias:
sum {(i,j) in Matriz} Prod[i,j] * PV[i];
Archivo “Ejemplo2_guia3.dat”:
param PV:=
1 15
2 20
3 10;
param Tiempo:=
1 0.12
2 0.15
3 0.08;
38
param T_disponible:=
1 500
2 650;
param D_max :
1 2 :=
1 500 500
2 0 0
3 650 650;
Use el comando expand para observar el código algebraico. En el anexo 6 puede observar todo el
código algebraico de este modelo.
Si desea más información sobre cómo usar los operadores lógicos puede leer el capítulo 7 del libro
The AMPL Book.
3. LA FUNCION IF-THEN-ELSE
Como pudo notar en el ejemplo 1, para poder hacer las ecuaciones de inventarios tuvo que crear
dos diferentes sentencias, una para el mes 1 y otra para los demás meses. Esto puede evitarse
usando la función if-then-else.
if a then b else c.
#Ecuaciones de inventario
subject to Produccion {i in Periodo}:
(if i=1 then II else IFLANCHA[i-1]) + PRODNORMAL[i] + PRODEXTRA[i] -
DEMANDA[i] = IFLANCHA[i];
Tenga en cuenta que la función if-then-else ha sido escrita entre paréntesis en la restricción,
en caso no se usaran los paréntesis “( )” la función en AMPL reconocería que si i=1 entonces se
debe devolver el valor de II y en caso i>1 entonces se debe devolver IFLANCHA[i-1] +
PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i]cuando para i>1 solo se debe devolver el
valor IFLANCHA[i-1].
Use el comando expand y podrá notar que el código algebraico que se genera es el mismo que
cuando tenía dos sentencias para la misma restricción.
39
Cuidado:
La función if-then-else no puede ser escrita de la siguiente manera:
ya que solo puede colocarse colocar signos como “>”, “<”, “>=” ó “<=” al final de la restricción
y no en medio de la función.
Si desea más información sobre cómo utilizar la función if-then-else puede leer los capítulos 7
y 13 del libro The AMPL Book que se encuentra disponible en la página web de AMPL.
4. PROBLEMAS PROPUESTOS
Un alimento se produce mediante refinado y mezcla de cinco tipos de sustancias líquidas de dos
clases: artificiales y naturales. Cada sustancia puede adquirirse para reparto inmediato o futuro. La
tabla 6 muestra los precios en cierta moneda por cada kilogramo de las sustancias para el primer
semestre del año entrante.
El precio de venta del producto es de 170 u.m. por kilogramo de sustancia refinada.
A lo sumo se puede refinar 320 kilogramos de sustancias artificiales y 350 kg de sustancias naturales
por mes. El proceso de refinado se realiza sin pérdida de peso y sin costo. Además, se puede
almacenar hasta 1360 kg de cada sustancia para su posterior uso, con costo de almacenamiento
de 6 u.m./kg. No es posible almacenar el alimento ni las sustancias refinadas. Existe además una
restricción tecnológica sobre la dureza del alimento que debe estar entre 5 y 7 unidades. Se supone
que las durezas de las sustancias se mezclan linealmente, tales datos se muestran en la tabla 7.
40
Tabla 7: Dureza de cada sustancia
Dureza
Artificial 1 Artificial 2 Natural 1 Natural 2 Natural 3
9.5 7.1 3.4 5.2 4.8
Se comienza con un inventario de 730 kg de cada sustancia y se desea disponer de ese mismo
inventario al final de junio.
41
Anexo 4
set Periodo = 1..6;
minimize Costo_total:
sum {i in Periodo} (COSTONORMAL[i] * PRODNORMAL[i] + COSTOEXTRA[i]
* PRODEXTRA[i]) + sum {i in Periodo: i<=5} COSTOALMACEN *
IFLANCHA[i] + COSTOALMACEN * II;
#RESTRICCIONES
#Ecuaciones de inventario
subject to Produccion_mes1 {i in Periodo: i=1}:
IFLANCHA[i] = II + PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i];
#Capacidad maxima
subject to Capacidad_maxima {i in Periodo}:
PRODNORMAL[i] <= CAPNORMAL[i];
42
Anexo 5
Función objetivo:
Ecuaciones de inventario:
Capacidad máxima:
43
Anexo 6
Función objetivo:
44
CUARTA GUÍA DE AMPL
Para ver la aplicación de un archivo “.run” se usará el modelo “Ejemplo1.mod” de la guía 1 cuyo
código era el siguiente:
var A;
var B;
maximize Utilidad: 7*A + 3*B;
subject to Tiempo_disponible: 0.1*A + 0.2*B <= 80;
subject to Demanda_max_A: A <= 200;
subject to Demanda_max_B: B <= 160;
Si usted desea conocer el valor de la función objetivo y el de las variables tendría que escribir una
serie de códigos en la ventana de comandos; y en caso realizara algún cambio en el modelo tendría
que usar el comando reset y volver a escribir todo el código para resolver el modelo nuevamente.
Este procedimiento se vuelve engorroso cuando se trabaja a gran escala y con modelos más
complejos. Por ello, a continuación va a aprender cómo utilizar un archivo “.run” que va a facilitar
mucho el proceso de resolver varias veces un mismo modelo.
El proceso para crear un archivo “.run” es similar al de los archivos “.mod” y “.dat” con ayuda del
ícono New File. La diferencia está en que ahora se deberá escoger la opción “.run” en la extensión
de archivo como se muestra en la figura 19. Para el ejemplo se usará el nombre “Run1”.
Como observará, se abrió una nueva pestaña en la ventana de modelado. En este nuevo archivo
escriba lo siguiente:
45
model Ejemplo1.mod;
solve;
display A,B;
reset;
Estos son los códigos que normalmente tendría que escribir en la ventana de comandos para
obtener el valor de la función objetivo y de las variables. Sin embargo, al estar en la ventana de
modelado, no se ejecuta la solución tras escribir las sentencias. Otra diferencia que resalta es el
color de las palabras. Grabe el archivo “.run” y para poder ejecutarlo en AMPLIDE deberá ingresar
el siguiente código en la ventana de comandos:
A continuación se procede a mostrar el modelo matemático del Ejemplo 1 traducido a lenguaje AMPL
y que usted trabajó en la guía 2. Podrá encontrarlo en la intranet con el nombre de
“Ejemplo1_guia4.mod” dentro de la carpeta “Cuarta guía” de la carpeta “Guías de laboratorio”.
var P {i in Productos};
maximize Utilidades:
sum {i in Productos} Margen[i] * P[i];
46
subject to Tp {j in Procesos}:
sum {i in Productos} Tiempo_prod[i,j] * P[i] <= RecursoT[j];
Ingrese a su intranet y dentro de la carpeta “Guía de laboratorio” encontrará la carpeta “Cuarta guía”
donde está el archivo “Cuarta guía ejemplo 1.xlsx”, descárguelo ya que en él se encuentran los
datos de todos los parámetros necesarios para resolver el “Ejemplo 1” de la segunda guía. En la
figura 20 se muestran dichos datos.
Tenga en cuenta:
Al inicio de cada una de las columnas de
datos se ha escrito el nombre del
parámetro tal y como fue declarado en
el archivo “.mod”.
Por ejemplo, en la celda C1 se ha escrito
el nombre Demandamin y en las
siguientes 20 celdas se ha ingresado la
demanda mínima que le corresponde a
cada producto
En el mismo archivo Excel también se ha creado una tabla a la cual se exportarán los resultados de
la variable P, que empieza en la celda A24. En la figura 21 se muestra dicha tabla. En la columna
B24 se ha escrito el nombre de la variable de la cual se van a exportar los resultados. Recuerde que
el nombre de la variable que escriba en el archivo debe ser exactamente el mismo que utilizó en el
archivo “.mod”.
47
Figura 21: columna donde se exportarán los datos
Debe usar el administrador de nombres para darle un nombre a cada una de las tablas y AMPL
pueda reconocerlas para importar o exportar datos.
Para nombrar cada una de las tablas debe ir a la pestaña “Fórmulas” y luego presionar el ícono
“Administrador de nombres”. Se desplegará la ventana que se muestra en la figura 22.
48
A1:D21 (véase la figura 18); la figura 23 presenta el rango seleccionado, nótese que en una sola
tabla se están ingresando los valores de varios parámetros. Presione el botón Aceptar y Excel
retornará a la ventana “Administración de nombres”.
Haga lo mismo para las tablas donde se muestran los datos de “RecursoMP” y “RecursoT”.
Ahora vamos a declarar los nombres de las matrices que tienen los datos de los parámetros “MP” y
“Tiempo_prod”. Para el caso de la matriz “Tiempo” el rango que debería ingresar es O2:V22.
Tenga en cuenta:
El nombre que utilice para una
tabla no puede ser igual que el
de un parámetro, variable,
función objetivo o restricción-
También se debe declarar el nombre de la tabla donde se van a exportar los datos de la variable P.
En la figura 25 se muestra como se ha declarado el nombre de esa tabla.
49
Luego de declarar los nombres de todas las tablas donde están los datos que necesita para resolver
el modelo, la ventana “Administrador de Nombres” de su archivo Excel se debería ver como la de la
figura 26.
Cuidado:
En el campo “Hace referencia a:” deberá colocar todo el rango de la tabla, incluyendo las
celdas donde están los nombres de los parámetros y la columna donde están los miembros
de los sets a los que está indexado cada parámetro.
Por ejemplo, para la matriz “Tiempos” se debe incluir la fila P2:V2 y la columna donde están
los miembros del set Productos, cuyas celdas son O2:O22.
50
A continuación, se va a explicar que significa cada una de las partes del código:
Código que utiliza AMPL Nombre del archivo donde se encuentra la tabla declarada. Se
para reconocer una tabla debe agregar la extensión, que puede ser .xls, .xlsx o .xlsz
Nombre de la tabla. Debe ser Código que utiliza AMPL saber leer archivos de Excel. La
el mismo que declaro en Excel palabra IN debe ir en mayúscula. Siempre se debe ingresar
Indica que los valores de la primera columna Indica que los datos de la segunda columna serán
de la tabla Prod_par, que empieza con la asignados al parámetro Margen, los de la tercera al
palabra Productos, son los 20 miembros del parámetro Demandamin y los de la cuarta a Demandamax
set Productos
Ahora usted declare en el archivo “Cuarta_guia.run” las demás tablas de datos vectoriales que faltan
en para resolver en modelo. Recuerde que debe grabar su archivo.
La primera línea de código tiene exactamente la misma sintaxis que en el caso de datos vectoriales,
por lo que sólo se explicará que significa la segunda línea de código:
Asocia los valores de la Lee los valores de cada celda y los va almacenando, esto
primera columna de la es, para i=1 va a leer y almacenar los valores que tendría
tabla al set Productos Tiempo_prod[1,1], Tiempo_prod[1,2], etc.
Ahora usted ingrese en su archivo “Cuarta_guia.run” el código para declarar la matriz MP.
Luego de declarar todas las tablas en su archivo “Cuarta_guia.run” usted debería tener el siguiente
código:
51
table Prod_par IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':
[Productos], Margen, Demandamin, Demandamax;
Cuidado:
Recuerde que debe guardar el archivo Excel del que va a importar los datos en la misma
carpeta de los archivos “.mod” y “.run”, de lo contrario deberá colocar toda la ruta donde
se encuentra el archivo. Tendría que ser de la siguiente manera:
En el ejemplo mostrado, solo se tiene que exportar los resultados de la variable P. A continuación
se va a mostrar el código que se debe ingresar para declarar en AMPL la tabla donde se van a
exportar esos resultados.
table Resultados OUT 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':
[Productos], P;
Como puede notar, la sintaxis es exactamente la misma que cuando se quiere declarar tablas para
lectura de datos, solo que en vez de usar la palabra IN se usa la palabra OUT, la cual también debe
ser escrita en mayúsculas.
Como para el Ejemplo 1 no se tienen variables matriciales se usará el Ejemplo 2 para explicar la
exportación de variables matriciales. No se va a explicar sobre qué trata dicho ejemplo, solo se le
proporcionará el archivo “.mod” con el código. En su intranet, en la carpeta “Cuarta guia” encontrará
los archivos “Cuarta guía ejemplo 2.xlsx”, “Ejemplo2_guia4.mod”, “Ejemplo2_guia4.dat” y
“Ejemplo2_guia4.run”, descárguelos y notará que en archivo “.mod” se encuentra el siguiente
código:
set Inicio := 1..5;
set Destinos := 1..5;
set Matriz := {Inicio,Destinos};
52
param Distancias {Matriz};
var u {Inicio};
var X {Matriz} binary;
minimize Distancia_total:
sum {(i,j) in Matriz:i<>j} X[i,j] * Distancias[i,j];
En el archivo “.dat” están los valores del parámetro Distancias y en el archivo “.run” va a encontrar
el siguiente código:
model Ejemplo2_guia4.mod;
data Ejemplo2_guia4.dat;
Como puede notar, la sentencia es muy parecida a la que se utilizó para leer datos matriciales, solo
que en este caso se usa la palabra OUT en vez de IN. A continuación se va a explicar con
detenimiento la segunda línea del código:
Asocia los valores de la primera Exporta los valores de las variables en cada celda de la tabla, esto
columna de la tabla al set Inicio es, para i=1 va a exportar el valor X[1,1], X[1,2], X[1,3] y así
sucesivamente
Ejecute el archivo “.run” y notará que en el archivo Excel se han exportado los resultados de la
variable X.
53
2.6. Comandos read table y write table
Finalmente, ya que ha declarado todas las tablas que necesita y ha escrito los comandos para leer
y escribir datos, su archivo “.run” debería quedar de la siguiente forma. En caso no sea así complete
lo que le falte para que quede exactamente igual.
model Ejemplo1_guia4.mod;
Si desea más información sobre cómo exportar e importar datos con AMPL y Excel lea el capítulo
10 del libro The AMPL Book.
54
Datos importantes:
También se puede leer y escribir datos cuando hay parámetros o variables indexadas
a tres sets. Se utilizará el siguiente ejemplo:
Una empresa produce 2 productos, usando 2 máquinas en 2 diferentes turnos. Se
tienen costos diferentes dependiendo del horario, máquina y producto. Mostraremos
sólo la declaración de sets, parámetros y variables.
A continuación se mostrará el código para declarar la tabla de donde se van a leer los
datos.
table Costo_Prod IN 'tableproxy' 'odbc' 'Ejemplo 3 set.xlsx':
[Producto, Maquina, Dia], Costo;
55
2.7. UTILIDAD DE UN ARCHIVO “.run”
56
QUINTA GUÍA DE AMPL
En la quinta guía se explicaran los comandos LET, FIX, UNFIX, FOR y REPEAT usando
el AMPL.
Nociones previas
A lo largo de esta guía se va a aprender cómo crear scripts (ejecutables) y modificarlos, de manera
que se pueda evaluar diferentes escenarios que podrían proporcionar diferentes soluciones para un
mismo modelo y que ayudarán en la toma de decisiones.
A lo largo de esta guía se usará el ejemplo 1 de la guía 2 para todos los ejemplos. Para ello, en su
intranet se encuentran los archivos del modelo y de datos con los nombres de “Ejemplo_guia5.mod”
y “Ejemplo_guia5.dat”.
A continuación se detallará los comandos let, fix y unfix, además de desarrollar ejercicios y analizar
sus ventajas.
El comando let permite cambiar valores en un modelo sin tener que cargar nuevamente el modelo
o cambiar algo en el archivo de datos. Como ejemplo, en el “Ejemplo_guia5.mod” se analizará cuál
de sus restricciones tendría que incrementar para poder aumentar las utilidades y se usará el
comando let para incrementar el recurso requerido.
ampl: solve;
CPLEX 12.6.3.0: optimal solution; objective 50289.23077
1 dual simplex iterations (0 in phase I)
Se puede observar que el proceso 7 está empleando el total de tiempo disponible, es por esto que
se incrementará el límite a 400 horas. Eso se realiza de la siguiente manera:
57
ampl: let RecursoT[7] := 400;
ampl: solve;
CPLEX 12.6.3.0: optimal solution; objective 50655
1 simplex iterations (0 in phase I)
Ahora se va a incrementar la cantidad máxima de cada producto. Para hacerlo se usará una
expresión indexada para que con solo una sentencia se incremente la cantidad máxima de todos
los productos. No use el comando reset.
En el caso anterior se está incrementando en 10% la cantidad máxima de todos los productos, pero
también se podría definir la misma cantidad máxima para todos los productos, que se haría de la
siguiente manera:
Datos importantes:
Al usar la expresión indexada con el comando let se ha utilizado el índice “i”, que es el
mismo que se usa a lo largo del modelo, pero también puede usar otro índice, por ejemplo,
use el índice “h” y notará que ocurre lo mismo.
let {h in Productos} Demandamax[h] := 1.1 * Demandamax[h];
El comando fix sirve para asignar valores a las variables, como si se hubiera colocado una restricción
en el modelo a que obligara a las variables a tomar ciertos valores arbitrarios; y, el comando unfix
sirve para revertir este efecto. Por ejemplo, para el ejemplo 1 de la guía 2 se va a asignar los valores
de la demanda mínima a la variable P.
58
1 10
2 15
3 0
4 0
5 10
6 0
7 10
8 0
9 20
10 25
11 15
12 10
13 0
14 0
15 0
16 10
17 0
18 0
19 0
20 0
;
Si se resuelve nuevamente el modelo notará que ahora si se obtiene la cantidad óptima a producir
de cada producto de acuerdo a las restricciones planteadas.
ampl: solve;
CPLEX 12.6.3.0: optimal solution; objective 50289.23077
1 dual simplex iterations (0 in phase I)
ampl: display P;
P [*] :=
1 150
2 80
3 90
4 100
5 180
6 150
7 122.906
8 145
9 100
10 110
11 150
12 160
13 165
14 155
15 150
16 250
17 150
18 200
59
19 250
20 180
;
AMPL tiene comandos que permiten iterar sentencias automáticamente, de manera que se puedan
realizar varias de las operaciones que se desarrollaron en los ejemplos de ésta guía usando menor
cantidad de sentencias. El comando for ejecuta un grupo de sentencias en un archivo “.run” un
determinado número de veces.
model Ejemplo_guia5.mod;
data Ejemplo_guia5.dat;
for {1..3} {
let {i in Procesos} RecursoT[i] := RecursoT[i] * 1.05;
let {h in Productos} Demandamax[h] := Demandamax[h] * 1.1;
solve;
display P;
}
Esta forma de analizar un modelo se entiende mejor con modelos más grandes o cuando se desea
crear bucles con iteraciones más complicadas y que permitan entender mejor los resultados sin
necesidad de tener que mover los datos. Para ejemplificar esto se va a crear un nuevo archivo “.run”
que devuelva una tabla final donde se muestren los resultados de la variable “P” y otra donde se
muestren los valores obtenidos en la función objetivo para cada iteración.
model Ejemplo_guia5.mod;
data Ejemplo_guia5.dat;
for {a in iteracion} {
let {i in Procesos} RecursoT[i] := RecursoT[i] * 1.05;
let {h in Productos} Demandamax[h] := Demandamax[h] * 1.1;
solve;
display P;
let Ganancias[a] := Utilidades;
let {h in Productos} Prod[h,a] := P[h];
display Ganancias;
display Prod;
}
Se han creado dos nuevos sets: el set “iteracion”, se usa para las iteraciones del bucle for, de
manera que “a=1” es la primera iteración, “a=2” la segunda y “a=3” la tercera; y, el set “Compuesto”
que se usará para la tabla que en la que se mostrará los valores de la variable “P” en cada iteración.
60
También se han creado los parámetros “Ganancias”, que es donde se va a almacenar el valor de la
función objetivo, y “Prod”, que se usará para mostrar la tabla con los valores de la variable “P” en
cada iteración.
El comando repeat no tiene un número máximo de iteraciones, sino que se detiene cuando se
cumple una determinada condición.
Retornando al análisis del “Ejemplo_guia5.mod”, ahora se desea conocer cuál debería ser la
demanda máxima de cada producto y la cantidad de horas que se deberían contratar para que se
tenga por lo menos una ganancia de 60 000 U.M.. Por ello se debe especificar que el bucle se
detendrá cuando el valor de la función sea mayor que 60 000 U.M. usando el comando repeat de la
siguiente manera:
Cree un archivo “.run” con el código que se le muestra a continuación que permitirá conocer la
cantidad a producir de cada producto hasta que por lo menos se tenga una utilidad de 60 000 U.M.
model Ejemplo_guia5.mod;
data Ejemplo_guia5.dat;
61
Datos importantes:
model Ejemplo_guia5.mod;
data Ejemplo_guia5.dat;
repeat {
let {i in Procesos} RecursoT[i] := RecursoT[i] * 1.05;
let {h in Productos} Demandamax[h] := Demandamax[h] *
1.1;
solve;
display P;
} while Utilidades > 60000;
Notará que se ejecuta el bucle una sola vez, ya que luego de ejecutarlo el valor de
“Utilidades” es 53258.9 y no cumple con la condición, por tanto, repeat se detendrá.
62
PROBLEMAS PROPUESTOS
Problema 1
Una empresa de productos agrícolas se dedica a vender 5 tipos de frutas y verduras a clientes que
se ubican en la Unión Europea y Asia. La empresa tiene 4 plantas de producción ubicadas en
diferentes lugares del país y está pensando seriamente cerrar una de ellas debido a que sus ventas
han caído.
Para poder desarrollar el trabajo usted le solicita al gerente que le proporcione algunos datos
importantes de producción y demanda. Éste se los manda por correo en un archivo Excel. Usted
podrá encontrarlos en su intranet, en la carpeta “AMPL/Archivos guía 5” con el nombre “Datos
problema 1”.
Usted investiga un poco en sus libros de Investigación Operativa y encuentra el siguiente modelo
de programación lineal que se aplica a sus necesidades:
Variables de decisión:
Función objetivo:
Maximizar i=1…4j=1…5k=1…6(PVj – Costoij) * Pijk
Restricciones:
Restricciones de demanda:
i=1…4 Pijk = DEMANDAjk ; j=1,2…5; k=1,2…6
Restricciones de tiempo:
TIEMPOij*Pijk ≤ TMAX ; i=1,2…4; j=1,2…5; k=1,2…6
Restricciones de materia prima:
Eficij*Pijk ≤ DISPONIBLEij ; i=1,2…4; j=1,2…5; k=1,2…6
Rango de existencia:
Pijk ≥ 0 ; i=1,2…4; j=1,2…5; k=1,2…6
Se pide:
a) Cree un archivo ejecutable “.run” que le permita analizar en una sola corrida qué fábrica se
debe cerrar de manera que se pueda minimizar las pérdidas de utilidades.
63
b) En el archivo ejecutable “.run” que creó agregue las sentencias que considere necesarias de
manera que luego de resolver todos los escenarios se devuelva una tabla con el siguiente
formato:
Fabrica Utilidad total
cerrada
1 Monto 1
2 Monto 2
3 Monto 3
4 Monto 4
Problema 2
Perú se encuentra entre los países latinoamericanos productores de café oro o café orgánico. Como
orgánico es denominado el café que proviene de cultivos con un manejo agronómico que se
caracteriza por prácticas de conservación del suelo, siembra a la sombra de árboles de mayor altura
(principalmente leguminosas) y la carencia de determinados agroquímicos y fertilizantes minerales.
La mayoría del café certificado cómo orgánico tiene además el certificado de comercio justo (fair
trade), que garantiza a los productores un precio mínimo y acceso a un pre- financiamiento de la
cosecha por el comprador.
Los departamentos de Huánuco, Junín y Pasco son los principales productores de éste tipo de café
en el país. Los agricultores cultivan, cosechan y secan el café para que posteriormente sea
transportado a Lima para ser trillado (se le quite la cáscara), embalado y transportado a puerto para
su exportación a Europa.
Las empresas trilladoras tienen algunos problemas al momento de comprar el café de los
productores, ya que cada productor puede venderle café con diferentes excesos de humedad en el
grano. Otro problema que tienen es que del total del café, el 16% es de baja calidad, ya sea por
tamaño de grano, color o peso y debe ser considerado como café descarte, el cual se vende a un
precio mucho más bajo que el café oro.
Una de las empresas trilladoras de Lima tiene entre sus practicantes estudiantes de Ingeniería
Industrial de la PUCP, los cuales les comentaron que se pueden usar técnicas de investigación de
operaciones para optimizar el proceso de compra del café y minimizar los gastos. Por ello el gerente
le ha pedido a usted que lo ayude a resolver el problema de minimizar el costo de compra y oreado
del café.
Usted investiga y desarrolla un modelo de programación lineal que le permita optimizar el proceso
de compra de café minimizando el gasto.
Variables de decisión:
Cafeij: Cantidad de café en toneladas que se le compraré al producto i el
trimestre j.
i=1, productor 1; i=2, productor 2; i=3, productor 3; i=4, productor 4; i=5,
productor 5; i=6, productor 6; i=7, productor 7; j=1, trimestre 1; j=2, trimestre
2; j=3, trimestre 3; j=4, trimestre 4.
64
Función objetivo:
Minimizar i=1…4j=1…5 Cafeij * Humedad_excesoi * Costo_oreado +
Cafeijk * Costo_compraij
Restricciones:
Restricciones de demanda:
i=1…7 Cafeij (1-Porcen_descarte) = DEMANDAj ; j=1,2…6
Restricciones de materia prima:
Cafeij ≤ Cafe_productoresi ; i=1,2…7; j=1,2…6
Rango de existencia:
Cafeij ≥ 0 ; i=1,2…4; j=1,2…5
Los datos del problema podrá encontrarlos en su intraner, en la carpeta “AMPL/Archivos guía 5” con
el nombre “Datos problema 2”
Se pide:
a) Cree un archivo “.mod” para minimizar los costos de compra y oreado de café.
b) Usted se acaba de enterar que hay una vacante disponible de analista en la empresa y
conversando con el gerente, él le menciona que está muy complacido con su trabajo y
dependiendo de su desempeño estaría dispuesto a contratarlo. Investigando y viendo los
registros de los análisis de humedad, nota que el exceso de humedad no es fijo ya que algunas
veces los productores venden café con un exceso de humedad mayor y eso genera mayores
costos en el oreado del café. Usted decide presentarle al gerente un análisis de escenarios
donde la humedad en exceso del café varía en 0.05%. Buscando en registros pasados, notó
que el monto máximo que podría gastarse en compra y oreado de café es 492000 U.M..
Sugerencia: Haga un archivo “.run” donde utilice el comando repeat para saber cuál es la
humedad en exceso que como máximo podría aceptar en el café de los productores.
c) Ahora, como desea hacer un mejor trabajo, decide analizar qué ocurriría si el porcentaje de
descarte varía en 1% y cuál sería el porcentaje máximo aceptable si sabe que el gasto en
compra y oreado de café, para este escenario, no debe ser mayor a 410000.
65
SEXTA GUÍA DE AMPL
En la sexta guía se explicaran los comandos necesarios para la programación lineal entera
usando el AMPL.
Como ya se explicó en la segunda guía, al momento de declarar las variables se puede definir su
rango, pero hasta el momento solo sabe definir el rango usando valores escalares. En muchos
casos, dichos rangos son definidos por parámetros, y por ello, AMPL tiene la funcionalidad de
permitirle usar parámetros para definir el rango de existencia de una variable al declararla.
Para demostrar cómo se utiliza parámetros para declarar el rango de las variables al momento de
declararlas, se usará el ejemplo 1 de la segunda guía. A continuación se procederá a mostrar cómo
se ha escrito el modelo en el archivo “.mod” definiendo el rango con parámetros.
maximize Utilidades:
sum {i in Productos} Margen[i] * P[i];
subject to Tp {j in Procesos}:
sum {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j];
Como pudo notar, al definir el rango de las variables al momento de declararlas, se pudo eliminar
dos familias de restricciones, lo cual permitirá simplificar el modelo y por tanto disminuir el tiempo
de procesamiento requerido para resolverlo. Descargue los archivos “Ejemplo1_guia6.mod” y
“Ejemplo1_guia6.dat”, modifique el archivo “.mod” para que pueda declarar el rango de las variables
66
al declararlas y resuelva los modelos. Note que la solución que se obtiene es la misma que la que
obtuvo en la segunda guía.
Datos importantes:
En muchas ocasiones las variables de decisión deben tomar valores enteros para que la solución
óptima pueda tener sentido. Los modelos matemáticos que requieren que sus variables sean
enteras se denominan modelos de programación entera. Para este tipo de problemas, ¿cómo se
declara el rango de existencia usando el lenguaje de modelado de AMPL?
Como ya se explicó en la segunda guía, AMPL asume por defecto que las variables son continuas
y que pueden tomar valores mayores o menores a cero; sin embargo, si el usuario desea declarar
las variables como enteras o binarias, AMPL dispone de dos palabras reservadas para ello:
A continuación, se presenta el ejemplo 2 que es muy similar al ejemplo 1 de la guía 2; sin embargo,
en este caso los productos no se fabrican en kilogramos sino en unidades por lo que es necesario
indicar en el modelo que estas variables son enteras. Asimismo, presenta restricciones en los costos
fijos controlables que obligan a definir variables binarias.
Ejemplo 2
En cierta empresa manufacturera se fabrica 20 diferentes productos y cada uno pasa por una
secuencia de siete procesos distintos en donde la materia prima se agrega en los cinco primeros ya
que los dos últimos procesos son de acabado de los productos. La secuencia de los procesos para
cada producto es la misma y se identifica con proceso 1 al primero, proceso 2 al segundo y así
sucesivamente. Por las características de los productos no tiene sentido que se fabriquen fracciones
de estos, por tanto, son unidades completas.
Los anexos al final de cada guía muestran una serie de datos que a continuación se describen:
En el anexo 1 se muestra los costos variables unitarios, los precios de venta, el margen de
contribución y los costos fijos; también se muestra la demanda que por exigencias contractuales
debe ser como mínimo igual a 50 para todos los productos que la empresa atienda; asimismo, se
muestra la demanda máxima de cada producto. En caso se fabrique el producto i se incurrirá en el
costo fijo i, si no se produce dicho producto entonces no se incurrirá en tal costo fijo y será igual a
cero.
El anexo 2 presenta el tiempo en cada proceso requerido por cada unidad de tipo de producto y la
disponibilidad del recurso tiempo.
67
El anexo 3 muestra los datos de la cantidad de materia prima también por cada unidad de producto
así como la disponibilidad del recurso materia prima.
Los productos han sido solicitados por un prestigioso cliente con quién se ha negociado que la
empresa elija cuáles productos atenderá, luego se firmaría el contrato. La empresa desea
determinar cuántos productos de cada tipo debe fabricar con el objetivo de maximizar las utilidades,
para tal fin, las variables de decisión son:
En el anexo 7 se muestra el resto del modelo de programación lineal; revise la formulación antes de
proseguir con la lectura de esta guía.
Función objetivo:
Maximizar i=1...20(MARGENi*Pi) - i=1..20(COSTO_FIJOi*Yi)
Restricciones:
Restricciones de demanda:
Pi ≥ DEMANDAMINi*Yi ; i=1,2…20
Pi ≤ DEMANDAMAXi ; i=1,2…20
Restricciones de tiempo:
j=1…20(TIEMPOji*Pj) ≤ RECURSOTi ; i=1,2…7
Restricciones de materia prima:
j=1…20(MPji*Pj) ≤ RECURSOMPi ; i=1,2…5
Restricciones para los costos fijos:
Pi ≤ M*Yi ; i=1,2…20 ; M>>0
Rango de existencia:
Pi son variables enteras no negativas ; i=1,2…20
Yi = 0 ó 1 ; i=1,2…20
A continuación vamos a reconocer los parámetros y variables del modelo, los cuales son muy
parecidos a los del Ejemplo1 de la segunda guía.
68
Lista de variables Etiqueta
Variable de decisión que toma valor 1 si se fabrica el producto i,
Yi
caso contrario toma valor 0
Cantidad de unidades que se fabrica de cada tipo de producto,
Pi
estas son variables enteras
En el campus virtual PUCP usted tiene los siguientes archivos, ábralos y grábelos en su disco
#Función Objetivo
maximize Ganancias:
sum {i in Productos} (Margen[i] * P[i] - Costo_fijo[i] * Y[i]);
#RESTRICCIONES
#Restricciones de demanda
#Minima
subject to Produccion_minima {i in Productos}:
P[i] >= Demandamin[i] * Y[i];
69
#Maxima
subject to Produccion_maxima {i in Productos}:
P[i] <= Demandamax[i];
#Restricciones de tiempo
subject to Tiempo_max {j in Procesos}:
sum {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j];
#Restriciones de MP
subject to MP_maxima {j in ProcesoMP}:
sum {i in Productos} MP[i,j] * P[i] <= RecursoMP[j];
En modelo se observa que el valor del parámetro M es igual a 1000. También, se observa que la
variable P se ha declarado como entera y la variable Y como binaria.
Resuelva el modelo usando el archivo “.run” y en los resultados notará que no se debe producir el
producto 3, y no hay problemas ya que en este caso, algunos productos tienen demanda mínima
igual a 0, por lo que el productor puede elegir los productos que le convengan producir.
Revise los resultados que obtiene y notará que la variable P toma valores que no son enteros, y lo
mismo ocurre con la variable Y. Esto ocurre porque MINOS considera como continuas todas las
variables, por más que hayan sido declaradas como enteras o binarias. Para poder obtener la
respuesta que se desea use el solver “cplex” para resolver el modelo.
Ahora haga algunas modificaciones, cambie la demanda mínima de todos los productos a 50, de
manera que se obligue al productor a fabricar todos los productos.
Resuelva nuevamente el problema y compare los valores obtenidos en la función objetivo para
ambos casos.
70
Anexo 7
Funcion Objetivo:
Restricciones de demanda:
71
Restricciones de tiempo:
72
0.1*P[1] + 0.2*P[2] + 0.1*P[3] + 0.1*P[4] + 0.1*P[5] + 0.2*P[6] +
0.2*P[7] + 0.1*P[10] + 0.1*P[11] + 0.15*P[12] + 0.05*P[13] + 0.2*P[14] +
0.1*P[15] + 0.2*P[16] + 0.05*P[17] + 0.1*P[18] + 0.1*P[19] + 0.15*P[20]
<= 400;
73
Bibliografía
https://pucp.ent.sirsi.net/client/es_ES/campus/search/detailnonmodal/ent:$002f$00
2fSD_ILS$002f0$002fSD_ILS:519408/one
WINSTON, Wayne
2005 Investigación de operaciones: aplicaciones y algoritmos. Cuarta edición.
México. Thompson.
https://pucp.ent.sirsi.net/client/es_ES/campus/search/detailnonmodal/ent:$002f$00
2fSD_ILS$002f0$002fSD_ILS:392874/one
CORNEJO, Christian
2014 Guía Lingo. Publicación de material para la docencia PUCP.
74