Apuntes Ampl

GUÍA DE INVESTIGACIÓN
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.
¿Por qué AMPL?
El software AMPL soporta todo el ciclo de vida de modelado de optimización: formulación,

prueba, despliegue y mantenimiento, desde un enfoque integrado para promover un rápido
desarrollo y resultados fiables. Usando una representación algebraica de alto nivel que
describe los modelos de optimización de la misma manera que la gente piensa acerca de
ellos, AMPL puede proporcionarle la ventaja que necesita para implementar con éxito
proyectos de optimización a gran escala.
AMPL integra un lenguaje de modelado para describir datos de optimización: variables,

función objetivo y las restricciones; en un lenguaje de comandos para depurar los modelos y
análisis de resultados; y un lenguaje de script para la manipulación de los datos y la
implementación de estrategias de optimización. Todos utilizan los mismos conceptos para
promover la creación de solicitud más eficiente.
http://ampl.com/
ii
DEDICATORIA
A todos los alumnos con ganas de seguir aprendiendo

más y más.
iii
ÍNDICE GENERAL
INDICE DE GRÁFICOS ...................................................................................................................... vii

PRIMERA GUÍA DE AMPL ................................................................................................................. 1
1. ENTORNO DEL SOFTWARE AMPLIDE .............................................................................. 1
1.1. Instalación de AMPL ........................................................................................................ 1
1.2. Interfaz de usuario del software AMPLIDE ................................................................... 3
1.3. Barra de herramientas del software AMPLIDE ............................................................ 4
1.4. Opciones de la ventana de comandos .......................................................................... 6
2. EJECUCIÓN DE UN MODELO EN AMPL ........................................................................... 7
SEGUNDA GUÍA DE AMPL .............................................................................................................. 11
1. LENGUAJE DE MODELADO DE AMPL ............................................................................. 11
2. ESTRUCTURA DE UN MODELO EN AMPL ..................................................................... 16
2.1. SET ................................................................................................................................... 16
2.2. Parámetros: ..................................................................................................................... 16
2.3. Variables: ......................................................................................................................... 17
2.4. Función objetivo (F.O.): ................................................................................................. 17
2.5. Restricciones: .................................................................................................................. 18
3. COMO INGRESAR DATOS EN UN ARCHIVO “.dat”....................................................... 21
4. COMO ELEGIR UN SOLVER PARA RESOLVER EL MODELO ................................... 24
5. COMO RESOLVER UN MODELO USANDO EL LENGUAJE AMPL Y LA INTERFAZ
AMPLIDE ......................................................................................................................................... 25
6. PROBLEMAS PROPUESTOS (desarrollando los problemas del manual de Lingo en
AMPL) ............................................................................................................................................... 25
TERCERA GUÍA DE AMPL .............................................................................................................. 31
1. ANÁLISIS DE SENSIBILIDAD CON AMPL ........................................................................ 31
2. OPERADORES LÓGICOS EN AMPL ................................................................................. 34
2.1. Modelado de la función objetivo con operadores lógicos......................................... 36
2.2. Modelado de las restricciones con los operadores lógicos ...................................... 37
3. LA FUNCION IF-THEN-ELSE .............................................................................................. 39
4. PROBLEMAS PROPUESTOS ............................................................................................. 40
CUARTA GUÍA DE AMPL ................................................................................................................. 45
1. COMO CREAR Y EJECUTAR UN ARCHIVO “.run” ......................................................... 45
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
Tabla 1: Lista de parámetros ............................................................................................................ 15

Tabla 2: Costo de transporte desde la planta i hasta el cliente j ................................................ 25
Tabla 3: requerimiento de tiempo por mil unidades ...................................................................... 26
Tabla 4: requerimiento de recursos ................................................................................................. 27
Tabla 5: Lista de parámetros ............................................................................................................ 35
Tabla 6: Precio por kilogramo de las sustancias ........................................................................... 40
Tabla 7: Dureza de cada sustancia ................................................................................................. 41
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
La modelación matemática propone la optimización de procesos y sistemas a partir del uso

eficiente de los recursos que posee la organización, optimizando el flujo total del sistema.
Haciendo énfasis en el impacto del sistema y no en un proceso. Además, permite incrementar
la probabilidad de tomar mejores decisiones en cualquier organización, basándose en
sistemas de información, métodos estadísticos, técnicas de ingeniería, evaluación económica
y el procesamiento de datos.
La modelación matemática aplicada en la carrera de Ingeniería Industrial, optimiza los

procesos de producción, marketing, finanzas, procesos logísticos y de distribución usando
modelos de programación lineal, modelos de redes, modelos no lineales, métodos heurísticos,
análisis de datos, métodos de pronósticos multivariados y minería de datos.
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.
Fuente: Scimago Journal & Country Rank
viii
http://www.scimagojr.com/countryrank.php?category=1803&region=Latin%20America
Por lo tanto, nuestro objetivo es incrementar las habilidades de investigación de nuestros

alumnos desde pregrado. Una de las principales causas detectadas en el problema de
investigación, es la solución de los modelos propuestos, es decir un modelo complejo puede
tardar muchos meses en encontrar una solución óptima, siendo el tiempo de solución uno de
los factores que desanima a las empresas, catedráticos e investigadores a continuar esta
línea. Haciendo un diagnóstico entre los países de mayor producción científica se determinó
que el AMPL es el software más usado por los investigadores, teniendo como solver más
usados al Minos, Gurobi y Cplex. Por lo que proponemos el uso de este software en los cursos
pilares de Ingeniería Industrial.
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
En la primera guía conoceremos que es el AMPL, su entorno e interface. Además de

trabajar con las ventanas principales donde compartimos datos, codificamos y
encontramos la solución de nuestro modelado.
Objetivos de esta guía

• El entorno del software AMPLIDE.
• Aprender a ejecutar un modelo en AMPLIDE.
1. ENTORNO DEL SOFTWARE AMPLIDE
1.1. Instalación 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.
Figura 1: Página web de software 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.
Figura 2: Libro desarrollado por AMPL
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.
Figura 3: Página web de software AMPL con licencia académica
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.
Figura 4: Documentación de la descarga AMPL - Students
2
1.2. Interfaz de usuario del software AMPLIDE
INICIO 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.
Figura 5: ventana de instalación de AMPL
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.
Figura 6: aceptar el Amplide.
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
Figura 7: Interface del Amplide.
3
El software AMPLIDE tiene 3 componentes principales:
● Ventana de archivos: Permite navegar en las carpetas de la computadora para poder

abrir los archivos que se encuentren en ellas.
● Ventana de comandos: Se utiliza para ejecutar los comandos en el software e
interactuar con los modelos matemáticos.
● Ventana de modelado: Área para editar el modelo, datos y otros archivos necesarios
para resolver un modelo de optimización.
TIPO DE ARCHIVOS DEL SOFTWARE AMPL
En el software AMPLIDE interactúa con 3 tipos de archivos: “.mod”, “.dat” y “.run”. A

continuación, se procede a explicar las características de cada uno de estos tres tipos de
archivos:
● 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”.
1.3. Barra de herramientas del software AMPLIDE
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.
Figura 8: Comando New
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”.
Figura 9: Comando New file
En la Figura 8 se muestra el archivo creado con el nombre “model_prueba.mod”.
Figura 10: archivos para modelar
El comando New se puede ejecutar rápidamente presionando en la barra de herramientas

el siguiente ícono:
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:
COMANDO SAVE ALL
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:
1.4. Opciones de la ventana de comandos
En la ventana de comandos se tiene la cinta de opciones que se muestra en la Figura 12.
Figura 12: opciones de consola
6
BOTÓN INTERRUPT
Cuando se está resolviendo un modelo matemático con el software AMPLIDE, existe la

