CURSUL NR. 9.

PREZENTAREA FUNCŢIILOR CONŢINUTE ÎN MATLAB-

OPTIMIZATION TOOLBOX-partea a treia

5. fminsearch
Scop: procedura determina minimul pentru o functie multivariabila fara constringeri

unde
este un vector iar f(x) o functie care retuneaza un scalar
Sintaxa:
x = fminsearch(fun,x0)
x = fminsearch(fun,x0,options)
x = fminsearch(fun,x0,options,P1,P2,...)
[x,fval] = fminsearch(...)
[x,fval,exitflag] = fminsearch(...)
[x,fval,exitflag,output] = fminsearch(...)

Descriere: procedura fminsearch , asa cum a fost definita anterior, rezolva problemele
de optimizre de tip neliniar si fara constringeri.

x = fminsearch(fun,x0) procedura porneste din punctul initial x0 (care poate fi un

scalar, vector sau matrice) si determina minimul x al functiei descrisa in fun
x = fminsearch(fun,x0,options) priocedura minimizeaza folosind parametrii setati in
structura options. Se utilizeaza functia optimset pentru setarea parametrilor.
x = fminsearch(fun,x0,options,P1,P2,...) transfera problema dependenta de parametrii
P1, P2, etc., direct functiei fun. Se seteaza options = [] in situatia in care nu sunt
optiuni setate.
[x,fval] = fminsearch(...) returneaza in fval valoarea functiei obiectiv fun in x
[x,fval,exitflag] = fminsearch(...) returneaza o valoare exitflag valoare ce descrie
conditiile de iesire din procedura fminsearch.
[x,fval,exitflag,output] = fminsearch(...) returneaza o structura output, ce contine
informatii despre optimizare

1
Argumente de intrare :
fun functie de minimizat. fun accepta un vector x si returneaza un scalar f, ce
reprezinta functia obiectiv evaluata in x. Functia fun se scrie::
x = fminsearch(@myfun,x0,A,b) unde myfun este o functie MATLAB :
function f = myfun(x)
f = ... % calculeaza faloarea functiei in x
fun poate fi de asemenea si un obiect in-line:
x = fminsearch(inline('norm(x)^2'),x0,A,b);

Argumente de iesire:
exitflag descrie conditiile de iesire
>0 functia converge catre solutia x
0 numarul maxim de functii evaluate prin algoritm a fost depasit
<0 functia nu converge catre o solutie
output contine informatii despre optimizare, avind structura:
iterations numarul de iteratii considerate
funcCount numarul evaluarilor functiei.
algorithm algoritm folosit

Optiuni:
Display tipurile afisarii 'off' nu se afiseaza iesirea; 'iter' se afiseaza iesirea dupa fiecare
iteratie; 'final' se afiseaza doar iesirea finala.
MaxFunEvals numarul maxim permis pentru evaluarile functiei
MaxIter numarul maxim permis pentru iteratii
TolFun limita tolerantei pentru valorile functiei
TolX limita tolerantei pentru x

Exemplu: sa se minimizeze functia unidimensionala

Pentru a cera un M-file deforma fun = 'myfun' se creaza file-ul myfun.m
function f = myfun(x)
f = sin(x) + 3;
Se apeleaza procedura fminsearch pentru a determina minimul lui fun din vecinatatea
lui 2.
x = fminsearch(@myfun,2)

2
Penrtru a minimiza functia f(x) = sin(x) + 3 folosind un obiect inline:
f = inline('sin(x)+3');
x = fminsearch(f,2);
Procedura fminsearch utilizeaza metoda de cautare simplex. Aceasta metoda este o
forma directa de cautare care nu utilizeaza gradinti, sub forma nalaitica ori numarica,
asa cum se procedeaza la celelalte proceduri prezentate. Procedura fminsearch poate
agata discontinuitati, mai ales daca ea nu este lansata, ca punct de start, din apropierea
solutiei. De asemenea, ea poate opera doar cu functii reale.In cazul functiilor
complexa, este nevoie ca functia sa fie despartita in cele doua componente.

6. fminunc
Scop: procedura determina minimul pentru o functie multivariabila avind constringeri

