Guía Del Ampl _ind-273 2c185r

GUÍA DE INVESTIGACIÓN OPERATIVA A mathematical programming language

GIOPA Autores Jonatán Rojas Polo Christian Cornejo Sánchez Alessandro Gilardino Arias Renzo Benavente Sotelo Alexia Cáceres Cansaya Pedro Muñante Chihuantito

Ingeniería Industrial

i

RESUMEN Esta guía básica pretende explicar el uso del software AMPL, el cual es ampliamente reconocido a nivel mundial como uno de los mejores lenguajes de programación en modelos matemáticos de optimización, y utilizado en las mejores universidades del mundo. Este software es usado como solver en papers de investigación, en publicaciones indizadas, y son ganadores de premios internacionales por su alta capacidad de procesamiento de datos. El proyecto AMPL pretende mejorar las habilidades de modelación matemática, teniendo así una educación transversal, interrelacionando el área de Investigación de Operaciones con áreas Core de Ingeniería Industrial como las áreas de Producción y de Finanzas. Con el uso de las guías pretendemos aprovechar 3 cursos pilares de ingeniería industrial. En el curso de Investigación Operativa 1, se pretende fortalece el análisis, realización de modelos matemáticos lineales y el uso del software. Posteriormente, en el ciclo siguiente, se pretende aplicar modelos matemáticos para los sistemas de producción en el curso de Planeamiento y Control de Operaciones, y finalmente en curso de Investigación Operativa 2 consolidaremos el aprendizaje cuantitativo con la elaboración de papers aplicando modelación matemática con solver’s proporcionados por AMPL. ¿Por qué AMPL? El software AMPL soporta todo el ciclo de vida de modelado de optimización: formulación, prueba, despliegue y mantenimiento, desde un enfoque integrado para promover un rápido desarrollo y resultados fiables. Usando una representación algebraica de alto nivel que describe los modelos de optimización de la misma manera que la gente piensa acerca de ellos, AMPL puede proporcionarle la ventaja que necesita para implementar con éxito proyectos de optimización a gran escala. AMPL integra un lenguaje de modelado para describir datos de optimización: variables, función objetivo y las restricciones; en un lenguaje de comandos para depurar los modelos y análisis de resultados; y un lenguaje de script para la manipulación de los datos y la implementación de estrategias de optimización. Todos utilizan los mismos conceptos para promover la creación de solicitud más eficiente. http://ampl.com/

ii

DEDICATORIA

A todos los alumnos con ganas de seguir aprendiendo más y más.

iii

ÍNDICE GENERAL

INDICE DE GRÁFICOS ...................................................................................................................... vii PRIMERA GUÍA DE AMPL ................................................................................................................. 1 1.

2.

ENTORNO DEL SOFTWARE AMPLIDE .............................................................................. 1 1.1.

Instalación de AMPL ........................................................................................................ 1

1.2.

Interfaz de del software AMPLIDE ................................................................... 3

1.3.

Barra de herramientas del software AMPLIDE ............................................................ 4

1.4.

Opciones de la ventana de comandos .......................................................................... 6

EJECUCIÓN DE UN MODELO EN AMPL ........................................................................... 7

SEGUNDA GUÍA DE AMPL .............................................................................................................. 11 1.

LENGUAJE DE MODELADO DE AMPL ............................................................................. 11

2.

ESTRUCTURA DE UN MODELO EN AMPL ..................................................................... 16 2.1.

SET ................................................................................................................................... 16

2.2.

Parámetros: ..................................................................................................................... 16

2.3.

Variables: ......................................................................................................................... 17

2.4.

Función objetivo (F.O.): ................................................................................................. 17

2.5.

Restricciones: .................................................................................................................. 18

3.

COMO INGRESAR DATOS EN UN ARCHIVO “.dat”....................................................... 21

4.

COMO ELEGIR UN SOLVER PARA RESOLVER EL MODELO ................................... 24

5. COMO RESOLVER UN MODELO USANDO EL LENGUAJE AMPL Y LA INTERFAZ AMPLIDE ......................................................................................................................................... 25 6. PROBLEMAS PROPUESTOS (desarrollando los problemas del manual de Lingo en AMPL) ............................................................................................................................................... 25 TERCERA GUÍA DE AMPL .............................................................................................................. 31 1.

ANÁLISIS DE SENSIBILIDAD CON AMPL ........................................................................ 31

2.

OPERADORES LÓGICOS EN AMPL ................................................................................. 34 2.1.

Modelado de la función objetivo con operadores lógicos......................................... 36

2.2.

Modelado de las restricciones con los operadores lógicos ...................................... 37

3.

LA FUNCION IF-THEN-ELSE .............................................................................................. 39

4.

PROBLEMAS PROPUESTOS ............................................................................................. 40

CUARTA GUÍA DE AMPL ................................................................................................................. 45 1.

COMO CREAR Y EJECUTAR UN ARCHIVO “.run” ......................................................... 45

iv

2.

IMPORTACIÓN Y EXPORTACIÓN DE DATOS USANDO EXCEL ............................... 46 2.1.

Declaración de los nombres de las tablas en Excel .................................................. 47

2.2.

Declaración de tablas en AMPL para lectura de datos vectoriales ........................ 50

2.3.

Declaración de tablas en AMPL para lectura de datos matriciales ........................ 51

2.4.

Declaración de tablas en AMPL para escritura de variables vectoriales ............... 52

2.5.

Declaración de tablas en AMPL para escritura de variables matriciales ............... 52

2.6.

Comandos read table y write table .............................................................................. 54

2.7.

UTILIDAD DE UN ARCHIVO “.run” ............................................................................. 56

QUINTA GUÍA DE AMPL .................................................................................................................. 57 1.

COMANDOS DE MODELADO LET, FIX Y UNFIX ........................................................... 57 1.1.

El comando let................................................................................................................. 57

1.2.

Los comandos fix y unfix ............................................................................................... 58

2.

COMANDO FOR: ITERACION DE SENTENCIAS ........................................................... 60

3.

COMANDO REPEAT: ITERAR RESPECTO A UNA CONDICION ................................ 61

SEXTA GUÍA DE AMPL .................................................................................................................... 66 1.

DEFINICIÓN DE RANGOS DE VARIABLES USANDO PARÁMETROS ...................... 66

2.

DECLARACIÓN DE VARIABLES COMO ENTERAS Y BINARIAS ............................... 67

Bibliografía ........................................................................................................................................... 74

v

INDICE DE TABLAS Tabla 1: Lista de parámetros ............................................................................................................ 15 Tabla 2: Costo de transporte desde la planta i hasta el cliente j ................................................ 25 Tabla 3: requerimiento de tiempo por mil unidades ...................................................................... 26 Tabla 4: requerimiento de recursos ................................................................................................. 27 Tabla 5: Lista de parámetros ............................................................................................................ 35 Tabla 6: Precio por kilogramo de las sustancias ........................................................................... 40 Tabla 7: Dureza de cada sustancia ................................................................................................. 41

vi

INDICE DE GRÁFICOS Figura 1: Página web de software AMPL ......................................................................................... 1 Figura 2: Libro desarrollado por AMPL ............................................................................................. 1 Figura 3: Página web de software AMPL con licencia académica ............................................... 2 Figura 4: Documentación de la descarga AMPL - Students .......................................................... 2 Figura 5: ventana de instalación de AMPL ...................................................................................... 3 Figura 6: aceptar el Amplide. .............................................................................................................. 3 Figura 7: Interface del Amplide. ......................................................................................................... 3 Figura 8: Comando New ...................................................................................................................... 4 Figura 9: Comando New file ............................................................................................................... 5 Figura 10: archivos para modelar ...................................................................................................... 5 Figura 11: modelado en .mod y .dat .................................................................................................. 6 Figura 12: opciones de consola ......................................................................................................... 6 Figura 13: interrumpir proceso ........................................................................................................... 7 Figura 14: limpiar pantalla ................................................................................................................... 7 Figura 15: sintaxis del modelo .mod .................................................................................................. 8 Figura 16: Programación en la consola ............................................................................................ 8 Figura 17: Búsqueda de archivo ........................................................................................................ 9 Figura 18: Búsqueda de la solución .................................................................................................. 9 Figura 19: creación de un archivo run ............................................................................................. 45 Figura 20: selección de datos ........................................................................................................... 47 Figura 21: columna donde se exportarán los datos ...................................................................... 48 Figura 22: 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: 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 istración e Investigación de Operaciones es casi nula, es decir durante los años de 1996 al 2016 solo se publicó 62 papers en revistas indizadas (SCOPUS), mientras que en ese mismo periodo en Chile se publicaron 709; Colombia, 337 y Argentina, 185.

Fuente: Scimago Journal & Country Rank