opción de detener el proceso de cálculo del modelo. Para poder hacer esto, se deberá
presionar el botón Interrupt de la cinta de opciones (Figura 13).
Figura 13: interrumpir proceso
También se puede detener el proceso de cálculo del modelo matemático presionando Ctrl
+ C.
BOTÓN CLEAR CONSOLE
Para borrar el texto acumulado en la ventana de comandos se utiliza el botón clear console,
el cual tiene el siguiente ícono:
Figura 14: limpiar pantalla
2. EJECUCIÓN DE UN MODELO EN AMPL
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:
P: unidades a fabricar del mueble Premium en un mes.
C: unidades a fabricar del mueble Clásico en un mes.
En la ventana de modelado de AMPLIDE ingrese lo que se muestra en la siguiente pantalla
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 “_”.
Figura 15: sintaxis del modelo .mod
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:
ampl: model Ejemplo1.mod;

ampl: solve;
Luego de escribir el comando solve, AMPLIDE devolvió el siguiente mensaje:

ampl: solve;
MINOS 5.51: optimal solution found.
2 iterations, objective 43000
ampl:
Figura 16: Programación en la consola
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 creó el archivo “Ejemplo1.mod” con

la ruta “\\Google Drive\AMPL\Primera
guía” debe asegurarse que dicha ruta
se muestra en la ventana de archivos.
Si en su ventana de archivos se muestra otra ruta, al momento de llamar al archivo se

mostrará el siguiente error:
Can't find file Ejemplo1.mod
Figura 17: Búsqueda de archivo
Si queremos obtener el valor que toman las variables en la solución óptima debemos escribir lo
siguiente:
ampl: display A, B;
Luego de ejecutar este comando, AMPLIDE mostrará el siguiente mensaje:

ampl: solve;
2 iterations, objective 43000
ampl: display P, C;
P = 33.3333
C = 100
Figura 18: Búsqueda de la solución
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;
Como modo de evaluación de lo aprendido, resuelva el siguiente ejemplo.
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:
a) ¿Cuál es el solver que se utiliza para este problema?

b) ¿Cuánto se espera tener de utilidades?
c) Indique cuánto se fabricará de cada uno de los productos en cuestión.
10
SEGUNDA GUÍA DE AMPL
En la segunda guía iniciaremos en la modelación / programación en el AMPL.

• Formular modelos de programación lineal con el lenguaje de AMPL
• Elaborar archivos de extensión “.dat” para ingresar los parámetros del modelo
• Aprender a seleccionar el solver para resolver el programa lineal.
• Aprender a resolver un modelo usando el lenguaje AMPL y la interfaz AMPLIDE
1. LENGUAJE DE MODELADO 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.
Ejemplo 1 – Introducción a la formulación
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: cantidad de kilogramos por fabricar de cada tipo de producto. i= 1,2…20
Usando notación matemática, este problema lo modelamos de la siguiente forma:

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
Restricciones de materia prima:
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]
P[1] <= 60;

P[2] <= 100;
P[3] <= 120;
P[4] <= 75;
0.5*P[1] + 0.4*P[2] + 0.5*P[3] + 0.2*P[4] <= 690;
0.1*P[1] + 0.2*P[2] + 0.05*P[3] + 0.3*P[4] <= 620;
3*P[1] + 2.8*P[2] + 1.2*P[3] + 1.4*P[4] <= 880;

2.6*P[1] + 1.33*P[2] + 2.26*P[3] + 2.7*P[4] <= 950;
12*P[1] + 4*P[2] + 8*P[3] + 13*P[4] <= 2400;
0.56*P[1] + 0.3*P[2] + 0.45*P[3] + P[4] <= 1000;
Ejemplo 2 – Problema de producción con 20 productos
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:
Pi: cantidad de kilogramos por fabricar de cada tipo de producto. i= 1,2…20
Usando notación matemática, éste problema lo representaríamos de la siguiente forma:
12
Función objetivo:
Restricciones:
Pi ≥ DEMANDAMINi ; i=1,2…20
i=1…20(TIEMPOij*Pi) ≤ RECURSOTj ; j=1,2…7

i=1…20(MPij*Pi) ≤ RECURSOMPj ; j=1,2…5
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;
!Restricciones de materia prima:

0.4 * P_1 + 0.3 * P_2 + 0.4 * P_3 + 0.3 * P_4 + 0.4 * P_5 + 0.5 * P_6 +
0.4 * P_7 + 0.5 * P_8 + 0.3 * P_9 + 0.4 * P_10 + 0.35 * P_11 + 0.45 * P_12
+ 0.5 * P_13 + 0.25 * P_14 + 0.35 * P_15 + 0.45 * P_16 + 0.4 * P_17 + 0.3
* P_18 + 0.35 * P_19 + 0.3 * P_20 <= 1200;
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.
Tabla 1: Lista de parámetros

Lista de parámetros Etiqueta
El margen de contribución de cada producto MARGENi

La demanda mínima de cada producto DEMANDAMINi
La demanda máxima de cada producto DEMANDAMAXi
Disponibilidad del recurso tiempo de cada proceso RECURSOTj
Disponibilidad del recurso materia prima para cada proceso RECURSOMPj
El tiempo unitario por kilogramo de cada producto en cada proceso TIEMPOij
El consumo de materia prima por kilogramo de cada producto en cada proceso Mpij
Lista de variables Etiqueta
Cantidad de kilogramos por fabrica de cada tipo de producto, estas son las
variables de decisión
Pi
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:
set Productos := 1..20;
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:
set Matriz1 := {Productos, Procesos};
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:
Para declararlos use la palabra reservada param,

seguida del nombre que usted elija. Así por Tenga en cuenta:
En AMPL se tiene la opción de declarar
ejemplo, para declarar el parámetro cuyo nombre
el rango de existencia de los
es “Margen” siga la sintaxis siguiente: parámetros agregando “>100”, “<0”,
“>=0” ó “<=500”, dependiendo de lo que
param Margen se necesite. La sintaxis que se debe
seguir puede ser cualquiera de las
Por otro lado, si el parámetro “Margen” fuese de siguientes:
tipo escalar (es decir, tiene un único valor) basta param Margen{Productos}>=0;
param Margen{Productos}<=100;
con colocar “;” a la sentencia mostrada, es decir, param Margen{Productos}>0, <=10;
param Margen;. Sin embargo, si el parámetro
fuese vectorial o matricial (conjunto de valores)
16
debe asociarlo a un set para tomar su dimensión de acuerdo a lo requerido. La siguiente
sentencia ilustra este caso:
param Margen {Productos};
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.
2.4. Función objetivo (F.O.):
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.
Pero, recordemos como escribimos la F.O. en notación matemática:
En lenguaje de AMPL, el símbolo ∑ se reemplaza por la palabra reservada sum; la expresión i

= 1..20, que denota que se va a usar el índice i y se va a hacer la sumatoria en el set Productos
que tiene 20 miembros, se expresa de la siguiente forma: {i in Productos}; la notación
MARGENi*Pi se expresa Margen[i]*P[i]. Entonces, la F.O. se expresaría de la siguiente
forma en AMPL:
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.
La sentencia que se escribe en lenguaje de AMPL normalmente representa a una familia de

restricciones, para poder entenderlo, veamos el código algebraico de las dos primeras
restricciones de cantidad máxima de tiempo disponible.
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:
{(i,j) in “Nombre del set compuesto”} ó

{i in “set simple1”, j in “set simple2”}
¿Y si debo iterar usando tres índices?

Entonces se escribiría de la siguiente manera:
{(i,j,k) in “Nombre del set compuesto”} ó

{i in “set simple1”, j in “set simple2”, k in “set simple3”}
Código de AMPL para el ejemplo 2

