Vous êtes sur la page 1sur 6

Universit Technique de Moldova

FCIM

RAPORT
Travail de laboratoire NR.1 i NR. 2
a la discipline
Recherches oprationnelles
Thme: L'optimisation inconditionnelle

Effectue par:
l`tudiante du gr.FI-111:

Oleinicov Mihaela

Vrifie par:
le professeur

Moraru Vasile

Gh. Tarsi

Chiinau 2013
Les objectifs du travail:

1. L`tude des mthodes d`optimisation inconditionnelle.


1. Dfinition et l`utilisation des procdures pour calculer le minimum de la fonction a
l`aide du mthode de Gradient et de la mthode des directions conjugues avec une
erreur =10-5.
2. Analyser les rsultants obtenus, et l`tablissement du type du minimum local :local
ou global.
3. Comparer les rsultats en considrant le nombre des itrations pour la fonction.
Problme 1
Listing du programme:
#include <iostream.h>
#include <conio.h>
#include <math.h>
class OptimizareNeconditionata
{
public:
float functia(float x, float y);
void introducere(void);
void gradientul(void);
void MetodaGradientului(void);
void MetodaHestenesStiefel(void);
int a,b;
float alfa,gama,delta,epsilon;
float X[2],Y[2],grad[2];
};
float OptimizareNeconditionata::functia(float x, float y)
{
return a*x*x+2*x*y+b*y*y-2*x-3*y;
}
void OptimizareNeconditionata::introducere(void)
{
a= 3;
b=2;
}
void OptimizareNeconditionata::gradientul(void)
{
grad[0]=2*a*X[0]+2*X[1]-2;
grad[1]=2*X[0]+2*b*X[1]-3;
}
void OptimizareNeconditionata::MetodaGradientului(void)
{
int numarIteratii=0;
float temp;
alfa=0.1;
gama=0.1;
delta=0.1;
X[0]=1;
X[1]=1;
epsilon=0.00001;
gradientul();
while(sqrt(grad[0]*grad[0]+grad[1]*grad[1])>=epsilon)
{
++numarIteratii;
alfa=0.1;
Y[0]=X[0]-alfa*grad[0];
Y[1]=X[1]-alfa*grad[1];
while((functia(Y[0],Y[1])-functia(X[0],X[1]))>delta*alfa*(grad[0]*grad[0]+grad[1]*grad[1]))
{
alfa*=gama;
Y[0]=X[0]-alfa*grad[0];
Y[1]=X[1]-alfa*grad[1];
}

temp=alfa;
X[0]=X[0]-temp*grad[0];
X[1]=X[1]-temp*grad[1];
gradientul();

}
cout<<" La methode du GRADIENT:";
cout<<" \nLe point a les coordonnees: "<<X[0]<<" "<<X[1]<<endl;
cout<<"\n f(x)="<<functia(X[0],X[1])<<endl;
cout<<"Le nombre d`iterations:"<<numarIteratii<<endl;

void OptimizareNeconditionata::MetodaHestenesStiefel(void)
{
int numarIteratii = 0,k = 0;
float temp,grad1[2]={0},d[2],X1[2];
X[0]=1; X[1]=1;
gradientul();
while((grad[0]!=0&&grad[1]!=0))
{
++numarIteratii;
if(k++==0)
{
d[0]=-grad[0];
d[1]=-grad[1];
}
else
{
d[0]=d[0]*(grad[0]*grad[0]+grad[1]*grad[1])/
(grad1[0]*grad1[0]+grad1[1]*grad1[1])-grad[0];
d[1]=d[1]*(grad[0]*grad[0]+grad[1]*grad[1])/
(grad1[0]*grad1[0]+grad1[1]*grad1[1])-grad[1];
};
temp=-(grad[0]*d[0]+grad[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]; grad1[0]=grad[0]; grad1[1]=grad[1];
X[0]=X[0]+temp*d[0];
X[1]=X[1]+temp*d[1];
if(X[0]==X1[0]&&X[1]==X1[1])break;
gradientul();
}
cout<<"\n\nLa methode du HESTENES-STIEFEL:";
cout<<"\nLe point a les coordonnees: "<<X[0]<<" "<<X[1]<<endl;
cout<<"\nf(x)="<<functia(X[0],X[1])<<endl;
cout<<"Le nombre d`iterations:"<<numarIteratii<<endl;
}
void main()
{
clrscr();
OptimizareNeconditionata optNec;
optNec.introducere();
optNec.MetodaGradientului();
cout<<"\n============================================";
optNec.MetodaHestenesStiefel();
getch();
}

Problme 2
Listing du programme:
#include <iostream>
#include <conio.h>
#include <math.h>
#include <windows.h>>
using namespace std;
class OptimizareNeconditionata
{
public:
float alfa,delta,gama,epsilon;
float x[2],y[2],grad[2];
float F(float x, float y)
{
return ( exp(-x*x-y*y)*(3*x*x + 5*y*y ) );
}
void gradient()
{
grad[0]=2*x[0]*exp(-x[0]*x[0]-x[1]*x[1])*(2-x[0]*x[0]-2*x[1]*x[1]);
grad[1]=2*x[1]*exp(-x[0]*x[0]-x[1]*x[1])*(4-x[0]*x[0]-2*x[1]*x[1]);
}
float f(float x, float g,float a)
{
return x-a*g;
}
void MetodaGradientului(void)
{
int numarIteratii = 0;
alfa=0.1;
gama=0.1;
delta=0.1;
x[0]=1;
x[1]=1;
epsilon=0.00001;
gradient();
while(sqrt(grad[0]*grad[0]+grad[1]*grad[1])>=epsilon)
{
++numarIteratii;
alfa=0.1;
y[0]=f(x[0],grad[0],alfa);
y[1]=f(x[1],grad[1],alfa);
while((F(y[0],y[1])-F(x[0],x[1]))>delta*alfa*(grad[0]*grad[0]+grad[1]*grad[1]))
{
alfa*=gama;

y[0]=f(x[0],grad[0],alfa);
y[1]=f(x[1],grad[1],alfa);
}
x[0]=f(x[0],grad[0],alfa);
x[1]=f(x[1],grad[1],alfa);
gradient();
}
cout<<"\nD`apres la methode du GRADIENT:";
cout<<"\nLe point a les coordonnees: "<<x[0]<<", "<<x[1]<<""<<endl;
cout<<"f(x)="<<F(x[0],x[1])<<endl;
cout<<"Le nombre d`iterations:"<<numarIteratii<<endl;

}
void FletcherReevs()
{
float d1,d2,beta=0,g1,g2;
int iteratii=0,n=10;
alfa=0.1;
x[0]=1;
x[1]=1;
gradient();
d1=-grad[0];
d2=-grad[1];
g1=grad[0];
g2=grad[1];
while(sqrt(d1*d1+d2*d2)>=epsilon)
{
if(iteratii>=1)
{
if(iteratii%n==0)beta=0;
else
{
gradient();
beta=(grad[0]*grad[0]+grad[1]*grad[1])/(g1*g1+g2*g2);
}
d1=-grad[0]+beta*d1;
d2=-grad[1]+beta*d2;
}
x[0]=x[0]+alfa*d1;
x[1]=x[1]+alfa*d2;
++iteratii;
}
cout<<"\n\nD`apres la methode du Fletcher Reevs:";
cout<<"\nLe point a les coordonnees:"<<x[0]<<", "<<x[1]<<""<<endl;
cout<<"f(x)="<<F(x[0],x[1])<<endl;
cout<<"Le nombre d`iterations:"<<iteratii<<endl;
}
};
int main()
{
system("cls");
OptimizareNeconditionata optNec;
optNec.MetodaGradientului();
cout<<"\n============================================";
optNec.FletcherReevs();
getch();
}

Le rsultat :

Conclusion:
En effectuant ce travail de laboratoire j`ai tudie les mthodes d`optimisation
inconditionnelles. J`ai dfinie et j`ai utilise des procdures pour calculer le minimum des
fonctions a l`aide de la mthode du Gradient et des mthodes de directions conjugues.