Sunteți pe pagina 1din 4

Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Catedra ATI

RAPORT
Lucrarea de laborator nr.1
la disciplina Metode si modele de calcul

Varianta:

A efectuat:
st. gr. SI-161 Gh.Rotari

A verificat:
dr., conf.univ. V.Bagrin

Chiinu 2017
Obiectivele lucrrii:
Studierea metodelor de optimizare neliniar far restricii.
Definirea i utilizarea unor proceduri pentru minimizarea funciilor cu
ajutorul metodei gradientului i fractionare a pasului.
Analiza rezultatelor obinute, inclusiv stabilirea tipului minimului: local sau
global.
S se compare rezultatele, lund in consideraie numrul de iteraii,
evalurile pentru funcie i gradient.

Sarcina lucrrii:
Sa se determine minimul global al functiei :
f(x,y)=ax2+2xy+by2-2x-3y
a=5 ; b=2.
f(x,y)=5x2+2xy+2y2-2x-3y.

Pasii algoritmilor:
1)Metoda Gradientului cu fractionarea pasului:
Pasul1: Se alege , (0,1), (0,1. Se recomanda =1, (0.05,0.5), =0.5;
Pasul2:Se calculeaza Z()=X(k)- f(x(k)) si f(Z()).
Pasul3:Se verifica inegalitatea f(Z( ))-f(X(k))<=- f(x(k))2. Daca
inegalitatea este adevarata atunci k= ,in caz contrar = * si se trece la pasul 2.

Listingul programului:
#include <iostream.h>
#include <conio.h>
#include <math.h>
class OPTIMIZARE
{
public:
float F(float x, float y);
void INPUT(void);
void GRADIENT(void);
void METODA_GRADIENTULUI(void);
void ALGORITMUL_HESTENES_STIEFEL(void);

private:
float a,b,ALFA,GAMA,DELTA,EPS,X[2],Z[2],G[2];
};

float OPTIMIZARE::F(float x, float y)


{
return a*x*x+2*x*y+b*y*y-2*x-3*y;
}

void OPTIMIZARE::INPUT(void)
{
cout<<"Introdu parametrul a: "; cin>>a;
cout<<"Introdu parametrul b: "; cin>>b;
}

void OPTIMIZARE::GRADIENT(void)
{
G[0]=2*a*X[0]+2*X[1]-2;
G[1]=2*X[0]+2*b*X[1]-3;
}

void OPTIMIZARE::METODA_GRADIENTULUI(void)
{
int N=0;
float Ak;
ALFA=0.1; GAMA=0.1; DELTA=0.1;
X[0]=1; X[1]=1; EPS=0.00001;
GRADIENT();
while(sqrt(G[0]*G[0]+G[1]*G[1])>=EPS)
{
++N;
ALFA=0.1;
Z[0]=X[0]-ALFA*G[0];
Z[1]=X[1]-ALFA*G[1];
while((F(Z[0],Z[1])-F(X[0],X[1]))>-DELTA*ALFA*(G[0]*G[0]+G[1]*G[1]))
{
ALFA*=GAMA;
Z[0]=X[0]-ALFA*G[0];
Z[1]=X[1]-ALFA*G[1];
}
Ak=ALFA;
X[0]=X[0]-Ak*G[0];
X[1]=X[1]-Ak*G[1];
GRADIENT();
}
cout<<"\nMETODA GRADIENTULUI CU FRACTIONAREA PASULUI:";
cout<<"\nPunctul are urmatoarele coordonate (x,y): "<<X[0]<<" "<<X[1]<<endl;
cout<<"Valoarea functiei f(x)="<<F(X[0],X[1])<<endl;
cout<<"Numarul de iteratii N="<<N<<endl;
}

void OPTIMIZARE::ALGORITMUL_HESTENES_STIEFEL(void)
{
int N=0,k=0;
float Ak,G1[2]={0},d[2],X1[2];
X[0]=1; X[1]=1;
GRADIENT();
while((G[0]!=0&&G[1]!=0))
{
++N;
if(k++==0){ d[0]=-G[0]; d[1]=-G[1]; }
else {
d[0]=d[0]*(G[0]*G[0]+G[1]*G[1])/(G1[0]*G1[0]+G1[1]*G1[1])-G[0];
d[1]=d[1]*(G[0]*G[0]+G[1]*G[1])/(G1[0]*G1[0]+G1[1]*G1[1])-G[1];
};
Ak=-(G[0]*d[0]+G[1]*d[1])/(2*a*d[0]*d[0]+4*d[0]*d[1]+2*b*d[1]*d[1]);
X1[0]=X[0]; X1[1]=X[1]; G1[0]=G[0]; G1[1]=G[1];
X[0]=X[0]+Ak*d[0];
X[1]=X[1]+Ak*d[1];
if(X[0]==X1[0]&&X[1]==X1[1])break;
GRADIENT();
}
cout<<"\nALGORITMUL HESTENES-STIEFEL";
cout<<"\nCoordonatele punctului (x,y): "<<X[0]<<" "<<X[1]<<endl;
cout<<"Valoarea functiei f(x)="<<F(X[0],X[1])<<endl;
cout<<"Numarul de iteratii N="<<N<<endl;
}

void main()
{
clrscr();
OPTIMIZARE ob;
cout<<"\nLucrarea de laborator Nr.1\n\n";
ob.INPUT();
ob.METODA_GRADIENTULUI();
ob.ALGORITMUL_HESTENES_STIEFEL();
getch();
}

Rezultatele:

Analiza rezultatelor:
Avem la dispozitie 2 metode cu ajutorul carora determinam minimul global al
functiei. Ambele obtin aproximativ acelasi rezultat intr-un timp foarte mic in cazul
functiei pe care o avem. Insa daca comparam numarul de iteratii,observam ca
metoda gradientului cu fractionarea pasului converge lent. Aceasta inseamna ca
pentru functii mari aceasta metoda nu va mai fi utila deoarece va avea nevoie de
mai mult timp pentru a gasi solutia. In asa fel algoritmul Hestenes-Stiefel va fi mai
rapid.

Concluzie: Efectuind aceasta lucrare de laborator am insusit 2 metode de cautare a


minimului functiei, si anume Metoda Gradientului cu fractionarea pasului si
metoda Hestenes-Stiefel.Am facut cunostinta cu pasii necesari spre a gasi solutia si
am obtinut rezultatele. Insa cind comparam ele putin difera.Se poate de spus ca
unul este mai reusit decit altul,insa trebuie sa tinem cont si de functia pe care o
avem. Deci ambii algoritmi au atit plusuri cit si minusuri unul fata de altul.