Prácticas de Optimización - Departamento de Matemática Aplicada

Prácticas de Optimización
Jose Salvador Cánovas Peña & Silvestre Paredes Hernández
Departamento de Matemática Aplicada y Estadística
Contents
1 Optimización con MAXIMA
1.1 Optimización sin restricciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Optimización con restricciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3
1.2.1 Paquete cobyla . . . . . . . . . . . . . . .
1.2.2 Función augmented_lagrangian_method
Optimización lineal . . . . . . . . . . . . . . . . .
1.3.1 Función linear_program . . . . . . . . . .
1.3.2 Funciones minimize_lp y maximize_lp .
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
9
9
12
13
14
14
Chapter 1
Optimización con MAXIMA
MAXIMA tiene implementados una serie de comandos para resolver problemas de optimización. Se incluyen
comandos para optimización con restricciones (fmin_cobyla, augmented_lagrangian_method), sin restricciones
(lbfgs) y lineal (simplex). También se implementan comandos para la resolución de ecuaciones no lineales
(mnewton) y para problemas de ajustes de funciones (lsquares, minpack), aunque en esta práctica sólo introduciremos los primeros.
En casi todos los algoritmos numéricos de optimización se procede de la misma forma; se toma un valor o
aproximación inicial y se construye una sucesión de aproximaciones para las que el valor de la función objetivo o
criterio de rendimiento va decreciendo (o creciendo según el objetivo del problema). Para encontrar una nueva
aproximación, a partir de una dada, en casi todos los métodos existe una estructura fundamental: Se comienza
desde un punto inicial x0 , a continuación se determina mediante una regla (el método elegido) una dirección
de movimiento, y se avanza por esa dirección hasta llegar a un mínimo (relativo) de la función objetivo sobre
ella. Ese nuevo punto, es ahora el punto de partida desde el que reiniciar el proceso. El esquema general sigue
el siguiente esquema:
x0
xk+1
: Aproximación inicial
= xk + αk dk po
siendo xk es la aproximación k—ésima, dk es la dirección, llamada de descenso, a lo largo de la cual la función
objetivo va decreciendo y αk que sería la cantidad de movimiento que se debe realizar en la dirección dk .
Como se puede suponer la diferencia entre los métodos radica en la regla mediante la cual se selecciona la
dirección de movimiento en cada paso del algoritmo. El proceso de búsqueda del mínimo sobre la recta se llama
búsqueda lineal. Una vez fijada la dirección de movimiento, el valor de la función objetivo depende solamente
de una variable, que es precisamente la longitud recorrida en la dirección elegida
1.1
Optimización sin restricciones
Las funciones empleadas por MAXIMA para resolver problemas de optimización sin restricciones se resumen en
la siguiente tabla:
Método
lbfgs
Descripción
Minimización sin restricciones
Algoritmo
Cuasi Newton BFGS
Función lbfgs
La función lbfgs implementa el llamado algoritmo L-BFGS (método de Broyden-Fletcher-Goldfarb-Shanno con
Limitación de memoria) para resolver el problema de minimización sin restricciones
min
f (x)
x ∈ Rn
2
Antes de poder utilizar este comando, es necesario cargar la librería correspondiente con el comando load de
esta forma:
load(lbfgs);
La forma de utilizar lbfgs viene dada en la siguiente tabla
lbfgs(Fobj, X, X0, epsilon, iprint)
lbfgs( [Fobj, Grad], X, X0, epsilon, iprint)
Cálculo automático de ∇f (x) .
∇f (x) definido por el usuario.
Todos los parámetros son obligatorios, salvo Grad. Cuando este argumento está presente, debe contener
el gradiente de la función objetivo Fobj respecto de las variables X. La variable Grad puede ser una lista o
una función que devuelva una lista con igual número de elementos que X. Si esta variable no está presente, el
gradiente se calcula automáticamente mediante derivación simbólica.
El cometido de este comando es encontrar una aproximación a la solución del problema de minimización sin
restricciones cuya función objetivo viene dada por Fobj y variables de decisión dadas en X, para ello se toma
como aproximación inicial la contenida en el vector X0, de tal manera que se cumpla la siguiente desigualdad
|| Grad(X) || < epsilon*max(1, || X || )
(1.1)
siendo ||·|| la norma cuadrática del vector correspondiente.
El argumento iprint es un vector que controla los mensajes que aparecen en pantalla durante el proceso.
Cada componente se describe a continuación:
iprint[1]
Descripción
Frecuencia de los mensajes
Valores
<0
=0
>0
Interpretación
No se envían mensajes. Sólo la solución.
Mensajes únicamente en la primera y última iteraciones.
Imprime un mensaje cada iprint[1] iteraciones.
iprint[2]
Cantidad de información
=0
Imprime contador de iteraciones,
número de evaluaciones de FOM,
valor de FOM,
módulo de gradiente FOM y
amplitud del paso
Igual que para el valor 0, pero incluye X0
y el gradiente de FOM evaluado en X0.
Igual que para el valor 1,
incluyendo los valores de X en cada iteración.
Igual que para el valor 2,
incluyendo el gradiente de FOM en cada iteración.
=1
=2
=3
Las columnas que devuelve lbfgs son los siguientes:
Nombre
I
NFN
FUNC
GNORM
STEPLENGTH
DESCRIPCIÓN
Número de iteraciones. Se incrementa tras cada búsqueda lineal.
Número de evaluaciones de la función objetivo.
Valor de la función objetivo al final de cada iteración.
Módulo del gradiente de la función objetivo al final de cada iteración.
Un parámetro interno del algoritmo de búsqueda.
Example 1 Por ejemplo, si queremos encontrar el mínimo de la función f (x) = x sen (x + 1) utilizando a 0
como aproximación inicial, utilizamos el comando
lbfgs(x*sin(x + 1), [x], [0],1e-4, [1,0])
3
cuya respuesta es
N= 1 NUMBER OF CORRECTIONS=25
INITIAL VALUES
F= 0.000000000000000D+00 GNORM= 8.414709848078965D-01
*************************************************
I NFN FUNC
GNORM
STEPLENGTH
1 3
-2.400322755462485D-01 1.932430953437936D-02 6.068590410450232D-01
2 4
-2.401194982937205D-01 4.813037906504836D-03 1.000000000000000D+00
3 5
-2.401252441267841D-01 1.071982675449057D-05 1.000000000000000D+00
THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
IFLAG = 0
(%o36) [x=-0.52026367101869]
Podemos comprobar que se trata de un mínimo local, ya que si realizamos la representación de la función en el
intervalo mediante el comando
wxplot2d(x* sin(x + 1), [x,-10, 10] )
obtendremos la siguiente representación
Representación gráfica de x ∗ sen (x + 1)
donde podemos observar que el mínimo global del problema se encuentra cercano al punto 10¨, bastante alejado
de la solución que se ha encontrado con la función lbfgs. Debido a la presencia de la función periódica sen (·),
es posible deducir que la función no tendrá mínimo (ni máximo) global.
El punto que ha suministardo la rutina depende del punto de partida elegido, para comprobarlo, cambiaremos
el punto de partida. Así, por ejemplo, si utilizamos el valor X0=2, y llamamos de nuevo a la función
lbfgs(x*sin(x + 1), [x], [2],1e-4, [-1,0])
obtendremos como solución
N= 1 NUMBER OF CORRECTIONS=25
INITIAL VALUES
F= 2.822400161197344D-01 GNORM= 1.838864985141024D+00
*************************************************
I NFN FUNC
GNORM
STEPLENGTH
1 5
-3.838086557765887D+00 9.884041156093981D-02 1.053260970366502D+00
2 7
-3.839222860317910D+00 5.647031582457496D-04 2.074409490772091D-01
3 8
-3.839222897150713D+00 2.974017014767405D-06 1.000000000000000D+00
THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
IFLAG = 0
(%o36) [x=3.95975816226166]
4
Y comprobamos, efectivamente, que la respuesta dada ahora no coincide con la obtenida con anterioridad,
también podemos comprobar en la gráfica 1.1 que se trata de otro mínimo local. Está claro que el punto de
partida es fundamental a la hora de obtener una u otra solución. El valor devuelto por el comando de MAXIMA,
en este caso lbfgs, es aquel que cumple unos determinados criterios.
Podemos emplear la misma instrucción para funciones de varias variables, especificando en cada caso
¡ 2 un valor
¢
inicial
en
cada
variable,
por
ejemplo,
para
localizar
un
mínimo
local
de
la
función
f
(x,
y)
=
cos
x − 3y +
¡ 2
¢
sen x + y 2 cerca del punto (1, 1) utilizaremos la expresión:
lbfgs( cos(x^2-3*y) + sin(x^2+y^2), [x,y], [1,1], 1e-3, [-1,0])
En este caso tanto el vector X=[x,y], como el vector X0=[1,1] tienen dos componentes. La respuesta que
proporciona la función es:
[x = 1.376379353356124, y = 1.678681594080048]
Si representamos (ver en la gráfica 1.2) la función mediante el comando:
plot3d(cos(x^2-3*y) + sin(x^2+y^2), [x,-2,2], [y,-2,2])
podemos ver que la función tiene infinitos máximos y mínimos y por tanto, como en el ejemplo en una variable,
Figure 1.1: Minimización en 2 variables.
la respuesta dependerá del punto de partida. En este caso también es interesante representar gráficamente los
isocontornos de la función. Si utilizamos el comando:
contour_plot(cos(x^2-3*y)+sin(x^2+y^2), [x,-2,2], [y,-2,2], [legend,false], [gnuplot_preamble,"set cntrparam levels 20"]);
obtendremos la gráfica 1.3:
5
¡
¢
¡
¢
Isocontornos de la función cos x2 − 3y + sen x2 + y 2 .
donde se pueden observar las zonas donde se encuentran los extremos locales.
Si no se especifica, el gradiente se calcula automáticamente y de forma simbólica, no obstante es posible
incluirlo como argumento en la función lbfgs, como en el siguiente ejemplo:
Example 2 Encuentra mediante lbfgs el mínimo de la función
F (x, y, z) = (x − 5)2 + (y − 3)4 + (z − 2)6
Incluye en la resolución el gradiente de la función objetivo.
load(lbfgs)
F(x, y, z):=(x - 5)^2 + (y - 3)^4 + (z - 2)^6;
define(F_grad(x,y,z), map(lambda([t], diff(F(x,y,z),t)), [x,y,z]))
solucion : lbfgs([F,F_grad], [x,y,z], [0,0,0], 1e-4, [1, 0]);
el resultado del código anterior se refleja en la siguiente tabla:
*************************************************
N= 3 NUMBER OF CORRECTIONS=25
INITIAL VALUES
F= 1.700000000000000D+02 GNORM= 2.205175729958953D+02
*************************************************
I
NFN FUNC
GNORM
STEPLENGTH
1
2
6.632967565917637D+01 6.498411132518770D+01 4.534785987412505D-03
15 16
7.683645404048677D-06
6.011057038099202D-04
1.000000000000000D+00
THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
IFLAG = 0
(%o36) [x=5.000086823042934,y=3.052395429705181,z=1.927980629919583]
Teniendo en cuenta que estamos buscando el mínimo de una función que es siempre positiva por ser suma
de cuadrados, la solución óptima del problema se encuentra en el único punto donde se anula la función:
x∗ = (5, 3, 2) , por tanto
F (x, y, z) ≥ 0 = F (5, 3, 2)
6
Podemos comprobar el error cometido por la rutina al tomar como solución aproximada al número obtenido en
%o36:
x = (5.000086823042934, 3.052395429705181, 1.927980629919583)
kx∗ − xk = 0.0891
Y comprobamos que se cumple la condición (1.1)
³
´
∇F (x, y, z) =
2 (x − 5) , 4 (y − 3)3 , 6 (z − 2)5 ⇒ k∇F (x)k = 6.011057038099343e − 04
epsilon* max {1, kxk} = 1e − 4 ∗ max {1, 6.167259959382106} = 6.167259959382106e − 04
que es el criterio de parada utilizado por el comando lbfgs.
Es posible definir las funciones empleadas como variables
load(lbfgs)
F : (x - 5)^2 + (y - 3)^4 + (z - 2)^6;
F_grad: [diff(F,x), diff(F,y), diff(F,z)]
solucion : lbfgs([F,F_grad], [x,y,z], [0,0,0], 1e-4, [1, 0]);
Variables de sistema relacionadas
Hay dos variables relacionadas con la función lbfgs y que describimos a continuación:
• lbfgs_nfeval_max (Valor por defecto: 100)
La variable lbfgs_nfeval_max almacena el número máximo de evaluaciones que lbfgs utiliza en la función
objetivo. Cuando se alcanza el valor lbfgs_nfeval_max, la función lbfgs devuelve el resultado de la última
iteración. Este límite evita que se pueda entrar en un bucle debido a la precisión finita del ordenador.
• lbfgs_ncorrections (Valor por defecto: 25)
La variable lbfgs_ncorrections está relacionada con el algoritmo de optimización empleado y tiene que ver
con una aproximación a la inversa de la matriz hessiana en cada punto.
A continuación se incluyen algunos ejemplos del uso de la función lbgfs.
Example 3 Resuelve el siguiente problema con MAXIMA
2
min e−x
Solución:
load (lbfgs)
fobjetivo(x) := exp(-x^2);
x0: [0.5];
epsilon:1e-3;
output:[1,0];
lbfgs(fobjetivo(x),[x],x0,epsilon,output);
7
que tiene por salida la siguiente
N= 1 NUMBER OF CORRECTIONS=25
INITIAL VALUES
F= 7.788007830714049D-01 GNORM= 7.788007830714049D-01
*************************************************
I NFN FUNC
GNORM
STEPLENGTH
1 2
1.053992245618643D-01 3.161976736855930D-01 1.284025416687741D+00
2 3
8.499465465214358D-03 3.711747613438485D-02 1.000000000000000D+00
3 4
5.667470485332136D-03 2.578048134689472D-02 1.000000000000000D+00
4 5
2.120490154477348D-03 1.052251059218531D-02 1.000000000000000D+00
5 6
1.024155213369504D-03 5.374185440592811D-03 1.000000000000000D+00
6 7
4.587713525504515D-04 2.543920635365517D-03 1.000000000000000D+00
THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
IFLAG = 0
(%o31) [x=2.772536494729975]
También es posible definir la función en forma de variable:
fobjetivo : exp(-x^2);
En este caso la llamada a la función lbfgs sería:
lbfgs(fobjetivo,[x],x0,epsilon,output);
Example 4 Resuelve el siguiente problema con MAXIMA
min x2 + y 2
Solución:
fobjetivo(x,y) := x^2 + y^2;
x0: [0.5, 0.5];
epsilon:1e-3;
output:[1,0];
lbfgs(fobjetivo(x,y),[x,y],x0,epsilon,output);
que tiene por salida la siguient
N= 2 NUMBER OF CORRECTIONS=25
INITIAL VALUES
F= 5.000000000000000D-01 GNORM= 1.414213562373095D+00
*************************************************
I NFN FUNC
GNORM
STEPLENGTH
1 2
1.053992245618643D-01
5.857864376269047D-01
7.071067811865475D-01
2 3
8.578643762690490D-02
3.711747613438485D-02
1.000000000000000D+00
3 4
0.000000000000000D+00 0.000000000000000D+00 1.000000000000000D+00
THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
IFLAG = 0
(%o36) [x=0.0,y=0.0]
Como antes también es posible definir la función como una variable
fobjetivo(x) := exp(-x^2);
y en este caso la llamada a la función lbfgs sería:
lbfgs(fobjetivo, [x,y], x0, epsilon, output);
8
Actividad 1 Halla los extremos locales y globales de f (x) = x3 − 12x + 3 en el intervalo [−4, 4].
Actividad 2 Estudia los extremos relativos y absolutos de las siguientes funciones
f (x, y) = x2 + 3xy − y 2
f (x, y) = x3 + 3xy 2 − 15x − 12y
f (x, y) = sen x + sen y + cos (x + y) 0 < x, y < 2π
Actividad 3 Dada la función
h
ih
i
f (x, y) = x2 + (y + 1)2 x2 + (y − 1)2
1.2
Optimización con restricciones
Las funciones empleadas por MAXIMA para resolver problemas de optimización con restricciones se resumen en
la siguiente tabla:
Método
fmin_cobyla
augmented_lagrangian_method
1.2.1
Descripción
Minimización con restricciones
Minización con restricciones h (x) = 0
Algoritmo
Aproximaciones lineales sucesivas.
Función de penalización.
Paquete cobyla
El nombre de COBYLA es la abreviatura en inglés de Constrained Optimization BY Linear Aproximacion, es
decir, optimización con restricciones mediante aproximaciones lineales.
COBYLA se utiliza para resolver problemas del tipo
min
s.a.
f (x)
g (x) ≥ 0
Las restricciones en forma de igualdades se pueden sustituir por pares de desigualdades:
⎧
⎨ h (x) ≥ 0
h (x) = 0 ⇐⇒
⎩
−h (x) ≤ 0
No obstante la interfaz MAXIMA para COBYLA admite restricciones de igualdad transformándolas luego
internamente a pares de desigualdades.
El algoritmo hace uso de aproximaciones lineales, tanto de la función objetivo como de las funciones de
restricción; tales aproximaciones se hacen mediante interpolación lineal de n+1 puntos en el espacio de variables.
Los puntos de interpolación son los vértices de un símplex (símplice o simplejo) que es la extensión a dimensión
n de un triángulo en dimensión 2. Así un simplex en dimensión 3 sería un tetraedro (ver figura).
El parámetro RHO controla el tamaño del símplex y se reduce automáticamente de RHOBEG a RHOEND.
Para cada valor del parámetro RHO la subrutina intenta alcanzar un vector adecuado de variables para el
tamaño actual, reduciéndose entonces RHO hasta alcanzar el valor de RHOEND. Por eso, tanto a RHOBEG
como a RHOEND se les deben asignar valores razonables, lo que requeriría cierto trabajo empírico previo.
La rutina trata cada restricción individualmente, en lugar de considerarlas todas dentro de una función de
penalización.
9
Figure 1.2: Tetraedro (simplex en dimensión 3).
Función fmin_cobyla
Antes de su uso, se debe cargar la librería correspondiente con la instrucción load
load(fmin_cobyla);
El uso de fmin_cobyla viene dado en la siguiente tabla
fmin_cobyla(FObj, X, X0)
fmin_cobyla(FObj, X, X0, optional_args)
Devuelve una aproximación del valor mínimo de la expresión FObj respecto de las variables X, sujeta a un
conjunto opcional de restricciones. X0 es una lista que contiene la aproximación inicial en X. FObj debe ser
una expresión ordinaria, no valen nombres de funciones ni expresiones tipo lambda (ver manual de MAXIMA).
X es un vector de variables de n componentes.
El parámetro optional_args hace referencia a argumentos adicionales, que se especifican en la forma symbol
= value. Los argumentos opcionales que se reconocen son:
• constraints
Lista de restricciones en forma de desigualdades e igualdades que debe satisfacer X. Las restricciones de
desigualdad deben ser de la forma g(X) >= h(X) o g(X) <= h(X). Las restricciones de igualdad deben ser de la
forma g(X) = h(X).
• rhobeg
Valor inicial de la variable interna RHO, que controla el tamaño del simplex. Su valor por defecto es 1.0.
• rhoend
El valor final deseado para el parámetro RHO. Es aproximadamente la precisión de las variables. Su valor
por defecto es 1d-6.
10
• iprint
Nivel de información de salida. Los posibles valores se indican en la siguiente tabla, su valor por defecto
es 0.
iprint
Descripción
Nivel de información de salida
.
Valores
0
1
2
3
Interpretación
Sin información de salida.
Sumario al final de los cálculos.
Se van mostrando los nuevos valores de RHO y SIGMA,
incluyendo el vector de variables.
Como en 2, pero la información se muestra
cuando se calcula F(X).
• maxfun
Número máximo de evaluaciones de la función. Su valor por defecto es 1000.
El resultado que devuelve la función fmin_cobyla es un vector cuyas componentes están descritas en la
siguiente tabla:
Componente
1
2
3
4
Interpretación
Los valores de las variables en las que se alcanza el valor mínimo.
Es una lista de elementos de la forma var = value para cada una de las variables listadas en X
El valor mínimo de la función objetivo.
El número de evaluaciones de la función.
Código de respuesta con los siguientes significados:
0 - No ha habido errores
1 - Alcanzado el número máximo de evaluaciones de la función.
2 - Los errores de redondeo han impedido el avance del proceso.
Example 5 Resuelve el siguiente problema con MAXIMA
min
xy
s.a. 1 − x2 − y 2 ≥ 0
Solución:
load (fmin_cobyla);
fobjetivo(x,y) := x*y;
x0: [1, 1];
fmin_cobyla(fobjetivo(x,y),[x,y], x0, constraints=[x^2+y^2<=1], iprint=1);
que tiene por salida la siguiente:
Normal return from subroutine COBYLA
NFVALS = 66 F =-5.000000E-01 MAXCV = 1.999845E-12
X = 7.071058E-01 -7.071077E-01
(%o6) [[x=0.70710584934848,y=-0.7071077130248],-0.49999999999926,66,0]
También es posible definir la función como una variable de esta forma
fobjetivo : x*y;
en este caso la llamada a la función fmin_cobyla sería:
fmin_cobyla(fobjetivo,[x,y], x0, constraints=[x^2+y^2<=1], iprint=1);
11
1.2.2
Función augmented_lagrangian_method
La función augmented_lagrangian_method minimiza el llamado lagrangiano aumentado (o penalizado) haciendo
uso del algoritmo LBFGS, se utiliza para problemas del tipo:
min
s.a.
f (x)
h (x) = 0
que se transforma en un problema sin restricciones de la forma
min f (x) +
m
X
λ2i h2i (x)
i=1
Como el sumatorio está formado por términos positivos, cualquier valor de x que no sea factible (h (x) 6= 0)
contribuirá con un valor positivo y será penalizado frente a puntos que si son factibles (h (x) 6= 0).
Antes de su uso, se debe cargar la librería correspondiente con la instrucción load:
load(augmented_lagrangian);
El uso de augmented_lagrangian_method viene dado en la siguiente tabla
augmented_lagrangian_method(FObj, X, R, X0)
augmented_lagrangian_method(FObj, X, R, X0, optional_args)
augmented_lagrangian_method([FObj, Grad], X, R, X0)
augmented_lagrangian_method([FObj, Grad], X, R, X0, optional_args)
La función devuelve una aproximación del valor mínimo de la función objetivo FObj respecto de las variables
dadas en el vector X y manteniendo las restricciones definidas en R igual a cero. La lista X0 contiene las
aproximaciones iniciales para X.
Si Grad está presente en la llamada a la función, se interpreta como el gradiente de la función FObj respecto
de las variables X y estará representado como una lista de tantas expresiones como variables tenga X. Si el
argumento Grad no está, se calculará de forma automática.
El argumento optional_args hace referencia a argumentos adicionales, los cuales se especifican de la forma
symbol = value. Estos argumentos son:
niter
lbfgs_tolerance
iprint
lambda
Descripción
Número de iteraciones del algoritmo
Tolerancia del algoritmo
Lista de dos enteros que
controlan la frecuencia de mensajes y la
cantidad de información en cada mensaje
durante el proceso.
Valores/Interpretación
Ver función lbfgs
Valor inicial de %lambda que será utilizado
para calcular el lagrangiano aumentado.
Example 6 Resuelve el siguiente problema con MAXIMA y la función augmented_lagrangian_method
min x2 + 2y 2
s.a. x + y = 1
12
Solución:
load (augmented_lagrangian);
FObj(x,y) := x^2 + 2*y^2;
R : [x+y-1];
x0: [1, 1];
augmented_lagrangian_method(FObj(x,y), [x,y], R, x0, iprint=[-1,0]);
que tiene por salida la siguiente:
[[x=0.66665984108002,y=0.33334027245545], %lambda=[-1.333337940892525]]
También es posible definir la función como una variable:
FObj : x^2+2*y ^2;
en este caso la llamada a la función augmented_lagrangian_method sería:
augmented_lagrangian_method(FObj, [x,y], R, x0, iprint=[-1,0]);
Example 7 Resuelve el siguiente problema con MAXIMA y la función
min
s.a.
y
x2 + z 2 = 10
x+y+z =3
Solución:
load (augmented_lagrangian);
FObj(x,y,z) := y;
R : [x̀ ^2+z ^2-10, x+y+z-3];
x0: [1, 1, 1];
augmented_lagrangian_method(FObj(x,y,z), [x,y,z], R, x0, iprint=[-1,0]);
que tiene por salida la siguiente:
[[x=2.236499068014832,y=-1.47153167636176,z=2.236499068014832],%lambda=[0.97436850268555,0.97436850268555]]
Actividad 4 Determina los puntos de la elipse que se obtienen al cortar el cilindro de ecuación x2 + y 2 = 1
con el plano x + y + z = 1, cuyas distancias al origen sean respectivamente máxima y mínima.
Actividad 5 Resuelve el problema
Optimizar
Sujeto a
f (x, y, z) = x2 + y 2 + z 2
x + y 2 + z 2 + xy + yz + zx − 1 = 0
x + 2y − 3z = 0
2
Actividad 6 Halla la mínima distancia entre la recta x + y = 4 y la circunferencia x2 + y 2 = 1
Actividad 7 Resuelve el siguiente problema
Optimizar
Sujeto a
1.3
−x2 + 2y + z
x + 2y − z = 0
2y + z = 0
Optimización lineal
El paquete simplex utiliza el algoritmo del mismo nombre para resolver problemas de programación lineal.
13
1.3.1
Función linear_program
La función linear_program es una implementación del algoritmo simplex y se utiliza para resolver problemas de
la forma
min c1 x1 + c2 x2 + · · · cn xn
s.a.
Ax = b
xk ≥ 0
donde A es una matriz, b y c son vectores.
La instrucción
linear_program(A, b, c)
calcula un vector x tal que minimiza c.x (c1 x1 + c2 x2 + · · · cn xn ) bajo las restricciones A.x = b y x >= 0. El
argumento A es una matriz y los argumentos b y c son vectores.
Si el problema tiene solución, entonces el valor que devuelve linear_program es una lista que contiene un
vector x, con la solución óptima y el valor óptimo. Por el contrario, si el problema no está acotado devuelve
el mensaje "Problem not bounded!" y si el problema no es factible devuelve el mensaje "Problem not
feasible!".
Para usar esta función, hay que cargar primero el paquete con la instrucción
load(simplex).
Example 8 Resuelve el siguiente problema con MAXIMA y la función linear_program
min
s.a.
x1 − 2x2
x1 + x2 − x3 = 1
2x1 − 3x2 − x4 = 1
4x1 − 5x2 = 6
xj ≥ 0
Solución:
load (simplex);
A : matrix([1,1,-1,0], [2,-3,0,-1], [4,-5,0,0]);
b : [1, 1,6];
c : [1, -2, 0, 0];
linear_program(A,b,c)
que tiene por salida la siguiente:
1.3.2
∙∙
¸
¸
13
19
3
, 4, , 0 , −
2
2
2
Funciones minimize_lp y maximize_lp
La función minimize_lp se utiliza para resolver problemas lineales de la forma:
min
Sujeto a.
c1 x1 + · · · + cn xn
ae11 x1 + · · · + ae1n xn = be1
..
.
aem1 x1 + · · · + aemn xn = bem
ag11 x1 + · · · + ag1n xn ≥ bg1
agp1 x1 + · · · + agpn xn ≥ bgp
al11 x1 + · · · + al1n xn ≤ bl1
..
.
alq1 x1 + · · · + alqn xn ≤ blq
xk ≥ 0
14
El uso de esta función sería de la forma
minimize_lp(obj, con, [pos])
Esta función minimiza la función objetivo lineal obj (c1 x1 +· · ·+cn xn ) sujeta a las restricciones lineales indicadas
en la variable cond, estas restricciones se representan como una lista de ecuaciones o inecuaciones lineales. A
la hora de resolver el problema en las inecuaciones estrictas se reemplaza > por ≥ y < por ≤. El argumento
pos es opcional y contiene una lista con las variables de decisión que deben ser positivas, en otro caso serían
libres. Si el mínimo existe, minimize_lp devuelve una lista que contiene el valor mínimo de la función objetivo
y una lista de valores para las variables de decisión con los que se alcanza el mínimo. Si el problema no está
acotado, devuelve el mensaje "Problem not bounded!" y si el problema no es factible, devuelve el mensaje
"Problem not feasible!".
Si no se especifica lo contrario, las variables de decisión serían libres, para indicar que todas las variables
de decisión son no negativas, se le puede asignar el valor true a la variable del sistema nonegative_lp. Si sólo
algunas de las variables de decisión fueran positivas entonces se pueden incluir restricciones de la forma x ≥ 0,
aunque es más eficiente utilizar el argumento pos.
La función minimize_lp utiliza el algoritmo simplex implementado en la función linear_program de Maxima
y por tanto para usar esta función, es necesario cargar primero el paquete con la instrucción
load(simplex).
La función maximize_lp es identica en funcionamiento a minimize_lp pero en este caso el objetivo del problema sería maximizar.
A continuación pondremos una tabla con diferentes ejemplos
⎧ Problema
⎨ min x + y
3x + y = 0
⎩
⎧ x + 2y ≥ 2
min x + y
⎪
⎪
⎨
3x + y > 0
x + 2y > 2
⎪
⎪
⎩
⎧ x, y ≥ 0
min 2x + y
⎪
⎪
⎪
⎪
x+y ≤2
⎪
⎪
⎨
−x + y ≤ 3
3x + 2y ≤ 10
⎪
⎪
⎪
⎪
x libre
⎪
⎪
⎩
y≥0
⎧
min
−10x + 4y
⎪
⎪
⎨
x−y ≤2
5x − 2x ≤ 16
⎪
⎪
⎩
⎧ x, y ≥ 0
max 2x + 5y
⎪
⎪
⎨
x+y ≥4
x≥2
⎪
⎪
⎩
x,
y≥0
⎧
min
x+y
⎪
⎪
⎨
x + y <= 1
4x + 2y >= 6
⎪
⎪
⎩
x, y ≥ 0
Instrucciones MAXIMA
minimize_lp(x+y, [3*x+y=0, x+2*y>2]);
minimize_lp(x+y,[3*x+y>0,x+2*y>2]),nonegative_lp=true;
o
minimize_lp(x+y,[3*x+y>0,x+2*y>2],[x,y]);
maximize_lp(2*x+y,[x+y<=2,-x+y<=3,3*x+2*y<=10],[y]);
minimize_lp(-10*x+4*y,[x-y<=2, 5*x-2*y<=16]),nonegative_lp=true;
o
minimize_lp(-10*x+4*y,[x-y<=2, 5*x-2*y<=16],[x,y]);
Respuesta
[4/5,[y=6/5,x=-2/5]]
[1, [y = 1, x = 0]]
[4, [y=0, x=2]]
[-32, [y=2, x=4]]
maximize_lp(2*x+5*y,[x+y>=4, x>=2]),nonegative_lp=true;
o
maximize_lp(2*x+5*y,[x+y>=4, x>=2],[x,y]);
Problem not bounded!
minimize_lp(x+y, [x+y<=1,4*x+2*y>=6]), nonegative_lp=true;
o
minimize_lp(x+y, [x+y<=1,4*x+2*y>=6],[x,y]);
Problem not feasible!
Funcion maximize_lp
La función maximize_lp esMaximiza la función objetivo lineal obj sujeta a ciertas restricciones lineales cond.
Véase minimize_lp para una descripción detallada de los argumentos y de la respuesta dada por esta función.
15
Variables opcionales
• nonegative_lp Valor por defecto: false.
Si nonegative_lp vale true todas las variables de decisión pasadas a minimize_lp y a maximize_lp se suponen
positivas.
Actividad 8 Resuelve el siguiente problema
Optimizar
Sujeto a
−x + 2y + z
x + 2y − z = 0
2y + z = 0
Actividad 9 Resuelve el siguiente problema
min
x+y
s.a. 3x + 2y > 2
x + 4y > 3
Actividad 10 Resuelve el siguiente problema
Minimizar
x +2y
Sujeto a
−5x +y
x +y
x
y
= 7
≥ 26
≥ 3
≥ 4
Actividad 11 Resuelve los siguientes problemas
Minimizar
x+y
s.a.
x + 2y ≥ 3
x, y ≥ 0
Minimizar
x+y
s.a.
x + 2y = 3
x, y ≥ 0
Minimizar
x+y
s.a.
x + 2y ≤ 3
x, y ≥ 0
Minimizar
s.a.
x+y
x + 2y ≥ 3
−1 ≤ x ≤ 2
−1 ≤ y ≤ 1
16