Optimització Lineal Amb Mètodes Diferenciables I de Punt Interior

Curs de doctorat: Mètodes de punt interior.
Alumne: Jordi Cuesta i Andrea 1
Programa de Doctorat:
Aplicacions tècniques i informàtiques de
l’Estadística, l’Investigació Operativa i
l’Optimització
Curs de doctorat:
Mètodes de punt interior
Alumne: Jordi Cuesta i Andrea
Curs acadèmic 99/2000

Contingut d’aquest document:
 Temari del curs, bibliografía i avaluació.

 Pràctiques:
P1: Algorisme d'escalat afí primal
P2:Algorisme primal-dual path-following per a problemes lineals, en la variant
ús de les equacions normals
P3: Algorisme primal-dual path-following per a problemes lineals, en la
variant ús del sistema augmentat
P4: Algorisme primal-dual path-following per a problemes lineals, en la
variant ús de l’heurística de Mehrotra amb les direccions predictor-
corrector.
P5: Algorisme primal-dual path-following per a problemes quadràtics, en la
variant ús del sistema augmentat.
variant transformació del problema en un equivalent separable, usant
aleshores les equacions normals.
P7: Algorisme primal-dual path-following per a problemes convexos (variant
ús del sistema augmentat).
 Apèndix 1: Deducció del dual del programa quadràtic separable equivalent a
un programa quadràtic convex. Equacions normals.
Cada pràctica s’ha estructurat en quatre apartats:
1. Introducció: informa de la font bibliogràfica en la que es basa el

algorisme i , si s’escau, es dedueixen les expressions necesàries per a la
implementació pràctica.
2. Algorisme: llistat de l’algorisme en Matlab.
3. Prova de l’algorisme: enunciats dels problemes que s’han resolt i
sol.lució obtinguda.
4. Conclusions.
TEMARI PER AL CURS DE PUNT INTERIOR DE 1999/2000
T1. Algorisme d'escalat afí.

Bibliografia del tema:
Jordi Castro, "Una introducción al algoritmo del escalado afín", Document de
Recerca DR-2000-02 del Departament d'EIO.
T2. Algorisme primal-dual "path-following" (de seguiment de camí).

Robert Vanderbei, "Linear Programming, Foundations and Extensions".
Capítols 16, 17 i 18.
T3. Aspectes d'implementació de l'algorisme primal-dual path-following.

Robert Vanderbei, "Linear Programming, Foundations and Extensions". Capítol
19, excepte la secció 3.
S.J. Wright, "Primal-Dual Interior Point methods", Capítols 10 i 11.
T4. Extensions a problemes quadràtics i convexos.

Robert Vanderbei, "Linear Programming, Foundations and Extensions".
Capítols 23 i 24.
T5. Mètodes per a problemes no lineals.

El-Bakry, Tapia, Tsuchiya i Zangh, "On the formulation of the Newton interior-
point method for nonlinear programming".
Byrd, Hribar, Nocedal, "An interior-point algorithm for large scale nonlinear
programming". SIAM J. on Optim. V. 9, N.4, pp. 877-900 (1999).
Avaluació: Entrega d'alguns dels algorismes estudiats, programats en Matlab.

Aquests seran:
1) Algorisme d'escalat afí primal del T1.

2) Algorisme primal-dual path-following per a problemes lineals, en les variants:
2.1) Ús de les equacions normals (sistema simètric i definit positiu,
factorització de Cholesky del sistema).
2.2) Ús del sistema augmentat (sistema simètric quasi-definit, factorització
standard del sistema).
2.3) Heurística de Mehrotra amb les direccions predictor-corrector.
3) Algorisme primal-dual path-following per a problemes quadràtics, en les variants:
3.1) Ús del sistema augmentat.
3.2) Transformació del problema en un equivalent separable, usant aleshores les
equacions normals.
4) Algorisme primal-dual path-following per a problemes convexos (variant ús del
sistema augmentat).
P1: Algorisme d'escalat afí primal
1. Introducció.
Aquest algorisme és pràcticament idèntic al que apareix en “Jordi Castro, "Una
introducción al algoritmo del escalado afín", Document de Recerca DR-2000-02 del
Departament d'EIO”.
2. Algorisme.
El fitxer d’ script en matlab s’anomena ESCALAFI.M i el llistat és el següent:
% Algorisme de l'escalat af¡ primal per P.L.

% trova l'òptim de: cx
% subjecte a: Ax=b, x>=0
%*****************************
function xopt=eap(A,b,c,info)
%*****************************
%------ comprova que les dimensions siguin coherents
[m,n]=size(A);
[mb,nb]=size(b);
[mc,nc]=size(c);
if((nc ~= 1) | (nb ~= 1))

error('error: b,c han de ser vectors');
end%if
if((mc ~= n) | (mb ~= m))

error('error: b,c incompatibles amb A');
end%if
if(rank(A) ~= m)
error('error: A no es de rang complert');
end%if
% ----- info de les dimensions dels problema