set Procesos := 1..7;
set ProcesoMP := 1..5; CUIDADO:
set Matriz1 := {Productos,Procesos};
set Matriz2 := AMPL diferencia entre
{Productos,ProcesoMP}; mayúsculas y minúsculas, por
eso productos, Productos y
param Margen {Productos}; PRODUCTOS son palabras
param Demandamin {Productos}; diferentes en AMPL.
param Demandamax {Productos};
param RecursoT {Procesos};
param RecursoMP {ProcesoMP};
param Tiempo {Matriz1};
param MP {Matriz2};
var P {Productos};
subject to Materia {j in ProcesoMP}:

sum {i in Productos} MP[i,j] * P[i] <= RecursoMP[j];
19
subject to Minimo {i in Productos}:
P[i] >= Demandamin[i];
subject to Maximo {i in Productos}:

P[i] <= Demandamax[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”.
ERRORES AL DECLARAR LOS SETS
• 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 “{ }”.
ERRORES EN EL MODELADO DE LA FUNCIÓN OBJETIVO Y LAS RESTRICCIONES
• La sentencia debe terminar con el signo “;”.

• Luego de la función sum y para escribir los sets que se utilizarán para hacer la suma de las
variables y parámetros, se debe usar “{ }” y no “( )” o “[ ]”.
• No olvide usar el nombre exacto de cada parámetro, variable y set declarado anteriormente,
cualquier diferencia ya sea debido a algún carácter o a alguna letra mayúscula o minúscula
enviará un mensaje de error.
• Tenga en cuenta que los índices de las variables y parámetros de la función objetivo y
restricciones deben usarse los signos “[ ]”.
• La función sum realizará la sumatoria solo hasta el siguiente signo “+” o “-“. Para ilustrar esto,
imagine que en vez de darle el margen le dan el precio de venta (PV) y el costo de producción
(Costo) de cada producto, por lo tanto, si usted escribe la función objetivo de la siguiente
manera:
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:
sum {i in Productos} (PV[i] * P[i] - Costo[i] * P[i]);
sum {i in Productos} (PV[i] - Costo[i]) * P[i];
20
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.
COMO OBTENER INFORMACION ADICIONAL:
• 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.
3. COMO INGRESAR DATOS EN UN ARCHIVO “.dat”
Como se mencionó en la declaración de parámetros, se puede tener parámetros escalares,

vectoriales y matriciales. En esta parte de la guía se va a explicar cómo ingresar cada uno de estos
en un archivo de datos.
INGRESO DE DATOS ESCALARES
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:
param Tiempo_total := 1000;
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:
• set: para definir los grupos de objetos relacionados en grupos.

• param: se utiliza para definir parámetros ya conocidos que se ingresarán al modelo.
• var: se utiliza para definir las variables que se utilizarán en el modelo.
• minimize: se utiliza para definir la función objetivo a minimizar.
• maximize: se utiliza para definir la función objetivo a maximizar.
• subject to: se utiliza para definir las restricciones del modelo.
• in: para definir los índices que estarán en cada uno de los sets.
• sum: se utiliza para desarrollar las sumatorias de las variables o parámetros en las
restricciones función objetivo.
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.
A continuación, se muestra como ingresar los datos del parámetro Margen.
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.
Ingreso de datos matriciales de tres dimensiones
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
• Cada grupo de datos termina con el signo “;”. Verifique si

lo digitó. Datos importantes:
• Recuerde que debe de asegurarse de usar exactamente ¿Como se entiende [*,*,1]?
[*,*,1]:
los signos “;”, “:”, “=” y “:=” en las partes donde 1 2 3 :=
corresponde según se muestra en los ejemplos, ya que de 1
lo contrario tendrá errores de sintaxis. 2
• Recuerde que en el caso de parámetros de matrices de 3
tres dimensiones debe colocar el signo “;” solamente 4
5
luego de haber ingresado todas las tablas que se tengan
6
y no luego de cada tabla.
El primer “*” se refiere a los
• No olvide usar exactamente los nombres declarados para
miembros del set Productos y el
cada parámetro y no vaya a usar alguna mayúscula o
segundo “*” se refiere a los
minúscula extra o menos debido a que AMPL distingue
miembros del set Maquinas.
entre mayúsculas y minúsculas.
• No olvide que entre dato y dato que ingresa en una matriz
debe haber por lo menos un espacio (“ “) debido a que si
los datos estuvieran juntos AMPL arrojaría un mensaje de
error.
COMO OBTENER INFORMACION ADICIONAL:
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.
4. COMO ELEGIR UN SOLVER PARA RESOLVER EL MODELO
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:
ampl: option solver;
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:
option solver minos;
Para poder cambiar de solver se debe usar la siguiente sintaxis:
option solver “solver_name”;
Por ejemplo, si quisiéramos cambiar de solver y utilizar el cplex en vez del minos, deberíamos
ingresar el siguiente código:
ampl: option solver cplex;
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: model Ejemplo2_guia2.mod;
ampl: data Ejemplo2_guia2.dat;
ampl: solve;
Y AMPLIDE devolverá el siguiente mensaje:
20 iterations, objective 50289.23077
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.
6. PROBLEMAS PROPUESTOS (desarrollando los problemas del manual de Lingo en

AMPL)
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.
Tabla 2: Costo de transporte desde la planta i hasta el cliente j

En dólares por cada mil unidades
Cliente 1 Cliente 2 Cliente 3 Cliente 4 Cliente 5 Cliente 6 Cliente 7 Cliente 8 Cliente 9 Cliente 10
Planta 1 100 40 30 150 55 98 55 135 95 85
Planta 2 110 65 25 140 60 70 65 125 85 55
Planta 3 100 70 50 160 65 75 70 145 105 50
Planta 4 90 80 65 110 100 85 75 110 120 60
Planta 5 120 90 35 180 110 65 60 165 115 90
Precio de venta 180 120 120 200 150 160 150 200 180 110
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
Xij: cantidad de productos, en miles, fabricados en la planta i y

embarcados al cliente j
i=1, planta 1; i=2, planta 2; i=3, planta 3; i=4, planta 4; i=5, planta 5.
j=1, cliente 1; j=2, cliente 2; j=3, cliente 3; j=4, cliente 4; j=5, cliente 5;
j=6, cliente 6; j=7, cliente 7; j=8, cliente 8; j=9, cliente 9; j=10, cliente 10.
MO: …
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
…
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
…
Restricción del tiempo:

…
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?
Problema 2 (tomado y adaptado de Winston (2005))
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.
Tabla 4: requerimiento de recursos

Mano de obra Mano de obra Ventas
Producto Máquina 1 Máquina 2
calificada no calificada (dólares)
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
Costos variables Margen de Demanda mínima del Demanda máxima del

Precio de venta
Productos unitarios contribución producto producto
en US$
en US$ en US$ en kilogramos en kilogramos
Producto 1 5.00 16.00 11.00 10.00 150
Producto 2 3.00 18.75 15.75 15.00 80
Producto 3 4.50 15.00 10.50 0.00 90
Producto 4 4.25 15.00 10.75 0.00 100
Producto 5 3.50 18.00 14.50 10.00 180
Producto 6 2.75 20.00 17.25 0.00 150
Producto 7 6.50 20.00 13.50 10.00 150
Producto 8 8.00 20.00 12.00 0.00 145
Producto 9 9.00 25.00 16.00 20.00 100
Producto 10 8.00 25.00 17.00 25.00 110
Producto 11 5.00 25.00 20.00 15.00 150
Producto 12 4.00 26.00 22.00 10.00 160
Producto 13 8.50 27.00 18.50 0.00 165
Producto 14 7.50 24.50 17.00 0.00 155
Producto 15 6.50 22.00 15.50 0.00 150
Producto 16 4.00 23.00 19.00 10.00 250
Producto 17 3.50 25.00 21.50 0.00 150
Producto 18 2.50 24.00 21.50 0.00 200
Producto 19 3.50 19.00 15.50 0.00 250
Producto 20 5.50 20.00 14.50 0.00 180
28
Anexo 2
Tiempo unitario por cada kilogramo del producto i

Productos
en el proceso j, en minutos
Proceso 1 Proceso 2 Proceso 3 Proceso 4 Proceso 5 Proceso 6 Proceso 7

Producto 1 10 5 6 4 3 6 5
Producto 2 12 4 4 5 2 7 6
Producto 3 25 8 10 4 4 7 3
Producto 4 12 9 11 6 4 8 4
Producto 5 15 2 12 6 4 8 7
Producto 6 17 2 13 7 5 9 8
Producto 7 19 3 8 8 7 9 7
Producto 8 30 4 11 9 6 8 6
Producto 9 20 5 14 10 8 10 5
Producto 10 21 6 15 11 9 11 6
Producto 11 20 5 10 7 5 10 7
Producto 12 22 8 13 9 7 11 7
Producto 13 20 10 15 6 4 5 8
Producto 14 15 11 14 10 8 6 7
Producto 15 18 5 13 4 2 8 4
Producto 16 17 3 12 5 3 9 3
Producto 17 15 4 12 4 3 8 2
Producto 18 16 2 11 6 4 9 9
Producto 19 14 3 10 7 5 10 8
Producto 20 12 2 9 8 6 9 4
Disponibilidad de
tiempo en horas
900 250 600 380 270 450 300
29
Anexo 3
Materia prima requerida por cada kilogramo del producto i

Productos
en el proceso j, en gramos
Proceso 1 Proceso 2 Proceso 3 Proceso 4 Proceso 5

Producto 1 400 200 200 100 100
Producto 2 300 200 100 200 200
Producto 3 400 300 100 100 100
Producto 4 300 300 200 100 100
Producto 5 400 300 100 100 100
Producto 6 500 150 0 150 200
Producto 7 400 300 0 100 200
Producto 8 500 300 200 0 0
Producto 9 300 300 300 100 0
Producto 10 400 200 200 100 100
Producto 11 350 150 250 150 100
Producto 12 450 50 200 150 150
Producto 13 500 200 200 50 50
Producto 14 250 250 300 0 200
Producto 15 350 150 300 100 100
Producto 16 450 50 100 200 200
Producto 17 400 200 250 100 50
Producto 18 300 250 250 100 100
Producto 19 350 250 200 100 100
Producto 20 300 200 200 150 150
Disponibilidad de
materia prima en 1200 650 600 350 400
kilogramos
30
TERCERA GUÍA DE AMPL
En la tercera guía iniciaremos el análisis de sensibilidad usando el AMPL.

• Realizar el análisis de sensibilidad con AMPL.
• Aprender a usar los operadores lógicos de AMPL.
• Aprender a usar la función if-then-else.
1. ANÁLISIS DE SENSIBILIDAD CON 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.
¿Qué indicadores son importantes para un análisis de sensibilidad?
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:
 Incrementando el ingreso unitario.

 Reduciendo el costo unitario de los recursos consumidos.
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.
El costo reducido indica cuánto se puede aumentar (cuando se maximiza) o disminuir

(cuando se minimiza) este coeficiente antes de que cambie la solución óptima y esta variable
se convierta en básica. Sin embargo, recuerde que esta información se obtiene mediante el
intervalo permisible para seguir óptimo para el coeficiente de esta variable en la función
objetivo. El costo reducido (de una variable no básica) es sólo el aumento permitido (cuando
se maximiza), a partir del valor actual del coeficiente para quedar dentro de su intervalo
permisible o la reducción permitida (cuando se minimiza).
Para explicar el análisis de sensibilidad se va a utilizar el ejemplo 1 de la guía 2 para aprender a

obtener el análisis de sensibilidad de un modelo de optimización. Use el solver cplex para resolver
el modelo y empezar con el análisis.
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)
display Tp, Tp.slack;
AMPLIDE devolverá el siguiente mensaje:
ampl: display Tp, Tp.slack;