viii

http://www.scimagojr.com/countryrank.php?category=1803&region=Latin%20America

Por lo tanto, nuestro objetivo es incrementar las habilidades de investigación de nuestros alumnos desde pregrado. Una de las principales causas detectadas en el problema de investigación, es la solución de los modelos propuestos, es decir un modelo complejo puede tardar muchos meses en encontrar una solución óptima, siendo el tiempo de solución uno de los factores que desanima a las empresas, catedráticos e investigadores a continuar esta línea. Haciendo un diagnóstico entre los países de mayor producción científica se determinó que el AMPL es el software más usado por los investigadores, teniendo como solver más usados al Minos, Gurobi y lex. 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 istració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 AMPL Antes de leer esta guía, descargue la versión demo del software AMPLIDE que está disponible en la página web de AMPL en la siguiente dirección electrónica http://ampl.com/try-ampl/-a-free-demo/. En la figura 1 se observa la página web de AMPL.

Figura 1: Página web de software AMPL En dicha página también encontrará el libro "AMPL: A Modeling Language for Mathematical Programming", que es un documento con información completa sobre este software en caso requiera más detalles. Ver figura 2.

Figura 2: Libro desarrollado por AMPL

1

Para la descarga del software, le recomendamos inicialmente trabajar con la versión académica (DEMO). Diríjase a la pestaña de producto, luego AMPL y posteriormente aplique la opción for students tal como se observa la figura 3.

Figura 3: Página web de software AMPL con licencia académica Una vez que se encuentra en la página for students, de un clic en Demo Version, con lo cual no dirige a la documentación de Free Demo Version s, usted debe darle clic en a Free Demo, con lo cual nos envía a la documentación de 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 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 del software AMPLIDE INICIO DEL SOFTWARE AMPLIDE Para iniciar el software lo primero que debe de hacer es extraer los archivos que se encuentran en el archivo comprimido que descargo de la página de AMPL e ingresar a dicha carpeta. Cuando ingrese a la carpeta busque el archivo amplide.exe mostrado en la figura 5.

Figura 5: ventana de instalación de AMPL

Para poder ingresar al software deberá hacer doble clic en el ícono amplide.exe. Tenga en cuenta que no debe mover dicho ejecutable de la carpeta original donde se encuentra, ya que en caso se modifique la ubicación el software arrojará el siguiente mensaje de error mostrado en la figura 6.

Figura 6: aceptar el Amplide.

Inicie AMPLIDE para Windows y observamos que la primera pantalla que muestra es como la que se ilustra en la Figura 7.

Ventana de 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 archivos: Permite navegar en las carpetas de la computadora para poder abrir los archivos que se encuentren en ellas. Ventana de comandos: Se utiliza para ejecutar los comandos en el software e interactuar con los modelos matemáticos. Ventana de modelado: Área para editar el modelo, datos y otros archivos necesarios para resolver un modelo de optimización.

TIPO DE ARCHIVOS DEL SOFTWARE AMPL En el software AMPLIDE interactúa con 3 tipos de archivos: “.mod”, “.dat” y “.run”. A continuación, se procede a explicar las características de cada uno de estos tres tipos de archivos: ● ● ●

1.3.

Archivos “.mod”: Son los archivos donde se edita el modelo de optimización con el lenguaje de programación AMPL, el cual se visualiza en la ventana de modelado. Archivos “.dat”: Son los archivos donde se ingresan los parámetros necesarios para resolver el modelo de optimización. Archivos “.run”: Son archivos que facilitan dar ciertas órdenes a los archivos “.mod”.

Barra de herramientas del software AMPLIDE El software AMPLIDE tiene varias opciones que pueden ser útiles para crear archivos, guardarlos y ejecutarlos. A continuación, se exponen algunos de los comandos del menú File: COMANDO NEW Este comando permite crear un nuevo archivo. Siga los pasos de la figura 8 File/New/File.

Figura 8: Comando New

4

Al dar clic sobre File aparecerá la ventana que se muestra en la figura 9. Usted puede elegir el tipo de archivo que desea crear dando clic sobre el menú desplegable File Extension. En este caso vamos a crear un archivo “.mod” con el nombre “model_prueba”.

Figura 9: Comando New file

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

Figura 10: archivos para modelar

El comando New se puede ejecutar rápidamente presionando en la barra de herramientas el siguiente ícono:

COMANDO SAVE Cuando se hace alguna modificación en un archivo aparecerá un “*” al lado del nombre del mismo. En la Figura 11, en la parte izquierda, se muestra el archivo “diet.mod” sin modificaciones; y en la derecha, se muestra el mismo archivo “diet.mod” solo que con una línea adicional.

5

Figura 11: modelado en .mod y .dat Para grabar solo ese archivo se debe ir al menú File y seleccionar el comando Save. Asimismo, el comando Save también se puede ejecutar rápidamente presionando “Ctrl + S” o el siguiente ícono en la barra de herramientas:

COMANDO SAVE ALL El comando Save All graba todos los archivos que hayan sido modificados y que estén abiertos en la ventana de modelado. Esto resulta muy útil debido a que se puede tener numerosos archivos abiertos en simultáneo y evita estar grabando uno a uno. Al igual que con el comando Save, se puede ejecutar ingresando al Menú File, presionando Ctrl + Shft + S o desde la barra de herramientas presionando el siguiente ícono:

1.4.

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

Figura 12: opciones de consola

6

BOTÓN INTERRUPT Cuando se está resolviendo un modelo matemático con el software AMPLIDE, existe la opción de detener el proceso de cálculo del modelo. Para poder hacer esto, se deberá presionar el botón Interrupt de la cinta de opciones (Figura 13).

Figura 13: interrumpir proceso

También se puede detener el proceso de cálculo del modelo matemático presionando Ctrl + C. BOTÓN CLEAR CONSOLE Para borrar el texto acumulado en la ventana de comandos se utiliza el botón clear console, el cual tiene el siguiente ícono:

Figura 14: limpiar pantalla

2.

EJECUCIÓN DE UN MODELO EN AMPL

Para que se familiarice con el lenguaje de programación AMPL, en la presente sección resolveremos un modelo de optimización con dos variables. Ejemplo 1 Una empresa fabrica dos tipos de muebles, 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 y 100 unidades para el mueble Clásico. El taller de la empresa puede fabricar un mueble tipo 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 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

#variables var P; var C; #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;

Tenga en cuenta: Para los nombres de los archivos “.mod”, “.dat”, sets, parámetros, 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”, “DemandamaxP” y “Demanda_max_C”. En la ventana de comandos, para poder leer un archivo se utiliza el comando “model” seguido del nombre del archivo y para resolverlo se debe escribir el comando “solve”. Para poder obtener el valor de las variables se escribe el comando “display” seguido del nombre de las variables que desee ver. Finalmente, se utiliza el comando “reset” para resetear la memoria del software y debe ingresarse siempre que desee resolver un nuevo modelo, como se muestra a continuación. ampl: reset; Como modo de evaluación de lo aprendido, resuelva el siguiente ejemplo. Ejemplo 2 La misma empresa del ejemplo anterior comenzará a producir también un nuevo mueble modelo Trébol, que va a vender junto con los otros dos que ya tiene. El margen de contribución de este tipo de mueble es de S/.300 y demora 3.2 horas producirlo en el taller. El tiempo disponible se ha ampliado a 120 horas y la demanda máxima del mueble tipo Trébol es de 35. Realice un modelo que optimice las utilidades de la empresa y responda las siguientes preguntas: a) ¿Cuál es el solver que se utiliza para este problema? b) ¿Cuánto se espera tener de utilidades? c) Indique cuánto se fabricará de cada uno de los productos en cuestión.

10

SEGUNDA GUÍA DE AMPL En la segunda guía iniciaremos en la modelación / programación en el AMPL. 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 ≥ DEMANDAMINi

;

i=1,2…20

Pi ≤ DEMANDAMAXi

;

i=1,2…20

;

j=1,2…7

Restricciones de tiempo: i=1…20(TIEMPOij*Pi) ≤ RECURSOTj 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 ≥ DEMANDAMINi

;

i=1,2…20

Pi ≤ DEMANDAMAXi

;

i=1,2…20

;

j=1,2…7

;

j=1,2…5

;

i=1,2…20

Restricciones de tiempo: i=1…20(TIEMPOij*Pi) ≤ RECURSOTj 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

MARGENi

La demanda mínima de cada producto

DEMANDAMINi

La demanda máxima de cada producto

DEMANDAMAXi

Disponibilidad del recurso tiempo de cada proceso

RECURSOTj

Disponibilidad del recurso materia prima para cada proceso

RECURSOMPj

El tiempo unitario por kilogramo de cada producto en cada proceso