unde
este un vector iar f(x) o functie care retuneaza un scalar
Sintaxa:
x = fminunc(fun,x0)
x = fminunc(fun,x0,options)
x = fminunc(fun,x0,options,P1,P2,...)
[x,fval] = fminunc(...)
[x,fval,exitflag] = fminunc(...)
[x,fval,exitflag,output] = fminunc(...)
[x,fval,exitflag,output,grad] = fminunc(...)
[x,fval,exitflag,output,grad,hessian] = fminunc(...)

Descriere: procedura fminunc determina minimul unei functiisscalare cu mai multe

variabile, pornind dintr-un punct initial estimat. Procedura rezolva probleme de
optimizari neliniare fara constringeri.
x = fminunc(fun,x0) procedura porneste din punctul initial x0 (care poate fi un scalar,
vector sau matrice) si determina minimul x al functiei descrisa in fun
x = fminunc(fun,x0,options) priocedura minimizeaza folosind parametrii setati in
structura options. Se utilizeaza functia optimset pentru setarea parametrilor.

3
x = fminunc(fun,x0,options,P1,P2,...) transfera problema dependenta de parametrii
P1, P2, etc., direct functiei fun. Se seteaza options = [] in situatia in care nu sunt
optiuni setate.
[x,fval] = fminunc(...)returneaza in fval valoarea functiei obiectiv fun in x
[x,fval,exitflag] = fminunc(...)returneaza o valoare exitflag valoare ce descrie
conditiile de iesire din procedura fminsearch.
[x,fval,exitflag,output] = fminunc(...) returneaza o structura output, ce contine
informatii despre optimizare
[x,fval,exitflag,output,grad] = fminunc(...) returneaza in grad valoarea gradientului
lui fun calculata la solutia x.
[x,fval,exitflag,output,grad,hessian] = fminunc(...)returneaza hessian valoarea
hessianului functiei obiectiv fun calculata la solutia x.

Argumente de intrare :
fun functia minimizta prin procedura. fun accepta un vector x si returneaza scalarul f,
respectiv functia obiectiv calculata in x. Functia fun se poate scrie:c
x = fminunc(@myfun,x0), unde myfun este o functie MATLAB, astefel:
function f = myfun(x)
f = ... % calculeaza valoarea functiei in x x
De asemenea functia fun poate fi ca obiect inline:
x = fminunc(inline('norm(x)^2'),x0);
daca gradientul lui fun poate fi calculat si parametrul functiei GradObj este setat 'on',
prin options = optimset('GradObj','on') , atunci functia fun trebuie sa returneze in al
doilea parametru de iesire valoarea gradientului g, care este un vector, calculat in x.
Prin verificarea valorii lui nargout functia poate evita calculul lui g cind fun este
apelata cu doar un singur parametru de iesire, caz in care problema de optimizare are
nevoie doar de f dar nu si de g.
function [f,g] = myfun(x)
f = ... % ca;culeaza valoarea functiei in x
if nargout > 1 % fun apelata cu 2 argumente de iesire
g = ... % calculeaza gradientul g in x
end
Gradientul reprezinta derivatele partiale ale lui f in punctul x. Astel, componenta i a
lui g este derivata partiala a lui f dupa componenta i a lui x.

4
Daca matricea hessenian poate fi calculata si parametrul functiei Hessian este setat pe
'on', prin optiunea options = optimset('Hessian','on'), atunci functia fun trebuie sa
returneze valoarea hessianului H, care este o matrice patratica, prin al treilea argument
de iesire a lui x. Prin verificarea valorii lui nargout functia poate evita calculul lui H
cind fun este apelata cu doar un singur parametru de iesire sau cu doi parametri, caz
in care problema de optimizare are nevoie doar de f , g dar nu si de H.
function [f,g,H] = myfun(x)
f = ... % calculeaza valoarea functiei obiectiv in x
if nargout > 1 % fun apelata cu doua argumente de iesire
g = ... % gradientul; functiei calculat in x
if nargout > 2
H = ... % hessianul calculat in x
end
Matricea hessian este matricea derivatelor partiale de ordinul doi ale functiei f in
punctul x. Astfel, daca componenta (i,j) a lui H derivata partiala de ordin doi a lui f in
acord xi si xj, . Prin definitie, matricea hessian este o matrice simetrica.

