Tarea N5 de Optimizaci

on
Universidad de la Frontera
Diego Quintana
Jean Paul Duprat
Ingeniera Civil El
ectrica

Leandro Reyes
Ingeniera Civil Industrial en Bioprocesos

Temuco, 12 de diciembre de 2010

1. Se nos pide minimizar dos funciones, ambas no sujetas a ninguna clase de restriccion. Estas
funciones no son lineales, y adem
as f es tal que f : R R. Es decir, el punto mnimo x

satisface:
df (
x)
=0
dx
x)
d2 f (
0
2
dx
d2 f (
x)
>0
dx2

(1)
(2)
(3)

La verificacion de la primera condici

on implica la resoluci
on de una ecuacion eventualmente
no lineal. Implementamos el algoritmo de Regula Falsi o de Falsa Posicion en Matlab:

N
% M
ETODO DE FALSA POSICIO
% funx @function_handle almacenado en fun1 y fun2
% a,b cotas del intervalo inicial
% epsilon es la tolerancia ||f(x_k)-f(x_{k-1})||<epsilon
% maxiter es el n m
aximo de iteraciones
% ELEMENTOS DE SALIDA
% c es el punto donde se cumple la condici
on de t
ermino del
% algorimo
% fval es la funci
on evaluada en c y iter es el n
umero de
% iteraciones
function [c,fval,iter]=regulafalsi(funx,a,b,epsilon,maxiter)
% evaluar las funciones en a0 y b0
ya=feval(funx,a);
yb=feval(funx,b);
iter=1;
%revisando la factibilidad en el intervalo
if ya==0
fprintf(El punto x=%g es una ra
z de f,a)
c=a;
fval=ya;
return
end
if yb==0
fprintf(El punto x=%g es una ra
z de f.,b)
c=b;
fval=yb;
return
end
if ya*yb>0
fprintf(ERROR: El intervalo [%g,%g] no contiene una ra
z....
Intentar con un nuevo intervalo.,a,b)
c=[];
fval=[];
iter=0;
return
end
iter=0;
for k=1:maxiter

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

dx=yb*(b-a)/(yb-ya);%d_k
c=b-dx;%x_{k+1}
yc=feval(funx,c);%f(x_{k+1})
if yc==0
fprintf(El punto x=%g es ra
z de f.,c)
fval=feval(funx,c);
iter=iter+1;
break;
else
if yb*yc>0
b=c;
yb=yc;
else
a=c;
ya=yc;
end
iter=iter+1;
% proximidad de f(c) a cero
if abs(yc)<epsilon
disp(Advertencia: Se ha alcanzado la...
tolerancia para la soluci
on.)
break
end
end
if k==maxiter
disp(Advertencia: Se ha alcanzado el m
aximo...
de iteraciones.)
break
end
fval=feval(funx,c);
end
En base a estas observaciones previas, procedemos:
2

a. Mnimizar f (x) = e(x1) + (x 1)2 con una tolerancia de = 104 , en el intervalo [0, 5].
Para estos efectos, se debe cumplir:
2
df (
x)
= 2(
x 1)(1 + e(x1) ) = 0
dx

(4)

2
d f (
x)
= 2e(x1) (2
x2 4
x + 3) + 2 0
2
dx
2
d2 f (
x)
= 2e(x1) (2
x2 4
x + 3) + 2 > 0
dx2

(5)
(6)

Crearemos dos funciones para efectos posteriores. Una sera f (x) y la otra sera g(x) = f (x),
como siguen:
function [Y1]=fun1(x)
Y1=exp((x-1)^2)+(x-1)^2;
end
%-----------------------------------function [DY1]=derfun1(x)
DY1=2*(x-1)*(1+exp((x-1)^2));
end

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

Luego, llamamos a regulafalsi:

>> [c,fval,iter]=regulafalsi(@derfun1,0,5,1E-4,100)
Advertencia: Se ha alcanzado el m
aximo de iteraciones.
c =
5.2301e-005
fval =
-7.4356
iter =
100
Aqu debemos hacer un peque
no analisis de convergencia: la funcion g(x) = f (x) tiene un
cero en x=1, y los dem
as ceros C. Como nuestro analisis compete s
olo a las funciones
real valuadas, aproximaremos los lmites en una prueba de ensayo-error:
>> [c,fval,iter]=regulafalsi(@derfun1,0,1.5,1E-4,100)
Advertencia: Se ha alcanzado la tolerancia para la soluci
on.
c =
1.0000
fval =
1.0391e-004
iter =
13
Es decir, el punto x
= 1 satisface (4). Evaluando este punto en (5), obtenemos que f (
x) =
4 > 0. Podemos concluir que f (x) tiene un mnimo en p = (1, 1). Un gr
afico es mas
explicativo:

Figura 1: Minimizando f (x) = e(x1) + (x 1)2

Podemos verificar esto r
apidamente mediante la funcion fminunc:
>> x=fminunc(@fun1,0)

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

Warning: Gradient must be provided for trust-region method;

using line-search method instead.
> In fminunc at 281
Optimization terminated: relative infinity-norm
of gradient less than options.TolFun.
x =
1.0000
b. minimizar f (x) = 5ex x3 + 2(x 5) con una tolerancia de = 103 , en el intervalo [5, 5].
Analogamente al procedimiento anterior, se debe cumplir:
df (
x)
= 5ex 3
x2 + 2 = 0
dx
d2 f (
x)
= 5ex 6
x0
2
dx
d2 f (
x)
= 5ex 6
x>0
dx2

(7)
(8)
(9)

Creando nuevamente dos funciones tales que la segunda es la derivada de la primera,

escribimos en consola:
>> [c,fval,iter]=regulafalsi(@derfun2,-5,5,1E-3,100)
Advertencia: Se ha alcanzado el m
aximo de iteraciones.
c =
-1.1046
fval =
-0.0042
iter =
100
Se ha alcanzado el n
umero maximo de iteraciones, sin haber alcanzado la tolerancia . Sin
embargo, fval es cercano a cero por lo que la raz de la funcion est
a cercana a c. Reingresamos la funcion en consola, achicando el intervalo de modo que encierre una vecindad en
torno a c:
>> [c,fval,iter]=regulafalsi(@derfun2,-2,-1,1E-3,100)
Advertencia: Se ha alcanzado la tolerancia para la soluci
on.
c =
-1.1041
fval =
0.0015
iter =
5
Es decir, el punto x
= 1.1041 es candidato a mnimo. Evaluando en la segunda derivada,
2
f (
x)
obtenemos d dx
= 8.282145531 > 0 por lo que el punto p = (1.1041, 9.204715938) es
2
un mnimo local del problema.
Podemos representar este problema gr
aficamente:

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

Figura 2: Minimizando f (x) = 5ex x3 + 2(x 5)

Igual que en el caso anterior, podemos verificar esto mediante fminunc:
>> x=fminunc(@fun2,0)
Warning: Gradient must be provided for trust-region method;
using line-search method instead.
> In fminunc at 281
Optimization terminated: relative infinity-norm
of gradient less than options.TolFun.
x =
-1.1042
2. Para este ejercicio, se nos pide aplicar el metodo de maximo descenso con b
usqueda lineal
inexacta, usando biseccion. Para ello programamos en matlab una rutina como la que sigue:
function [C,exitflag2,k,pasos,D,caso]=maxdescent(caso,x0,y0,epsilon2,maxiter2)
%M
ETODO DE M
AXIMO DESCENSO
% S
olo funciona para funciones en R2, para agregar m
as casos se agregan
% dentro del programa y se genera un nuevo caso. El caso n se refiere al
% problema n.
%
% Argumentos de entrada
% caso: problema sobre el cual se trabaja
% x0 e y0 son el punto inicial
% epsilon2 es la tolerancia
% maxiter2 es el m
aximo de iteraciones permitidas
%
% Elementos de salida
% C es el punto candidato a m
nimo
% exitflag2 es un indicador de estado:
% 2 indica que el algoritmo se detuvo pues lambda es m
nimo

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

%
%
%
%
%
%
%

y no puede seguir decreciendo

1 indica convergencia dentro de
0 indica que se excedi
o en el n
k es el n
umero de iteraciones
pasos es un vector compuesto de
en cada iteracion
D es una estructura formada por

la tolerancia
de iteraciones
los k pasos creados
k vectores d_k

syms x y
switch caso
case 1
funcion=x^4 + y^2 - 3*x - 6*y + 2;
case 2
funcion=10*x^2+2*y^2-2*x-2*y-4*x*y+1;
case 3
funcion=100*(x^2-y)^2+(1-x)^2;
otherwise
disp(S
olo hay 3 casos. Ingrese un valor entero entre 1 y 3.)
return
end

%% definici
on de funciones simb
olicas
gradx=diff(funcion,x);
grady=diff(funcion,y);
gradiente=[gradx,grady];
norma_grad=sqrt(gradx^2+grady^2);
%% conversi
on a @function_handle
fchandle1 = char(gradiente);
fcv1 = symvar(fchandle1);
fchandle2 = [@(, sprintf(%s,, fcv1{1:end-1}),...
fcv1{end}, ) , fchandle1];
gradiente = eval(fchandle2);
fchandle3 = char(norma_grad);
fcv2 = symvar(fchandle3);
fchandle4 = [@(, sprintf(%s,, fcv2{1:end-1}),...
fcv2{end}, ) , fchandle3];
norma_grad = eval(fchandle4);
fchandlegradx = char(gradx);
fcvgradx = symvar(fchandlegradx);
fchandlegradx2 = [@(, sprintf(%s,, fcvgradx{1:end-1}),...
fcvgradx{end}, ) , fchandlegradx];
gradx = eval(fchandlegradx2);
fchandlegrady = char(grady);
fcvgrady = symvar(fchandlegrady);
fchandlegrady2 = [@(, sprintf(%s,, fcvgrady{1:end-1}),...
fcvgrady{end}, ) , fchandlegrady];
grady = eval(fchandlegrady2);

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

clear x y; %limpieza de variables para usarlas despu

es
%% Inicio de algoritmo
%iniciar contador
k=1;
x(1)=x0;
y(1)=y0;
verif_norma_grad=feval(norma_grad,x(k),y(k));
verif_norma_grad_prev=0;
for i=1:maxiter2
%evalua el punto x_k en la norma del gradiente, y verifica si el valor
%es cero o es inferior a la tolerancia.
if verif_norma_grad==0 || verif_norma_grad<=epsilon2
fprintf(El punto [%g,%g] es un candidato a m
nimo.,x(k),y(k))
C=[x(k) y(k)];
exitflag2=1;
return;
end
%formar d_k
switch caso
case 1
d{k}(1)=-1*feval(gradx,x(k));
d{k}(2)=-1*feval(grady,y(k));
otherwise
d{k}(1)=-1*feval(gradx,x(k),y(k));
d{k}(2)=-1*feval(grady,y(k),y(k));
end
D{k}=[d{k}(1) d{k}(2)];
% formar phi(lambda) como un nuevo @function_handle en funci
on de un
% par
ametro lambda, para ser llamada por biseccion y encontrar puntos
% cr
ticos de phi.
X{k}=[x(k) y(k)];
f_phi=conversion(X{k},D{k},caso);
%% b
usqueda del paso para phi(lambda)
a0=-5;
b0=5;
exitflag=0;
while exitflag~=1 %exitflag=1 indica convergencia
% busca el paso por bisecci
on
[paso,fval,iter,exitflag]=biseccion(f_phi,a0,b0,1E-4,500);
% si el intervalo no contiene ra
z, agrandar el intervalo
% progresivamente hasta encontrar una.
if exitflag==-1
a0=a0-1;
b0=b0+1;
break;
end
end
pasos(k)=paso; % almacenar el paso resultante en un vector
% formar nuevos puntos
x(k+1)=x(k)+paso*d{k}(1);
y(k+1)=y(k)+paso*d{k}(2);
verif_norma_grad_prev=verif_norma_grad;

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

verif_norma_grad=feval(norma_grad,x(k+1),y(k+1));
if verif_norma_grad_prev==verif_norma_grad;
C=[x(k+1) y(k+1)];
exitflag2=2;
return;
end
if k==maxiter2
exitflag2=0;
C=[x(k+1) y(k+1)];
return
end
C=[x(k+1) y(k+1)];
k=k+1;
%si se excede en iteraciones, devuelve el punto en que se queda.
end
end
function f_phi=conversion(Xk,dk,caso)
% la funcion conversion lo que hace es convertir f(x) en f(x+lambda*d),
% lambda como nueva variable, x y d constantes. Regresa phi(lambda) como
% @function_handle, es
% decir la derivada de phi(lambda) para fines evaluativos.
syms lambda x y
switch caso
case 1
f=inline(x^4 + y^2 - 3*x - 6*y + 2);
case 2
f=inline(10*x^2+2*y^2-2*x-2*y-4*x*y+1);
case 3
f=inline(100*(x^2-y)^2+(1-x)^2);
end
yk=Xk+lambda*dk;
f2=subs(f,x,yk(1));
f2=subs(f2,y,yk(2));
f2=diff(f2,lambda);
fc = char(f2);
fcv = symvar(fc);
f2 = [@(, sprintf(%s,, fcv{1:end-1}), fcv{end}, ) , fc];
f_phi = eval(f2);%creacion de phi(lambda)
end
function [c,fval,iter,exitflag]=biseccion(funx,a,b,epsilon,maxiter)
% ARGUMENTOS DE ENTRADA
% funx @function_handle
% a,b cotas del intervalo inicial
% epsilon es la tolerancia para un epsilon dado
% maxiter es el n m
aximo de iteraciones
% ELEMENTOS DE SALIDA
% c es el punto donde se cumple la condici
on de t
ermino del
% algorimo

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

%
%
%
%

fval es la funci
on evaluada en c
exitflag es un indicador de estado:
1 indica convergencia, 0 indica m
aximo de iteraciones y -1
indica que el intervalo [a,b] no contiene ra
z.

% evaluar las funciones en a0 y b0

ya=feval(funx,a);
yb=feval(funx,b);
iter=1;
%revisando la factibilidad en el intervalo
if ya==0
c=a;
fval=ya;
exitflag=1;
return
end
if yb==0
c=b;
fval=yb;
exitflag=1;
return
end
if ya*yb>0
c=[];
fval=[];
iter=0;
exitflag=-1;
return
end
iter=0;
for k=1:maxiter
c=(a+b)/2;%x_{k+1}
yc=feval(funx,c);%f(x_{k+1})
if yc==0
fval=feval(funx,c);
iter=iter+1;
exitflag=1;
break;
else
if yb*yc>0
b=c;
yb=yc;
else
a=c;
ya=yc;
end
iter=iter+1;
% proximidad de f(c) a cero
if abs(yc)<epsilon
exitflag=1;
fval=yc;
break
end

10

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

11

end
if k==maxiter
exitflag=0;
break
end
fval=feval(funx,c);
end
end
Este programa es bastante rudimentario: acepta s
olo funciones en R2 y est
a dise
nado para
trabajar con 3 casos correspondientes a cada ejercicio. Las explicaciones est
an contenidas
como comentarios dentro del codigo. A primeras observamos que est
a conformado por tres
funciones, donde la primera, maxdescent llama a las otras dos, conversion y biseccion. El
argumento operacional del algoritmo se basa principalmente en la conversion de funciones:
toma inicialmente una funcion simbolica f (~x), y genera dos funciones simbolicas nuevas
f (~x) y ||f (~x)|| a partir de la primera, luego convierte la funcion al tipo char y luego al
tipo @function_handle usando el comando eval.
Para efectos ilustrativos creamos la siguiente funcion, que grafica el campo gradiente y el
punto mnimo obtenido:
function[]=graficagrad(caso,C)
v = -4:0.2:4;
x0=C(1); y0=C(2);
[x,y] = meshgrid(v);
switch caso
case 1
z=x.^4 + y.^2 - 3.*x - 6.*y + 2;
case 2
z=10.*x.^2+2.*y.^2-2.*x-2.*y-4.*x.*y+1;
case 3
z=100.*(x.^2-y).^2+(1-x).^2;
end
[px,py] = gradient(-z,.2,.2);
contour(v,v,z)
hold on
quiver(v,v,px,py)
plot(x0,y0,-mo,LineWidth,2,MarkerEdgeColor,k,...
MarkerFaceColor,[.49 1 .63])
hold off
end
Se explica a continuacion el comportamiento y la resoluci
on de los problemas a, b y c:
a. escribimos en consola, obteniendo:1
>> [C,exitflag2,k,pasos,D,caso]=maxdescent(1,1,3,0.03,10)
El punto [0.908562,3] es un candidato a m
nimo.
C =
0.9086
3.0000
exitflag2 =
1
k =
2
1 Nota:

Se omitir
a la respuesta D y la respuesta pasos, para no saturar la lectura

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

12

caso =
1
Este punto es candidato a mnimo. Gr
aficamente este se puede visualizar:
4
3
2
1
0
1
2
3
4
4

Figura 3: Minimizando f (x, y) = x4 + y 2 3x 6y + 2)