TIEMPOij

El consumo de materia prima por kilogramo de cada producto en cada proceso

Mpij

Lista de variables

Etiqueta

Cantidad de kilogramos por fabrica de cada tipo de producto, estas son las variables de decisión

Pi

15

2.

ESTRUCTURA DE UN MODELO EN AMPL

2.1. SET SETS SIMPLES Para declararlos use la palabra reservada set, seguida del nombre que usted elija. Así por ejemplo, para declarar el set simple cuyo nombre es “Productos” siga la sintaxis siguiente: set Productos A continuación debe declarar el número de 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 cuenta: 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 archivo “.mod” los parámetros restantes para formular el programa lineal del ejemplo 2. 2.3. Variables: Para declararlos use la palabra reservada var, seguida del 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 usar otro nombre. Siempre es recomendable que guarde relación con lo que se quiere lograr en la F.O. Pero, recordemos como escribimos la F.O. en notación matemática: 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 , 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 importantes: A veces se debe iterar usando dos índices. ¿Cómo escribo eso con el lenguaje de AMPL? Se escribiría en la expresión indexada, que puede usarse tanto para iterar todas las restricciones de una familia o en una función sum, en cualquiera de los dos casos, se debe escribir de la siguiente manera: {(i,j) in “Nombre del set compuesto”} ó {i in “set simple1”, j in “set simple2”} ¿Y si debo iterar usando tres índices? Entonces se escribiría de la siguiente manera: {(i,j,k) in “Nombre del set compuesto”} ó {i in “set simple1”, j in “set simple2”, k in “set simple3”}

Código de AMPL para el ejemplo 2 set Productos := 1..20; set Procesos := 1..7; set ProcesoMP := 1..5; set Matriz1 := {Productos,Procesos}; set Matriz2 := {Productos,ProcesoMP}; param param param param param param param

Margen {Productos}; Demandamin {Productos}; Demandamax {Productos}; RecursoT {Procesos}; RecursoMP {ProcesoMP}; Tiempo {Matriz1}; MP {Matriz2};

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: sum {i in Productos} Margen[i] * P[i]; subject to Tp {j in Procesos}: sum {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j]; subject to Materia {j in ProcesoMP}: sum {i in Productos} MP[i,j] * P[i] <= RecursoMP[j];

19

subject to Minimo {i in Productos}: P[i] >= Demandamin[i]; subject to Maximo {i in Productos}: P[i] <= Demandamax[i]; Ahora que ya hemos ingresado nuestro modelo y que aseguramos que no tiene errores, vamos mencionar algunos errores frecuentes que se pueden presentar cuando ingresamos nuestro modelo matemático en el archivo “.mod”. ERRORES AL DECLARAR LOS SETS • Los comentarios y las líneas que contienen los nombres de los sets terminan con el signo “;”. Verifique si lo digitó. • Los nombres de los sets primitivos invocados en los sets compuestos se separan con comas y deben iniciar y terminar con los signos “{ }”, verifique que usó esos signos y no “( )” o “[ ]” • Se recomienda nombres para los sets que sean fáciles de recordar (se sugiere que tengan relación con los datos a los que van a ser asignados) porque serán usados en el resto del programa y usted deberá invocarlos exactamente igual a como los definió en la zona de sets. • No olvide usar exactamente los nombres declarados para cada set y parámetro ya que AMPL distingue entre mayúsculas y minúsculas. • Los sets que se van a asignar a un parámetro deben ingresarse entre “{ }”. ERRORES EN EL MODELADO DE LA FUNCIÓN OBJETIVO Y LAS RESTRICCIONES • • •

• •

La sentencia debe terminar con el signo “;”. Luego de la función sum y para escribir los sets que se utilizarán para hacer la suma de las variables y parámetros, se debe usar “{ }” y no “( )” o “[ ]”. No olvide usar el nombre exacto de cada parámetro, variable y set declarado anteriormente, cualquier diferencia ya sea debido a algún carácter o a alguna letra mayúscula o minúscula enviará un mensaje de error. Tenga en cuenta que los índices de las variables y parámetros de la función objetivo y restricciones deben usarse los signos “[ ]”. La función sum realizará la sumatoria solo hasta el siguiente signo “+” o “-“. Para ilustrar esto, imagine que en vez de darle el margen le dan el precio de venta (PV) y el costo de producción (Costo) de cada producto, por lo tanto, si usted escribe la función objetivo de la siguiente manera: maximize Utilidades: sum {i in Productos} PV[i] * P[i] - Costo[i] *

P[i];

AMPL devolverá un error de sintaxis ya que AMPL solo reconocerá PV[i] * P[i] como parte de la función sum. Para que AMPL arroje errores puede escribir la sentencia de tres formas: maximize Utilidades: sum {i in Productos} (PV[i] * P[i] - Costo[i] * maximize Utilidades: sum {i in Productos} (PV[i] - Costo[i]) *

20

P[i];

P[i]);

maximize Utilidades: sum {i in Productos} PV[i] * P[i] - sum {i in Productos} Costo[i] * P[i]; Si hubiera tenido el signo “+” después de la función sum habría ocurrido el mismo error que se menciona un par de líneas arriba. COMO OBTENER INFORMACION ADICIONAL: •

Si desea más información sobre la declaración de sets con el lenguaje de AMPL puede leer los capítulos 5 y 6 del libro The AMPL Book.

•

Si desea tener más información sobre como declarar las variables e ingresar la función objetivo y restricciones de un modelo en AMPL puede leer el capítulo 8 del libro The AMPL Book.

COMO INGRESAR DATOS EN UN ARCHIVO “.dat”

3.

Como se mencionó en la declaración de parámetros, se puede tener parámetros escalares, vectoriales y matriciales. En esta parte de la guía se va a explicar cómo ingresar cada uno de estos en un archivo de datos. INGRESO DE DATOS ESCALARES En vista que no tenemos un parámetro escalar en el ejemplo 2, supongamos que tenemos que el tiempo total disponible para todos los procesos es de 1000 horas, y utilizaremos el nombre Tiempo_total para ese parámetro. Para ingresar el valor de dicho parámetro se debe usar la siguiente sintaxis: param Tiempo_total := 1000;

CUIDADO: Como ya vimos en esta sección, hay varias palabras reservadas que utiliza AMPL para definir funciones y otros comandos, estas deben ser escritas siempre de la misma forma ya que en caso las escribiéramos con mayúsculas AMPL no las reconocería, las palabras que hemos usado son las siguientes: • • • • • • • •

set: para definir los grupos de objetos relacionados en grupos. param: se utiliza para definir parámetros ya conocidos que se ingresarán al modelo. var: se utiliza para definir las variables que se utilizarán en el modelo. minimize: se utiliza para definir la función objetivo a minimizar. maximize: se utiliza para definir la función objetivo a maximizar. subject to: se utiliza para definir las restricciones del modelo. in: para definir los índices que estarán en cada uno de los sets. sum: se utiliza para desarrollar las sumatorias de las variables o parámetros en las restricciones función objetivo.

21

Ingreso de datos vectoriales: Los datos vectoriales son los que tienen “m” filas, pero solo una columna, de este tipo de datos tenemos varios en el ejemplo 2, margen, demanda mínima, demanda máxima, recurso de materia prima y tiempo máximo disponible. A continuación, se muestra como ingresar los datos del parámetro Margen. param 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Margen:= 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 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. param Tiempo: 1 2 1 0.167 0.083 2 0.200 0.067 3 0.417 0.133 4 0.200 0.150 5 0.250 0.033 6 0.283 0.033 7 0.317 0.050 8 0.500 0.067 9 0.333 0.083 10 0.350 0.100 11 0.333 0.083 12 0.367 0.133 13 0.333 0.167 14 0.250 0.183 15 0.300 0.083 16 0.283 0.050 17 0.250 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 cuenta: 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 tres dimensiones En el ejemplo 2 no tenemos un caso con matrices de 3 dimensiones, por ello, suponga el siguiente ejemplo 3: Usted tiene una empresa donde hace 6 productos y tiene 3 máquinas para producir cualquiera de los 6 productos, además, en su empresa se trabaja 3 turnos. Producir un producto en cada máquina y en cada turno tiene costos diferentes; por ejemplo, el producto 1 en la maquina 1 en el turno 1 puede costar 10 UM mientras que el producto 1 en la máquina 2 en el turno 1 puede costar 12 UM. Para poder crear y asignar los valores al parámetro Costo, primero crearemos los sets primitivos, el set compuesto, el parámetro. #Sets primitivos set Turno; set Maquinas; set Productos; #Sets compuestos set Matriz={Productos,Maquinas,Turno}; #Parametro de Costos param Costo {Matriz}; Ahora, procederemos a asignar los valores al parámetro costo: param Costo := [*,*,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;

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: subject to ¨Nombre¨ {i in Productos, k in Turnos}