Argumente de iesire:
exitflag descrie conditiile de iesire
>0 functia converge catre solutia x
0 numarul maxim de functii evaluate prin algoritm a fost depasit
<0 functia nu converge catre o solutie
output contine informatii despre optimizare, avind structura:
iterations numarul de iteratii considerate
funcCount numarul evaluarilor functiei.
algorithm algoritm folosit
cgiterations numarul de iteratii PCG –doar pentru algoritmii tip large scale
stepsize masuara pasului final-doar pentru algoritmii mediun scale
firstorderopt masura normei optimale de ordin prim pentru gradient la x.

Optiuni: pentru procedura fminunc, gradientul trebuie asigurat, in caz contrar, se va

utiliza un algoritm minumum-scale: Se seteaza :
LargeScale foloseste algoritm large-scale daca se seteaza pe 'on'.
foloseste algoritm medium-scale daca se seteaza pe'off'.

5
Parametrii pentru algoritmi large-scale si medium-scale. Parametrii urmatori se
folosesc la ambele tipuri de algoritmi:
Diagnostics tipareste informatii tip diagnostic despre functia optimizata
Display tipurile afisarii 'off' nu se afiseaza iesirea; 'iter' se afiseaza iesirea dupa fiecare
iteratie; 'final' se afiseaza doar iesirea finala..
GradObj gardientul pentru functia obiectiv definite de utilizator. Se foloseste la
aplicatiile de tip large scale si este optionala folosirea la cele standard, medium scale
MaxFunEvals numarul maxim permis pentru evaluarile functiei
MaxIter numarul maxim permis pentru iteratii
TolFun limita tolerantei pentru valorile functiei
TolX limita tolerantei pentru x

Parametrii folositi doar in algoritmii de tip large-scale ::

Hessian daca este setat 'on', atunci fmincon foloseste hessianul definit in fun sau
informatii despre hessian daca folosim HessMult. Daca se seteaza 'off', fmincon
aproximeaza hessianul folosind diferente finite.
HessMult construita pentru functia hessian multiplicator. Pentru problemele large-
scale aceata functie calculeaza matricea hessian produs H*Y fara a calcula forma
actuala H. Functia are forma W = hmfun(Hinfo,Y,p1,p2,...) unde Hinfo si parametrii
aditionali p1,p2,...contin matricile folosite pentru a calcula H*Y. Primul argument
trebuie sa fie acelasi cu al treilea argument returnat de functia obiectiv fun.
[f,g,Hinfo] = fun(x,p1,p2,...). Parametrii p1,p2,...sunt aceeasi parametrii aditionali
care au fost la fminunc (si la fun) : fminunc(fun,...,options,p1,p2,...). Y este o matrice
care are numarul de linii egal cu dimensiunea problemei W = H*Y desi H nu este
formata explicit. fminunc foloseste Hinfo pentru a calcula preconditionarea.
HessPattern modelul de tip rar al hessianului pentru diferente finite.Daca nu este
convenabil calculul matricei de tip rara a hessenianul H in fun, pentru metodele large-
scale din fmincon se poate aproxima H prion metoda diferentelor finite. In cel mai
defavorabil caz, cind structura nu este cunoascuta, se poate seta HessPattern sa fie o
matrice tip dens, si la fiecare iteratie se calculeaza intreaga aproximare prin diferente
finite. Aceata metoda poate fi foarte dificila pentro problemele tip large-scale si din
acest motiv se apeleaza la structurile matriceale de tip matrici rare.
.

6
MaxPCGIter numarul maxim de iteratii tip PCG (preconditioned conjugate gradient)
PrecondBandWidth limita superioara a domeniului preconditionat pentru PCG. Pentru
unele probleme marirea domeniului reduce numarul de itaratii PCG..
TolPCG limita abaterii pentru oteratiile PCG
TypicalX valorile tipice ale lui x .

Parametrii folositi doar in algoritmii medium-scale:

DerivativeCheck compara gradientii functiei obiectiv si ai constringerilor cu
derivatele de tip diferente finite
DiffMaxChange variatia maxima din variabile pentru gradientii diferentelor finite
DiffMinChange variatia minima din variabile pentru gradientii diferentelor finite.
LineSearchType algoritmul ales de tip line-seach

Exemple: sa se minimizeze functia

