Ministerul Educației, Culturii Și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul ISA

Raport

Tema: Optimizarea necondiționată

A realizat student grupa TI-182 Movileanu Dorin

A verificat Andrievschi-Bagrin Veronica

Chișinău 2019
 Cuprins
1. Sarcina lucrării ............................................................................................................................ 3
2. Obiectivele lucrării...................................................................................................................... 4
3. Mersul lucrării ............................................................................................................................. 5
Concluzii ......................................................................................................................................... 8
1. Sarcina lucrării

 Să se determine minimul global al funcţiei: 𝑓(𝑥, 𝑦) = 𝑎𝑥 2 + 2𝑥𝑦 + 𝑏𝑦 2 − 2𝑥 − 3𝑦,

unde a=4, b=1, prin Algoritmul Fletcher - Reevs cu calcularea lui Beta după algoritmul
Polak – Ribiere.
2. Obiectivele lucrării
 Studiul metodelor de optimizare neliniară fără restricţii.
 Definirea şi utilizarea unor proceduri pentru minimizarea funcţiilor cu ajutorul metodei
gradientului şi a metodelor de direcţii conjugate cu o eroare mai mică ε=10-5.
 Analiza rezultatelor obţinute, inclusiv stabilirea tipului minimului: local sau global.
 Să se compare rezultatele, luînd în consideraţie numărul de iteraţii, evaluările pentru
funcţie şi gradient.
 3. Mersul lucrării

Declararea variabilelor:

int i, a, b;
float e=0.00001;
float grad1=0, grad2=0, mod=0, grad1P=0, grad2P=0;
float a1=0, a2=0, d1=0, d2=0, alpha=0, beta;
Citirea a și b din varianta respectivă:

cout << "Enter a and b: " << endl;

cin >> a;

cin >> b;

Se calculează gradientul inițial apoi suma modulo2 a acestuia, aceatsa fiind mai mare
decât episilon se calculează vectorul d, care inițial este egal cu gradientul funcției cu semnul
inversat.

grad1P = 2*a*a1+2*a2-2;

grad2P = 2*a1+2*b*a2-3;

cout << "Grad = " << grad1P << ", " << grad2P << endl;

mod=sqrt(pow(grad1P,2)+pow(grad2P,2));

cout << "Mod = " << mod << endl;

d1=-grad1P;

d2=-grad2P;

cout << "d = " << d1 << ", " << d2 << endl << endl << endl;

i = 1;
 Se verifică prin condiția ciclului while dacă suma modulo2 a gradientului este mai mică
decât epsilon (e). Acest ciclu trebuie să se execute până când suma modulo2 nu va fi mai mică.

In interiorul ciclului se calculează alpha după formula: alpha = -((grad1P*d1 +

grad2P*d2) / ((2*a*d1+2*d2)*d1 + (2*d1+2*b*d2)*d2));

În baza lui alpha și a vectorului d se calculează x-șii noi. După aceea cu aceștea se
calculează suma modulo2 a gradientului și se verifică dacă aceasta este mai mică decât epsilon,
dacă e mai mică, programul se întrerupe aici, dacă nu, programul continuă cu calcularea lui beta.
Pentru aceasta se verifică dacă indexul lui x este par sau impar, dacă este par beta = 0, dacă
impar beta se calculează după formula: beta = (grad1*(grad1-grad1P) + grad2*(grad2-
grad2P)) / (grad1P*grad1P + grad2P*grad2P)

După aceea în baza lui beta se calculează vectorul d înmulțindu-se beta cu d-ul
precedent și adunându-se la vectorul gradientului luat cu semn opus.

Pe urmă calculele din ciclu se repetă cu beta nou.

while (mod > e)

{
alpha = -((grad1P*d1 + grad2P*d2) / ((2*a*d1+2*d2)*d1 + (2*d1+2*b*d2)*d2));
cout << "alpha = " << alpha << endl;
a1 = a1 + alpha*d1;
a2 = a2 + alpha*d2;
cout << "x = ( " << a1 << ", " << a2 << " )" << endl;
grad1 = 2*a*a1+2*a2-2;
grad2 = 2*a1+2*b*a2-3;
cout << "Grad = " << grad1 << ", " << grad2 << endl;
mod=sqrt(pow(grad1,2)+pow(grad2,2));
cout << "Mod = " << mod << endl;
if (mod <= e)
break;
if (i % 2 != 0)
beta = (grad1*(grad1-grad1P) + grad2*(grad2-grad2P)) / (grad1P*grad1P + grad2P*grad2P);
else
 beta = 0;
cout << "beta = " << beta << endl;
d1 = -grad1 + beta*d1;
d2 = -grad2 + beta*d2;
cout << "d = " << d1 << ", " << d2 << endl;
grad1P = grad1; grad2P = grad2;
cout << "GradP = " << grad1P << ", " << grad2P << endl << endl << endl;
i++;
}
 Concluzii

Scopul propus de această lucrare de laborator este înțelegerea metodelor de

optimizare matematică ale anumitor probleme.
Am avut sarcina de a calcula punctul minimul global al unei funcții folosind
Algoritmul Fletcher – Reevs și găsirea lui beta după metoda lui Polak - Ribier. S-a
utilizat în practică proceduri pentru minimizarea gradientului cu o eroare de
ε=0.00001.
Am observat că în comparație cu metoda gradientului folosită pentru rezolvarea
aceleași probleme în lucrarea de laborator numărul 1, metoda folosită acum este cu
mult mai eficientă, aceasta găsind minimul global efectuând doar 2 iterații.