No se coloca el signo “;” al final de cada tabla, sino solo en la última

No se coloca el signo “;” al final de cada tabla, sino solo 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 del set Productos y el segundo “*” se refiere a los 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 lex en vez del minos, deberíamos ingresar el siguiente código: ampl: option solver lex;

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 PU con el propósito de que usted los pegue en el software AMPLIDE.

Tabla 2: Costo de transporte desde la planta i hasta el cliente j En dólares por cada mil unidades Cliente 1 Cliente 2 Cliente 3 Cliente 4 Cliente 5 Cliente 6 Cliente 7 Cliente 8 Cliente 9 Cliente 10 Planta 1

100

40

30

150

55

98

55

135

95

85

Planta 2

110

65

25

140

60

70

65

125

85

55

Planta 3

100

70

50

160

65

75

70

145

105

50

Planta 4

90

80

65

110

100

85

75

110

120

60

Planta 5

120

90

35

180

110

65

60

165

115

90

Precio de venta

180

120

120

200

150

160

150

200

180

110

Los requerimientos de tiempo de mano de obra en cada planta para fabricar mil productos se muestran en la tabla 3, asimismo, el tiempo total disponible de cada una de las cinco plantas suman en total 60 000 horas; sin embargo, es posible comprar horas de mano de obra adicionales a 10 dólares la hora.

25

Tabla 3: requerimiento de tiempo por mil unidades Horas por cada mil unidades 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, en miles, fabricados en la planta i y embarcados al cliente j i=1, planta 1; i=2, planta 2; i=3, planta 3; i=4, planta 4; i=5, planta 5. j=1, cliente 1; j=2, cliente 2; j=3, cliente 3; j=4, cliente 4; j=5, cliente 5; j=6, cliente 6; j=7, cliente 7; j=8, cliente 8; j=9, cliente 9; j=10, cliente 10.

MO: … Restricciones Restricciones de capacidad: Para la planta 1: X_1_1 + X_1_2 + X_1_3 + X_1_4 + X_1_5 + X_1_6 + X_1_7 + X_1_8 + X_1_9 + X_1_10 <= 750; Que expresado como sumatoria es: 10

 X1j ≤ 750 j=1

… 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 LEX y conteste las siguientes preguntas:

26

▪ ▪ ▪ ▪

¿Cuál es la utilidad óptima? ¿Qué clientes se atienden y qué cantidad desde cuál planta? ¿En qué plantas se usa el total de su capacidad en unidades? ¿La solución óptima del modelo sugiere adquirir horas adicionales?

Problema 2 (tomado y adaptado de Winston (2005)) Machinco elabora cuatro productos, los cuales requieren de tiempo en dos máquinas y de dos tipos de mano de obra (calificada y no calificada). La cantidad de tiempo de máquina y de mano de obra en horas necesarias para cada producto y los precios de venta se proporcionan en la tabla 4. Se dispone todos los meses de 700 horas en la máquina 1 y 500 horas en la máquina 2. Machinco puede comprar cada mes hasta 600 horas de mano de obra calificada a 8 dólares la hora, y hasta 650 horas de mano de obra no calificada a 6 dólares la hora.

Tabla 4: requerimiento de recursos Mano de obra Mano de obra 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 SENSIBILIDAD CON AMPL

AMPL proporciona opciones que permiten analizar la sensibilidad de un modelo matemático y que son útiles para poder variar algunos valores de parámetros, variables o de la función objetivo. ¿Qué indicadores son importantes para un análisis de sensibilidad?

Precio dual

Holguras Costo reducido

▪

Precio dual: Representa la variación en la cantidad de la función objetivo como consecuencia de modificar la cantidad de un recurso, se puede calcular como una ratio de contribución de un aumento o disminución unitaria en la disponibilidad de un recurso sobre la función objetivo: 𝑃𝑟𝑒𝑐𝑖𝑜 𝑑𝑢𝑎𝑙 =

∆𝑓𝑢𝑛𝑐𝑖ó𝑛 𝑜𝑏𝑗𝑒𝑡𝑖𝑣𝑜  𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒𝑙 𝑟𝑒𝑐𝑢𝑟𝑠𝑜 𝑏𝑖

Algunos autores la denominan precio sombra. El signo de este indicador está en función del tipo de restricción, es decir, si la restricción es “≤” utiliza una variable de holgura "+ hi", por lo cual tiene un signo positivo; así también si la restricción es “≥” utiliza una variable de excedente "-ei", por lo que tiene un signo negativo.

31

▪

Holgura / excedente: La holgura o excedente se analiza en cada restricción (Slack or surplus). La holgura representa la cantidad que no se usa de un recurso (sobrante), y el exceso representa la cantidad adicional de uso mínimo de un recurso.

▪

Costo reducido: La definición del costo reducido se basa en la explicación del análisis de sensibilidad de la función objetivo. Se formaliza en la literatura de PL como: 𝐼𝑛𝑔𝑟𝑒𝑠𝑜 𝐶𝑜𝑠𝑡𝑜 𝑟𝑒𝑑𝑢𝑐𝑖𝑑𝑜 𝐶𝑜𝑠𝑡𝑜𝑠 𝑑𝑒 𝑙𝑜𝑠 𝑟𝑒𝑐𝑢𝑟𝑠𝑜𝑠 ( )=( )−( ) 𝑝𝑜𝑟 𝑢𝑛𝑖𝑑𝑎𝑑 𝑐𝑜𝑛𝑠𝑢𝑚𝑖𝑑𝑜𝑠 𝑝𝑜𝑟 𝑙𝑎 𝑢𝑛𝑖𝑑𝑎𝑑 𝑝𝑜𝑟 𝑢𝑛𝑖𝑑𝑎𝑑 Con la definición dada de costo reducido, podemos ver que una variable no rentable (variable no básica, cuyo valor es cero) puede hacerse rentable de dos maneras:

 Incrementando el ingreso unitario.  Reduciendo el costo unitario de los recursos consumidos. En la mayoría de las situaciones, las condiciones del mercado dictan el precio por unidad y puede ser difícil incrementarlo a voluntad. Por otra parte, una opción más viable es reducir el consumo de recursos porque el fabricante puede reducir el costo si hace que el proceso de producción sea más eficiente. El costo reducido indica cuánto se puede aumentar (cuando se maximiza) o disminuir (cuando se minimiza) este coeficiente antes de que cambie la solución óptima y esta variable se convierta en básica. Sin embargo, recuerde que esta información se obtiene mediante el intervalo permisible para seguir óptimo para el coeficiente de esta variable en la función objetivo. El costo reducido (de una variable no básica) es sólo el aumento permitido (cuando se maximiza), a partir del valor actual del coeficiente para quedar dentro de su intervalo permisible o la reducción permitida (cuando se minimiza). Para explicar el análisis de sensibilidad se va a utilizar el ejemplo 1 de la guía 2 para aprender a obtener el análisis de sensibilidad de un modelo de optimización. Use el solver lex para resolver el modelo y empezar con el análisis. En el ejemplo 1 es importante saber cuántas horas se tienen disponibles en cada uno de los procesos y cuánto costaría aumentar una hora a un proceso en caso sea necesario; por lo tanto, se necesita conocer los precios sombra y las holguras. Para ello se usará el siguiente código: (El nombre de la restricción es Tp) display Tp, Tp.slack; AMPLIDE devolverá el siguiente mensaje: ampl: display : Tp 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: LEX 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 lex_option ‘sensitivity’; Y luego de resolver el modelo se usa el siguiente código: display variable.down, variable.current, variable.up;

33

AMPL indica que, como todos los valores de P son positivos, presentan costos reducidos iguales a cero y por tanto no es necesario variar los coeficientes de la función objetivo pues las variables Pi ya forman parte de la solución básica. Si desea más información sobre los comandos de análisis de sensibilidad de AMPL puede consultar el capítulo 12 del libro The AMPL Book.

2.

OPERADORES LÓGICOS EN AMPL

AMPL dispone de operadores lógicos para definir expresiones condicionales con el propósito de aplicar ciertas condiciones a una familia de restricciones, a un grupo de variables en las restricciones y a la función objetivo, entre otros casos. Los operadores lógicos de AMPL son los siguientes: = <> < <= > >=

: Igual a : Diferente de : Menor que : Menor o igual a : Mayor a : Mayor o igual a