Primul pas este crearea myfun.m
function f = myfun(x)
f = 3*x(1)^2 + 2*x(1)*x(2) + x(2)^2; % Functia obiectiv
Acum se poate apela procedura de optimizare myfun in vecinatatea lui [1,1].
x0 = [1,1];
[x,fval] = fminunc(@myfun,x0)
Dupa un numar de iteratii, solutia x si valoarea functiei penstru solutia obtinuta fval
sunt afisate :
x=
1.0e-008 *
-0.7512 0.2479
fval =
1.3818e-016
Pentru a minimiza functia prin intermediul gradientului, se modifica M-file-ul
myfun.m asa incit gradientul devine al doilea argument de tip iasire:
function [f,g] = myfun(x)
f = 3*x(1)^2 + 2*x(1)*x(2) + x(2)^2; % functia obiectiv
if nargout > 1
g(1) = 6*x(1)+2*x(2);
g(2) = 2*x(1)+2*x(2);
end

7
De asemenea se indica faptul ca valoarea gradientului este o data valabila prin
crearea structurii optionale de optimizare GradObj al carei parametru se seteaza pe on
folosinf functia optimset:
options = optimset('GradObj','on');
x0 = [1,1];
[x,fval] = fminunc(@myfun,x0,options)
Rezultatele obtinute dupa mai multe iteratii sunt:
x=
1.0e-015 *
0.1110 -0.8882
fval2 =
6.2862e-031

Un al doilea exemplu realizeaza optimizarea functiei folosind varianta

de obiect inline :
f = inline('sin(x)+3');
x = fminunc(f,4)
Se obtine solutia :
x =4.7124

Observatii :
Procedura fminunc nu este recomandata pentru rezolvarea problemelor de optimizare
care au forma «suma de patrate » :

7. fseminf
Scop: procedura determina minimul pentru o functie multivariabila, neliniara, avind
un set de constringeri semi-infinit:

avind restrictiile:

A x  b
Aeq  x  beq

8
 …

unde:
x, b, beq, lb, si ub sunt vectori,
A si Aeq sunt matrici,
c(x) and ceq(x) sunt functii care returneaza vectori,
f(x) functie care returneaza scalar.
f(x), c(x), ceq(x) pot fi functii neliniare
sunt vectori sau matrici ce reprezinta functii continue cu variabile x, plus
un numar suplimentar variabile . Functiile acestea returneaza vectori.
Sintaxa:
x = fseminf(fun,x0,ntheta,seminfcon)
x = fseminf(fun,x0,ntheta,seminfcon,A,b)
x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq)
x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,lb,ub)
x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,lb,ub,options)
x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,...
lb,ub,options,P1,P2,...)
[x,fval] = fseminf(...)
[x,fval,exitflag] = fseminf(...)
[x,fval,exitflag,output] = fseminf(...)
[x,fval,exitflag,output,lambda] = fseminf(...)

Descriere: procedura fseminf determina minimul unei functii scalare supusa unui set
de restrictii de tip functii multivariabile. Scopul este minimizarea functiei f(x) si in
acelasi timp de a tine seama de toate variabilele
x = fseminf(fun,x0,ntheta,seminfcon) porneste procedura in punctul x0 si determina
minimul functiei fun sub constringerea ntheta de tip semi-infinit, constringere
continuta in functia seminfcon.

9
x = fseminf(fun,x0,ntheta,seminfcon,A,b) rezolva restrictiile de tip inecuatii liniare
A*x <= b.
x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq) rezolva si restrictiile de tip ecuatii
liniare Aeq*x = beq. Daca nu exista restrictii tip inecuatii, se seteaza A=[] , b=[] .
x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,lb,ub) definesc limitele pentru
variabila de optimizare x, de forma lb <= x <= ub.
x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,lb,ub,options) minimizarea tine
seama de parametrii de optimizare din structura options. Setarea optiunii se face prin
optimset.
x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,lb,ub,options,
P1,P2,...) Transfera problema de tip dependenta de parametrii P1, P2, etc., direct
functiilor fun si seminfcon. Se folosesc matrici goale si placeholderi daca din
problema lipsesc, in sensul ca nu sunt necesari A, b, Aeq, beq, lb, ub, options.
[x,fval] = fseminf(...) returneaza faloarea functiei obiectiv fun calculata in x.
[x,fval,exitflag] = fseminf(...) returneaza valoarea parametrului exitflag care descrie
conditiile de parasire a procedurii
[x,fval,exitflag,output] = fseminf(...) returneaza structura output care ofera informatii
aspra optimizarii
[x,fval,exitflag,output,lambda] = fseminf(...)returneaza lambda care contine
multiplicatorul lagrange calculat in punctul x.

