GUÍA DE INVESTIGACIÓN OPERATIVA A mathematical programming language
GIOPA Autores Jonatán Rojas Polo Christian Cornejo Sánchez Alessandro Gilardino Gilardino Arias Arias Renzo Benavente Sotelo Alexia Cáceres 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, investigación, en publicaciones publicaciones indizadas, y son ganadores de premios internacionales 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 ’s proporcionados por AMPL. con solver ’s 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
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, investigación, en publicaciones publicaciones indizadas, y son ganadores de premios internacionales 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 ’s proporcionados por AMPL. con solver ’s 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 ÍNDICE GENERAL
...................................................................................................................... .......................................................vii INDICE DE GRÁFICOS ............................................................... ................................................................................................................. ........... 1 PRIMERA GUÍA DE AMPL ......................................................................................................
1.
2.
.............................................................................. ........................................... 1 ENTORNO DEL SOFTWARE AMPLIDE ...................................
1.1.
Instalación de AMPL ........................................................................................................ 1
1.2.
.................................................................. 3 Interfaz de usuario del software AMPLIDE ...................................................................
1.3.
Barra de herramientas del software AMPLIDE ............................................................ 4
1.4.
.......................................................................... ...................... 6 Opciones de la ventana de comandos ....................................................
EJECUCIÓN DE UN MODELO EN AMPL ........................................................................... 7
............................................................................................................. ......... 11 SEGUNDA GUÍA DE AMPL .....................................................................................................
1.
............................................................................ 11 LENGUAJE DE MODELADO DE AMPL .............................................................................
2.
ESTRUCTURA DE UN MODELO EN AMPL ..................................................................... 16 2.1.
................................................................................................................................... ............................... 1 16 6 SET ....................................................................................................
2.2.
..................................................................................................................... ......... 16 Parámetros: ............................................................................................................
2.3.
......................................................................................................................... .................... 1 7 Variables: .....................................................................................................
2.4.
Función objetivo (F.O.): ................................................................................................. 17
2.5.
................................................................................................................. 1 8 Restricciones: ..................................................................................................................
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 ................................................................................................................................ ........................................................................... ......... 2 5 AMPLIDE .............................................................. 6. PROBLEMAS PROPUESTOS (desarrollando los problemas del manual de Lingo en .............................................................................................................................................. .................... 25 AMPL) ........................................................................................................................... TERCERA GUÍA DE AMPL .............................................................................................................. 31 1.
........................................................................ 3 1 ANÁLISIS DE SENSIBILIDAD CON AMPL ........................................................................
2.
................................................................................. ............................... 34 OPERADORES LÓGICOS EN AMPL ..................................................
2.1.
Modelado de la función objetivo con operadores lógicos ......................................... 36
2.2.
...................................... 37 Modelado de las restricciones con los operadores lógicos ......................................
3.
LA FUNCION IF-THEN-ELSE .............................................................................................. 39
4.
PROBLEMAS PROPUESTOS ............................................................................................. 40
................................................................................................................. ............................... 45 CUARTA GUÍA DE AMPL ..................................................................................
1.
......................................................... 45 COMO CREAR Y EJECUTAR UN ARCHIVO “.run” .........................................................
iv
2.
IMPORTACIÓN Y EXPORTACIÓN DE DATOS USANDO EXCEL ............................... 46 2.1.
Declaración de los nombres de las tablas en Excel .................................................. 4 7
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 ................................................................................................................. 5 7
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 ........................................................................................................................................... 7 4
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®ion=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. 1.1.
ENTORNO DEL SOFTWARE AMPLIDE Instalación de A MPL 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 soft ware 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 inst alació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 dirección de archivos
Ventana de comandos para Solver y reporte de pantalla
Ventana de modelado y de almacenamiento de datos
Figura 7: Interface del Amplide.
3
El software AMPLIDE tiene 3 componentes principales: ●
● ●
Ventana de archivo s: 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: ● ● ●
1.3.
Ar ch ivos “ .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. Ar ch ivos “ .dat ” : Son los archivos donde se ingresan los parámetros necesarios para resolver el modelo de optimización. Ar ch ivos “ .run ” : Son archivos que facilitan dar ciertas órdenes a los archivos “.mod”.
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 cons ola
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: i nterrumpir 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: Para los nombres de los
#variables var P; var C;
archivos “.mod”, “.dat”, sets, parámetros,
#Funcion objetivo maximize Utilidad: 450*P + 280*C; #Restricciones subject to Tiempo_disponible: 4.5*P + 2.5*C <= 400; subject to DemandamaxP: 0 <= P <= 60; subject to Demanda_max_C: 0 <= C <= 100;
variables, función objetivo y restricciones se puede utilizar una sola palabra o dos palabras unidas con el 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: model Ejemplo1.mod; 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: model Ejemplo1.mod; ampl: solve; MINOS 5.51: optimal solution found. 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”, “Demanda maxP” 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. Objetivos de esta guía • 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 ≥ DEMANDAMIN i
;
i=1,2…20
Pi ≤ DEMANDAMAX i
;
i=1,2…20
;
j=1,2…7
Restricciones de tiempo: i=1…20(TIEMPOij*Pi)
≤ RECURSOT j
Restricciones de materia prima: 11
i=1…20(MPij*Pi)
≤ RECURSOMPj
;
j=1,2…5
;
i=1,2…20
Rango de existencia: Pi ≥ 0
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] P[2] P[3] P[4]
<= <= <= <=
60; 100; 120; 75;
Restricciones de tiempo: 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; Restricciones de materia prima: 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: Maximizar
i=1…20 (MARGENi*Pi)
Restricciones: Restricciones de demanda: Pi ≥ DEMANDAMIN i
;
i=1,2…20
Pi ≤ DEMANDAMAX i
;
i=1,2…20
;
j=1,2…7
;
j=1,2…5
;
i=1,2…20
Restricciones de tiempo: i=1…20(TIEMPOij*Pi)
≤ RECURSOT j
Restricciones de materia prima: i=1…20(MPij*Pi)
≤ RECURSOMPj
Rango de existencia: Pi ≥ 0
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
MARGEN i
La demanda m ínima de cada producto
DEMANDAMIN i
La dem anda máxima de cada producto
DEMANDAMAX i
Disponibi lidad del recurso tiempo de cada proceso Disponibi lidad del recurso materia prima para cada proceso
RECURSOTj
El tiempo unitario por kilogramo de cada producto en cada proceso
RECURSOMPj
El consum o de m ateria prima por kilogramo de cada producto en cada proceso
TIEMPOij
Mpij
Lista de variables
Etiqueta
Cantidad de kilogramos por fabrica de cada tipo de producto, estas s on las variables de decis ió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 ejemplo, para declarar el parámetro cuyo nombre es “Margen” siga la sintaxis siguiente : param Margen Por otro lado, si el parámetro “Margen” fuese de
tipo escalar (es decir, tiene un único valor) basta con colocar “;” a la sentencia mostrada, es decir, param Margen;. Sin embargo, si el parámetro
fuese vectorial o matricial (conjunto de valores)
16
Tenga en c uenta: En AMPL se tiene la opción de declarar el rango de existencia de los parámetros agregando “> 100”, “<0”, “>=0” ó “<= 500”, dependiendo de lo que se necesite. La sintaxis que se debe seguir puede ser cualquiera de las siguientes: param Margen{Productos}>=0; param Margen{Productos}<=100; param Margen{Productos}>0, <=10;
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 arc hivo “.mod” los parámetros restantes para formular e l programa lineal del ejemplo 2. 2.3. Variables: Para declararlos use la palabra reservada var, seguida del nombre que usted elija y de un set previamente declarado. Así, por ejemplo, para declarar la variable de decisión P del ejemplo 1 la sintaxis sería la siguiente: var P {Productos}; Ahora usted declare en su archivo “.mod” el resto de
variables que se necesitan para formular el programa lineal del ejemplo 2.
Tenga en cuenta: En AMPL se tiene la opción de declarar el rango de las variables agregando “> 100”, “<0”, “>=0” ó “<=500”, dependiendo de lo que se necesite. La sintaxis que se debe seguir puede ser cualquiera de las siguientes: var P {Productos}>=0; var P {Productos}<=0; var P {Productos}>=0, <200;
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 us ar 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: Maximizar
i=1…20 (MARGENi*Pi)
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: maximize Utilidades: sum {i in Productos} Margen[i] * P[i]; En su archivo “.mod” ingrese la sentencia para la F.O. que se muestra en la línea anterior.
17
Datos importantes: ¿Y si quiero saber si estoy ingresando bien el código?
Para saber si está ingresando bien el código en sus archivos, cargue los 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 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 el ejemplo 2 set Productos := 1..20; set Procesos := 1..7; set ProcesoMP := 1..5; set Matriz1 := {Productos,Procesos}; set Matriz2 := {Productos,ProcesoMP}; Margen {Productos}; Margen param Demandamin {Productos}; Demandamin param Demandamax {Productos}; Demandamax param RecursoT {Procesos}; RecursoT param RecursoMP {ProcesoMP}; RecursoMP param param Tiempo {Matriz1}; Tiempo MP MP {Matriz2}; param
CUIDADO: AMPL diferencia entre mayúsculas y minúsculas, por eso productos, Productos y PRODUCTOS son palabras diferentes en AMPL.
var P {Productos}; maximize Utilidades: {i {i in Productos} Margen[i] * P[i]; sum subject to Tp {j in Procesos}: {i {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j]; sum subject to Materia {j in ProcesoMP}: {i {i in Productos} MP[i,j] * P[i] <= RecursoMP[j]; sum 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
•
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
los
sets
primitivos
invocados
en
los
sets
compuestoss compuesto
se
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 ol olvide vide usar usar el nombre exacto de cada cada parámetro, 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 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, t anto, si usted escribe la función objetivo de la siguiente manera: maximize Utilidades: {i {i in Productos} PV[i] * P[i] - Costo[i] * sum
P[i];
AMPL devolverá un error de sintaxis ya que AMPL solo reconocerá PV[i] * P[i] como parte de la función sum. Para que AMPL arroje errores puede escribir la sentencia de tres formas: maximize Utilidades: {i {i in Productos} (PV[i] * P[i] - Costo[i] * sum maximize Utilidades: {i {i in Productos} (PV[i] - Costo[i]) * sum
20
P[i];
P[i]);
maximize Utilidades: {i {i in Productos} PV[i] * P[i] - sum {i {i in Productos} sum 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 más información información sobre sobre como declarar las las variables variables e ingresar ingresar la función objetivo 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 siempre de la misma forma ya que en caso las escribiéramos con mayúsculas mayúsculas AMPL no las reconocería, las palabras que hemos usado son las siguientes: • • • • • • • •
set: para definir los grupos de objetos relacionados relacionados en en grupos. param: se utiliza para definir parámetros ya conocidos que se ingresarán al modelo. var: se utiliza para definir las variables variables que se utilizarán utilizarán en el modelo. 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 para desarrollar desarrollar las las sumatorias sumatorias de las variables variables o parámetros en en las restricciones función objetivo.
21
Ingreso 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. Margen:= Margen:= param 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
11 15.75 10.5 10.75 14.5 17.25 13.5 12 16 17 20 22 18.5 17 15.5 19 21.5 21.5 15.5 14.5;
Este signo es el de asignación, y se utiliza siempre que se desea asignar un valor a un parámetro.
Ahora usted ingrese los valores de los demás parámetros vectoriales. Ingreso Ingreso de datos matriciales: Para mostrar cómo se deben ingresar los datos de una matriz de dos dimensiones, utilizaremos el parámetro Tiempo e ingresaremos sus datos. Tiempo: Tiempo: param 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
1 0.167 0.200 0.417 0.200 0.250 0.283 0.317 0.500 0.333 0.350 0.333 0.367 0.333 0.250 0.300 0.283 0.250
2 0.083 0.067 0.133 0.150 0.033 0.033 0.050 0.067 0.083 0.100 0.083 0.133 0.167 0.183 0.083 0.050 0.067
3 0.100 0.067 0.167 0.183 0.200 0.217 0.133 0.183 0.233 0.250 0.167 0.217 0.250 0.233 0.217 0.200 0.200
4 0.067 0.083 0.067 0.100 0.100 0.117 0.133 0.150 0.167 0.183 0.117 0.150 0.100 0.167 0.067 0.083 0.067
5 0.050 0.033 0.067 0.067 0.067 0.083 0.117 0.100 0.133 0.150 0.083 0.117 0.067 0.133 0.033 0.050 0.050
22
6 0.100 0.117 0.117 0.133 0.133 0.150 0.150 0.133 0.167 0.183 0.167 0.183 0.083 0.100 0.133 0.150 0.133
7 := 0.083 0.100 0.050 0.067 0.117 0.133 0.117 0.100 0.083 0.100 0.117 0.117 0.133 0.117 0.067 0.050 0.033
Tenga en en c uenta: Para datos matriciales, se coloca en la primera fila el nombre del parámetro al que se le van asignar los datos, y recién desde la segunda fila se comienzan a colocar los índices.
18 19 20
0.267 0.033 0.183 0.100 0.067 0.150 0.150 0.233 0.050 0.167 0.117 0.083 0.167 0.133 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 tr es 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; set Maquinas; set Productos;
Tenga en cuenta: Podemos iterar en varios sets con los que no se ha creado un set compuesto. Por ejemplo, si tuviéramos que iterar una restricción en Productos y Turnos, haríamos lo siguiente:
#Sets compuestos set Matriz={Productos,Maquinas,Turno};
subject to ¨Nombre¨ {i in Productos, k in Turnos}
#Parametro de Costos Costo {Matriz}; param
Ahora, procederemos a asignar los valores al parámetro costo: Costo := param [*,*,1]: 1 2 3 4 5 6 [*,*,2]: 1 2 3 4 5 6 [*,*,3]: 1 2 3 4 5 6
1 13.0 13.0 10.0 14.0 10.0 12.0
2 10.0 13.0 15.0 15.0 14.0 14.0
3 := 12.0 13.0 14.0 11.0 12.0 12.0
1 21.0 17.0 18.0 21.0 24.0 21.0 1 30.0 27.0 31.0 32.0 28.0 31.0
2 19.0 22.0 18.0 19.0 24.0 17.0 2 30.0 30.0 27.0 32.0 29.0 29.0
3 := 25.0 20.0 20.0 18.0 25.0 20.0 3 := 29.0 32.0 32.0 27.0 29.0 27.0;
No se coloca el signo “;” al final de cada tabla,
sino sol o en la última
No se coloca el signo “;” al final de cada
tabla, sino so lo en la última
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ó. Recuerde que debe de asegurarse de usar exactamente los signos “;”, “:”, “=” y “:=” en las partes donde corresponde según se muestra en los ejemplos, ya que de lo contrario tendrá errores de sintaxis. Recuerde que en el caso de parámetros de matrices de tres dimensiones debe colocar el signo “;” solamente luego de haber ingresado todas las tablas que se tengan y no luego de cada tabla. No olvide usar exactamente los nombres declarados para cada parámetro y no vaya a usar alguna mayúscula o minúscula extra o menos debido a que AMPL distingue 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.
Datos importantes: ¿Como se entiende [*,*,1]? [*,*,1]: 1 2 3 := 1 2 3 4 5 6 El primer “*” se refiere a los miembros del set Productos y el segundo “*” se refiere a los miembros del set Maquinas.
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: MINOS 5.51: optimal solution found. 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 tr ansporte 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
Producto
Planta 1
Planta 2
Planta 3
Planta 4
Planta 5
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, embarcados al cliente j
en miles,
fabricados
en la
planta
i
y
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
…
Restricciones de demanda: Para el cliente 1: X_1_1 + X_2_1 + X_3_1 + X_4_1 + X_5_1 >= 400;
Que expresado como sumatoria es: 5
Xi1 ≥ 400 i=1
…
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 recurso s Mano de obra Mano de obra calificada no calificada
Ventas (dólares)
Producto
Máquina 1
Máquina 2
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 unitarios en US$
Precio de venta en US$
Margen de contribución en US$
Demanda mínima del producto en kilogramos
Demanda máxima del producto 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
Productos
28
Anexo 2 Tiempo unitario por cada kilogramo del producto i en el proceso j, en minutos
Productos
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
Productos
Materia prima requerida por cada kilogramo del producto i 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 kilogramos
1200
650
600
350
400
30
TERCERA GUÍA DE AMPL En la tercera guía iniciaremos el análisis de sensibilidad usando el AMPL. Objetivos de esta guía • 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 SENSIBIL IDAD 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 si gno 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 T p) display Tp, Tp.slack;
AMPLIDE devolverá el siguiente mensaje: ampl: display : Tp 1 0 2 0 3 0 4 0 5 0 6 0 7 115.385
Tp, Tp.slack; Tp.slack 27.4438 9.4797 29.0435 38.8285 24 21.1441 0;
:=
Datos importantes: Para los precios sombra se escribe: display Restricción;
Y para la holgura: display Restricción.slack;
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: PRODNORMAL t: 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:
t= 1,2…5
inventario final de lanchas en el mes t.
Usando notación matemática, el resto del modelo es el siguiente: Función objetivo: Minimizar
t=1…6(COSTNORMALt*PRODNORMAL t t=1…5(COSTOALMACEN*IFLANCHA t)
+ COSTEXTRAt*PRODEXTRA t) + + COSTOALMACEN*II
Restricciones: Ecuaciones de inventario:
IFLANCHA1 = II + PRODNORMAL1 + PRODEXTRA1 – DEMANDA1 IFLANCHAt = IFLANCHAt-1 + PRODNORMALt + PRODEXTRAt – DEMANDAt; t=2,3…6
Capacidad normal:
PRODNORMAL t ≤ CAPNORMAL t ;
t=1,2…6
Producción mínima en los dos primeros meses:
PRODNORMAL t ≥ 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:
PRODNORMAL t + PRODEXTRAt ≤ PRODMAX;
t=4,5,6
Rango de existencia: PRODNORMAL t
≥ 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: Lis ta de parámetros List a de parámetros Costo de la producción en tiempo normal Costo de la producción en tiempo extra Costo de almacenamiento Demanda mensual de lanchas Capacidad de la producción en tiempo normal Producción mínima en los dos primeros meses Producción máxima en tiempo extra en los dos primeros meses Producción máxima en tiempo normal más tiempo extra en los tres últimos meses List a de variables Cantidad de lanchas a producir en tiempo normal Cantidad de lanchas a producir en tiempo extra Inventario final de lanchas
35
Etiqueta COSTONORMALt COSTOEXTRAt COSTOALMACEN DEMANDAt CAPNORMALt PRODMIN PRODMAXTEX12 PRODMAXTEX12
Etiqueta PRODNORMALt PRODEXTRAt IFLANCHAt
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; COSTONORMAL {Periodo}; param COSTOEXTRA {Periodo}; param CAPNORMAL {Periodo}; param DEMANDA {Periodo}; param II; param COSTOALMACEN; param PRODMIN; param PRODMAXTEX12; param 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 c on 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] * COSTOEXTRA[i] * PRODEXTRA[i]) + sum {i COSTOALMACEN*IFLANCHA[i]+COSTOALMACEN*II;
PRODNORMAL[i] + in Periodo:i<=5}
Este operador lógico se usa para que i tome sol amente los valo res d e 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. minimize Costo_total: 500*PRODNORMAL[1] + 525*PRODNORMAL[2] + 550*PRODNORMAL[3] 575*PRODNORMAL[4] + 600*PRODNORMAL[5] + 625*PRODNORMAL[6] 550*PRODEXTRA[1] + 580*PRODEXTRA[2] + 610*PRODEXTRA[3] 640*PRODEXTRA[4] + 670*PRODEXTRA[5] + 700*PRODEXTRA[6] 15*IFLANCHA[1] + 15*IFLANCHA[2] + 15*IFLANCHA[3] + 15*IFLANCHA[4] 15*IFLANCHA[5] + 300;
+ + + + +
Note que al final de la expresión anterior hay una cifra igual a 300, esta es el resultado del producto COSTOALMACEN*II ; usualmente AMPL realiza las operaciones aritméticas de parámetros cuyos valores son únicos.
36
2.2. Modelado de las restricciones con l os 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 restricción Produccion_mes1 se va a mostrar solo las ecuaciones para el mes 1.
expand con
la
-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] -PRODNORMAL[3] -PRODNORMAL[4] -PRODNORMAL[5] -PRODNORMAL[6]
-
PRODEXTRA[2] PRODEXTRA[3] PRODEXTRA[4] PRODEXTRA[5] PRODEXTRA[6]
-
IFLANCHA[1] IFLANCHA[2] IFLANCHA[3] IFLANCHA[4] IFLANCHA[5]
+ + + + +
IFLANCHA[2] IFLANCHA[3] IFLANCHA[4] IFLANCHA[5] IFLANCHA[6]
= = = = =
-600; -750; -250; -300; -450;
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 Productos := 1..3; set Matriz := {Productos, Periodos}; Tiempo {Productos}; param T_disponible {Periodos}; param param D_min; PV {Productos}; param D_max {Matriz}; param
var Prod {Matriz}; maximize Ganancias: sum {(i,j) in Matriz} Prod[i,j] * PV[i]; subject to Tiempo_maximo {j in Periodos}: {i in Productos} Prod[i,j] * Tiempo [i] <= T_disponible[j]; sum Este operador ló gico se usa para que la restricción se genere solo para el producto 2 en el mes 1 j=1}: subject to Demanda_minima {(i,j) in Matriz: i=2 and Prod[i,j] >= D_min;
Este operador lógico se usa para que la restricción se genere solo para los producto s 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”:
D_min := 100; param PV:= param 1 15 2 20 3 10; Tiempo:= param 1 0.12 2 0.15 3 0.08;
38
T_disponible:= param 1 500 2 650;
param D_max : 1 1 2 3
2 := 500 500 0 0 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 . #Ecuaciones de inventario subject to Produccion {i in Periodo}: (if i=1 then II else IFLANCHA[i-1]) + PRODNORMAL[i] + PRODEXTRA[i] DEMANDA[i] = IFLANCHA[i];
Tenga en cuenta que la función if-then-else ha sido escrita entre paréntesis en la restricción, en caso no se usaran los paréntesis “( )” la función en AMPL reconocería que si i=1 entonces se debe devolver el valor de II y en caso i>1 entonces se debe devolver IFLANCHA[i-1] + PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i]cuando para i>1 solo se debe devolver el valor IFLANCHA[i-1]. Use el comando expand y podrá notar que el código algebraico que se genera es el mismo que cuando tenía dos sentencias para la misma restricción. -PRODNORMAL[1] -PRODNORMAL[2] -PRODNORMAL[3] -PRODNORMAL[4] -PRODNORMAL[5] -PRODNORMAL[6]
-
PRODEXTRA[1] PRODEXTRA[2] PRODEXTRA[3] PRODEXTRA[4] PRODEXTRA[5] PRODEXTRA[6]
+ -
IFLANCHA[1] IFLANCHA[1] IFLANCHA[2] IFLANCHA[3] IFLANCHA[4] IFLANCHA[5]
39
= + + + + +
-380; IFLANCHA[2] IFLANCHA[3] IFLANCHA[4] IFLANCHA[5] IFLANCHA[6]
= = = = =
-600; -750; -250; -300; -450;
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 ki logramo de las sus tancias Mes
Sustancia 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
140
130
140
140
145
Mayo
120
140
170
130
125
Junio
110
120
160
100
155
Abril
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 sust ancia 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; COSTONORMAL {Periodo}; param param COSTOEXTRA {Periodo}; CAPNORMAL {Periodo}; param DEMANDA {Periodo}; param param II; COSTOALMACEN; param PRODMIN; param PRODMAXTEX12; param PRODMAX; param
var PRODNORMAL {Periodo} >=0; var PRODEXTRA {Periodo} >=0; var IFLANCHA {Periodo} >=0; minimize Costo_total: {i in Periodo} (COSTONORMAL[i] * PRODNORMAL[i] + COSTOEXTRA[i] sum * PRODEXTRA[i]) + sum {i in Periodo: i<=5} COSTOALMACEN * IFLANCHA[i] + COSTOALMACEN * II; #RESTRICCIONES #Ecuaciones de inventario subject to Produccion_mes1 {i in Periodo: i=1}: IFLANCHA[i] = II + PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i];
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: 500*PRODNORMAL[1] + 525*PRODNORMAL[2] + 550*PRODNORMAL[3] + 575*PRODNORMAL[4] + 600*PRODNORMAL[5] + 625*PRODNORMAL[6] + 550*PRODEXTRA[1] + 580*PRODEXTRA[2] + 610*PRODEXTRA[3] + 640*PRODEXTRA[4] + 670*PRODEXTRA[5] + 700*PRODEXTRA[6] + 15*IFLANCHA[1] + 15*IFLANCHA[2] + 15*IFLANCHA[3] + 15*IFLANCHA[4] + 15*IFLANCHA[5] + 300; Ecuaciones de inventario: -PRODNORMAL[1] -PRODNORMAL[2] -PRODNORMAL[3] -PRODNORMAL[4] -PRODNORMAL[5] -PRODNORMAL[6]
-
PRODEXTRA[1] PRODEXTRA[2] PRODEXTRA[3] PRODEXTRA[4] PRODEXTRA[5] PRODEXTRA[6]
+ -
IFLANCHA[1] IFLANCHA[1] IFLANCHA[2] IFLANCHA[3] IFLANCHA[4] IFLANCHA[5]
= + + + + +
-380; IFLANCHA[2] IFLANCHA[3] IFLANCHA[4] IFLANCHA[5] IFLANCHA[6]
= = = = =
-600; -750; -250; -300; -450;
Capacidad máxima: PRODNORMAL[1] PRODNORMAL[2] PRODNORMAL[3] PRODNORMAL[4] PRODNORMAL[5] PRODNORMAL[6]
<= <= <= <= <= <=
200; 200; 200; 200; 300; 300;
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; PRODNORMAL[5] + PRODEXTRA[5] <= 550; PRODNORMAL[6] + PRODEXTRA[6] <= 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] Prod[1,2] Prod[3,1] Prod[3,2]
<= <= <= <=
500; 500; 650; 650;
44
CUARTA GUÍA DE AMPL En la cuarta guía importamos y exportamos datos usando el AMPL. Objetivos de esta guía •
1.
Aprender a crear y ejecutar un archivo “.run”.
•
Importar y exportar datos usando Excel.
•
Conocer la utilidad y aplicaciones de un archivo “.run”.
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 es cribir 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 pued e 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 Productos := 1..20; set Procesos := 1..7; set ProcesoMP := 1..5; set Matriz1 := {Productos,Procesos}; set Matriz2 := {Productos,ProcesoMP}; param Margen {Productos}; param Demandamin {Productos}; param Demandamax {Productos}; param RecursoT {Procesos}; param RecursoMP {ProcesoMP}; param Tiempo_prod {Matriz1}; param MP {Matriz2}; var P {i in Productos}; maximize Utilidades: sum {i in Productos} Margen[i] * P[i];
46
subject to Tp {j in Procesos}: sum {i in Productos} Tiempo_prod[i,j] * P[i] <= RecursoT[j]; subject to Materia {j in ProcesoMP}: sum {i in Productos} MP[i,j] * P[i] <= RecursoMP[j]; subject to Minimo {i in Productos}: P[i] >= Demandamin[i]; subject to Maximo {i in Productos}: P[i] <= Demandamax[i];
2.1. Declaración de los nombres d e 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 r eferencia 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ónFigura 24: declarando la matriz ti empo 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 A MPL 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: Nombre del archi vo dond e se encuentra la tabla declarada. Se debe agregar la extensión, que puede ser .xls, .xlsx o .xlsz
Código que utiliza AMPL para reconocer una tabla
table Prod_par IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx':
Nombre de la tabla. Debe ser el mismo q ue declaro en Excel
Código que utiliza AMPL saber leer archivos de Excel. La palabra IN debe ir en mayúscula. Siempre se debe ingresar
[Productos], Margen, Demandamin, Demandamax;
Indica que los valores de la primera columna de la tabla Prod_par, que empieza con la palabra Productos, son los 20 miembros del set Productos
Indica que los datos de la segunda columna serán asignados al parámetro Margen, los de la tercera al parámetro Demandamin y los de la cuarta a Demandamax
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 A MPL 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} ;
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 primera columna de la tabla al set Productos
Lee los valores de cada celda y los va almacenando, esto es, para i=1 va a leer y almacenar los valores que tendría Tiempo_prod[1,1], Tiempo_prod[1,2], etc.
[i ~ Productos], {j in Procesos} ; Ahora usted ingrese en su archivo “Cuarta_guia.run” el código para declarar la matriz MP.
Luego de declarar todas las tablas en su archivo “Cuarta_guia.run” usted debería tener el siguiente código:
51
table Prod_par IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [Productos], Margen, Demandamin, Demandamax;
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 Tiempos IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [i ~ Productos], {j in Procesos} ; table Materia_prima
IN
'tableproxy'
'odbc'
'Cuarta
guia
ejemplo
1.xlsx': [i ~ Productos], {j in ProcesoMP} ;
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': [ProcesoMP], RecursoMP;
2.4. Declaración de tablas en AMPL para escrit ura 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 t ablas en A MPL para escritu ra 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
Distancias {Matriz}; param
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}: {j in Destinos:i<>j} X[i,j] = 1; sum subject to Todo_sale {i in Inicio}: {j in Destinos:i<>j} X[j,i] = 1; sum j>1 and i<>j}: subject to subtours {(i,j) in Matriz: i>1 and 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} ; 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': {i in Inicio} -> [Inicio], {j in Destinos} ;
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 columna de la tabla al set Inicio
Exporta los valores de las variables en cada celda de la tabla, esto es, para i=1 va a exportar el valor X[1,1], X[1,2], X[1,3] y así sucesivamente
{i in Inicio} -> [Inicio], {j in Destinos} ;
Nombre de la primera celda de la rimera 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 writ e 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 datos. Para leer los datos de una tabla debe usar el comando read table y para escribir los resultados de una variable en un archivo de Excel debe usar el comando write table. A continuación se muestra como
Tenga en c uenta: El comando write table se ha escrito después de resolver el modelo ya que si lo pusiéramos antes la variable 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 Prod_par IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [Productos], Margen, Demandamin, Demandamax;
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 Tiempos IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [i ~ Productos], {j in Procesos} ; table Materia_prima IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [i ~ Productos], {j in ProcesoMP} ; 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 Productos := 1..2; set Maquinas := 1..2; set Dias := 1..2; set Matriz := {Productos, Maquinas, Dias}; Costo {Matriz}; param
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} ; ampl: table Materia_prima IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx': ampl? [i ~ Productos], {j in ProcesoMP} ; 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. Objetivos de esta guía 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; CPLEX 12.6.3.0: optimal solution; objective 53270.5409 4 dual simplex iterations (0 in phase I)
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; CPLEX 12.6.3.0: optimal solution; objective 53353.27253 11 dual simplex iterations (3 in phase I)
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: ampl: ampl: ampl: ampl:
model Ejemplo_guia5.mod; data Ejemplo_guia5.dat; let {i in Productos} P[i] := Demandamin[i]; fix {i in Productos} P[i]; solve;
All variables fixed; objective Utilidades = 2081.25.
Para fijar los valores de todas las variables P se debe usar una expresión i ndexada
ampl: display P; P [*] := 58
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ;
10 15 0 0 10 0 10 0 20 25 15 10 0 0 0 10 0 0 0 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; CPLEX 12.6.3.0: optimal solution; objective 50289.23077 1 dual simplex iterations (0 in phase I) ampl: display P; P [*] := 1 150 2 80 3 90 4 100 5 180 6 150 7 122.906 8 145 9 100 10 110 11 150 12 160 13 165 14 155 15 150 16 250 17 150 18 200 59
19 20 ;
2.
250 180
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 sentenc ias 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 eje mplificar esto se va a crear un nuevo archivo “.run” que devuelva una tabla final donde se muestren los resultados de la variable “P” y otra donde se
muestren los valores obtenidos en la función objetivo para cada iteración. model Ejemplo_guia5.mod; data Ejemplo_guia5.dat; set iteracion := 1..3; set Compuesto := {Productos,iteracion}; Ganancias {iteracion}; param Prod {Compuesto}; param for {a in iteracion} { let {i in Procesos} RecursoT[i] := RecursoT[i] * 1.05; let {h in Productos} Demandamax[h] := Demandamax[h] * 1.1; solve; display P; let Ganancias[a] := Utilidades; let {h in Productos} Prod[h,a] := P[h]; display Ganancias; display Prod; } Se han creado dos nuevos sets: el set “ iteracion ”, se usa para las iteraciones del bucle for, de manera que “a=1” es la primera iteración, “a=2” la segunda y “a=3” la tercera; y, el set “Compuesto” que se usará para la tabla que en la que se mostrará los valores de la variable “P” en cada iteración. 60
También se han creado los parámetros “Ganancias”, que es donde se va a almacenar el valor de la función objetivo, y “Prod”, que se usará para mostrar la tabla con los valores de la variable “P” en
cada iteración.
COMANDO REPEAT: ITERAR RESPECTO A UNA CONDICION
3.
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 < repeat {...} until Utilidades >
{...}; {...}; 60000; 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. model Ejemplo_guia5.mod; data Ejemplo_guia5.dat; repeat while Utilidades < 60000 { let {i in Procesos} RecursoT[i] := RecursoT[i] * 1.05; let {h in Productos} Demandamax[h] := Demandamax[h] * 1.1; solve; display P; }
61
Datos importantes: ¿Cuál es la diferencia entre escribi r primero l a 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:
model Ejemplo_guia5.mod; data Ejemplo_guia5.dat; repeat while Utilidades > 60000 { let {i in Procesos} RecursoT[i] := RecursoT[i] * 1.05; let {h in Productos} Demandamax[h] := Demandamax[h] * 1.1; 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 obli ga 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 {i in Procesos} RecursoT[i] := RecursoT[i] * 1.05; let {h in Productos} Demandamax[h] := Demandamax[h] * 1.1;
solve; display P; } while Utilidades > 60000;
Notará que se ejecuta el bucle una sola vez, ya que luego de ejecutarlo el valor de “Utilidades” es 53258.9 y no cumple con la condición, por tanto, repeat se detendrá.
62
PROBLEMAS PROPUESTOS Problema 1 Una empresa de productos agrícolas se dedica a vender 5 tipos de frutas y verduras a clientes que se ubican en la Unión Europea y Asia. La empresa tiene 4 plantas de producción ubicadas en diferentes lugares del país y está pensando seriamente cerrar una de ellas debido a que sus ventas han caído. 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: Variables de decisión: 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…4j=1…5k=1…6(PVj – Costoij) * Pijk Restricciones: Restricciones de demanda: i=1…4
Pijk = DEMANDAjk Restricciones de tiempo:
;
j=1,2…5; k=1,2…6
TIEMPOij*Pijk ≤ TMAX Restricciones de materia prima:
;
i=1,2…4; j=1,2…5; k=1,2…6
Eficij*Pijk ≤ DISPONIBLE ij Rango de existencia:
;
i=1,2…4; j=1,2…5; k=1,2…6
;
i=1,2…4; j=1,2…5; k=1,2…6
Pijk ≥ 0
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 cerrada 1
Utilidad total
2
Monto 2
3
Monto 3
4
Monto 4
Monto 1
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. Variables de decisión: Cafeij: Cantidad de café en toneladas que se le compraré al producto i el trimestre j. i=1, productor 1; i=2, productor 2; i=3, productor 3; i=4, productor 4; i=5, productor 5; i=6, productor 6; i=7, productor 7; j=1, trimestre 1; j=2, trimestre 2; j=3, trimestre 3; j=4, trimestre 4.
64
Función objetivo: Minimizar
i=1…4j=1…5
Cafeij *
Humedad_excesoi *
Costo_oreado
+
Cafeijk * Costo_compraij Restricciones: Restricciones de demanda: i=1…7
Cafeij (1-Porcen_descarte) = DEMANDAj ; Restricciones de materia prima:
j=1,2…6
Cafeij ≤ Cafe_productores i Rango de existencia:
;
i=1,2…7; j=1,2…6
;
i=1,2…4; j=1,2…5
Cafeij ≥ 0
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) b)
Cree un archivo “.mod” para minimizar los costos de compra y oreado de café. 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. Objetivos de esta guía 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.
set Productos := 1..20; set Procesos := 1..7; set ProcesoMP := 1..5; set Matriz1 := {Productos,Procesos}; set Matriz2 := {Productos,ProcesoMP}; param Margen {Productos}; param Demandamin {Productos}; param Demandamax {Productos}; param RecursoT {Procesos}; RecursoMP {ProcesoMP}; param Tiempo {Matriz1}; param MP {Matriz2}; param var P {i in Productos} >=Demandamin[i], <=Demandamax[i] ; maximize Utilidades: {i in Productos} Margen[i] * P[i]; sum subject to Tp {j in Procesos}: {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j]; sum subject to Materia {j in ProcesoMP}: {i in Productos} MP[i,j] * P[i] <= RecursoMP[j]; sum
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 l os 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 u nidades co mpletas. 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. Yi:
i= 1,2…20
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) Restricciones: Restricciones de demanda:
i=1..20(COSTO_FIJOi*Yi)
Pi ≥ DEMANDAMIN i*Yi
;
i=1,2…20
Pi ≤ DEMANDAMAX i Restricciones de tiempo:
;
i=1,2…20
j=1…20 (TIEMPOji*Pj)
;
i=1,2…7
j=1…20 (MPji*Pj)
≤ RECURSOMP i Restricciones para los costos fijos:
;
i=1,2…5
Pi ≤ M*Yi Rango de existencia:
;
i=1,2…20 ; M>>0
≤ RECURSOT i Restricciones de materia prima:
Pi son variables enteras no negativas
;
Yi = 0 ó 1
;
i=1,2…20 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. Lista de parámetros
Etiqueta
El margen de contribución de cada producto
MARGENi
Costo fijo que se incurre si se fabrica el producto i
COSTO_FIJO i
La demanda mínima de cada producto
DEMANDAMIN i
La demanda máxima de cada producto
DEMANDAMAX i
Disponibilidad del recurso tiempo de cada proceso Disponibilidad del recurso materia prima para cada proceso El tiempo unitario por kilogramo de cada producto en cada proceso El consumo de materia prima por kilogramo de cada producto en cada proceso Número positivo lo suficientemente grande
RECURSOTj
68
RECURSOMPj TIEMPOij Mpij M
Lista de variables Variable de decisión que toma valor 1 si se fabrica el producto i, caso contrario toma valor 0 Cantidad de unidades que se fabrica de cada tipo de producto, estas son variables enteras
Etiqueta Yi Pi
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 set Productos := 1..20; set Procesos := 1..7; set ProcesoMP := 1..5; set Matriz1 := {Productos,Procesos}; set Matriz2 := {Productos,ProcesoMP};
#Parámetros del modelo param Margen {Productos}; param Demandamin {Productos}; param Demandamax {Productos}; param Costo_fijo {Productos}; param RecursoT {Procesos}; param RecursoMP {ProcesoMP}; param Tiempo {Matriz1}; 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}: P[i] <= Demandamax[i]; #Restricciones de tiempo subject to Tiempo_max {j in Procesos}: sum {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j]; #Restriciones de MP subject to MP_maxima {j in ProcesoMP}: sum {i in Productos} MP[i,j] * P[i] <= RecursoMP[j]; #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 MINOS 5.51: optimal solution found. 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]; Restricciones de demanda: 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
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; 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