Con el siguiente ejemplo se podrá entender mejor cómo funcionan estos operadores lógicos. Ejemplo 1 Friedman S.A. desea determinar cuántas lanchas debe producir los próximos seis meses para satisfacer a tiempo la demanda, que en el primer mes es 400 unidades, en el segundo 600 unidades, en el tercero 750, en el cuarto 250, en el quinto 300 y en el sexto 450. Para los cuatro primeros meses la capacidad normal de producción es 200 lanchas, y para los dos últimos es hasta 300 lanchas. Cada unidad fabricada en tiempo normal cuesta 500 dólares el primer mes y en los siguientes se estima que crezca en 25 dólares mensualmente. La empresa también puede producir más lanchas haciendo trabajar horas extras a su personal a un costo de 550 dólares el primer mes y cuyo incremento es 30 dólares mensualmente. Se sabe que el nivel de existencias al inicio del primer mes es 20 lanchas. La empresa decide al principio de cada mes cuántas lanchas hay que construir en dicho período pero debe cumplirse las siguientes políticas: ▪ ▪ ▪

Necesariamente en los dos primeros meses la producción debe ser como mínimo 50 lanchas en cada mes. La producción en tiempo extra de los dos primeros meses debe ser como máximo 350 lanchas en cada mes. En los tres últimos meses la producción en tiempo normal más lo elaborado en tiempo extra no debe superar las 550 unidades en cada mes.

La demanda se satisface al final de cada mes, luego de atenderla, las lanchas sobrantes se envían a un almacén y se incurre en costos por almacenamiento cuyo importe es 15 dólares por cada lancha guardada durante un mes. El modelo de programación lineal que permite a Friedman programar su producción a costo mínimo para el próximo semestre es el siguiente.

34

Variables de decisión: PRODNORMALt: cantidad de lanchas a producir en tiempo normal en el mes t.

t= 1,2…6

PRODEXTRAt: cantidad de lanchas a producir en tiempo extra en el mes t.

t= 1,2…6

IFLANCHAt:

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*PRODNORMALt + COSTEXTRAt*PRODEXTRAt) +

t=1…5(COSTOALMACEN*IFLANCHAt) + COSTOALMACEN*II Restricciones: Ecuaciones de inventario: IFLANCHA1 = II + PRODNORMAL1 + PRODEXTRA1 – DEMANDA1 IFLANCHAt = IFLANCHAt-1 + PRODNORMALt + PRODEXTRAt – DEMANDAt; t=2,3…6

Capacidad normal: PRODNORMALt ≤ CAPNORMALt ; t=1,2…6 Producción mínima en los dos primeros meses: PRODNORMALt ≥ PRODMIN; t=1,2 Producción máxima en tiempo extra en los dos primeros meses: PRODEXTRAt ≤ PRODMAXTEX12; t=1,2 Producción máxima en los tres últimos meses: PRODNORMALt + PRODEXTRAt ≤ PRODMAX; t=4,5,6 Rango de existencia: PRODNORMALt ≥ 0 ; PRODEXTRAt ≥ 0 ; IFLANCHAt ≥ 0 ;

t=1,2…6

Antes de empezar a escribir el ejercicio en lenguaje de AMPL vamos a reconocer los parámetros y las variables del problema que se muestran en la tabla 5. Tabla 5: Lista de parámetros Lista de parámetros

Etiqueta

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 Lista de variables Cantidad de lanchas a producir en tiempo normal Cantidad de lanchas a producir en tiempo extra Inventario final de lanchas

COSTONORMALt COSTOEXTRAt COSTOALMACEN DEMANDAt CAPNORMALt PRODMIN

35

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; param param param param param param param param param

COSTONORMAL {Periodo}; COSTOEXTRA {Periodo}; CAPNORMAL {Periodo}; DEMANDA {Periodo}; II; COSTOALMACEN; PRODMIN; PRODMAXTEX12; PRODMAX;

var PRODNORMAL {Periodo} >=0; var PRODEXTRA {Periodo} >=0; var IFLANCHA {Periodo} >=0; En su intranet va a encontrar un archivo Excel con el nombre “Datos_ejemplo1_guia3.xlsx”, descárguelo e ingrese los datos del problema en un archivo “.dat”. 2.1. Modelado de la función objetivo con operadores lógicos En la función objetivo del ejercicio 1, los costos de almacenamiento son considerados solo hasta el mes 5, por lo que se debe usar operadores lógicos para escribir la F.O. A continuación se muestra como se escribe dicha sentencia: minimize Costo_total: sum {i in Periodo} (COSTONORMAL[i] COSTOEXTRA[i] * PRODEXTRA[i]) + sum COSTOALMACEN*IFLANCHA[i]+COSTOALMACEN*II;

* {i

PRODNORMAL[i] + in Periodo:i<=5}

Este operador lógico se usa para que i tome solamente los valores de 1, 2, 3, 4 y 5.

Use el comando expand para ver cuál es el código algebraico que genera dicha sentencia. Debe tener en cuenta que no se considera el costo de mantener en almacén las lanchas del periodo 6. A continuación se muestra el código generado por la sentencia. minimize Costo_total: 500*PRODNORMAL[1] + 525*PRODNORMAL[2] + 550*PRODNORMAL[3] 575*PRODNORMAL[4] + 600*PRODNORMAL[5] + 625*PRODNORMAL[6] 550*PRODEXTRA[1] + 580*PRODEXTRA[2] + 610*PRODEXTRA[3] 640*PRODEXTRA[4] + 670*PRODEXTRA[5] + 700*PRODEXTRA[6] 15*IFLANCHA[1] + 15*IFLANCHA[2] + 15*IFLANCHA[3] + 15*IFLANCHA[4] 15*IFLANCHA[5] + 300;

+ + + + +

Note que al final de la expresión anterior hay una cifra igual a 300, esta es el resultado del producto COSTOALMACEN*II; usualmente AMPL realiza las operaciones aritméticas de parámetros cuyos valores son únicos.

36

2.2. Modelado de las restricciones con los operadores lógicos Para las ecuaciones de inventario, debe tener en cuenta que para el mes 1 no se tiene inventario final de un mes anterior, sino que se considera el inventario inicial. Para modelar dicha situación se van a utilizar los operadores lógicos. A continuación se muestra cómo escribir las ecuaciones de inventario con los operadores lógicos:

Este operador lógico se usa para crear la ecuación de inventarios solo para el mes 1

#Ecuaciones de inventario subject to Produccion_mes1 {i in Periodo: i=1}: IFLANCHA[i] = II + PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i];

Este operador lógico se usa para crear las ecuaciones de inventarios para los meses 2, 3, 4, 5 y 6.

subject to Produccion_otros_meses {i in Periodo: i>1}: IFLANCHA[i] = IFLANCHA[i-1] + PRODNORMAL[i] + PRODEXTRA[i] DEMANDA[i]; Como puede notar, se han creado dos restricciones; por tanto, al usar el comando expand con la restricción Produccion_mes1 se va a mostrar solo las ecuaciones para el mes 1. -PRODNORMAL[1] - PRODEXTRA[1] + IFLANCHA[1] = -380; Y cuando se usa el comando expand con la restricción Produccion_otros_meses se mostrarán las ecuaciones de inventarios para los próximos meses. -PRODNORMAL[2] -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}; param param param param param

Tiempo {Productos}; T_disponible {Periodos}; D_min; PV {Productos}; D_max {Matriz};

var Prod {Matriz}; maximize Ganancias: sum {(i,j) in Matriz} Prod[i,j] * PV[i]; subject to Tiempo_maximo {j in Periodos}: sum {i in Productos} Prod[i,j] * Tiempo [i] <= T_disponible[j]; Este operador lógico se usa para que la restricción se genere solo para el producto 2 en el mes 1

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

subject to Demanda_maxima {(i,j) in Matriz: i=1 or i=3}: Prod[i,j] <= D_max[i,j];

Archivo “Ejemplo2_guia3.dat”: param D_min := 100; param PV:= 1 15 2 20 3 10; param Tiempo:= 1 0.12 2 0.15 3 0.08;

38

param T_disponible:= 1 500 2 650; param D_max : 1 2 := 1 500 500 2 0 0 3 650 650; Use el comando expand para observar el código algebraico. En el anexo 6 puede observar todo el código algebraico de este modelo. Si desea más información sobre cómo usar los operadores lógicos puede leer el capítulo 7 del libro The AMPL Book.

3.

LA FUNCION IF-THEN-ELSE

Como pudo notar en el ejemplo 1, para poder hacer las ecuaciones de inventarios tuvo que crear dos diferentes sentencias, una para el mes 1 y otra para los demás meses. Esto puede evitarse usando la función if-then-else. if a then b else c. Donde a es un expresión lógica. Si a es verdadera, la expresión condicional toma el valor de b; si la expresión a es falsa, la expresión toma el valor de c. En caso c sea cero, la parte else de la función puede ser obviada. A continuación se muestra como se ha escrito la sentencia con la función if-then-else. #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 kilogramo de las sustancias 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