Argumente de intrare : fun, ntheta, options,seminfcon: Vom dezvolta doar

argumentele care nu au mai fost utilizate pina acum ntheta si seminfcon.

ntheta numarul constringerilor de tip semi-infinit

seminfcon functia calculeaza vectorul constringerilor de tip inegalitati neliniare c, a
celor de tip ecuatii liniare ceq si constringerile de tip semi-infinit ntheta care sunt
vectori ori matrici K1, K2,...Kntheta cu evaluari facute in intervalul S punctul x.
Functia seminfcon se poate scrie
x = fseminf(@myfun,x0,ntheta,@myinfcon)
unde myinfcon este o functie MATLAB
function [c,ceq,K1,K2,...,Kntheta,S] = myinfcon(x,S) % intervalul initial esantionat
if isnan(S(1,1)),
S = ...% matricea S are ntheta rinduri si doua coloane

10
end
w1 = ...% calculeaza setul de esantioane
w2 = ...% calculeaza setul de esantioane
...
wntheta = ... % calculeaza setul de esantioane
K1 = ... % prima constringere semi-infinita in x si w
K2 = ... % a doua constringere semi-infinita in x si w

...
Kntheta = ...% ultima constringere semi-infinita in x si w
c = ... % calculeaza inecuatiile neliniare in x
ceq = ... % calculeaza ecuatiile neliniare in x
S este intervalul de esantionare recomandat care poat fi sau nu utilizat.

Argumente de iesire: exitflag , lambda, output:

Optiuni: DerivativeCheck, Diagnostics, DiffMaxChange, DiffMinChange, .Display,

GradObj, MaxFunEvals, MaxIter, TolCon , TolFun, TolX

Exemple:
1.cazul unidimensional :
sa se minimizeze functia
unde :

pentru toate valorile lui din intervalul

Deoarece constringerile trebuiesc sa aibe forma , vom rescrie setul de

constringeri al problemei :

11
Se scrie M-file-ul care calculeaza functia obiectiv :
function f = myfun(x,s)
% functia obiectiv
f = sum((x-0.5).^2);
Se scrie M-file-ul mycon.m care calculeaza constringerile de tip ecuatii, inecuatii si
constringerile de tip semi-infint :
function [c,ceq,K1,K2,s] = mycon(X,s)
% internalul initial de esantionare
if isnan(s(1,1)),
s = [0.2 0; 0.2 0];
end
% setul de esantioanere
w1 = 1:s(1,1):100;
w2 = 1:s(2,1):100;
% constringerile semi-infinite
K1 = sin(w1*X(1)).*cos(w1*X(2)) - 1/1000*(w1-50).^2 -...
sin(w1*X(3))-X(3)-1;
K2 = sin(w2*X(2)).*cos(w2*X(1)) - 1/1000*(w2-50).^2 -...
sin(w2*X(3))-X(3)-1;
% nu exista constringeri finite neliniare
c = []; ceq=[];
% traseaza graficul constringerilor semi-infinite
plot(w1,K1,'-',w2,K2,':'),title('constringeri semi-infinite')
drawnow

Se apeleaza acum procedura de optimizare:

x0 = [0.5; 0.2; 0.3]; % punctul de start
[x,fval] = fseminf(@myfun,x0,2,@mycon)
Dupa opt iteratii se obtin rezultatele:
x=
0.6673
0.3013
0.4023
Valoarea functiei obiectiv si valorile restrictiilor semi-infinite sunt:
fval =
0.0770

[c,ceq,K1,K2] = mycon(x,NaN); % folosind intervalul de esantionare initial

max(K1)
ans =
-0.0017

12
 max(K2)
ans =
-0.0845
Graficul constringerilor semi-infinite este:

Graficul arata cum virfurile ambelor constringeri se regasesc in limitele impuse.

2.cazul bidimensional :
Sa se determina x care minimizeaza functia

unde :

pentru toate valorile lui din intervalul , punctul de start fiind

Se scrie M-file-ul care calculeaza functia obiectiv :