: Tp Tp.slack :=
1 0 27.4438
Datos importantes:
2 0 9.4797 Para los precios sombra se escribe:
3 0 29.0435 display Restricción;
4 0 38.8285
5 0 24 Y para la holgura:
6 0 21.1441 display Restricción.slack;
7 115.385 0;
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;
AMPLIDE nos devolverá el siguiente mensaje:
ampl: display P.rc;

P.rc [*] :=
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
10 0
11 0
12 0
13 0
14 0
15 0
16 0
17 0
18 0
19 0
20 0;
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:
option cplex_option ‘sensitivity’;
Y luego de resolver el modelo se usa el siguiente código:
display variable.down, variable.current, variable.up;
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.
2. OPERADORES LÓGICOS EN AMPL
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.
Los operadores lógicos de AMPL son los siguientes:
= : 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:
PRODNORMALt: cantidad de lanchas a producir en tiempo normal en el mes t. t= 1,2…6

PRODEXTRAt: cantidad de lanchas a producir en tiempo extra en el mes t. t= 1,2…6
IFLANCHAt: inventario final de lanchas en el mes t. t= 1,2…5
Usando notación matemática, el resto del modelo es el siguiente:
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
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.
Tabla 5: Lista de parámetros

Costo de la producción en tiempo normal COSTONORMALt
Costo de la producción en tiempo extra COSTOEXTRAt
Costo de almacenamiento COSTOALMACEN
Demanda mensual de lanchas DEMANDAt
Capacidad de la producción en tiempo normal CAPNORMALt
Producción mínima en los dos primeros meses PRODMIN
Producción máxima en tiempo extra en los dos primeros
PRODMAXTEX12
meses
Producción máxima en tiempo normal más tiempo extra en
PRODMAXTEX12
los tres últimos meses
Cantidad de lanchas a producir en tiempo normal PRODNORMALt
Cantidad de lanchas a producir en tiempo extra PRODEXTRAt
Inventario final de lanchas IFLANCHAt
35
A continuación se le muestran los sets, parámetros y variables que se han declarado e ingresado al
archivo “Ejercicio1_guia3.mod”.
set Periodo = 1..6;
param COSTONORMAL {Periodo};

param COSTOEXTRA {Periodo};
param CAPNORMAL {Periodo};
param DEMANDA {Periodo};
param II;
param COSTOALMACEN;
param PRODMIN;
param PRODMAXTEX12;
param PRODMAX;
var PRODNORMAL {Periodo} >=0;

var PRODEXTRA {Periodo} >=0;
var IFLANCHA {Periodo} >=0;
En su intranet va a encontrar un archivo Excel con el nombre “Datos_ejemplo1_guia3.xlsx”,

descárguelo e ingrese los datos del problema en un archivo “.dat”.
2.1. Modelado de la función objetivo con operadores lógicos
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;
Este operador lógico se usa

para que i tome solamente los
valores de 1, 2, 3, 4 y 5.
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.
500*PRODNORMAL[1] + 525*PRODNORMAL[2] + 550*PRODNORMAL[3] +
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];
Este operador lógico se usa para

crear las ecuaciones de inventarios
para los meses 2, 3, 4, 5 y 6.
subject to Produccion_otros_meses {i in Periodo: i>1}:

IFLANCHA[i] = IFLANCHA[i-1] + 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.
-PRODNORMAL[1] - PRODEXTRA[1] + IFLANCHA[1] = -380;
Y cuando se usa el comando expand con la restricción Produccion_otros_meses se mostrarán

las ecuaciones de inventarios para los próximos meses.
-PRODNORMAL[2] - PRODEXTRA[2] - IFLANCHA[1] + IFLANCHA[2] = -600;

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.
El producto 1 se vende a 15 UM, el 2 a 20 UM y el 3 a 10 UM. Para producir el producto 1 demora