Abril

140

130

140

140

145

Mayo

120

140

170

130

125

Junio

110

120

160

100

155

El precio de venta del producto es de 170 u.m. por kilogramo de sustancia refinada. A lo sumo se puede refinar 320 kilogramos de sustancias artificiales y 350 kg de sustancias naturales por mes. El proceso de refinado se realiza sin pérdida de peso y sin costo. Además, se puede almacenar hasta 1360 kg de cada sustancia para su posterior uso, con costo de almacenamiento de 6 u.m./kg. No es posible almacenar el alimento ni las sustancias refinadas. Existe además una restricción tecnológica sobre la dureza del alimento que debe estar entre 5 y 7 unidades. Se supone que las durezas de las sustancias se mezclan linealmente, tales datos se muestran en la tabla 7.

40

Tabla 7: Dureza de cada sustancia Dureza Artificial 1

Artificial 2

Natural 1

Natural 2

Natural 3

9.5

7.1

3.4

5.2

4.8

Se comienza con un inventario de 730 kg de cada sustancia y se desea disponer de ese mismo inventario al final de junio. El negocio requiere definir una política de compra y producción de máximo beneficio.

41

Anexo 4 set Periodo = 1..6; param param param param param param param param param

COSTONORMAL {Periodo}; COSTOEXTRA {Periodo}; CAPNORMAL {Periodo}; DEMANDA {Periodo}; II; COSTOALMACEN; PRODMIN; PRODMAXTEX12; PRODMAX;

var PRODNORMAL {Periodo} >=0; var PRODEXTRA {Periodo} >=0; var IFLANCHA {Periodo} >=0; minimize Costo_total: sum {i in Periodo} (COSTONORMAL[i] * PRODNORMAL[i] + COSTOEXTRA[i] * PRODEXTRA[i]) + sum {i in Periodo: i<=5} COSTOALMACEN * IFLANCHA[i] + COSTOALMACEN * II; #RESTRICCIONES #Ecuaciones de inventario subject to Produccion_mes1 {i in Periodo: i=1}: IFLANCHA[i] = II + PRODNORMAL[i] + PRODEXTRA[i] - DEMANDA[i]; 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]

= = = = =

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

-600; -750; -250; -300; -450;

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 • Aprender a crear y ejecutar un archivo “.run”. • Importar y exportar datos usando Excel. • Conocer la utilidad y aplicaciones de un archivo “.run”.

1.

COMO CREAR Y EJECUTAR UN ARCHIVO “.run”

Para ver la aplicación de un archivo “.run” se usará el modelo “Ejemplo1.mod” de la guía 1 cuyo código era el siguiente: var A; var B; maximize Utilidad: 7*A + 3*B; subject to Tiempo_disponible: 0.1*A + 0.2*B <= 80; subject to Demanda_max_A: A <= 200; subject to Demanda_max_B: B <= 160; Si usted desea conocer el valor de la función objetivo y el de las variables tendría que escribir una serie de códigos en la ventana de comandos; y en caso realizara algún cambio en el modelo tendría que usar el comando reset y volver a escribir todo el código para resolver el modelo nuevamente. Este procedimiento se vuelve engorroso cuando se trabaja a gran escala y con modelos más complejos. Por ello, a continuación va a aprender cómo utilizar un archivo “.run” que va a facilitar mucho el proceso de resolver varias veces un mismo modelo. El proceso para crear un archivo “.run” es similar al de los archivos “.mod” y “.dat” con ayuda del ícono New File. La diferencia está en que ahora se deberá escoger la opción “.run” en la extensión de archivo como se muestra en la figura 19. Para el ejemplo se usará el nombre “Run1”.

Figura 19: creación de un archivo run Como observará, se abrió una nueva pestaña en la ventana de modelado. En este nuevo archivo escriba lo siguiente:

45

model Ejemplo1.mod; solve; display A,B; reset; Estos son los códigos que normalmente tendría que escribir en la ventana de comandos para obtener el valor de la función objetivo y de las variables. Sin embargo, al estar en la ventana de modelado, no se ejecuta la solución tras escribir las sentencias. Otra diferencia que resalta es el color de las palabras. Grabe el archivo “.run” y para poder ejecutarlo en AMPLIDE deberá ingresar el siguiente código en la ventana de comandos: ampl: include Run1.run; A continuación se mostrará automáticamente el reporte de la solución óptima y el valor de las variables. Si desea modificar algo en el modelo original, simplemente tendrá que grabarlo y ejecutar el archivo “.run” en la ventana de comandos. No tendrá que escribir todo el código nuevamente pues ya está en el archivo “.run”, note que en este archivo también se incluye el comando reset, para que se borre la memoria del software y pueda resolver nuevamente el modelo sin ningún problema.

2.

IMPORTACIÓN Y EXPORTACIÓN DE DATOS USANDO EXCEL

Normalmente, cuando se desea resolver modelos de optimización, la información requerida se encuentra en archivos Excel, ya que permite manejar tablas de datos, y en muchos casos pasar los datos de Excel al archivo “.dat” de AMPL puede ser engorroso debido a la gran cantidad de datos que se podrían manejar. Por ello, en esta guía se explicará cómo importar y exportar datos de y hacia archivos Excel. Se usará el ejemplo 1 de la guía 2 para explicar el proceso de importación y exportación de datos. A continuación se procede a mostrar el modelo matemático del Ejemplo 1 traducido a lenguaje AMPL y que usted trabajó en la guía 2. Podrá encontrarlo en la intranet con el nombre de “Ejemplo1_guia4.mod” dentro de la carpeta “Cuarta guía” de la carpeta “Guías de laboratorio”. set set set set set

Productos := 1..20; Procesos := 1..7; ProcesoMP := 1..5; Matriz1 := {Productos,Procesos}; Matriz2 := {Productos,ProcesoMP};

param param param param param param param

Margen {Productos}; Demandamin {Productos}; Demandamax {Productos}; RecursoT {Procesos}; RecursoMP {ProcesoMP}; Tiempo_prod {Matriz1}; 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 de las tablas en Excel Ingrese a su intranet y dentro de la carpeta “Guía de laboratorio” encontrará la carpeta “Cuarta guía” donde está el archivo “Cuarta guía ejemplo 1.xlsx”, descárguelo ya que en él se encuentran los datos de todos los parámetros necesarios para resolver el “Ejemplo 1” de la segunda guía. En la figura 20 se muestran dichos datos.

Tenga en cuenta: Al inicio de cada una de las columnas de datos se ha escrito el nombre del parámetro tal y como fue declarado en el archivo “.mod”. Por ejemplo, en la celda C1 se ha escrito el nombre Demandamin y en las siguientes 20 celdas se ha ingresado la demanda mínima que le corresponde a cada producto

Figura 20: selección de datos En el mismo archivo Excel también se ha creado una tabla a la cual se exportarán los resultados de la variable P, que empieza en la celda A24. En la figura 21 se muestra dicha tabla. En la columna B24 se ha escrito el nombre de la variable de la cual se van a exportar los resultados. Recuerde que el nombre de la variable que escriba en el archivo debe ser exactamente el mismo que utilizó en el archivo “.mod”.

47

Figura 21: columna donde se exportarán los datos Debe usar el 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 “ de nombres”. Se desplegará la ventana que se muestra en la figura 22.

Figura 22: de nombres En la ventana “istración de nombres” presione el botón “Nuevo” y se desplegará la ventana “Editar nombre” que se observa en la figura 5. En el campo “Nombre:” anote el nombre que desea darle a la tabla, por ejemplo Prod_par. Luego en el campo “Hace referencia a:” seleccione en la hoja de cálculo el rango en donde están los datos de dicha tabla, en este ejemplo el rango es:

48

A1:D21 (véase la figura 18); la figura 23 presenta el rango seleccionado, nótese que en una sola tabla se están ingresando los valores de varios parámetros. Presione el botón Aceptar y Excel retornará a la ventana “istració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 tiempo También se debe declarar el nombre de la tabla donde se van a exportar los datos de la variable P. En la figura 25 se muestra como se ha declarado el nombre de esa tabla.

Figura 25: declarando el nombre de la matriz resultados

49

Luego de declarar los nombres de todas las tablas donde están los datos que necesita para resolver el modelo, la ventana “ de Nombres” de su archivo Excel se debería ver como la de la figura 26.

Figura 26: 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 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 del set Productos, cuyas celdas son O2:O22.

2.2. Declaración de tablas en AMPL para lectura de datos vectoriales A continuación se muestra el código que se debe ingresar en el archivo “Cuarta_guia.run” para declarar la tabla “Prod_par” en AMPL. table Prod_par IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [Productos], Margen, Demandamin, Demandamax;

