Introducción al programa AMPL

Introducción

• Introducción

AMPL es un programa dirigido a la construcción y
resolución de modelos de optimización,
fundamentalmente modelos de Programación Lineal,
Programación Entera y Programación No
Lineal. A diferencia de otros programas parecidos, como
LINGO, una vez definido un modelo en AMPL puede especificarse el
cómo queremos resolverlo, lo que permite
el diseño de muchos tipos de algoritmos.
Simultáneamente, existe una variedad muy grande de
solvers que pueden ser llamados desde AMPL (algunos de
dominio público), lo que da una gran potencia y
versatilidad al programa. Otro hecho a destacar es la continua
incorporación de mejoras y procedimientos recientes. Para
una descripción completa de los elementos básicos
del lenguaje la mejor fuente sigue siendo el libro de R. FOURER,
D. M. GAY & B. W. KERNIGHAN AMPL, A Modeling Language For
Mathematical Programming, The Scientific Press (1993, 2002).
Para acceder a los servicios de AMPL consultar la
dirección http://www.ampl.com.

Para una descripción de las mejoras que se han
ido incorporando desde la versión inicial, de los solvers
disponibles y de otras muchas cuestiones, consultar en
http://netlib.bell-labs.com/cm/cs/what/ampl/index.html

• Elementos fundamentales

El programa AMPL consta fundamentalmente de las
siguientes componentes:

• El procesador del lenguage AMPL, que
  corresponde al programa ampl.exe y que compila todos los
  ficheros y comandos. El procesador puede ser ejecutado en
  modo comando en una ventana de DOS, o bien puede ser
  ejecutado más cómodamente desde una ventana
  windows ejecutando el programa sw.exe (scroll
  windows).

• Los solvers, que son los algoritmos para
  resolver diferentes tipos de problemas. La edición
  Standar AMPL Student for Windows puede ejecutarse con
  diferentes solvers, entre los que destacan CPLEX (para
  problemas de PL, PE y Redes) y MINOS (para problemas
  de PL y PNL), y tiene la limitación de hasta 300
  variables y 300 restricciones. Además de la
  versión Standar AMPL Student for Windows, hay otras
  versiones como AMPL Plus para Windows, o versiones para
  Linux, Unix y otras plataformas.

• La forma más habitual de trabajar con AMPL es
  editar primero tres ficheros, con extensiones .mod,
  .dat y .run conteniendo, respectivamente, las
  componentes del modelo, los datos en el formato AMPL, y los
  comandos que se van a ejecutar. Estos ficheros de texto
  pueden editarse y mantenerse con cualquier editor de textos
  (p.e. con el bloc de notas). Aunque muchos de los comandos
  que aparecen en el archivo .run podrían ser ejecutados
  manualmente en la ventana de comandos, es más
  conveniente agruparlos en un archivo o script con
  extensión .run, donde además pueden ir todo
  tipo de opciones, bucles repetitivos, etc.

• Además de las tres ventanas de texto, es
  preciso tener activo el procesador de comandos AMPL o
  bien en una ventana de DOS, o más cómodamente
  desde una ventana windows en sw.exe.

• De una manera informal, podemos decir que en un
  fichero .mod decimos al ordenador qué modelo queremos
  resolver, con un fichero .dat le decimos al ordenador con que
  datos vamos a trabajar y con un fichero .run le decimos de
  que modo queremos resolver el problema y que
  información queremos que nos muestre.

• Instalación de AMPL

Ampl ofrece una versión gratuita para
estudiantes. Para instalar los ficheros necesarios pueden
seguirse los siguientes pasos.

Instalación de ficheros del entorno de
AMPL

• 1. Usando internet, entrar en
  www.ampl.com.

• 2. Pinchar en la palabra download,
  situada en la columna izquierda, en el párrafo que
  sigue a TryAMPL!

• 3. Pinchar en CPLEX8.0 Studet
  Edition.

• 4. Pinchar en For Windows user new to
  AMPL.