0.12 horas, para el producto 2 demora 0.15 horas y para el producto 3 demora 0.08 horas. Sabe
que la demanda mínima del producto 2 para el mes 1 es igual a 100 y que la demanda máxima de
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.
A continuación, se procede a mostrar el archivo “.mod” y “.dat” para el ejemplo 2.
Archivo “Ejemplo2_guia3.mod”:
set Periodos := 1..2;

set Matriz := {Productos, Periodos};
param Tiempo {Productos};

param T_disponible {Periodos};
param D_min;
param PV {Productos};
param D_max {Matriz};
var Prod {Matriz};
maximize Ganancias:
sum {(i,j) in Matriz} Prod[i,j] * PV[i];
subject to Tiempo_maximo {j in Periodos}:

sum {i in Productos} Prod[i,j] * Tiempo [i] <= T_disponible[j];
Este operador lógico se usa para que

la restricción se genere solo para el
producto 2 en el mes 1
subject to Demanda_minima {(i,j) in Matriz: i=2 and j=1}:

Prod[i,j] >= D_min;
Este operador lógico se usa para que la
restricción se genere solo para los
productos 1 y 3
subject to Demanda_maxima {(i,j) in Matriz: i=1 or i=3}:

Prod[i,j] <= D_max[i,j];
Archivo “Ejemplo2_guia3.dat”:
param D_min := 100;
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.
Donde a es un expresión lógica. Si a es verdadera, la expresión condicional toma el valor de b; si la

expresión a es falsa, la expresión toma el valor de c. En caso c sea cero, la parte else de la función
puede ser obviada.
A continuación se muestra como se ha escrito la sentencia con la función if-then-else.
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:
subject to Produccion {i in Periodo}:

if i=1 then II + PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i] =
IFLANCHA[i] else IFLANCHA[i-1]) + PRODNORMAL[i] +
PRODEXTRA[i] - DEMANDA[i] = IFLANCHA[i];
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
Problema 1 (tomado y adaptado de Ríos (1998))
Formule un modelo de programación lineal usando el lenguaje de modelado de AMPL. Asimismo

genere el código algebraico, resuelva el modelo e interprete sus resultados.
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.
Tabla 6: Precio por kilogramo de las sustancias

Sustancia
Mes
Artificial 1 Artificial 1 Natural 1 Natural 2 Natural 3
Enero 130 140 150 130 135
Febrero 150 150 130 110 135
Marzo 130 160 150 120 115
Abril 140 130 140 140 145
Mayo 120 140 170 130 125
Junio 110 120 160 100 155
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.
El negocio requiere definir una política de compra y producción de máximo beneficio.
41
Anexo 4
set Periodo = 1..6;
param COSTONORMAL {Periodo};

param COSTOEXTRA {Periodo};
param CAPNORMAL {Periodo};
param DEMANDA {Periodo};
param II;
param COSTOALMACEN;
param PRODMIN;
param PRODMAXTEX12;
param PRODMAX;
var PRODNORMAL {Periodo} >=0;

var PRODEXTRA {Periodo} >=0;
var IFLANCHA {Periodo} >=0;
sum {i in Periodo} (COSTONORMAL[i] * PRODNORMAL[i] + COSTOEXTRA[i]
* PRODEXTRA[i]) + sum {i in Periodo: i<=5} COSTOALMACEN *
IFLANCHA[i] + COSTOALMACEN * II;
#RESTRICCIONES
subject to Produccion_mes1 {i in Periodo: i=1}:
IFLANCHA[i] = II + PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i];
subject to Produccion_otros_meses {i in Periodo: i>1}:

IFLANCHA[i] = IFLANCHA[i-1] + PRODNORMAL[i] + PRODEXTRA[i] -
DEMANDA[i];
#Capacidad maxima
subject to Capacidad_maxima {i in Periodo}:
PRODNORMAL[i] <= CAPNORMAL[i];
#Produccion minima en los dos primeros meses

subject to Prod_min {i in Periodo: i<=2}:
PRODNORMAL[i] >= PRODMIN;
#Produccion maxima en tiempo extra en los dos primeros meses

subject to Tmax_ext {i in Periodo: i<3}:
PRODEXTRA[i] <= PRODMAXTEX12;
#Produccion maxima total en los ultimos tres meses

subject to Tmax_total {i in Periodo: i>=4}:
PRODNORMAL[i] + PRODEXTRA[i] <= PRODMAX;
42
Anexo 5
Función objetivo:

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;
Ecuaciones de inventario:

Capacidad máxima:
PRODNORMAL[1] <= 200;

Producción mínima en los primeros dos meses:
PRODNORMAL[1] >= 50;

PRODNORMAL[2] >= 50;
Producción máxima en los primeros dos meses en tiempo extra:
PRODEXTRA[1] <= 350;

PRODEXTRA[2] <= 350;
Producción máxima total en los últimos tres meses:
PRODNORMAL[4] + PRODEXTRA[4] <= 550;

43
Anexo 6
Función objetivo:
15*Prod[1,1] + 15*Prod[1,2] + 20*Prod[2,1] + 20*Prod[2,2] + 10*Prod[3,1] +

10*Prod[3,2];
Tiempo máximo disponible:
0.12*Prod[1,1] + 0.15*Prod[2,1] + 0.08*Prod[3,1] <= 500;

0.12*Prod[1,2] + 0.15*Prod[2,2] + 0.08*Prod[3,2] <= 650;
Demanda mínima del producto 2 para el periodo 1:
Prod[2,1] >= 100;
Demanda máxima para los productos 1 y 3:
Prod[1,1] <= 500;

Prod[1,2] <= 500;
Prod[3,1] <= 650;
Prod[3,2] <= 650;
44
CUARTA GUÍA DE AMPL
En la cuarta guía importamos y exportamos datos usando el AMPL.

• Aprender a crear y ejecutar un archivo “.run”.
• Importar y exportar datos usando Excel.
• Conocer la utilidad y aplicaciones de un archivo “.run”.
1. COMO CREAR Y EJECUTAR UN ARCHIVO “.run”
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”.
Figura 19: creación de un archivo run
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:
ampl: include Run1.run;
A continuación se mostrará automáticamente el reporte de la solución óptima y el valor de las

variables. Si desea modificar algo en el modelo original, simplemente tendrá que grabarlo y ejecutar
el archivo “.run” en la ventana de comandos. No tendrá que escribir todo el código nuevamente pues
ya está en el archivo “.run”, note que en este archivo también se incluye el comando reset, para que
se borre la memoria del software y pueda resolver nuevamente el modelo sin ningún problema.
2. IMPORTACIÓN Y EXPORTACIÓN DE DATOS USANDO EXCEL
Normalmente, cuando se desea resolver modelos de optimización, la información requerida se

encuentra en archivos Excel, ya que permite manejar tablas de datos, y en muchos casos pasar los
datos de Excel al archivo “.dat” de AMPL puede ser engorroso debido a la gran cantidad de datos
que se podrían manejar. Por ello, en esta guía se explicará cómo importar y exportar datos de y
hacia archivos Excel.
Se usará el ejemplo 1 de la guía 2 para explicar el proceso de importación y exportación de datos.
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”.

set ProcesoMP := 1..5;
set Matriz2 := {Productos,ProcesoMP};

param Demandamin {Productos};
param Tiempo_prod {Matriz1};
param MP {Matriz2};
var P {i in Productos};
46
sum {i in Productos} Tiempo_prod[i,j] * P[i] <= RecursoT[j];

subject to Minimo {i in Productos}:

P[i] >= Demandamin[i];
subject to Maximo {i in Productos}:

2.1. Declaración de los nombres de las tablas en Excel
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
Figura 20: selección de datos
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.
Figura 22: administrador de nombres
En la ventana “Administración de nombres” presione el botón “Nuevo” y se desplegará la ventana