fprintf('m = %f, n = %f\n',m,n);
% ----- paràmetres
optgap=1.0e-6;
myeps=1.0e-12;
rho=0.95;
M = 100*(max(abs(c)));
% ------ inicialitzacions
x=ones(n,1);
A = [A b-A*x];
x = [x;1];
c = [c;M];
D = diag(x)^2;
y = inv(A*D*A')*A*D*c;
i=0;
dualgap=abs(c'*x-b'*y)/(1.0+abs(c'*x));
if (info>0)
fprintf('iter.\t\t alph \t\t dualgap \t f(x)\n');
fprintf('=====================================================\
n');
end
% ------ iteracions
while(dualgap>optgap)
z = c-A'*y;
dx = -D*z;
if all(dx>myeps)
x = inf*ones(n,1);
fprintf('Problema ilimitat\n');
break;
end%if
alph = min(-x(dx<myeps) ./ dx(dx<myeps));

x = x+rho*alph*dx;
D = diag(x)^2;
y = inv(A*D*A')*A*D*c;
dualgap=abs(c'*x-b'*y)/(1.0+abs(c'*x));
% ---- mostra informació en cada iteració

if (info>0)
fobj=c'*x;
fprintf('%f \t ',i);
fprintf('%f \t ',alph);
fprintf('%f \t ',dualgap);
fprintf('%f \n',fobj);
end%if
i=i+1;
end
% ------ resultat
if(x(n+1)>1.0e-4)
fprintf('problema infactible');
xopt=nan*ones(1,n);
else
fprintf('sol.lució trovada en %f iteracions\n',i);
fprintf('dualgap = %f\n',dualgap);
xopt=x(1:n);
end
%end function
3. Prova de l’algorisme.
S’han resolt dos problemes lineals. El primer és el que apareix en la bibliografía

d’aquest algorisme, pàgina 41 exemple 8:
Min 3x1 + x2
Subjecte a 2x1 + x2 2
3x1 + 4x212
x1, x2 0
Les dades d’aquest problema estàn en el fitxer P1E1. El resultat de l’execució és el
seguent:
» escalafi(A,b,c,1)
m = 2.000000, n = 4.000000
iter. alph dualgap f(x)
=====================================================
0.000000 0.009065 0.763015 19.528709
1.000000 0.066909 0.355916 5.151152
2.000000 0.831116 0.086851 2.965092
3.000000 3.266003 0.068421 2.279263
4.000000 4.680468 0.016974 2.051757
5.000000 38.843983 0.004863 2.014684
6.000000 148.057449 0.000610 2.001831
7.000000 947.575410 0.000184 2.000553
8.000000 3768.363669 0.000031 2.000093
9.000000 23365.157320 0.000006 2.000018
10.000000 106830.650395 0.000001 2.000004
11.000000 448165.602648 0.000000 2.000001
sol.luci¢ trovada en 12.000000 iteracions
dualgap = 0.000000
ans =
0.0000
2.0000
0.0000
4.0000
El segon problema s’ha pres del mateix document, pàgina 25 exemple 6:
Min -3x1 - 2x2

Subjecte a 4x1 - 2x2 + x3
3x1 + 4x2x4 = 1
x1 + x2x5 = 2
xi 0 i=1..5
Les dades d’aquest problema estàn en el fitxer P1E2 i el resultat de l’execució és:
» escalafi(A,b,c,0)
m = 3.000000, n = 5.000000
dualgap = 0.000000
ans =
1.5000
0.5000
0.0000
5.5000
0.0000
»
Conclusions.
Aquest algorisme és relativament simple en quant als conceptes teòrics en els que es
basa i prou eficient. El seu principal problema potser és el de utilitzar un mètode poc
eficient per trovar el punt inicial factible i interior. La resta de mètodes d’aquest curs
pasen per alt la factibilitat i es conformen amb que el punt sigui interior a costa de
treballar simultàniament amb el problema primal i el dual asociat.
P2:Algorisme primal-dual path-following per a problemes lineals, en la

variant ús de les equacions normals
Introducció.
L’algorisme es basa en el que es trova en “Robert Vanderbei, Linear Programming,
Foundations and Extensions”, cap. 17, pàgina 274. El sistema d’equacions normals és
el que figura en la pàgina 286, eqs. 18.8 i 18.9 (primals) que ens dóna les direccions
de moviment dx, dy. Es resol factoritzant per Cholesky i resolent el sistema triangular
resultant. La funció SISTLIN.M s’encarrega d’aquesta tasca. Com a punt inicial
simplement prenem el vector unitari (interior no factible). Es aquest punt és molt
destacable la diferència existent respecte a l’algorisme d’escalat afí i d’altres que es
resolen en dos fases. La longitud de passa es calcula de forma única per el problemes
primal i dual, tal com es fa en el texte de referència.
Algorisme.
El fitxer s’anomena PATHFN.M i el llistat és el seguent:
%****************************************************
%* Algorisme primal-dual Path-Following en versi¢ *
%* "£s de les equacions normals" (sistema simŠtric *
%* definit positiu => fact. de Cholesky) per P.L. *
%* Us: per resoldre el problema primal-dual *
% max c'x min b'y *
% Ax + w = b A'y - z = c *
% x,w >= 0 y,z >=0 *
% escrivim *
% x = PathFN(A,b,c,info) *
% on info: 0 - nom‚s d¢na resultat final *
% 1 - d¢na tamb‚ els punts del cami central*
%****************************************************
function optim = CamiCentralNormal(A,b,c,info)
%--- obtŠ les dimensions del problema, comprovacions preliminars

[m,n]=size(A);
[mb,nb]=size(b);
[mc,nc]=size(c);
if((nc ~= 1) | (nb ~= 1)) error('error: b,c han de ser vectors columna');end
if((mc ~= n) | (mb ~= m)) error('error: b,c incompatibles amb A');end
if(rank(A) ~= m) error('error: A no ‚s de rang complet');end
%--- Inicialitzem (x,w,y,z) punt arbitrari estrictament positiu

x = ones(n,1);
w = ones(m,1);
y = ones(m,1);
z = ones(n,1);
%--- Par…metres
delt = 0.1; %delt ‚s la reducci¢ aplicada per el par…metre barrera
r = 0.9; %r ‚s la reducci¢ de la long. de pas
MaxNorm = 1e10; %valor m…xim perm‚s per ||x||, ||y|| (prob il.limitat)
Eps = 1e-6; %toler…ncia per les infactibilitats rho, sig i per la
%cond. de complementarietat (variable gm)
rho=1; sig=1; gm=1; %valors temporals

if(info>0)
fprintf('\t iter \t\t ||rho|| \t ||sig|| \t fobj\n');
fprintf('\t =========================================================\n');
end%if
%--- Mentre no •ptim...

ci=1; %contador d'iteracions
while(norm(x)<MaxNorm)&(norm(y)<MaxNorm)&((norm(rho)>Eps)|(norm(sig)>Eps)|
(gm>Eps))
%--- Calculem infactibilitats primal i dual: rho, sig

rho = b - A*x - w;
sig = c - A'*y + z;
%--- Calculem el valor del "par…metre de barrera": mh

gm = z'*x + y'*w;
mh = delt * (gm /(n + m));
%---------------------------------------------------------
%--- Trovar les direccions de moviment dx, dw, dy, dz ----
%---------------------------------------------------------
%--- primer: formar el sistema MA * dy = Mb
%--- dy contindr… les direccions dy
X = diag(x); %matrius diagonals
Y = diag(y);
Z = diag(z);
W = diag(w);
Em2 = inv(Y)*W; % E elevat a -2

D2 = X*inv(Z);
MA = (Em2 + A*D2*A'); %simŠtrica def. positiva

Mb = b - A*x - mh*inv(Y)*ones(m,1) - A*D2*(c - A'*y +
mh*inv(X)*ones(n,1));
%--- resoldre el sistema factoritzant per Cholesky

R=chol(MA);
dy = sistlin(R,Mb);
dy = -dy;
%--- trovar dx
dx = D2 * (c - A'*y + mh*inv(X)*ones(n,1) - A'*dy);
%--- trovar dz, dw
dz = inv(X)*(mh*ones(n,1) - X*Z*ones(n,1) - Z*dx);
dw = inv(Y)*(mh*ones(m,1) - Y*W*ones(m,1) - W*dy);
%-----------------------------------
%--- Trovar la longitud de pas th
%-----------------------------------
%--- trovem m…xim -dx/x,-dy/y,-dz/z,-dw/w ->k
k = -1e-50; %cota inferior per cerca del m…xim
for i=1:n
if((-dx(i)/x(i))>k)
k = -dx(i)/x(i);
end%if
if((-dz(i)/z(i))>k)
k = -dz(i)/z(i);
end%if
end%for
for i=1:m
if((-dy(i)/y(i))>k)
k = -dy(i)/y(i);
end%if
if((-dw(i)/w(i))>k)
k = -dw(i)/w(i);
end%if
end%for
%--- trovem th
th = r * (1/k);
if th > 1 th = 1; end%if
%------ actualitzar el punt (x,y,w,z)

x = x + th*dx;
y = y + th*dy;
z = z + th*dz;
w = w + th*dw;
if(info > 0)
fprintf('\t %f',ci);
fobj = c'*x;
fprintf('\t %f',norm(rho));
fprintf('\t %f',norm(sig));
fprintf('\t %f\n',fobj);
end%if
ci = ci + 1;
end%while
%--- Retorna
if(norm(x)>=MaxNorm)|(norm(y)>=MaxNorm)
fprintf('Problema il.limitat');
optim = MaxNorm*ones(1,n);
else
fprintf('sol.luci¢ trovada en %f iteracions',ci-1);
optim = x(1:n);
end%if
pause;
%End Function
Llistat de la rutina SISTLIN.M

% Resoldre un sistema lineal d'n equacions
% Ax=b on A=R'*R, R triangular superior
% on A ‚s simŠtrica i def. positiva, aplicant fact. Cholesky.
% Us: sistLin(R,b)
%
%*****************************
function xs=SistLin(R,b)
%*****************************
[m,n]=size(R);
if(m ~= n)
error('error: matriu R no ‚s n x n');
end
%--- tenim Ax=b => R'Rx=b

%--- resoldre el sistema triangular superior R*x = inv(R')*b => R*x = z
z = inv(R')*b;
x(n) = z(n)/R(n,n);
for i=(n-1):-1:1
s = 0;
for j=(i+1):n
s = s + R(i,j)*x(j);
end%for
x(i) = (z(i) - s) / R(i,i);
end%for
%--- retorna
y=x(1:n);
xs=y';
%end function
3. Prova de l’algorisme
S’han efectuat dues proves d’aquest algorisme. El primer problema (fitxer P2E1)és:
Max 5x1 + 4x2+ 6x3

Subjecte a x1 + x2 + x3100
3x1 + 2x24x3  210
3x1 + 2x2  150
xi 0 i=1..3
(Font: Mètodos de Programación Matemàtica, tomo 2, UNED). La sol.lució segons el

texte és (0, 75, 15) amb un valor de 390. El resultat de l’execució ha estat el següent:
» pathfn(A,b,c,1)
iter ||rho|| ||sig|| fobj
===================================================================
1.000000 262.821232 2.236068 25.287551
2.000000 254.833807 2.168111 42.869571
3.000000 241.415000 2.053945 58.733024
4.000000 230.050440 1.957256 71.890085
5.000000 222.248916 1.890881 84.362835
6.000000 214.570806 1.825556 93.406236
7.000000 208.342648 1.772567 166.311125
8.000000 157.189244 1.337357 259.682649
9.000000 91.628214 0.779568 361.030673
10.000000 20.293406 0.172655 388.870691
11.000000 0.764196 0.006502 389.931910
12.000000 0.043444 0.000370 389.996924
13.000000 0.001584 0.000013 389.999877
14.000000 0.000022 0.000000 389.999991
15.000000 0.000000 0.000000 389.999999
16.000000 0.000000 0.000000 390.000000
17.000000 0.000000 0.000000 390.000000
ans =
0.0000
75.0000
15.0000
5.0000
0.0000
0.0000
El segon problema resolt (fitxer P2E2) ha estat el següent:
Max 4x1 + 12x2+ 3x3

Subjecte a x1 1000
x2  500
x3  1500
3x1 + 6x2+ 2x3  6750
xi 0 i=1..3
Aquest problema s’ha copiat de la mateixa referència anterior, segons la qual la

sol.lució és (250, 500, 1500) amb un valor de 11500. El resultat de l’execució en
Matlab ha estat:
» pathfn(A,b,c,0)
ans =
1.0e+003 *
0.2500
0.5000
1.5000
0.3750
0.0000
0.0000
0.0000
Conclusió.
És molt notable la convergència d’aquest mètode partint d’un punt interior qualsevol
no factible.
P3: Algorisme primal-dual path-following per a problemes lineals, en la variant

ús del sistema augmentat
Introducció.
L’algorisme es basa en el que es trova en “Robert Vanderbei, Linear Programming,
Foundations and Extensions”, cap. 17, pàgina 274. El sistema d’equacions augmentat
és el que figura en la pàgina 286, eqs. 18.6 i 18.7 que ens dóna les direccions de
moviment dx, dy i es resol efectuant una factorització estàndard (funció lu de Matlab)
i una sustitució inversa del sistema triangular resultant (funció LIN.M). El fitxer
corresponent s’anomena PATHFA.M, i el llistat és:
%****************************************************
%* "ús del sistema augmentat" (sistema simétric *
%* quasi definit positiu => fact. estàndard) per PL.*
% max c'x min b'y *
% Ax + w = b A'y - z = c *
% x,w >= 0 y,z >=0 *
% escrivim *
% x = PathFA(A,b,c,info) *
% on info: 0 - només dóna resultat final *
% 1 - dóna també info. de cada iteració *
%****************************************************
function optim = CamiCentralAugmentat(A,b,c,info)
%--- obté les dimensions del problema, comprovacions preliminars

[m,n]=size(A);
[mb,nb]=size(b);
[mc,nc]=size(c);

x = 100*ones(n,1);
w = A*x-b;
y = 100*ones(m,1);
z = c-A'*y+Q*x;
dx = ones(n,1);
dy = ones(m,1);
%--- Paràmetres
delt = 0.1; %reducció aplicada per el paràmetre barrera
r = 0.9; %r és la reducció de la long. de pas
MaxNorm = 1e10; %valor màxim permés per ||x||, ||y|| (prob il.limitat)
Eps = 1e-6; %tolerància per les infactibilitats rho, sig i per
%la cond. de complementarietat (variable gm)
rho=1; sig=1; gm=1; %valors temporals

if(info>0)
fprintf('\t iter \t\t ||rho|| \t ||sig|| \t fobj\n');
fprintf('\t =========================================================\n');
end%if
%--- Mentre no òptim...

while(norm(x)<MaxNorm)&(norm(y)<MaxNorm)&((norm(rho)>Eps)|(norm(sig)>Eps)|
(gm>Eps))
%--- Calculem infactibilitats primal i dual: rho, sig

rho = b - A*x - w;
sig = c - A'*y + z;

gm = z'*x + y'*w;
mh = delt * (gm /(n + m));
%---------------------------------------------------------
%---------------------------------------------------------
%--- primer: formar el sistema MA * Mx = Mb
%--- Mx contindr… les direccions [dy;dx]
Y = diag(y);
Z = diag(z);
W = diag(w);
MA = [-inv(Y)*W A;
A' inv(X)*Z]; %simŠtrica quasi def. positiva
Mb = [rho-mh*inv(Y)*ones(m,1)+w ;
sig+mh*inv(X)*ones(n,1)-z];
%--- resoldre el sistema factoritzant: P*MA = L*U,

%--- on P ‚s una matriu de permutaci¢, L,U s¢n diagonals
%--- inferior i superior
Mx = lin(MA,Mb);
for i=1:m
dy(i) = Mx(i);
end%for
for i=1:n
dx(i) = Mx(i+m);
end%for
%--- trovar dz, dw

%-----------------------------------
%-----------------------------------
for i=1:n
if((-dx(i)/x(i))>k)
k = -dx(i)/x(i);
end%if
if((-dz(i)/z(i))>k)
k = -dz(i)/z(i);
end%if
end%for
for i=1:m
if((-dy(i)/y(i))>k)
k = -dy(i)/y(i);
end%if
if((-dw(i)/w(i))>k)
k = -dw(i)/w(i);
end%if
end%for
%--- trovem th
th = r * (1/k);

x = x + th*dx;
y = y + th*dy;
z = z + th*dz;
w = w + th*dw;
if(info > 0)
fobj = c'*x;
end%if
ci = ci + 1;
end%while
%--- Retorna
else
optim = x(1:n);
end%if
pause;
%End Function
Llistat de la funció LIN.M.

% Resoldre un sistema lineal d'n equacions amb
% factoritzaci¢ LU de la matriu A del sistema:
%
% Ax=b on A=L*U, L, U triangulars superior/inferior
%
% Us: Lin(A,b)
%
%*****************************
function xs=Lin(A,b)
%*****************************
eps = 0.00001;
[m,n]=size(A);
if(m ~= n)
error('error: matriu A no ‚s n x n');
end
%--- tenim Ax=b => factoritzem: PA=LU, P: permutaci¢

[L,U,P]=lu(A);
%--- resoldre el sistema triangular superior U*x = inv(L)*P*b = z
z = inv(L)*P*b;
x(n) = z(n)/U(n,n);
for i=(n-1):-1:1
s = 0;
for j=(i+1):n
s = s + U(i,j)*x(j);
end%for
x(i) = (z(i) - s) / U(i,i);
end%for
%--- retorna
xs=x(1:n);
%end function
S’han resol els mateixos problemes que per la pràctica 2, i els resultats han estat
idèntics com era d’esperar, ja que només hem canviat la forma de resolució del
sistema d’equacions que ens dóna les direccions de moviment dx, dy.
4. Conclusions.
La diferència entre aquest algorisme i el basat en les equacions normals s’evidencia al
tractar problemes reals de gran tamany amb matrius esparses. Amb el nostre cas no es
detecta cap diferència.
P4: Algorisme primal-dual path-following per a problemes lineals, en la variant

ús de l’heurística de Mehrotra amb les direccions predictor-corrector.
1. Introducció.
S’ha programat aquest algorisme seguint el texte “S.J. Wright, Primal-Dual Interior
Point methods", pàgina 198 (algorisme MPC)
2. Algorisme.
El fitxer Matlab s’anomena PFMeh.M
%****************************************************
%* Algorisme primal-dual heur¡stica de Mehrotra *
%* amb c…lcul de les direccions predictor-corector *
%* per PL. *
% min c'x max b'y *
% Ax = b A'y + z = c *
% x >= 0 z >=0 *
% escrivim *
% x = Meh(A,b,c,info) *
% 1 - informa de cada iteraci¢ *
%****************************************************
function optim = Mehrotra(A,b,c,info)

[m,n]=size(A);
[mb,nb]=size(b);
[mc,nc]=size(c);
%--- Inicialitzem (x,y,z) punt estrictament positiu (no massa infactible)

t = -100;
yy = inv(A*A')*((1/(2*t))*b + A*c);
x = (0.5/t) * (A'*yy - c);
y = zeros(m,1);
z=c;
for i=1:n
if(x(i)<=0) x(i)=100; end%if
if(z(i)<=0) z(i)=100; end%if
end%for
dza = z; dzc = z;
dya = y; dyc = y;
dxa = x; dxc = x;
k = 2*n+m; %dimensions de la matriu del sistema lineal (Newton)

Mx = ones(k,1); Mxc = Mx;
%--- Par…metres
mh = 0.9; %par…metre de centrat fix (mŠtode d'escalat af¡)
MinNorm = 1e-10; %valor m¡nim perm‚s per ||x||
MaxNorm = 1e10; %valor m…xim perm‚s per ||y|| (prob il.limitat)
MaxIter = 50; %nombre m…xim d'iteracions
if(info>0)
fprintf('iter\t\t ||rho||\t ||sig||\t gap\t\t fobj\n');
fprintf('============================================================\n');
end%if

rho = norm(A*x-b); %infactibilitat primal
sig = norm(A'*y + z - c); %infactibilitat dual
comp = x'*z; %cond. de complementarietat
mh = comp/n; %par…metre de centrat
while((ci<=MaxIter)&(norm(x)>MinNorm)&(norm(y)<MaxNorm)&((rho>Eps)|
(sig>Eps)|(comp>Eps)))
%---------------------------------------------------------
%--- Trovar les direccions de moviment dxa, dya, dza ----
%--- segons el mŠtode d'escalat af¡ (predicci¢) ----
%---------------------------------------------------------
%--- primer: formar el sistema d'equacions normals
%--- MA * Md = Mb
%--- Md contindr… les direcci¢ af¡ segons x,y,z

Y = diag(y);
Z = diag(z);
D = (Z^(-1/2))*(X^(1/2));
Unit = diag(ones(n,1),0);
rc = A'*y + z - c; %terme independent del pas af¡

rb = A*x - b;
rxs = X*Z*ones(n,1);
MA = [zeros(n,n) A' Unit;

A zeros(m,m) zeros(m,n);
Z zeros(n,m) X ];
Mb = [ -rc; -rb; -rxs];
Md = MA \ Mb;
for i=1:n
dxa(i) = Md(i);
end%for
for i=1:m
dya(i) = Md(i+n);
end%for
for i=1:n
dza(i) = Md(i+n+m);
end%for
%--------------------------------------------------------------
%- Calcular les llargades de pas alf_prim_aff, alf_dual_aff -
%--------------------------------------------------------------
alf_prim_aff=0; %cota inferior
for k=1:n
alf=-dxa(k)/x(k);
if((alf>=0)&(alf>alf_prim_aff))
alf_prim_aff=alf;
end%if
end%for
alf_prim_aff = 1/alf_prim_aff;
if(alf_prim_aff>1) alf_prim_aff = 1; end%if
alf_dual_aff=0; %cota inferior

for k=1:n
alf=-dza(k)/z(k);
if((alf>=0)&(alf>alf_dual_aff))
alf_dual_aff=alf;
end%if
end%for
alf_dual_aff = 1/alf_dual_aff;
if(alf_dual_aff>1) alf_dual_aff = 1; end%if
%--- mesura de l'efica‡ia de la direcci¢ d'escalat af¡

mh_aff = ((x + alf_prim_aff*dxa)'*(z + alf_dual_aff*dza))/n;
%--- par…metre de centrat (heur¡stic)

sig = (mh_aff/mh)^3;
%------------------------------------------------
%--- Trovar les direccions de pas corretgides, -
%--- dxc, dyc, dzc -> Mdc -
%------------------------------------------------
DX = diag(dxa);
DZ = diag(dza);
rc = zeros(n,1); %terme independent del pas corrector

rb = zeros(m,1);
rxs = -sig*mh*ones(n,1) + DX*DZ*ones(n,1);
Mb = [-rc; -rb; -rxs];
Mdc = MA \ Mb;
for i=1:n
dxc(i) = Mdc(i);
end%for
for i=1:m
dyc(i) = Mdc(i+n);
end%for
for i=1:n
dzc(i) = Mdc(i+n+m);
end%for
%--- c…lcul de la passa predictor-corrector dx, dy, dz

dx = dxa + dxc;
dy = dya + dyc;
dz = dza + dzc;
%-------------------------------------------------------------------
%- Calcular les llargades de pas m…ximes alf_prim_max, alf_dual_max
-
%-------------------------------------------------------------------
alf_prim_max=0; %cota inferior
for k=1:n
alf=-dx(k)/x(k);
if((alf>=0)&(alf>alf_prim_max))
alf_prim_max=alf;
end%if
end%for
alf_prim_max = 1/alf_prim_max;
alf_dual_max=0; %cota inferior

for k=1:n
alf=-dz(k)/z(k);
if((alf>=0)&(alf>alf_dual_max))
alf_dual_max=alf;
end%if
end%for
alf_dual_max = 1/alf_dual_max;
%--- correcci¢ de les long. de pas primal i dual

if((0.99*alf_prim_max) < 1)
alf_prim = 0.99*alf_prim_max;
else
alf_prim = 1;
end%if
if((0.99*alf_dual_max) < 1)
alf_dual = 0.99*alf_dual_max;
else
alf_dual = 1;
end%if
%------ actualitzar el punt (x,y,z)

x = x + alf_prim * dx;
y = y + alf_dual * dy;
z = z + alf_dual * dz;
rho = norm(A*x-b); %infactibilitat primal

sig = norm(A'*y + z - c); %infactibilitat dual
comp = x'*z; %cond. de complementarietat
mh = comp/n; %par…metre de centrat
fobj = c'*x;
gap = fobj-b'*y;
if(info > 0)
fprintf('%f',ci);
fprintf('\t %f',rho);
fprintf('\t %f',sig);
fprintf('\t %f',gap);
end%if
ci = ci + 1;
end%while
%--- Retorna
if(norm(x)<=MinNorm)|(norm(y)>=MaxNorm)
else
if(ci>MaxIter)
fprintf('Masses iteracions, posible problema infactible');
fobj = c'*x;
fprintf('\tvalor funci¢ = %f\n',fobj);
x
else
optim = x(1:n);
end%if
end%if
%End Function
3. Proves de l’algorisme
S’han provat els problemes P1E1 i P1E2 I en els dos casos obtenim l’òptim:
» load p1e1
» pfmeh(A,b,c,0)
Warning: Divide by zero

ans =
0.0000
2.0000
0.0000
4.0000
» load p1e2
» pfmeh(A,b,c,0)
ans =
1.5000
0.5000
0.0000
5.5000
0.0000
»
4. Conclusions.
Comparant l’algorisme P1 amb el P4 veiem que:
Algorisme Iteracions P1E1 Iteracions P1E2

Escalat afí primal 12 9
Predictor-Corrector 13 10

variant ús del sistema augmentat
1. Introducció.
S’ha seguit l’algorisme tal com es descriu en Vanderbei, pàgina 383. Cal advertir que
hi ha un error en aquest texte; en el sistema d’equacions per trovar les direccions dx,
dy, en el terme independent on diu:
B – Ax – Y-1e
ha de dir:
B – Ax + Y-1e
2. Algorisme.
%****************************************************
%* "£s del sistema augmentat" (sistema simŠtric *
%* quasi definit positiu => fact. est…ndard) per *
% programaci¢ quadr…tica convexa (Q semid.positiva)*
% min c'x+x'Qx/2 max b'y-x'Qx/2 *
% Ax - w = b A'y + z - Qx = c *
% x,w >= 0 y,z >=0 *
% escrivim *
% x = ProgQA(A,b,c,Q,info) *
% *
% 1 - informa del progres en cada iteraci¢ *
%****************************************************
function optim = PathFollowingPQ(A,b,c,Q,info)
[m,n]=size(A);
[mb,nb]=size(b);
[mc,nc]=size(c);
[mq,nq]=size(Q);
if((mq ~= n) | (nq ~= n)) error('error: Q t‚ dimensions incorrectes');end

x = 100*ones(n,1);
z = x;
w = A*x - b + 10*ones(m,1);
y = 100*ones(m,1);
for i=1:n
if (w(i)<0)w(i)=1; end%if
end%for
dx = ones(n,1);
dy = ones(m,1);
Mb = ones(n+m,1);
%--- Par…metres
mi = 30; %nombre m…xim d'iteracions
rho=1; sig=1; gm=1; gap=1; %valors temporals

if(info>0)
fprintf(' iter \t\t ||rho|| \t ||sig|| \t gap \t\t fobj\n');
fprintf('
============================================================================
=\n');
end%if

while(ci<mi)&(norm(x)<MaxNorm)&(norm(y)<MaxNorm)&((norm(rho)>Eps)|
(norm(sig)>Eps)|(abs(gap)>Eps))
%--- Calculem infactibilitats primal i dual: rho, sig, i el gap dual

rho = b - A*x + w;
sig = c - A'*y - z + Q*x;
fobj = c'*x + 0.5*x'*Q*x;
gap = fobj - (b'*y - 0.5*x'*Q*x);
if(info == 1)
fprintf('%f',ci);
end%if

gm = z'*x + y'*w;
mh = delt * (gm /(n + m));
%---------------------------------------------------------
%---------------------------------------------------------
%--- Mx contindr… les direccions [dx;dy]
Y = diag(y);
Z = diag(z);
W = diag(w);
MA = [-(inv(X)*Z + Q) A';
A inv(Y)*W ];
Mb1 = c - A'*y + mh*inv(X)*ones(n,1) + Q*x;
Mb2 = b - A*x + mh*inv(Y)*ones(m,1);
Mb=[Mb1;Mb2];
Mx = MA\Mb;
for i=1:n
dx(i) = Mx(i);
end%for
for i=1:m
dy(i) = Mx(i+m);
end%for
%--- trovar dz, dw

%-----------------------------------
%-----------------------------------
for i=1:n
if((-dx(i)/x(i))>k)
k = -dx(i)/x(i);
end%if
if((-dz(i)/z(i))>k)
k = -dz(i)/z(i);
end%if
end%for
for i=1:m
if((-dy(i)/y(i))>k)
k = -dy(i)/y(i);
end%if
if((-dw(i)/w(i))>k)
k = -dw(i)/w(i);
end%if
end%for
%--- trovem th
th = r * (1/k);
if (th > 1) th = 1; end%if

x = x + th*dx;
y = y + th*dy;
z = z + th*dz;
w = w + th*dw;
ci = ci + 1;
end%while
%--- Retorna
break;
end%if
if(ci==mi)
fprintf('masses iteracions: avortat. x = ')
for i=1:n
fprintf('%f, ',x(i));
end%for
fprintf('\n w = ');
for i=1:m
fprintf('%f, ',w(i));
end%for
break;
end%if

optim = x(1:n);
%End Function
3. Proves de l’algorisme.
El problema quadràtic és el seguent:
Min x1 + x2+ x1x2 +0.5x12 + 0.5x22

Subjecte a x1 - x21
-x1 + 4x24
xi 0 i=1..2
Les dades d’aquest problema estan en el fitxer PROGQ.MAT .Geomètricament és

inmediat veure que la sol.lució és (8/3, 5/3) amb un valor de 79/9. El resultat de
l’execució és:
progqa(A,b,c,Q,1)
iter ||rho|| ||sig|| gap fobj
======================================================================
1.000000 14.142136 223.163617 39700.000000 20200.000000
2.000000 0.000000 36.415999 12868.574479 6679.782836
3.000000 0.000000 19.729683 3908.161576 2088.379738
4.000000 0.000000 10.861346 1180.537272 665.442521
5.000000 0.000000 5.964291 354.889712 220.969224
6.000000 0.000000 3.231618 105.099736 79.294237
7.000000 0.000000 1.688527 29.475566 32.995500
8.000000 0.000000 0.796933 6.713626 18.068826
9.000000 0.000000 0.282553 0.758812 14.322545
10.000000 0.000000 0.054437 0.026518 13.805362
11.000000 0.000000 0.006639 0.000813 13.732003
12.000000 0.000000 0.000693 0.000010 13.723207
13.000000 0.000000 0.000070 0.000000 13.722321
14.000000 0.000000 0.000007 0.000000 13.722232
15.000000 0.000000 0.000001 0.000000 13.722223
ans =
2.6667
1.6667
»

variant transformació del problema en un equivalent separable, usant aleshores
les equacions normals
1. Introducció.
En aquest mètode usem la transformació descrita en Vanderbei pàgina 384 per pasar
d’un problema quadràtic convex a un de separable equivalent. La sol.lució del sistema
que dóna la direcció de moviment dx es realitza amb la rutina LIN.M la qual tracta els
pivots massa petits que poden apareixer. La funció TRIANG.M realitza la
factorització Q = F’DF. Les variables lliures que apareixen al transformar el problema
en separable es tracten amb una vanvi de variable del tipus y = y1 – y2 on y és lliure ,
y1,y2 són positives. Aquesta implementació està en el fitxer PROGQN3.M i és la que
es llista en aquest document. Existeix un altre versió en el fitxer PROGQN2.M que
manté la variables lliures, obtenint el pas de les variables primals sense tenir en
compte les lliures. En el cas de que al avançar una passa alguna de les variables lliures
pasi a valdre zero o negatiu s’efectúa el canvi de variable x’ = 2 – x i es modifica
convenientment la matriu de restriccions A i el terme independent b. Aquest
algorisme alternatiu ha estat també provat amb èxit.
2. Algorisme.
El llistat de LIN.M és:
% Resoldre un sistema lineal d'n equacions amb
% factoritzaci¢ LU de la matriu A del sistema:
%
% Ax=b on A=L*U, L, U triangulars superior/inferior
%
% Us: Lin(A,b)
%
%*****************************
function xs=Lin(A,b)
%*****************************
eps = 0.00001;
[m,n]=size(A);
if(m ~= n)
error('error: matriu A no ‚s n x n');
end%if
cotaInf = 1e-12;
cotaSup = 1e32;
%--- tenim Ax=b => factoritzem: PA=LU, P: permutaci¢
[L,U,P]=lu(A);
%--- resoldre el sistema triangular superior U*x = inv(L)*P*b = z
z = inv(L)*P*b;
if(abs(U(n,n))<cotaInf) U(n,n)=cotaInf; end%if
x(n) = z(n)/U(n,n);
for i=(n-1):-1:1
s = 0;
for j=(i+1):n
s = s + U(i,j)*x(j);
end%for
if(abs(U(i,i))<cotaInf) U(i,i)=cotaInf; end%if
x(i) = (z(i) - s) / U(i,i);
end%for
%--- retorna
xs=x(1:n);
%end function
El codi de TRIANG.M és el següent:

%factorització A=SDS' d'una matriu simètrica
%us: fact(A)
%retorna: una matriu R que conté a S triangular inferior i com
% a última fila un vector dels elements diagonals de D
function S=triang(A)
[m,n]=size(A)
if(m~=n) error('error: matriu no és nxn'); end%if;
for j=1:n
R(j,j)=1;
sum = 0;
for i=1:(j-1)
sum=sum+R(n+1,i)*R(j,i)^2;
end%for
R(n+1,j)=A(j,j) - sum;
for k=(j+1):n
sum = 0;
for i=1:(j-1)
sum = sum + R(n+1,i) * R(j,i) * R(k,i);
end%for
R(k,j) = (A(k,j) - sum)/R(n+1,j);
end%for
end%for
S=R;
%end Function
El fitxer PROGQN3.M conté l’algorisme del mètode:

%**************************************************************************
%* Algorisme primal-dual Path-Following per programaci¢ quadr…tica convexa*
%*(Q semid.positiva).Versió: transformació en un problema equivalent *
%separable, usant aleshores les equacions normals. *
%* Versió: substituir les variables lliures que apareixen en la transf. per
% altres estàndard. *
%***************************************************************************
******
% min c'*u+u'Qu/2 max b'y-u'Qu/2 *
% A*u - w = b A'*y + z - Qu = c *
% u,w >= 0 y,z >=0 *
% escriurem:
*
% x = ProgQR(A,b,c,Q,info) *
% *
% 1 - informa del progres en cada iteraci¢ *
%***************************************************************************
******
function optim = PathFollowingPQ(A,b,c,Q,info)

[m,n]=size(A);
[mb,nb]=size(b);
[mc,nc]=size(c);
[mq,nq]=size(Q);

if((mq ~= n) | (nq ~= n)) error('error: Q té dimensions incorrectes');end
if(rank(A) ~= m) error('error: A no és de rang complet');end
%--- Transformació en un problema separable equivalent: Q = F'DF

%--- Min c'*x + 0.5*x*D*x
%--- subjecte a A*x >= b, x>=0
%--- amb el canvi x = [u y1 y2], y = y1 - y2, y = Fx variable lliure
R = triang(Q); % R conté una matriu triangular inferior i la diagonal en

l'ùltima fila
F = zeros(n,n);
D = F;
for i=1:n
for j=1:n
F(j,i) = R(i,j);
end%for
D(i,i) = R(n+1,i);
end%for
QQ = F'*D*F;
for i=1:n
for j=1:n
if(QQ(i,j)~=Q(i,j)) error('error: Q no és semidef. positiva'); end%if
end%for
end%for
[k,k] = size(D);
%--- Canviem al nou problema separable

Unit = diag(ones(k,1),0); %matriu unitaria k x k;
Q = [zeros(n,n) zeros(n,k) zeros(n,k);
zeros(k,n) D -D;
zeros(k,n) -D D ];
c = [c; zeros(2*k,1)];
A = [A zeros(m,k) zeros(m,k);
F -Unit Unit ];
b= [b; zeros(k,1)];
n0 = n;
n = n + 2*k; % tenim k noves restriccions i 2k noves variables
m = m + k;

x = 100*ones(n,1);
z = x; w=100*ones(m,1);
y = 100*ones(m,1);
dx = x;
dy = y;
Mb = ones(n + m,1);
%--- Par…metres
mi = 20; %nombre m…xim d'iteracions
Eps = 0.5; %toler…ncia per les infactibilitats rho, sig i per la
mh = 1; rho=1; sig=1; gm=1; gap=1; th = 1; %valors temporals

if(info>0)
fprintf(' iter \t\t ||rho|| \t ||sig|| \t gap \t\t fobj\n');
fprintf('
============================================================================
=\n');
end%if

while(ci<mi)&(norm(x)<MaxNorm)&(norm(y)<MaxNorm)&((norm(rho)>Eps)|
(norm(sig)>Eps)|(abs(gap)>Eps))
%--- Calculem infactibilitats primal i dual: rho, sig, i el gap dual

rho = b - A*x + w;
sig = c - A'*y - z + Q*x;
fobj = c'*x + 0.5*x'*Q*x;
gap = fobj - (b'*y - 0.5*x'*Q*x);
if(info == 1)
fprintf('%f',ci);
fprintf(' %f\n ',fobj);
end%if

gm = z'*x + y'*w;
mh = delt * (gm /(n + m));
%-------------------------------------------------
%--- Trovar les direccions de moviment
%-------------------------------------------------
%--- primer: direcció dx, dy

Y = diag(y);
Z = diag(z);
W = diag(w);
%eqs. normals....
MA = -(A'*inv(W)*Y*A + inv(X)*Z + Q);
Mb = sig - mh*inv(X)*ones(n,1) - A'*inv(W)*Y*(rho +
mh*inv(Y)*ones(m,1) - w);
dx = lin(MA,Mb);
dx = dx';
dy = inv(W)*Y*(rho + mh*inv(Y)*ones(m,1) - w - A*dx);
%--- segon: dz, dw

%-----------------------------------
%-----------------------------------
%--- trovem m…xim -dx/x,-dy/y,-dz/z,-dw/w, -du/u, -dyb/yb ->k
k1 = -1e-50; %cota inferior per cerca del m…xim (primal i dual)
k2 = k1;
for i=1:n
if((-dx(i)/x(i))>k1)
k1 = -dx(i)/x(i);
end%if
if((-dz(i)/z(i))>k2)
k2 = -dz(i)/z(i);
end%if
end%for
for i=1:m
if((-dy(i)/y(i))>k2)
k2 = -dy(i)/y(i);
end%if
if((-dw(i)/w(i))>k1)
k1 = -dw(i)/w(i);
end%if
end%for
%--- trovem th
th1 = abs(r * (1/k1));
if (th1 > 1) th1 = 1; end%if
th2 = abs(r * (1/k2));
if (th2 > 1) th2 = 1; end%if

x = x + th1*dx;
y = y + th2*dy;
z = z + th2*dz;
w = w + th1*dw;
ci = ci + 1;
end%while
%--- Retorna
break;
end%if
if(ci==mi)
fprintf('masses iteracions: avortat. x = ')
for i=1:n
fprintf('%f, ',x(i));
end%for
fprintf('\n w = ');
for i=1:m
fprintf('%f, ',w(i));
end%for
break;
end%if

optim = x(1:n0);
%End Function
S’ha resolt el mateix problema quadràtic que en la pràctica 5 (fitxer de dades
PROGQ.MAT) obtenint el mateix resultat. El llistat d’execució és:
» load progq
» progqn3(A,b,c,Q,1)
iter ||rho|| ||sig|| gap fobj
===========================================================================
1.000000 242.109479 691.666104 -300.000000 200.000000
2.000000 0.000000 366.246178 2559.878660 1542.388605
3.000000 0.000000 170.195105 621.073046 541.472703
4.000000 0.000000 77.383538 443.050818 487.646286
5.000000 0.000000 37.316605 664.819022 687.536279
6.000000 0.000000 18.502488 929.628434 940.238816
7.000000 0.000000 9.764536 1120.542428 1126.059068
8.000000 0.000000 5.605070 1031.151350 1034.503749
9.000000 0.000000 3.218797 675.629030 677.888408
10.000000 0.000000 1.758133 327.897238 329.624857
11.000000 0.000000 0.928069 136.189600 137.744802
12.000000 0.000000 0.512367 39.501444 41.019137
13.000000 0.000000 0.408068 8.944760 10.487229
14.000000 0.000000 0.400519 3.261844 5.188068
15.000000 0.000000 0.339248 1.528659 4.463177
16.000000 0.000000 0.141515 0.488480 4.348393
ans =
2.6681
1.6675
»
4. Conclusions.
El nombre d’iteracions ha estat pràcticament igual a l’anterior mètode que usaba el
sistema augmentat. La diferència només la podrem trovar en problemes grans i
esparsos i algorismes que utilitzin rutines de tractament de l’esparsitat.
P7: Algorisme primal-dual path-following per a problemes convexos (variant ús

del sistema augmentat).
1. Introducció.
Aquest algorisme està basat en el sistema d’equacions que es presenta en Vanderbei
pàgina 393 eqs. 24.3 .Per implementar-lo en Matlab s’han programat un conjunt de
funcions de càlcul dels gradients i hessians de forma que l’algorisme del mètode resta
independent del programa convex a resoldre. Per cada problema caldrà modificar
cadascuna d’aquestes funcions abans d’executar l’algorisme. Aquestes funcions són:
Nom funció retorna

VA(x) valor d’A(x): vector d’m components
VC(x) valor de c(x)
GA(x) matriu m x n del gradient d'A en x
GC(x) vector d’n components del gradient de c(x)
HC(x) matriu n x n del hessià de c en x
HA(x) m matrius del hessià d’A en x
L’ùltima funció, HA(x), retorna una matriu mn x n que conté els m hessians de les
restriccions A(i) amb el següent format: les m primeres files són el hessià de la
restricció A(1), les m seguents el hessià d'A(2), etc.
L’algorisme accepta tres paràmetres: el punt inicial, el vector b de termes

independents constants i el nivell d’informació a proporcionar en la sortida.
2. Algorisme.
El fitxer PROGCON.M conté el següent script:
%************************************************************************
%* Algorisme primal-dual Path-Following adaptat a programes convexos. *
%************************************************************************
%* Us: per resoldre el problema *
% min c(x) c(x) funció convexa d'n variables *
% A(x) + w = b A(x) conté m funcions còncaves *
% w >= 0 *
% escrivim *
% x = ProgCon(x0,b,info) *
% *
% on x0: punt inicial (interior) *
% *
% *
% Previament informarem les seguents funcions auxiliars: VA dóna A(x) *
% VC dóna c(x), gA retorna el gradient d'A, gC el fradient de c, Hc el *
% hessià de c i HA retorna una matriu que conté els m hessians de les *
% restriccions A(i)les m primeres files són el hessià de la restricció *
%A(1), les m seguents el hessià d'A(2), etc. * %
Paràmetre info: 0 - nom‚s d¢na resultat final *
% 1 - informa sobre l'avanç en cada iteració *
%************************************************************************
function optim = CamiCentral(x,b,info)
[nx,mx] = size(x);
[nb,mb] = size(b);
if (mx~=1) error('error: el paràmetre x0 ha de ser un vector'); end%if
if (mb~=1) error('error: b ha de ser un vector'); end%if
n = nx; m = nb;
y = 10*ones(m,1);
w = y;
dx = x; dy = y; dw = w;
%--- Par…metres
Eps = 1e-6; %toler…ncia per la infactibilitat rho, sig i gap dual
MaxIter = 100; %iteracions màximes
rho=ones(n,1);
sig=ones(m,1);
gap=1; %valors temporals
if(info>0)
fprintf('\t iter \t\t ||rho|| \t ||sig|| \t |gap| \t\t fobj\n');
fprintf('\t
=========================================================================\
n');
end%if

while (ci<MaxIter)&(norm(x)<MaxNorm)&(norm(y)<MaxNorm)&((norm(rho)>Eps)|
(norm(sig)>eps)|(abs(gap)>eps))
%--- Calculem infactibilitats
rho = va(x) - w - b;
Msum = zeros(n,1);
GradA = ga(x);
for i=1:m
Msum = Msum + y(i)*GradA(i,1:n)';
end%for

gm = y'*w;
mh = delt * gm /m ;
%---------------------------------------------------------
%--- Trovar les direccions de moviment dx, dy, dw ----
%---------------------------------------------------------
%--- Mx contindr… les direccions [dx;dy]
Y = diag(y);
W = diag(w);
Msuma = zeros(n,n);
HA = ha(x);
for i=1:m
Hess_i = HA((i-1)*n + 1:i*n, 1:n); %hessià de la i-èsima
restricció
Msuma = Msuma + y(i)*Hess_i;
end%for
MA = [-hc(x)+ Msuma ga(x)';

ga(x) W*inv(Y) ];
Mb = [gc(x) - ga(x)'*y;
b - va(x) + mh*inv(Y)*ones(m,1)];
Mx = lin(MA,Mb);
Mx = Mx’;
for i=1:n
dx(i) = Mx(i);
end%for
for i=1:m
dy(i) = Mx(i+n);
end%for
%--- trovar dw
Vec = zeros(m,1);
for i=1:m
Vec(i) = -(w(i)/y(i))*dy(i);
end%for
dw = Vec + mh*(inv(Y)*ones(m,1)) - w;
%-----------------------------------
%-----------------------------------
%--- trovem m…xim -dx/x,-dy/y,-dw/w ->k
for i=1:n
if((-dx(i)/x(i))>k)
k = -dx(i)/x(i);
end%if
end%for
for i=1:m
if((-dy(i)/y(i))>k)
k = -dy(i)/y(i);
end%if
if((-dw(i)/w(i))>k)
k = -dw(i)/w(i);
end%if
end%for
%--- trovem th
th = r * (1/k);
%------ actualitzar el punt (x,y,w)

x = x + th*dx;
y = y + th*dy;
w = w + th*dw;
if(info > 0)
%--- func. objectiu i gap dual
fobj = vc(x);
suma = 0;
for i=1:m
suma = suma + log(w(i));
end%for
gap = mh*suma + y'*(b - va(x) + w);
end%if
ci = ci + 1;
end%while
%--- Retorna
if (ci>=MaxIter) error('error: masses iteracions'); end%if
else
optim = x(1:n);
end%if
pause;
%End Function
3. Proves de l’algorisme.
S’ha provat de resoldre el següent programa convex (font: Programación Matemática,
tomo 2, UNED):
Min x12 + x22 - 16x1-10x2

Subjecte a -x12 + 6x1-4x2
x1x2- 3x2- exp(x1- 3) 1
xi 0 i=1..2
La sol.lució és: (5.3, 3.7).
A continuació es llisten les funcions auxiliars que implementen aquest problema en

Matlab:
function valorA = VA(x)
%*********************************************************
% valor de la funció A(x); es cridada per la funció
% progcon.m Retorna un vector de m components.
%*********************************************************
[n,m] = size(x);
if (m ~= 1) error('error: x ha de ser un vector columna'); end%if
if (n ~= 2) error('error: x té dimensió errònia'); end%if
valorA = zeros(4,1);
valorA(1) = -x(1)^2 + 6*x(1) -4*x(2);

valorA(2) = x(1)*x(2) -3*x(2) - exp(x(1)-3);
valorA(3) = x(1);
valorA(4) = x(2);
%end function
function valorC = c(x)
%*********************************************************
% valor de la funció c(x); es cridada per la funció
% progcon.m Retorna un real.
%*********************************************************
[n,m] = size(x);
valorC = x(1)^2 + x(2)^2 -16*x(1) - 10*x(2);
%end function
function gradA = gA(x)
%*********************************************************
% gradient de la matriu A(x); es cridada per la funció
% progcon.m Torna una matriu m x n
%*********************************************************
[n,m] = size(x);
gradA(1,1) = -2*x(1) + 6;
gradA(1,2) = -4;
gradA(2,1) = x(2) + (3 - x(1))*exp(x(1) - 3);

gradA(2,2) = x(1) - 3;
gradA(3,1) = 1;
gradA(3,2) = 0;
gradA(4,1) = 0;
gradA(4,2) = 1;
%end function
function gradC = gc(x)
%*********************************************************
% valor del gradient de c en x; es cridada per la funció
% progcon.m Retorna un vector d'n components.
%*********************************************************
[n,m] = size(x);
gradC = zeros(n,1);
gradC(1) = 2*x(1) - 16;
gradC(2) = 2*x(2) - 10;
%end function
function HessA = HA(x)
%*********************************************************
% Hessians de les funcions a(x); es cridada per la funció
% progcon.m Retorna una matriu mn x n
%*********************************************************
[n,m] = size(x);
%--- hessiá de la 1ª restricció

HessA(1,1) = -2;
HessA(1,2) = 0;
HessA(2,1) = 0;
HessA(2,2) = 0;

HessA(3,1) = (-1 -(3 - x(1)))*exp(x(1) - 3);
HessA(3,2) = 1;
HessA(4,1) = 1;
HessA(4,2) = 0;

HessA(5,1) = 0;
HessA(5,2) = 0;
HessA(6,1) = 0;
HessA(6,2) = 0;

HessA(7,1) = 0;
HessA(7,2) = 0;
HessA(8,1) = 0;
HessA(8,2) = 0;
%end function
function HessC = Hc(x)
%*********************************************************
% Hessià de la funció c(x); es cridada per la funció
% progcon.m Retorna una matriu n x n
%*********************************************************
[n,m] = size(x);
HessC(1,1) = 2;
HessC(1,2) = 0;
HessC(2,1) = 0;
HessC(2,2) = 2;
%end function
El resultat de l’execució en Matlab ha estat el següent:
» x0=[10;10]
» b=[-11;-1;0;0]
» progcon(x0,b,0)
Warning: Matrix is close to singular or badly scaled.

Results may be inaccurate. RCOND = 6.503630e-034
ans =
5.2396
3.7460

Optimització Lineal Amb Mètodes Diferenciables I de Punt Interior

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Optimització Lineal Amb Mètodes Diferenciables I de Punt Interior

Uploaded by

Copyright:

Available Formats

Curs de doctorat: Mètodes de punt interior.

Alumne: Jordi Cuesta i Andrea 1

Alumne: Jordi Cuesta i Andrea

Curs acadèmic 99/2000

Contingut d’aquest document:

 Temari del curs, bibliografía i avaluació.

Cada pràctica s’ha estructurat en quatre apartats:

1. Introducció: informa de la font bibliogràfica en la que es basa el

T1. Algorisme d'escalat afí.

T2. Algorisme primal-dual "path-following" (de seguiment de camí).

T3. Aspectes d'implementació de l'algorisme primal-dual path-following.

T4. Extensions a problemes quadràtics i convexos.

T5. Mètodes per a problemes no lineals.

Avaluació: Entrega d'alguns dels algorismes estudiats, programats en Matlab.

1) Algorisme d'escalat afí primal del T1.

% Algorisme de l'escalat af¡ primal per P.L.

%------ comprova que les dimensions siguin coherents

if((nc ~= 1) | (nb ~= 1))

if((mc ~= n) | (mb ~= m))

% ----- info de les dimensions dels problema

alph = min(-x(dx<myeps) ./ dx(dx<myeps));

% ---- mostra informació en cada iteració

S’han resolt dos problemes lineals. El primer és el que apareix en la bibliografía

El segon problema s’ha pres del mateix document, pàgina 25 exemple 6:

Min -3x1 - 2x2

P2:Algorisme primal-dual path-following per a problemes lineals, en la

function optim = CamiCentralNormal(A,b,c,info)

%--- obtŠ les dimensions del problema, comprovacions preliminars

%--- Inicialitzem (x,w,y,z) punt arbitrari estrictament positiu

rho=1; sig=1; gm=1; %valors temporals

%--- Mentre no •ptim...

%--- Calculem infactibilitats primal i dual: rho, sig

%--- Calculem el valor del "par…metre de barrera": mh

Em2 = inv(Y)*W; % E elevat a -2

MA = (Em2 + A*D2*A'); %simŠtrica def. positiva

%--- resoldre el sistema factoritzant per Cholesky

%------ actualitzar el punt (x,y,w,z)

Llistat de la rutina SISTLIN.M

%--- tenim Ax=b => R'Rx=b

Max 5x1 + 4x2+ 6x3

(Font: Mètodos de Programación Matemàtica, tomo 2, UNED). La sol.lució segons el

El segon problema resolt (fitxer P2E2) ha estat el següent:

Max 4x1 + 12x2+ 3x3

Aquest problema s’ha copiat de la mateixa referència anterior, segons la qual la

P3: Algorisme primal-dual path-following per a problemes lineals, en la variant

function optim = CamiCentralAugmentat(A,b,c,info)

%--- obté les dimensions del problema, comprovacions preliminars

%--- Inicialitzem (x,w,y,z) punt arbitrari estrictament positiu

rho=1; sig=1; gm=1; %valors temporals

%--- Mentre no òptim...

%--- Calculem infactibilitats primal i dual: rho, sig

%--- Calculem el valor del "par…metre de barrera": mh

%--- resoldre el sistema factoritzant: P*MA = L*U,

%--- trovar dz, dw

%------ actualitzar el punt (x,y,w,z)

Llistat de la funció LIN.M.

%--- tenim Ax=b => factoritzem: PA=LU, P: permutaci¢

%--- resoldre el sistema triangular superior U*x = inv(L)*P*b = z

P4: Algorisme primal-dual path-following per a problemes lineals, en la variant

function optim = Mehrotra(A,b,c,info)

%--- obtŠ les dimensions del problema, comprovacions preliminars

%--- Inicialitzem (x,y,z) punt estrictament positiu (no massa infactible)

k = 2*n+m; %dimensions de la matriu del sistema lineal (Newton)

MA = (Em2 + AD2A'); %simŠtrica def. positiva

%--- resoldre el sistema factoritzant: PMA = LU,

%--- resoldre el sistema triangular superior Ux = inv(L)P*b = z

%--- resoldre el sistema triangular superior Ux = inv(L)P*b = z

valorA(1) = -x(1)^2 + 6x(1) -4x(2);

valorC = x(1)^2 + x(2)^2 -16x(1) - 10x(2);