function f = myfun(x,s)
% functia obiectiv
f = sum((x-0.2).^2);
Se scrie M-file-ul pentru constringeri , care se numeste mycon.m. Se include si
procedura de trasare a graficului.

13
 function [c,ceq,K1,s] = mycon(X,s)
% intervalul initial de esantionare
if isnan(s(1,1)),
s = [2 2];
end
% setul de esantioane
w1x = 1:s(1,1):100;
w1y = 1:s(1,2):100;
[wx,wy] = meshgrid(w1x,w1y);
% constringerile semi-infinite
K1 = sin(wx*X(1)).*cos(wx*X(2))-1/1000*(wx-50).^2 -...
sin(wx*X(3))-X(3)+sin(wy*X(2)).*cos(wx*X(1))-...
1/1000*(wy-50).^2-sin(wy*X(3))-X(3)-1.5;
% nu exista constringeri neliniare finite
c = []; ceq=[];
% Mesh plot
m = surf(wx,wy,K1,'edgecolor','none','facecolor','interp');
camlight headlight
title('constringeri semi-infinite')
drawnow
1 w1 100 ≤≤
1 w2 100 ≤≤
x 0.25 0.25 0.25 =
Se apeleaza acum procedura de optimizare:
x0 = [0.25, 0.25, 0.25]; % punctul de start
[x,fval] = fseminf(@myfun,x0,1,@mycon)
Dupa noua iteratii se obtin rezultatele:
x=
0.2926 0.1874 0.2202
fval =
0.0091
Graficul obtinut pentru constringere este:

14
 8. linprog
Scop: procedura rezolva problemele de programare liniara de tipul:

in conditiile:

unde f, x, b, beq, lb, ub sunt vectori iar A, Aeq sunt matrici

Sintaxa:
x = linprog(f,A,b,Aeq,beq)
x = linprog(f,A,b,Aeq,beq,lb,ub)
x = linprog(f,A,b,Aeq,beq,lb,ub,x0)
x = linprog(f,A,b,Aeq,beq,lb,ub,x0,options)
[x,fval] = linprog(...)
[x,fval,exitflag] = linprog(...)
[x,fval,exitflag,output] = linprog(...)
[x,fval,exitflag,output,lambda] = linprog(...)

Descriere: procedura linprog rezolva probleme de programare liniara

15
x = linprog(f,A,b) rezolva min f'*x asa incit A*x <= b.
x = linprog(f,A,b,Aeq,beq) rezolva acelasi tip de problema la care adauga si
constringeri de tip ecuatii Aeq*x = beq. Se seteaza A=[] si b=[] in cazul in care nu
exista inecuatii in cadrul constringerilor
x = linprog(f,A,b,Aeq,beq,lb,ub) definesc setul de limite superioare si inferioare
pentru variavila de optimizar lb <= x <= ub. Set seteaza Aeq=[], beq=[] daca nu exista
ecuatii in constringeri
x = linprog(f,A,b,Aeq,beq,lb,ub,x0) seteaza punctul de start in x0. Optiunea este
valabila pentru algoritmii de tip madium-scale.
x = linprog(f,A,b,Aeq,beq,lb,ub,x0,options) minimizeaza prin structura de parametrii
de optimizare din options. Se seteaza prin functia optimset
[x,fval] = linprog(...) returneaza valoarea functiei obiectiv fun in punctul solutiei
x: fval = f'*x.
[x,lambda,exitflag] = linprog(...) returneaza valoarea exitflag care descrie conditiile de
iesire din procedura
[x,lambda,exitflag,output] = linprog(...) returneaza structura output care contine
informatii despre optimizare
[x,fval,exitflag,output,lambda] = linprog(...) returneaza o structura lambda care
contine lagrangeanul multiplicator pentru solutia x.

Argumente de intrare : au fost descrise la functiile anterioare

Argumente de iesire: exitflag, lambda, output: Au fost descrisi la functiile
anterioare.
Optiuni: Diagnostics, Display, MaxIter, TolFun
Exemplu: sa se determine x care minimizeaza functia ,
avind restrictiile :

Prima operatie este introducerea coeficientilor :

f = [-5; -4; -6]