¿Pero qué significa todo ese código?

50

A continuación, se va a explicar que significa cada una de las partes del código: Nombre del archivo donde 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 que 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 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 AMPL para lectura de datos matriciales A continuación se va a mostrar el código que se debe ingresar en el archivo “Cuarta_guia.run” para declarar la tabla “Tiempos” en AMPL. table Tiempos IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [i ~ Productos], {j in Procesos} <Tiempo_prod[i,j] ~ (j)>; La primera línea de código tiene exactamente la misma sintaxis que en el caso de datos vectoriales, por lo que sólo se explicará que significa la segunda línea de código: Asocia los valores de la 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} <Tiempo_prod[i,j] ~ (j)>; 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} <Tiempo_prod[i,j] ~ (j)>; table Materia_prima IN 'tableproxy' 'odbc' 'Cuarta 1.xlsx': [i ~ Productos], {j in ProcesoMP} <MP[i,j] ~ (j)>;

guia

ejemplo

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' 's\Desktop\Cuarta guia ejemplo 1.xlsx': [ProcesoMP], RecursoMP;

2.4. Declaración de tablas en AMPL para escritura de variables vectoriales En el ejemplo mostrado, solo se tiene que exportar los resultados de la variable P. A continuación se va a mostrar el código que se debe ingresar para declarar en AMPL la tabla donde se van a exportar esos resultados. table Resultados OUT 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [Productos], P; Como puede notar, la sintaxis es exactamente la misma que cuando se quiere declarar tablas para lectura de datos, solo que en vez de usar la palabra IN se usa la palabra OUT, la cual también debe ser escrita en mayúsculas. 2.5. Declaración de tablas en AMPL para escritura de variables matriciales Como para el Ejemplo 1 no se tienen variables matriciales se usará el Ejemplo 2 para explicar la exportación de variables matriciales. No se va a explicar sobre qué trata dicho ejemplo, solo se le proporcionará el archivo “.mod” con el código. En su intranet, en la carpeta “Cuarta guia” encontrará los archivos “Cuarta guía ejemplo 2.xlsx”, “Ejemplo2_guia4.mod”, “Ejemplo2_guia4.dat” y “Ejemplo2_guia4.run”, descárguelos y notará que en archivo “.mod” se encuentra el siguiente código: set Inicio := 1..5; set Destinos := 1..5; set Matriz := {Inicio,Destinos};

52

param Distancias {Matriz}; var u {Inicio}; var X {Matriz} binary; minimize Distancia_total: sum {(i,j) in Matriz:i<>j} X[i,j] * Distancias[i,j]; subject to Todo_entra {i in Inicio}: sum {j in Destinos:i<>j} X[i,j] = 1; subject to Todo_sale {i in Inicio}: sum {j in Destinos:i<>j} X[j,i] = 1; subject to subtours {(i,j) in Matriz: i>1 and j>1 and i<>j}: u[i] - u[j] + card(Inicio) * X[i,j]<= card(Inicio)-1; En el archivo “.dat” están los valores del parámetro Distancias y en el archivo “.run” va a encontrar el siguiente código: model Ejemplo2_guia4.mod; data Ejemplo2_guia4.dat; table Result OUT 'tableproxy' 'odbc' 'Cuarta guia ejemplo 2.xlsx': {i in Inicio} -> [Inicio], {j in Destinos} <X[i,j] ~ (j)>; option solver lex; 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} <X[i,j] ~ (j)>; 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} <X[i,j] ~ (j)>;

Nombre de la primera celda de la primera columna de la tabla

Ejecute el archivo “.run” y notará que en el archivo Excel se han exportado los resultados de la variable X.

53

2.6. Comandos read table y write table Hasta ahora solo ha declarado las tablas que va a necesitar para poder obtener los valores de los parámetros y exportar los valores de las soluciones, pero aún no ha usado el comando para leer o escribir 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 se deben escribir dichos comandos en el archivo “.run”. read read read read read

table table table table table

Tenga en cuenta: 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.

Prod_par; MPdisp; T_disp; Tiempos; 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} <Tiempo_prod[i,j] ~ (j)>; table Materia_prima IN 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [i ~ Productos], {j in ProcesoMP} <MP[i,j] ~ (j)>; table Resultados OUT 'tableproxy' 'odbc' 'Cuarta guia ejemplo 1.xlsx': [Productos], P; read table Prod_par; read table MPdisp; read table T_disp; read table Tiempos; read table Materia_prima; option solver lex; 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 set set set

Productos := 1..2; Maquinas := 1..2; Dias := 1..2; Matriz := {Productos, Maquinas, Dias};

param Costo {Matriz}; var Prod {Matriz}; En la figura siguiente se muestra como deberían ordenarse las tablas

Para declarar el nombre de la tabla de costos en Excel deberá seleccionar el rango A1:D9 y para la tabla de resultados deberá seleccionar el rango F1:I9. A continuación se mostrará el código para declarar la tabla de donde se van a leer los datos. table Costo_Prod IN 'tableproxy' 'odbc' 'Ejemplo 3 set.xlsx': [Producto, Maquina, Dia], Costo; Donde [Producto, Maquina, Dia] se refiere a que la primera, segunda y tercera columna es donde se coloca los 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 de los sets y en la siguiente columna se exportarán los valores de la variable.

55

2.7. UTILIDAD DE UN ARCHIVO “.run” Puede que usted se esté preguntando porque está usando un archivo “.run” para la declarar tablas, leer y escribir datos en Excel. Pero recuerde que un archivo “.run” es un ejecutable, esto significa que todo el código que ha escrito en él podría escribirlo directamente en la ventana de comandos, sólo que tendría que escribir todos los comandos cada vez que quiera resolver un modelo usando Excel. Si desea probarlo, en su ventana de comandos escriba lo siguiente: ampl: model Ejemplo1_guia4.mod; ampl: table Prod_par IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx': ampl? Productos <- [Productos], Margen, Demandamin, Demandamax; ampl: table MPdisp IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx': ampl? ProcesoMP <- [ProcesoMP], RecursoMP; ampl: table T_disp IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx': ampl? Procesos <- [Procesos], RecursoT; ampl: table Tiempos IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx': ampl? [i ~ Productos], {j in Procesos} <Tiempo_prod[i,j] ~ (j)>; ampl: table Materia_prima IN 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx': ampl? [i ~ Productos], {j in ProcesoMP} <MP[i,j] ~ (j)>; ampl: table Resultados OUT 'tableproxy' 'odbc' 'Cuarta guía ejemplo1.xlsx': ampl? Productos <- [Productos], P; ampl: read table Prod_par; ampl: read table MPdisp; ampl: read table T_disp; ampl: read table Tiempos; ampl: read table Materia_prima; ampl: option solver lex; 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; LEX 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; LEX 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; LEX 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; LEX 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 indexada

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; LEX 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 sentencias en un archivo “.run” un determinado número de veces. Para realizar un análisis del “Ejemplo_guia5.mod”, el cual encontrará en la intranet, en la carpeta “Quinta guía”, se creará un archivo “.run” que permitirá resolver tres veces el problema incrementando en cada iteración un 5% a “RecursoT” y un 10% a “Demandamax”. model Ejemplo_guia5.mod; data Ejemplo_guia5.dat; for {1..3} { let {i in Procesos} RecursoT[i] := RecursoT[i] * 1.05; let {h in Productos} Demandamax[h] := Demandamax[h] * 1.1; solve; display P; } Esta forma de analizar un modelo se entiende mejor con modelos más grandes o cuando se desea crear bucles con iteraciones más complicadas y que permitan entender mejor los resultados sin necesidad de tener que mover los datos. Para ejemplificar esto se va a crear un nuevo archivo “.run” que devuelva una tabla final donde se muestren los resultados de la variable “P” y otra donde se muestren los valores obtenidos en la función objetivo para cada iteración. model Ejemplo_guia5.mod; data Ejemplo_guia5.dat; set iteracion := 1..3; set Compuesto := {Productos,iteracion}; param Ganancias {iteracion}; param Prod {Compuesto}; 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.

3.

COMANDO REPEAT: ITERAR RESPECTO A UNA CONDICION

El comando repeat no tiene un número máximo de iteraciones, sino que se detiene cuando se cumple una determinada condición. Retornando al análisis del “Ejemplo_guia5.mod”, ahora se desea conocer cuál debería ser la demanda máxima de cada producto y la cantidad de horas que se deberían contratar para que se tenga por lo menos una ganancia de 60 000 U.M.. Por ello se debe especificar que el bucle se detendrá cuando el valor de la función sea mayor que 60 000 U.M. usando el comando repeat de la siguiente manera: repeat repeat repeat repeat

while until {...} {...}