“Editar nombre” que se observa en la figura 5. En el campo “Nombre:” anote el nombre que desea
darle a la tabla, por ejemplo Prod_par. Luego en el campo “Hace referencia a:” seleccione en la
hoja de cálculo el rango en donde están los datos de dicha tabla, en este ejemplo el rango es:
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”.
Figura 23: valores de varios parámetros
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.
En la figura 24 se muestra como se ha declarado el nombre de la matriz “Tiempo_prod”. Ahora haga

lo mismo para la matriz “MP”.
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-
Figura 24: declarando la matriz tiempo
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.
Figura 25: declarando el nombre de la matriz resultados
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.
Figura 26: administrador de nombres
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.
2.2. Declaración de tablas en AMPL para lectura de datos vectoriales
A continuación se muestra el código que se debe ingresar en el archivo “Cuarta_guia.run” para

declarar la tabla “Prod_par” en AMPL.
table Prod_par IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':
[Productos], Margen, Demandamin, Demandamax;
¿Pero qué significa

todo ese código?
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.
2.3. Declaración de tablas en AMPL para lectura de datos matriciales
A continuación se va a mostrar el código que se debe ingresar en el archivo “Cuarta_guia.run” para

declarar la tabla “Tiempos” en AMPL.
table Tiempos IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':
[i ~ Productos], {j in Procesos} <Tiempo_prod[i,j] ~ (j)>;
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 MPdisp IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':

[ProcesoMP], RecursoMP;
table T_disp IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':

[Procesos], RecursoT;

table Materia_prima IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo

1.xlsx':
[i ~ Productos], {j in ProcesoMP} <MP[i,j] ~ (j)>;
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:
table MPdisp IN 'tableproxy' 'odbc' 'Users\Desktop\Cuarta guia

ejemplo 1.xlsx':
2.4. Declaración de tablas en AMPL para escritura de variables vectoriales
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.
2.5. Declaración de tablas en AMPL para escritura de variables matriciales
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];
subject to Todo_entra {i in Inicio}:

sum {j in Destinos:i<>j} X[i,j] = 1;
subject to Todo_sale {i in Inicio}:

sum {j in Destinos:i<>j} X[j,i] = 1;
subject to subtours {(i,j) in Matriz: i>1 and j>1 and i<>j}:

u[i] - u[j] + card(Inicio) * X[i,j]<= card(Inicio)-1;
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;
table Result OUT 'tableproxy' 'odbc' 'Cuarta guia ejemplo 2.xlsx':

{i in Inicio} -> [Inicio], {j in Destinos} <X[i,j] ~ (j)>;
option solver cplex;

display Distancias;
solve;
write table Result;
La sentencia para escribir los resultados en el archivo Excel es la siguiente:

table Result OUT 'tableproxy' 'odbc' 'Cuarta guia ejemplo 2.xlsx':
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
Nombre de la primera celda de la

primera columna de la tabla
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
Hasta ahora solo ha declarado las tablas que va a necesitar para

poder obtener los valores de los parámetros y exportar los valores de
las soluciones, pero aún no ha usado el comando para leer o escribir Tenga en cuenta:
datos. El comando write table se ha
escrito después de resolver el
Para leer los datos de una tabla debe usar el comando read table y modelo ya que si lo
para escribir los resultados de una variable en un archivo de Excel pusiéramos antes la variable
debe usar el comando write table. A continuación se muestra como tendría valor de 0.
se deben escribir dichos comandos en el archivo “.run”.
read table Prod_par;
read table MPdisp;
read table T_disp;
read table Tiempos;
read table Materia_prima;
write table Resultados;

Complete estos comandos en su archivo “.run”.
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;

table MPdisp IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':

table T_disp IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':

[Procesos], RecursoT;

table Materia_prima IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':

[i ~ Productos], {j in ProcesoMP} <MP[i,j] ~ (j)>;
table Resultados OUT 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':

[Productos], P;
read table Prod_par;

read table MPdisp;
read table T_disp;
read table Tiempos;
read table Materia_prima;
option solver cplex;
solve;
write table Resultados;
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.

set Maquinas := 1..2;
set Dias := 1..2;
set Matriz := {Productos, Maquinas, Dias};
param Costo {Matriz};
var Prod {Matriz};
En la figura siguiente se muestra como deberían ordenarse las tablas
Para declarar el nombre de la tabla de costos en Excel deberá seleccionar el rango

A1:D9 y para la tabla de resultados deberá seleccionar el rango F1:I9.
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;
Donde [Producto, Maquina, Dia] se refiere a que la primera, segunda y tercera

columna es donde se coloca los miembros de los sets y en la siguiente columna estarán
los valores de los parámetros.
table Resultado OUT 'tableproxy' 'odbc' 'Ejemplo 3 set.xlsx':
[Producto, Maquina, Dia], Prod;
Donde [Producto, Maquina, Dia] se refiere a que la primera, segunda y tercera

columna es donde se coloca los miembros de los sets y en la siguiente columna se
exportarán los valores de la variable.
55
2.7. UTILIDAD DE UN ARCHIVO “.run”
Puede que usted se esté preguntando porque está usando un archivo

“.run” para la declarar tablas, leer y escribir datos en Excel. Pero recuerde
que un archivo “.run” es un ejecutable, esto significa que todo el código
que ha escrito en él podría escribirlo directamente en la ventana de
comandos, sólo que tendría que escribir todos los comandos cada vez
que quiera resolver un modelo usando Excel. Si desea probarlo, en su
ventana de comandos escriba lo siguiente:
ampl: model Ejemplo1_guia4.mod;

ampl: table Prod_par IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx':
ampl? Productos <- [Productos], Margen, Demandamin, Demandamax;
ampl: table MPdisp IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx':
ampl? ProcesoMP <- [ProcesoMP], RecursoMP;
ampl: table T_disp IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx':
ampl? Procesos <- [Procesos], RecursoT;
ampl: table Tiempos IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx':
ampl? [i ~ Productos], {j in Procesos} <Tiempo_prod[i,j] ~ (j)>;
ampl: table Materia_prima IN 'tableproxy' 'odbc' 'Cuarta guía
ejemplo1.xlsx':
ampl? [i ~ Productos], {j in ProcesoMP} <MP[i,j] ~ (j)>;
ampl: table Resultados OUT 'tableproxy' 'odbc' 'Cuarta guía
ejemplo1.xlsx':
ampl? Productos <- [Productos], P;
ampl: read table Prod_par;
ampl: read table MPdisp;
ampl: read table T_disp;
ampl: read table Tiempos;
ampl: read table Materia_prima;
ampl: option solver cplex;
ampl: solve;
ampl: write table Resultados;
Usted puede pensar que no es muy complicado escribir esta

sentencia, no obstante tenga en cuenta que basta con que se
equivoque en una sola letra para que tenga que escribir de
nuevo todo. Imagine que en vez de escribir read table
MPdisp; usted escribe read table MPdis; esto le
devolvería un error por parte de AMPLIDE y tendría que
reescribir todo otra vez, desde model
Ejemplo1_guia4.mod;.
56
QUINTA GUÍA DE AMPL
En la quinta guía se explicaran los comandos LET, FIX, UNFIX, FOR y REPEAT usando
el AMPL.

• Aprender a usar los comandos de ejecución let, fix y unfix.
• Aprender a usar los comandos de ejecución for y repeat.
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”.
1. COMANDOS DE MODELADO LET, FIX Y UNFIX
A continuación se detallará los comandos let, fix y unfix, además de desarrollar ejercicios y analizar
sus ventajas.
1.1. El comando let
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: model Ejemplo_guia5.mod;

ampl: data Ejemplo_guia5.dat;
ampl: solve;
CPLEX 12.6.3.0: optimal solution; objective 50289.23077
1 dual simplex iterations (0 in phase I)
ampl: display Tp.slack;