16
 A = [1 -1 1
324
3 2 0];
b = [20; 42; 30];
lb = zeros(3,1);
Se apeleaza procedura de programare liniara:
[x,fval,exitflag,output,lambda] = linprog(f,A,b,[],[],lb);
Marimile inregistrate in procedura x, lambda.ineqlin, lambda.lower au valorile
x=
0.0000
15.0000
3.0000
lambda.ineqlin =
0
1.5000
0.5000
lambda.lower =
1.0000
0
0

9. quadprog
Scop: procedura rezolva problemele de programare patratica de tipul:

in conditiile:

unde f, x, b, beq, lb, ub sunt vectori iar A, Aeq sunt matrici

Sintaxa:
x = quadprog(H,f,A,b)
x = quadprog(H,f,A,b,Aeq,beq)
x = quadprog(H,f,A,b,Aeq,beq,lb,ub)
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0)

17
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0,options)
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0,options,p1,p2,...)
[x,fval] = quadprog(...)
[x,fval,exitflag] = quadprog(...)
[x,fval,exitflag,output] = quadprog(...)
[x,fval,exitflag,output,lambda] = quadprog(...)

Descriere: procedura quadprog rezolva probleme de programare geometrica, dupa

cum urmeaza :
x = quadprog(H,f,A,b) returneaza un vector x ce minimizeaza 1/2*x'*H*x + f'*x
supusa la restrictiile A*x <= b.
x = quadprog(H,f,A,b,Aeq,beq) rezolva acelasi tip de problema la care adauga si
constringeri de tip ecuatii Aeq*x = beq. Se seteaza A=[] si b=[] in cazul in care nu
exista inecuatii in cadrul constringerilor
x = quadprog(H,f,A,b,Aeq,beq,lb,ub) definesc setul de limite superioare si inferioare
pentru variavila de optimizar lb <= x <= ub. Set seteaza Aeq=[], beq=[] daca nu exista
ecuatii in constringeri
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0) seteaza punctul de start in x0x =
quadprog(H,f,A,b,Aeq,beq,lb,ub,x0,options) minimizeaza prin structura de parametrii
de optimizare din options. Se seteaza prin functia optimset
x = quadprog(H,f,A,b,Aeq,beq,lb,ub,x0,options,p1,p2,...) transfera parametrii
p1,p2,... catre functia hessian multiplicator, daca ea exista, prin utilizarea parametrului
HessMult din structura options
[x,fval] = quadprog(...) returneaza valoarea functiei obiectiv in punctul x, adica:
fval = 0.5*x'*H*x + f'*x.
[x,fval,exitflag] = quadprog(...)returneaza valoarea exitflag care descrie conditiile de
iesire din procedura quadprog.
[x,fval,exitflag,output] = quadprog(...)returneaza structura output care contine
informatii despre optimizare
[x,fval,exitflag,output,lambda] = quadprog(...)returneaza o structura lambda care
contine lagrangeanul multiplicator pentru solutia x.

Argumente de intrare :au fost prezentate la functiile anterioare

18
Argumente de iesire: exitflag, lambda, output:au fost prezentate anterior

Optiuni: Diagnostics, Display, MaxIter, HessMult, MaxPCGIter,

PrecondBandWidth, TolFun, TolPCG, TolX, TypicalX, au fost descrise la procedurile
anterioare

Exemplu: sa se determine valoarea lui x care minimizeaza functia

, avind restrictiile

Functia trebuie scrisa cu notatii de tip matricial, sub forma , unde:

Se intriduc la inceput coeficientii matricilor :

H = [1 -1; -1 2]
f = [-2; -6]
A = [1 1; -1 2; 2 1]
b = [2; 2; 3]
lb = zeros(2,1)
Se apeleaza procedura quadprog:
[x,fval,exitflag,output,lambda] = quadprog(H,f,A,b,[],[],lb)
Rezultatele obtinute sunt:
x=
0.6667
1.3333
fval =
-8.2222
exitflag =
1
output =
iterations: 3
algorithm: 'medium-scale: active-set'
firstorderopt: []
cgiterations: []
lambda.ineqlin
ans =

19
 3.1111
0.4444
0
lambda.lower
ans =
0
0
Obsevatii: procedura de programare patratica determina solutia locala in afara cazului
in care problemele sunt strict convexe. Rezultate numerice mai bune se obtin daca se
restrictiile de tip ecuatii sunt specificate explicit prin functiile Aeq, beq folosind si
limitele de interval lb, ub.

20