12x2 0
Adem
as 2 f (~x) =
0, x R, x 6= 0. Decimos entonces que el punto es
0
x2
mnimo local del problema.
b. Analogamente al procedimiento anterior:
>> [C,exitflag2,k,pasos,D,caso]=maxdescent(2,1,0,0.0005,10)
C =
0.2280
0.7539
exitflag2 =
2
k =
8
caso =
2
Si bien hay convergencia hemos verificado el punto usando fminunc El exitflag=2 nos
indica que el algoritmo se ha atascado en un punto, dando las siguientes iteraciones iguales.
~ = [0.2280, 0.7539] es la respuesta del
Esto quiere decir que no puede decrecer mas y C
sistema y candidato a mnimo de f . Grafiquemos este punto usando graficograd:

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

13

4
3
2
1
0
1
2
3
4
4

Figura 4: Minimizando f (x, y) = 10x2 + 2y 2 2x 2y 4xy + 1



20 4
Adem
as, 2 f (~x) =
0, ~x R2 . Decimos entonces que el punto es mnimo
4 4
local del problema.
c. Analogamente al procedimiento anterior:
>> [C,exitflag2,k,pasos,D,caso]=maxdescent(3,1,1.1,1E-6,10)
C =
-2.3942
5.7321
exitflag2 =
2
k =
5
caso =
3
Graficamente:

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