Tp.slack [*] :=
1 27.4438
2 9.4797
3 29.0435
4 38.8285
5 24
6 21.1441
7 0;
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)
Al incrementar el tiempo disponible para el proceso 7 se ha incrementado la cantidad de unidades

producidas y por tanto el valor de la función objetivo.
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.
ampl: let {i in Productos} Demandamax[i] := 1.1 * Demandamax [i];

ampl: solve;
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:
ampl: let {i in Productos} Demandamax[i] := 180;

ampl: solve;
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];
1.2. Los comandos fix y unfix
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.
ampl: model Ejemplo_guia5.mod;

ampl: data Ejemplo_guia5.dat;
ampl: let {i in Productos} P[i] := Demandamin[i];
ampl: fix {i in Productos} P[i];
ampl: solve;
All variables fixed; Para fijar los valores de todas

objective Utilidades = 2081.25. las variables P se debe usar
una expresión indexada
ampl: display P;
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
;
Para revertir el comando fix se ingresa el siguiente código en la ventana de comandos:
ampl: unfix {i in Productos} P[i];
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;
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
;
2. COMANDO FOR: ITERACION DE SENTENCIAS
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.
Para realizar un análisis del “Ejemplo_guia5.mod”, el cual encontrará en la intranet, en la carpeta

“Quinta guía”, se creará un archivo “.run” que permitirá resolver tres veces el problema
incrementando en cada iteración un 5% a “RecursoT” y un 10% a “Demandamax”.
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.
set iteracion := 1..3;

set Compuesto := {Productos,iteracion};
param Ganancias {iteracion};
param Prod {Compuesto};
for {a in iteracion} {
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.
3. COMANDO REPEAT: ITERAR RESPECTO A UNA CONDICION
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:
repeat while Utilidades < 60000 {...};

repeat until Utilidades > 60000 {...};
repeat {...} while Utilidades < 60000;
repeat {...} until Utilidades > 60000;
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.
repeat while Utilidades < 60000 {

solve;
display P;
}
61
Datos importantes:
¿Cuál es la diferencia entre escribir primero la condición y luego la sentencia

y hacerlo al revés?
Cuando se escribe primero la condición el bucle la analiza y en caso sea verdadera

se ejecuta la iteración; cuando la condición se escribe al final se ejecuta la iteración
sin importar si al inicio la condición es verdadera o no.
Para ejemplificarlo cree un archivo “.run” con el siguiente código:
repeat while Utilidades > 60000 {

solve;
display P;
}
Notará que luego de ejecutarlo, AMPLIDE no resuelve el problema y cuando ejecuta

el código
ampl: display Utilidades;
“Utilidades” tiene valor de 0, esto es debido a que la condición obliga a que se

ejecute el bucle solo cuando “Utilidades” es mayor a 60000 U.M. y como
inicialmente su valor es 0 y no cumple con la condición, el bucle no se ejecuta.
Ahora en su archivo “.run” ingrese el código:
repeat {
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.
El gerente de la empresa conoce que usted es un consultor especializado en toma de decisiones

usando modelos de optimización y tiene muy buenas referencias de usted. Le menciona que desea
analizar cuál de sus fábricas debería cerrar para que pueda tener las menores pérdidas en el corto
plazo (6 meses); también le menciona que quisiera que lo ayude a determinar el plan óptimo de
producción para cada una de las plantas que se mantendrían abiertas.
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:
Pijk: Cantidad en toneladas que la fábrica 1 va a producir del producto j

en el mes k.
i=1, planta 1; i=2, planta 2; i=3, planta 3; i=4, planta 4; j=1, producto 1; j=2,
producto 2; j=3, producto 3; j=4, producto 4; j=5, producto 5; k=1, mes 1; k=2,
mes 2; k=3, mes 3; k=4, mes 4; k=5, mes 5; k=6, mes 6.
Función objetivo:
Maximizar i=1…4j=1…5k=1…6(PVj – Costoij) * Pijk
Restricciones:
i=1…4 Pijk = DEMANDAjk ; j=1,2…5; k=1,2…6
TIEMPOij*Pijk ≤ TMAX ; i=1,2…4; j=1,2…5; k=1,2…6
Eficij*Pijk ≤ DISPONIBLEij ; i=1,2…4; j=1,2…5; k=1,2…6
Pijk ≥ 0 ; i=1,2…4; j=1,2…5; k=1,2…6
El modelo de programación lineal en lenguaje AMPL y el archivo de datos puede encontrarlos en la

intranet del curso, en la carpeta “AMPL/Archivos guía 5” con los nombres “Problema1_guia5.mod”
y “Problema1_guia5.dat”.
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
En la carpeta “AMPL/Archivos guía 5” encontrará el archivo “Problema1_guia5.run” con la

solución de la parte “a)”.
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.
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…4j=1…5 Cafeij * Humedad_excesoi * Costo_oreado +
Cafeijk * Costo_compraij
Restricciones:
i=1…7 Cafeij (1-Porcen_descarte) = DEMANDAj ; j=1,2…6
Cafeij ≤ Cafe_productoresi ; i=1,2…7; j=1,2…6
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.

• Aprender a definir los rangos de las variables usando parámetros
• Aprender a declarar variables como enteras o binarias
1. DEFINICIÓN DE RANGOS DE VARIABLES USANDO PARÁMETROS
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.


param MP {Matriz2};
var P {i in Productos} >=Demandamin[i], <=Demandamax[i] ;

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 la declaración de variables, al momento de definir los rangos, usted ha utilizado el

índice “i” que es el mismo que ha utilizado en las restricciones y función objetivo, pero
esto no es obligatorio. Para probarlo utilice el índice “h” y escriba la declaración de
variables de la siguiente forma:
var P {h in Productos} >=Demandamin[h], <=Demandamax[h] ;
2. DECLARACIÓN DE VARIABLES COMO ENTERAS Y BINARIAS
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:
integer: palabra reservada para declarar una variable como entera.

binary: palabra reservada para declarar variables binarias (1 ó 0).
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:
Pi: cantidad de unidades por fabricar de cada tipo de producto. i= 1,2…20

Yi: 1; sí se fabrica el producto i
0; no se fabrica el producto i
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.
Usando notación matemática, el ejemplo 2 es el siguiente:
Función objetivo:
Maximizar i=1...20(MARGENi*Pi) - i=1..20(COSTO_FIJOi*Yi)
Restricciones:
Pi ≥ DEMANDAMINi*Yi ; i=1,2…20
 j=1…20(TIEMPOji*Pj) ≤ RECURSOTi ; i=1,2…7
 j=1…20(MPji*Pj) ≤ RECURSOMPi ; i=1,2…5
Restricciones para los costos fijos:
Pi ≤ M*Yi ; i=1,2…20 ; M>>0
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.

El margen de contribución de cada producto MARGENi
Costo fijo que se incurre si se fabrica el producto i COSTO_FIJOi
La demanda mínima de cada producto DEMANDAMINi
La demanda máxima de cada producto DEMANDAMAXi
Disponibilidad del recurso tiempo de cada proceso RECURSOTj
Disponibilidad del recurso materia prima para cada proceso RECURSOMPj
El tiempo unitario por kilogramo de cada producto en cada
TIEMPOij
proceso
El consumo de materia prima por kilogramo de cada producto en
Mpij
cada proceso
Número positivo lo suficientemente grande M
68
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
1) Archivo “Ejemplo2_guia6.mod” en donde está el modelo escrito en el lenguaje de modelado de

AMPL.
2) Archivo Excel “Ejemplo2_guia6.xlsx” en donde están anotados los datos para importarlos al
editor de AMPL y para exportar la solución de AMPL a este archivo Excel. También descargue
el archivo “Ejemplo2_guia6.run” que usará para resolver el modelo importando los datos desde
Excel y exportando los resultados.
A continuación se muestra el modelo que está en el archivo “Ejemplo2_guia6.mod”.
#Sets del modelo