• 5. Pinchar en amplcml.zip y guardar en
  la carpeta elegida el fichero .zip correspondiente
  (amplcml).

• 6. Descomprimir el fichero amplcml.zip antes
  bajado. Puede hacerse pulsando el botón derecho y
  eligiendo la opción extract to folder:
  C:……….

• 7. Entre otros, al final debemos tener los
  siguientes ficheros:

• ampl.exe (procesador de AMPL).

• cplex.exe (solver de PL, PE y redes).

• cplex80.dll (librería de cplex).

• minos.exe (solver de PL y PNL).

• sw.exe (ventana en la que puede ejecutar el
  procesador de AMPL de una forma cómoda).

Instalación del editor
PFE32.exe

Este editor resulta cómodo para trabajar en la
elaboración de los ficheros .mod, .dat y .run.

Puede bajarse buscando con google las palabras
pfe32.zip. Entre las búsquedas encontradas elegir una
adecuada. Por ejemplo, pinchando en factsheet.
Notas:

• La carpeta de trabajo del editor PFE32 (es decir,
  donde busca y guarda directamente los ficheros, si no le
  indicamos otra cosa) puede cambiarse seleccionando file +
  chage directory.

• El número de espacios en blanco que se
  obtienen al pulsar la tecla del tabulador puede cambiarse si,
  dentro del editor PFE32, usamos Options + Current modes +
  Test formatting.

Modelos
explícitos de programación lineal resueltos
interactivamente

• Introducción

En esta sección vamos a ver cómo se
introducen en AMPL ejemplos sencillos de Programación
Lineal de pocas variables, y cómo se ejecutan archivos de
comandos para las sesiones iniciales de AMPL. En estos ejemplos
los datos del problema (coeficientes de la función
objetivo, de las restricciones y del lado derecho), están
incluidos en el modelo, por lo que no es preciso crear un archivo
con los datos, es decir, no necesitamos el archivo .dat.
Les llamaremos modelos explícitos. Posteriormente
veremos que, como es importante lograr la separación
completa entre el modelo y los datos, es mejor usar
también este tipo de archivo. Tampoco usaremos el
archivo .run. Algunas ideas generales son:

• Los comentarios pueden ser añadidos desde el
  símbolo # hasta el final de la
  línea.

• Al final de cada declaración o comando debe
  ir un punto y coma (;).

• Las mayúsculas son distintas de las
  minúsculas.

• Se pueden insertar espacios en blanco o
  líneas en blanco sin afectar a la ejecución del
  programa.

• La multiplicación debe indicarse con el signo
  *; por ejemplo, debe escribirse 3*x1 + 4*x2, y no 3×1 +
  4×2.

A continuación, seguiremos los siguientes
pasos:

• Creación de un fichero .mod para indicar el
  modelo a resolver.

• Resolución del problema con AMPL desde la
  ventana de sw.exe.

Nota: no usaremos

• Creación de un fichero .mod

Tendremos en cuenta las siguientes
consideraciones:

• Cada variable debe ser declarada
  explícitamente (con la declaración var);
  además, si corresponde, podemos indicar su no
  negatividad, sus cotas, si es entera o si es
  binaria.

• La función objetivo debe ser declarada
  explícitamente después de maximize o minimize,
  y es conveniente darle un nombre seguido de dos puntos. En
  cada problema el nombre de la función objetivo puede
  ser distinto, aunque, por comodidad, podemos poner siempre el
  mismo nombre (por ejemplo, objetivo).

• Cada restricción debe ser declarada
  explícitamente (con la declaración subject
  to), y es conveniente darle un nombre seguido de dos
  puntos.

Resumen

Ejemplo de un modelo de PL explícito con dos
variables (ejemplo1.mod): Supongamos que queremos resolver el
problema:

maximizar la funcion 3×1+4×2 sujeta a: x1+x2 <= 2
4×1+6×2 <= 9 x1>=0, x2>=0 Con el editor pfe32.exe
creamos el fichero ejemplo1.mod siguiente:

# declaracion de las variables y de su no negatividad
var x1>=0; var x2>=0; # declaracion de la funcion objetivo
# la palabra objetivo es elegible a gusto personal maximize
objetivo: 3*x1+4*x2; # declaracion de las restricciones subject
to res1: x1+x2 <= 2; # la palabra res1 es elegible a gusto
personal subject to res2: 4*x1+6*x2 <= 9; # la palabra res2 es
elegible a gusto personal Notas:

• La declaración de variables debe preceder a
  la declaración de restricciones y de la función
  objetivo.

• Entre las declaraciones de restricciones y de la
  función objetivo no hay precedencias obligatorias
  .

• Resolución interactiva del problema
  anterior usando el procesador de comandos en la ventana
  sw.exe

Una sesión inicial para resolver el problema
anterior puede conseguirse aplicando en modo secuencial e
interactivo los siguientes comandos:

• el comando reset elimina de la
  memoria de AMPL el modelo y los datos anteriores.

• el comando model envía al
  procesador de comandos el modelo especificado, y es preciso
  indicar todo el camino (path) donde esté el archivo
  correspondiente.

• con el comando option solver se elige el
  solver con el que resolver el modelo actual; dependiendo del
  tipo de problema a resolver elegiremos el más
  adecuado. Nosotros eligiremos la opción option
  solver cplex.

• el comando solve llama al solver
  elegido y aplica el algoritmo correspondiente,
  obteniéndose una solución
  óptima.

Una vez obtenida una solución óptima podemos
elegir lo que queremos que nos muestre el programa. Para ello
tenemos varios comandos. Por ejemplo, los comandos display y
printf permiten mostrar en pantalla datos, resultados o mensajes
de texto preestablecidos.

• Sufijos

Con el comando display se pueden también
visualizar otros valores asociados a las variables y a las
restricciones, mediante el uso de sufijos.

Los sufijos más habituales para las variables
son:

Los sufijos más habituales para las restricciones
son:

• Otros comandos

Aunque más adelante se verá un uso
más intensivo del lenguaje de comandos, hay otros comandos
sencillos que valen para ver el modelo en su conjunto como
son:

• el comando show que muestra las
  componentes del modelo.

• el comando expand que expande el
  modelo (salvo, en su caso, la no negatividad).

• Cotas y atributos integer y binary para las
  variables

En un fichero .mod, cuando se declara una variable, si
no se especifica nada la variable es continua y no tiene
restricción de signo. Las restricciones de signo, las
cotas sencillas y las restricciones de ser entera o binaria se
especifican en la misma declaración. Ejemplo:

Para poner x1 ( 0, 0 ( x2 ( 8, x3 ( 0 y entera, x4
binaria se escribe, respectivamente:

var x1 >=0 ; var x2 >=0, <=8 ; var x3 >=0,
integer ; var x1 binary ;

• Un primer ejercicio. El problema del
  transporte

Usando lo anteriormente expuesto, resolver el problema
del transporte de Winston p. 337.

• Ejercicios sobre los comandos print y
  printf

Se trata de entender la diferencia entre los comandos
print y printf , así como entre los
atributos n y t. sw: ampl ampl: print "jose";
jose ampl: printf "jose"; joseampl: printf "josen"; jose ampl:
printf "jose perez mateos"; jose perez mateosampl: printf "jose
perez mateosn"; jose perez mateos ampl: printf "njose nperez
nmateosn"; jose perez mateos ampl: printf "njose nperez
nmateosnn"; jose perez mateos ampl: printf "ntjose ntperez
ntmateosnn"; jose perez mateos ampl: printf "ntjose
nttperez ntttmateosnn"; jose perez mateos
ampl:

Resolución
automatizada o por lotes (batch). Creación de un fichero
.run

• Introducción

Una alternativa cómoda al modo interactivo usado
anteriormente se tiene usando un fichero .run. De este modo se
indica de una sola vez al procesador de comandos de AMPL todo lo
que queremos que haga. Es lo que se denomina ejecución por
lotes. Para ello ponemos tales comandos conjuntamente en un
fichero .run que ejecutamos en el procesador de comandos por
medio de la instrucción incluye.

Ejemplo para resolver el problema de Problema Lineal
establecido en la Parte II, secciones 2 y 3 (modelo
explícito), suponiendo que hemos guardado el fichero .mod
en D:userejemplo1.mod, se procede como sigue:. Con el editor
pfe32.exe creamos el fichero ejemplo1.run siguiente:

# intruccion para eliminar de la memoria de AMPL el
modelo y los datos anteriores reset; # intruccion para enviar al
procesador de AMPL el modelo actual model D:usersejemplo1.mod;
# intruccion para elegir solver (en este caso elegimos el cplex)
option solver cplex; # intruccion para que el solver elegido
actue solve; # intruccion para mostrar en pantalla los valores
optimos de las variables indicadas display x1, x2; # intruccion
para mostrar en pantalla el valor optimo de la funcion objetivo
display objetivo; Nota: Es claro que podemos suprimir todas las
líneas de comentarios que siguen al signo #.

• Una forma práctica de
  proceder

Una forma sencilla de ejecutar los comandos introducidos
en el fichero de comandos ejemplo1.run es la
siguiente.

• primero se guarda el archivo con extensión
  .run, es decir, en nuestro caso el fichero
  ejemplo1.run.

• a continuación se activa el fichero sw.exe y
  en el se escribe ampl para que aparezca el prompt de AMPL
  (ampl:).

• después con el comando include se
  incluyen en bloque los comandos escritos en ejemplo1.run;
  para ello se escribe include seguido del camino o "path" que
  localiza este fichro en el ordenador. Por ejemplo, si hemos
  guardado el fichero ejemplo1.run en el disco D,
  ponemos:

include D:usersejemplo1.run;

• se pulsa la tecla return.

• Ejemplo resumen

Una fichero . run con todo lo explicado hasta
aquí es el siguiente:

# fichero ejemplo1b.run # fichero .run para un problema
de Programacion Lineal ; # inclusion de sufijos y otros comandos
# intruccion para eliminar de la memoria de AMPL el modelo y los
datos anteriores reset; # intruccion para enviar al procesador de
AMPL el modelo actual model D:usersejemplo1.mod; # intruccion
para elegir solver (en este caso elegimos el cplex) option solver
cplex; # intruccion para que el solver elegido actue solve; #
instrucion para mostrar en pantalla un rotulo fijo elegido por
nosotros printf "n mostrar en pantalla los valores optimos de
las variables indicadas "; # intruccion para mostrar en pantalla
los valores optimos de las variables indicadas con sufijos
display x1, x1.val, x1.lb, x1.ub, x1.rc; display x2, x2.val,
x2.lb, x2.ub, x2.rc; # intruccion para mostrar en pantalla las
restricciones indicadas con sufijos display res1, res1.body,
res1.dual, res1.slack; display res2, res2.body, res2.dual,
res2.slack; # intruccion para mostrar en pantalla el valor optimo
de la funcion objetivo display objetivo; # intruccion para
mostrar en pantalla las componentes del modelo actual (variables,
restricciones y objetivo) show; # intruccion para mostrar en
pantalla el modelo actual expandido (sin las restriciones de no
negatividad ni cotas) expand; Nota: Es claro que podemos suprimir
todas las líneas de comentarios que siguen al signo
#.

• Nota

Puede resultar cómodo incluir en el fichero .run
el camino o path donde localizar el propio fichero para luego
copiarlo fácilmente en la ventana sw.exe. Es decir, al
final del programa anterior, podemos añadir:

# intrucción a copiar en el programa AMPL (dentro
de la ventana sw.exe) # para facilitar a AMPL la ubicación
de este fichero # include D:usersejemplo1b.run;

• Ejercicios sobre problemas mochila

A. Mochila continua sin cotas. Se trata de resolver el
problema: maximizar z=16*x1+22*x2+12*x3+8*x4 ; sujeta a:
5*x1+7*x2+4*x3+3*x4 <= 14 x1>=0, x2>=0, x3>=0,
x4>=0 # fichero mochila1.mod # declaracion de las
variables y de su no negatividad var x1>=0; var x2>=0; var
x3>=0; var x4>=0; # declaracion de las restricciones
subject to res1: 5*x1 + 7*x2 + 4*x3 + 3*x4 <= 14; # la palabra
res1 es elegible a gusto personal # declaracion de la funcion
objetivo # la palabra objetivo es elegible a gusto personal
maximize objetivo: 16*x1+22*x2+12*x3+8*x4 ; B. Mochila continua
con cotas. Se trata de resolver el problema: maximizar
z=16*x1+22*x2+12*x3+8*x4 ; sujeta a: 5*x1+7*x2+4*x3+3*x4 <= 14
0<=x1<=1, 0<=x2<=1, 0<=x3<=1,
0<=x4<=1.

# fichero mochila2.mod # declaracion de las
variables, de su no negatividad y de sus cotas var
x1>=0,<=1; var x2>=0,<=1; var x3>=0,<=1; var
x4>=0,<=1; # declaracion de las restricciones subject to
res1: 5*x1 + 7*x2 + 4*x3 + 3*x4 <= 14; # la palabra res1 es
elegible a gusto personal # declaracion de la funcion objetivo #
la palabra objetivo es elegible a gusto personal maximize
objetivo: 16*x1+22*x2+12*x3+8*x4 ;

C. Mochila entera sin cotas. Se trata de resolver
el problema: maximizar z=16*x1+22*x2+12*x3+8*x4 ; sujeta a:
5*x1+7*x2+4*x3+3*x4 <= 14 x1>=0, x2>=0, x3>=0,
x4>=0 y enteras.

# fichero mochila3.mod # declaracion de las
variables, de su no negatividad y de ser enteras var
x1>=0,integer; var x2>=0,integer; var x3>=0,integer; var
x4>=0,integer; # declaracion de las restricciones subject to
res1: 5*x1 + 7*x2 + 4*x3 + 3*x4 <= 14; # la palabra res1 es
elegible a gusto personal # declaracion de la funcion objetivo #
la palabra objetivo es elegible a gusto personal maximize
objetivo: 16*x1+22*x2+12*x3+8*x4 ;

D. Mochila binaria. Se trata de resolver el
problema: maximizar z=16*x1+22*x2+12*x3+8*x4 ; sujeta a:
5*x1+7*x2+4*x3+3*x4 <= 14 x1, x2, x3, x4 binarias.

# fichero mochila4.mod # declaracion de las
variables y de ser binarias var x1 binary; var x2 binary; var x3
binary; var x4 binary; # declaracion de las restricciones subject
to res1: 5*x1 + 7*x2 + 4*x3 + 3*x4 <= 14; # la palabra res1 es
elegible a gusto personal # declaracion de la funcion objetivo #
la palabra objetivo es elegible a gusto personal maximize
objetivo: 16*x1+22*x2+12*x3+8*x4 ;

Conjuntos.
Creación de fichero .dat

Para lo que sigue puede ser útil disponer de
ficheros en los que se dan ejemplos de modelos concretos ya
elaborados. En la página de www.ampl.com se dispone de los
siguientes de "Examples from the AMPL book".

• Un método de búsqueda:

• En la parte alta pinchar en BOOK.

• El la columna de la izquierda pinchar en
  examples.

• Pinchar en by filename.

• Otro método de búsqueda:

• En la parte alta pinchar en EXAMPLES.

• En el apartado "Examples from the AMPL book" pinchar
  en by filename.

• Conjuntos simples e índices

• Conjuntos simples definidos
  explícitamente

El tipo más sencillo de conjunto está
definido explícitamente mediante sus elementos como
sucesión de caracteres. Así podemos definir en el
archivo .mod dos conjuntos mediante las declaraciones:

set ORIGENES; set DESTINOS; y en el archivo de datos (
xxx.dat) especificar sus elementos del siguiente modo: set
ORIGENES:= orig1 orig2 orig3 ; set DESTINOS:=
dest1,dest2,dest3,dest4; Esta forma de definición de
conjuntos suele hacerse sólo para conjuntos
pequeños, donde, además, se quiere conservar el
nombre de los elementos.

• Conjuntos simples definidos
  implícitamente. Índices

Los tipos de conjuntos más utilizados son los
conjuntos de números, y generalmente van a corresponder a
los conjuntos de índices de un modelo. Por ejemplo, para
definir un conjunto de 12 elementos con nombre origenes,
basta declarar: set ORIGENES:= 1..12; Aunque la anterior
declaración es válida, es más conveniente
declarar en el modelo:

param m; set ORIGENES:= 1..m; y en el fichero de datos
especificar:

param m:=12; De esta forma se logra la separación
efectiva entre el modelo y los datos. Cuando en la
definición de un conjunto interviene un periodo distinto
de 1, esto puede indicarse mediante la cláusula
by, indicando el periodo. Por ejemplo, son
equivalentes:

set QUINQUENIOS:={1990, 1995, 2000, 2005, 2010, 2015,
2020}; set QUINQUENIOS:=1990..2020 by 5;

• Conjuntos de pares ordenados

A partir de conjuntos simples es posible formar
conjuntos compuestos. El más sencillo de todos ellos es el
producto cartesiano o conjunto de pares ordenados. Es útil
para manejar matrices de datos como cij o variables con dos
índices como xij. Hay varias formas de manejar tales
situaciones.

• Forma implícita: no se da nombre
  explícitamente al nuevo conjunto, pero se definen
  parámetros o variables sobre dicho conjunto. Por
  ejemplo:

param coste {ORIGENES,DESTINOS}>=0; # indica el coste
unitario del transporte var Transp {ORIGENES,DESTINOS}>=0; #
indica la cantidad a transportar Este método se usa en el
ejemplo que más adelante veremos en los ficheros
transp.mod y transp.dat.

• Forma explícita completa (se consideran
  todos los pares ordenados): se da nombre
  explícitamente al nuevo conjunto y, en su caso, se
  definen parámetros o variables sobre dicho conjunto.
  Por ejemplo:

set RUTAS:={ORIGENES, DESTINOS}; param coste
{RUTAS}>=0; # indica el coste unitario del transporte var
transp {RUTAS}>=0; # indica la cantidad a
transportar

• Forma explícita imcompleta (no se
  consideran todos los pares ordenados): se da nombre
  explícitamente al nuevo conjunto y, en su caso, se
  definen parámetros o variables sobre dicho conjunto.
  Por ejemplo:

set RUTAS within {ORIGENES, DESTINOS}; param coste
{RUTAS}>=0; # indica el coste unitario del transporte var
Transp {RUTAS}>=0; # indica la cantidad a
transportar

• Conjuntos de n-uplas

De la misma forma que para pares, pueden definirse
parámetros y variables con tres o más
índices, definiendo primero los conjuntos simples y
después el producto cartesiano. Así, por ejemplo,
si se han definido tres conjuntos con nombres PRODUCTOS, PERIODOS
y METODOS, y queremos definir una variable con tres
índices xijk basta poner:

var x {PRODUCTOS, PERIODOS,METODOS,}>=0; y del mismo
modo para los parámetros.

• Parámetros y expresiones

Los datos de un modelo se introducen en este mediante su
declaración como parámetros. Son posibles varias
situaciones:

• Parámetros unidimensionales. Basta una
  declaración del tipo:

param m;

• Parámetros vectoriales. Se asocian a
  conjuntos simples. Si DESTINOS es un conjunto simple, basta
  una declaración del tipo:

param demanda {DESTINOS}; Una alternativa
válida es poner:

param demanda {i in DESTINOS};

• Parámetros matriciales. Se asocian a
  conjuntos de pares ordenados. Si RUTAS es un conjunto de
  pares ordenados, basta una declaración del
  tipo:

param coste {RUTAS}; Alternativas válidas
son:

param coste {(i,j) in RUTAS}; param coste {i in ORIGENES
, j in DESTINOS}; En este último caso se supone que
ORIGENES y DESTINOS son conjuntos simples.

Restricciones sobre parámetros. (ver los
apuntes Breve introducción al programa AMPL de
Jesús Sáez Aguado, de fecha 18 de febrero de 2004,
p. 11).

Parámetros calculados. (ver los apuntes
Breve introducción al programa AMPL de
Jesús Sáez Aguado, de fecha 18 de febrero de 2004,
p. 12).

Expresiones. Para la construcción de
modelos de optimización un operador muy utilizado es
sum, que suma cierta expresión cuando se
recorre los elementos de un conjunto, y corresponde a los
sumatorios en modelos matemáticos. Así se pueden
usar expresiones del tipo:

sum {i in ORIGENES} oferta[i]; sum {j in DESTINOS}
demanda [j]; sum {(i,j) in RUTAS} coste[i,j]; sum {i in ORIGENES,
j in DESTINOS} coste[i,j];

• Comandos más utilizados

Comandos / Acción

data Lee el contenido de un archivo
.dat.

display Muestra en pantalla los valores de
conjuntos, parámetros y variables.

expand Expande el modelo actual.

include Incluye ficheros externos.

model Lee el contenido de un archivo
.mod.

printf Muestra en pantalla textos con
formato.

reset Elimina de la memoria de AMPL el modelo y
los datos anteriores.

reset data Elimina de la memoria de AMPL los
datos anteriores.

show Muestra las componentes del modelo
actual.

solve Resuelve el modelo actual.

• Ejercicios sobre la teoría
  anterior

• El problema del transporte (Winston p.
  337).

• El problema de la dieta (Winston p. 79).

• El problema de producción (ver los apuntes
  Breve introducción al programa AMPL de
  Jesús Sáez Aguado, de fecha 18 de febrero de
  2004, p. 252).

• El problema de flujo con coste mínimo
  (Winston p. 445 o alguno de los enunciados en la p.
  452).

• El problema del camino más corto (Winston p.
  396).

• El problema de flujo máximo (Winston p.
  402).

Otros
comandos

• El comando LET

• Sirve para asignar o cambiar el valor de un
  parámetro ya declarado.

• Ejemplo para un parámetro simple.

param a; let a:=5; display a; let a:=10;

• Ejemplo para un parámetro vectorial.
  Supongamos que se tiene declarado el conjunto DESTINOS y sobe
  el mismo los parametros oferta y demanda. Conocido este
  último, podemos poner:

let {i in DESTINOS} ofera[i]:=demanda[i];

• El comando FOR

• Sirve para ejecutar repetidamente una serie de
  comandos (bucle) que se escribe entre llaves, es decir, en la
  forma { serie de comandos}.

• Ejemplo sencillo.

for {i in 1..n} {serie de comandos}.

• Ejemplo si se tiene un conjunto simple cualquiera,
  llamémosle CONTADOR.

for {i in CONTADOR} {serie de comandos}.

• Ejemplo más complejo. Supongamos que en un
  modelo hay un parámetro llamado tasa y queremos
  resolver el modelo para los siguientes valores de tasa: 8, 9,
  10, 11 y 12. Puede hacerse lo siguiente:

set VALORES:= 8 9 10 11 12; for {t in VALORES} {let
tasa:=t; solve; display; }

• Ejercicios

• Del problema del CPM (ver fichero lasana03.doc en mi
  página web).

• Del problema del PERT.

• Otros ejercicios

Autor:

Iván José Pablo Turmero Astros