14

4
3
2
1
0
1
2
3
4
4

Figura 5: Minimizando f (x, y) = 100(x2 y)2 + (1 x)2

En este caso no hay una clara convergencia, el algoritmo se atasca en el punto C. Notamos
que a medida que el punto inicial tiende a (1, 1) la convergencia mejora considerablemente.
Podemos ver esto en el siguiente gr
afico:
4
3
2
1
0
1
2
3
4
4

Figura 6: Minimizando f (x, y) = 100(x2 y)2 + (1 x)2 ajustando el punto inicial en cada
ocasion
Efectivamente. Si usamos fminunc, obtenemos (x, y) = [0.9994, 0.9989] [1, 1]. Si graficamos este punto:

Tarea N 5 de Optimizaci
on - Universidad de la Frontera

15

>>graficagrad(3,[1,1]):
Nos da como resultado:
4
3
2
1
0
1
2
3
4
4

Figura 7: Minimizando f (x, y) = 100(x2 y)2 + (1 x)2



8022 400
Adem
as, 2 f (1, 1) =
0. Decimos entonces que el punto es mnimo
400 200
local del problema.

Referencias
[1] Mokthar S. Bazaraa, Hanif. D Sherali, C.M. Shetty; Nonlinear Programming: Theory and
Algorithms.
[2] Mathews, John H., Fink, Kurtis D.; Metodos Numericos con Matlab.
[3] David E. Luenberger; Programaci
on lineal y no lineal.