Utilidades < 60000 Utilidades > 60000 while Utilidades < 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 escribir primero la condición y luego la sentencia y hacerlo al revés? Cuando se escribe primero la condición el bucle la analiza y en caso sea verdadera se ejecuta la iteración; cuando la condición se escribe al final se ejecuta la iteración sin importar si al inicio la condición es verdadera o no. Para ejemplificarlo cree un archivo “.run” con el siguiente código: 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 obliga a que se ejecute el bucle solo cuando “Utilidades” es mayor a 60000 U.M. y como inicialmente su valor es 0 y no cumple con la condición, el bucle no se ejecuta. Ahora en su archivo “.run” ingrese el código: repeat { let {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…4j=1…5k=1…6(PVj – Costoij) * Pijk Restricciones: Restricciones de demanda:

i=1…4 Pijk = DEMANDAjk Restricciones de tiempo: TIEMPOij*Pijk ≤ TMAX Restricciones de materia prima: Eficij*Pijk ≤ DISPONIBLEij Rango de existencia: Pijk ≥ 0

;

j=1,2…5; k=1,2…6

;

i=1,2…4; j=1,2…5; k=1,2…6

;

i=1,2…4; j=1,2…5; k=1,2…6

;

i=1,2…4; j=1,2…5; k=1,2…6

El modelo de programación lineal en lenguaje AMPL y el archivo de datos puede encontrarlos en la intranet del curso, en la carpeta “AMPL/Archivos guía 5” con los nombres “Problema1_guia5.mod” y “Problema1_guia5.dat”. Se pide: a)

Cree un archivo ejecutable “.run” que le permita analizar en una sola corrida qué fábrica se debe cerrar de manera que se pueda minimizar las pérdidas de utilidades.

63

b)

En el archivo ejecutable “.run” que creó agregue las sentencias que considere necesarias de manera que luego de resolver todos los escenarios se devuelva una tabla con el siguiente formato:

Fabrica cerrada 1 2 3 4

Utilidad total Monto 1 Monto 2 Monto 3 Monto 4

En la carpeta “AMPL/Archivos guía 5” encontrará el archivo “Problema1_guia5.run” con la solución de la parte “a)”. Problema 2 Perú se encuentra entre los países latinoamericanos productores de café oro o café orgánico. Como orgánico es denominado el café que proviene de cultivos con un manejo agronómico que se caracteriza por prácticas de conservación del suelo, siembra a la sombra de árboles de mayor altura (principalmente leguminosas) y la carencia de determinados agroquímicos y fertilizantes minerales. La mayoría del café certificado cómo orgánico tiene además el certificado de comercio justo (fair trade), que garantiza a los productores un precio mínimo y 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 PU, 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…4j=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: Cafeij ≤ Cafe_productoresi ; Rango de existencia: Cafeij ≥ 0 ;

j=1,2…6

i=1,2…7; j=1,2…6

i=1,2…4; j=1,2…5

Los datos del problema podrá encontrarlos en su intraner, en la carpeta “AMPL/Archivos guía 5” con el nombre “Datos problema 2” Se pide: a) b)

c)

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. 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 set set set set

Productos := 1..20; Procesos := 1..7; ProcesoMP := 1..5; Matriz1 := {Productos,Procesos}; Matriz2 := {Productos,ProcesoMP};

param param param param param param param

Margen {Productos}; Demandamin {Productos}; Demandamax {Productos}; RecursoT {Procesos}; RecursoMP {ProcesoMP}; Tiempo {Matriz1}; MP {Matriz2};

var P {i in Productos} >=Demandamin[i], <=Demandamax[i] ; maximize Utilidades: sum {i in Productos} Margen[i] * P[i]; subject to Tp {j in Procesos}: sum {i in Productos} Tiempo[i,j] * P[i] <= RecursoT[j]; subject to Materia {j in ProcesoMP}: sum {i in Productos} MP[i,j] * P[i] <= RecursoMP[j]; Como pudo notar, al definir el rango de las variables al momento de declararlas, se pudo eliminar dos familias de restricciones, lo cual permitirá simplificar el modelo y por tanto disminuir el tiempo de procesamiento requerido para resolverlo. Descargue los archivos “Ejemplo1_guia6.mod” y “Ejemplo1_guia6.dat”, modifique el archivo “.mod” para que pueda declarar el rango de las variables

66

al declararlas y resuelva los modelos. Note que la solución que se obtiene es la misma que la que obtuvo en la segunda guía.

Datos importantes: En 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 desea declarar las variables como enteras o binarias, AMPL dispone de dos palabras reservadas para ello: integer: palabra reservada para declarar una variable como entera. binary: palabra reservada para declarar variables binarias (1 ó 0). A continuación, se presenta el ejemplo 2 que es muy similar al ejemplo 1 de la guía 2; sin embargo, en este caso los productos no se fabrican en kilogramos sino en unidades por lo que es necesario indicar en el modelo que estas variables son enteras. Asimismo, presenta restricciones en los costos fijos controlables que obligan a definir variables binarias. Ejemplo 2 En cierta empresa manufacturera se fabrica 20 diferentes productos y cada uno pasa por una secuencia de siete procesos distintos en donde la materia prima se agrega en los cinco primeros ya que los dos últimos procesos son de acabado de los productos. La secuencia de los procesos para cada producto es la misma y se identifica con proceso 1 al primero, proceso 2 al segundo y así sucesivamente. Por las características de los productos no tiene sentido que se fabriquen fracciones de estos, por tanto, son unidades completas. Los anexos al final de cada guía muestran una serie de datos que a continuación se describen: En el anexo 1 se muestra los costos variables unitarios, los precios de venta, el margen de contribución y los costos fijos; también se muestra la demanda que por exigencias contractuales debe ser como mínimo igual a 50 para todos los productos que la empresa atienda; asimismo, se muestra la demanda máxima de cada producto. En caso se fabrique el producto i se incurrirá en el costo fijo i, si no se produce dicho producto entonces no se incurrirá en tal costo fijo y será igual a cero. El anexo 2 presenta el tiempo en cada proceso requerido por cada unidad de tipo de producto y la disponibilidad del recurso tiempo.

67

El anexo 3 muestra los datos de la cantidad de materia prima también por cada unidad de producto así como la disponibilidad del recurso materia prima. Los productos han sido solicitados por un prestigioso cliente con quién se ha negociado que la empresa elija cuáles productos atenderá, luego se firmaría el contrato. La empresa desea determinar cuántos productos de cada tipo debe fabricar con el objetivo de maximizar las utilidades, para tal fin, las variables de decisión son: Pi: cantidad de unidades por fabricar de cada tipo de producto. 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) - i=1..20(COSTO_FIJOi*Yi) Restricciones: Restricciones de demanda: Pi ≥ DEMANDAMINi*Yi ; i=1,2…20 Pi ≤ DEMANDAMAXi Restricciones de tiempo:

;

i=1,2…20



;

i=1,2…7

j=1…20(TIEMPOji*Pj) ≤ RECURSOTi

Restricciones de materia prima:



j=1…20(MPji*Pj) ≤ RECURSOMPi ; Restricciones para los costos fijos: Pi ≤ M*Yi ; Rango de existencia: Pi son variables enteras no negativas ; Yi = 0 ó 1

i=1,2…5

i=1,2…20 ; M>>0 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_FIJOi

La demanda mínima de cada producto

DEMANDAMINi

La demanda máxima de cada producto

DEMANDAMAXi

Disponibilidad del recurso tiempo de cada proceso

RECURSOTj RECURSOMPj

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

TIEMPOij

Número positivo lo suficientemente grande

M

68

Mpij

Lista de variables

Etiqueta

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

Yi Pi

En el campus virtual PU 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 “lex” 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

Bibliografía FOURER, Robert; Gay, David; Kerninghan, Brian 2003 AMPL: A Modeling Language for Mathematical Programming. Segunda edición. Princeton University. HILLIER, Frederick; Lieberman, Gerald 2015 Introducción a la Investigación de operaciones. Décima edición. México D.F. McGraw-Hill. https://pu.ent.sirsi.net/client/es_ES/campus/search/detailnonmodal/ent:$002f$00 2fSD_ILS$002f0$002fSD_ILS:519408/one WINSTON, Wayne 2005 Investigación de operaciones: aplicaciones y algoritmos. Cuarta edición. México. Thompson. https://pu.ent.sirsi.net/client/es_ES/campus/search/detailnonmodal/ent:$002f$00 2fSD_ILS$002f0$002fSD_ILS:392874/one

CORNUEJOLS, Gerard; Trick, Michael 1998 Quantitative methods for the Management Sciences: Course notes. Pittsburgh. Carnegie Mellon University. CORNEJO, Christian 2014 Guía Lingo. Publicación de material para la docencia PU.

74