#Parámetros del modelo

param Costo_fijo {Productos};
param MP {Matriz2};
param M := 1000;
#Variables del modelo

var P {Productos} integer;
var Y {Productos} binary;
#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}:
#Restricciones de tiempo
subject to Tiempo_max {j in Procesos}:
#Restriciones de MP
subject to MP_maxima {j in ProcesoMP}:
#Restricciones para costos fijos

subject to Fijos {i in Productos}:
P[i] <= M * Y[i];
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.
Cuando resuelva el problema, AMPLIDE le devolverá el siguiente mensaje:
MINOS 5.51: ignoring integrality of 40 variables

21 iterations, objective 49450.9812
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:
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] - 400*Y[1] - 250*Y[2] - 600*Y[3] - 350*Y[4] - 400*Y[5] -
250*Y[6] - 300*Y[7] - 150*Y[8] - 200*Y[9] - 300*Y[10] - 200*Y[11] -
150*Y[12] - 100*Y[13] - 150*Y[14] - 200*Y[15] - 150*Y[16] - 200*Y[17] -
300*Y[18] - 500*Y[19] - 400*Y[20];
P[1] - 10*Y[1] >= 0;

P[2] - 15*Y[2] >= 0;
P[3] >= 0;
P[4] >= 0;
P[5] - 10*Y[5] >= 0;
P[6] >= 0;
P[7] - 10*Y[7] >= 0;
P[8] >= 0;
P[9] - 20*Y[9] >= 0;
P[10] - 25*Y[10] >= 0;
P[11] - 15*Y[11] >= 0;
P[12] - 10*Y[12] >= 0;
P[13] >= 0;
P[14] >= 0;
P[15] >= 0;
P[16] - 10*Y[16] >= 0;
P[17] >= 0;
P[18] >= 0;
P[19] >= 0;
P[20] >= 0;
P[1] <= 150;
P[2] <= 80;
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;
71
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;
0.4*P[1] + 0.3*P[2] + 0.4*P[3] + 0.3*P[4] + 0.4*P[5] + 0.5*P[6] +

0.4*P[7] + 0.5*P[8] + 0.3*P[9] + 0.4*P[10] + 0.35*P[11] + 0.45*P[12] +
0.5*P[13] + 0.25*P[14] + 0.35*P[15] + 0.45*P[16] + 0.4*P[17] + 0.3*P[18]
+ 0.35*P[19] + 0.3*P[20] <= 1200;
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;
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;
Restricciones de costos fijos:
P[1] - 1000*Y[1] <= 0;

P[2] - 1000*Y[2] <= 0;
P[3] - 1000*Y[3] <= 0;
P[4] - 1000*Y[4] <= 0;
P[5] - 1000*Y[5] <= 0;
P[6] - 1000*Y[6] <= 0;
P[7] - 1000*Y[7] <= 0;
P[8] - 1000*Y[8] <= 0;
P[9] - 1000*Y[9] <= 0;
P[10] - 1000*Y[10] <= 0;
P[11] - 1000*Y[11] <= 0;
P[12] - 1000*Y[12] <= 0;
P[13] - 1000*Y[13] <= 0;
P[14] - 1000*Y[14] <= 0;
P[15] - 1000*Y[15] <= 0;
P[16] - 1000*Y[16] <= 0;
P[17] - 1000*Y[17] <= 0;
P[18] - 1000*Y[18] <= 0;
P[19] - 1000*Y[19] <= 0;
P[20] - 1000*Y[20] <= 0;
73
Bibliografía
FOURER, Robert; Gay, David; Kerninghan, Brian

2003 AMPL: A Modeling Language for Mathematical Programming. Segunda edición.
Princeton University.
HILLIER, Frederick; Lieberman, Gerald

2015 Introducción a la Investigación de operaciones. Décima edición. México D.F.
McGraw-Hill.
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
CORNUEJOLS, Gerard; Trick, Michael

1998 Quantitative methods for the Management Sciences: Course notes. Pittsburgh.
Carnegie Mellon University.
CORNEJO, Christian
2014 Guía Lingo. Publicación de material para la docencia PUCP.
74

Apuntes Ampl

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apuntes Ampl

Cargado por

Copyright:

Formatos disponibles

GUÍA DE INVESTIGACIÓN

¿Por qué AMPL?

El software AMPL soporta todo el ciclo de vida de modelado de optimización: formulación,

AMPL integra un lenguaje de modelado para describir datos de optimización: variables,

A todos los alumnos con ganas de seguir aprendiendo

INDICE DE GRÁFICOS ...................................................................................................................... vii

Tabla 1: Lista de parámetros ............................................................................................................ 15

La modelación matemática propone la optimización de procesos y sistemas a partir del uso

La modelación matemática aplicada en la carrera de Ingeniería Industrial, optimiza los

Fuente: Scimago Journal & Country Rank

Por lo tanto, nuestro objetivo es incrementar las habilidades de investigación de nuestros

En la primera guía conoceremos que es el AMPL, su entorno e interface. Además de

Objetivos de esta guía

1. ENTORNO DEL SOFTWARE AMPLIDE

1.1. Instalación de AMPL

Figura 1: Página web de software AMPL

Figura 2: Libro desarrollado por AMPL

Figura 3: Página web de software AMPL con licencia académica

Figura 4: Documentación de la descarga AMPL - Students

INICIO DEL SOFTWARE AMPLIDE

Figura 5: ventana de instalación de AMPL

Figura 6: aceptar el Amplide.

Figura 7: Interface del Amplide.

● Ventana de archivos: Permite navegar en las carpetas de la computadora para poder

TIPO DE ARCHIVOS DEL SOFTWARE AMPL

En el software AMPLIDE interactúa con 3 tipos de archivos: “.mod”, “.dat” y “.run”. A

1.3. Barra de herramientas del software AMPLIDE

Figura 8: Comando New

Figura 9: Comando New file

En la Figura 8 se muestra el archivo creado con el nombre “model_prueba.mod”.

Figura 10: archivos para modelar

El comando New se puede ejecutar rápidamente presionando en la barra de herramientas

COMANDO SAVE ALL

1.4. Opciones de la ventana de comandos

En la ventana de comandos se tiene la cinta de opciones que se muestra en la Figura 12.

Figura 12: opciones de consola

Cuando se está resolviendo un modelo matemático con el software AMPLIDE, existe la

Figura 13: interrumpir proceso

BOTÓN CLEAR CONSOLE

Figura 14: limpiar pantalla

2. EJECUCIÓN DE UN MODELO EN AMPL

P: unidades a fabricar del mueble Premium en un mes.

C: unidades a fabricar del mueble Clásico en un mes.

En la ventana de modelado de AMPLIDE ingrese lo que se muestra en la siguiente pantalla

Figura 15: sintaxis del modelo .mod

ampl: model Ejemplo1.mod;

Luego de escribir el comando solve, AMPLIDE devolvió el siguiente mensaje:

ampl: model Ejemplo1.mod;

Figura 16: Programación en la consola

Si creó el archivo “Ejemplo1.mod” con

Si en su ventana de archivos se muestra otra ruta, al momento de llamar al archivo se

Can't find file Ejemplo1.mod

Figura 17: Búsqueda de archivo

Luego de ejecutar este comando, AMPLIDE mostrará el siguiente mensaje:

ampl: model Ejemplo1.mod;

Figura 18: Búsqueda de la solución

Como modo de evaluación de lo aprendido, resuelva el siguiente ejemplo.

a) ¿Cuál es el solver que se utiliza para este problema?

En la segunda guía iniciaremos en la modelación / programación en el AMPL.

Objetivos de esta guía

1. LENGUAJE DE MODELADO DE AMPL

Ejemplo 1 – Introducción a la formulación

Pi: cantidad de kilogramos por fabricar de cada tipo de producto. i= 1,2…20