Ministerul Educaţiei, Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare Informatică şi Microelectronică
Departamentul Ingineria Software şi Automatică

RAPORT
la lucrarea de laborator nr. 3
la disciplina

Cercetări Operaționale
Tema: Metoda gradientului conjugat Polak - Ribiere

A efectuat: st.gr.TI-162 Malachi Anastasia

A verificat: Veronica Andrievschi-Bagrin

 Chișinău 2017
Obiectivele lucrării:
 Studiul metodelor de optimizare neliniară fără restricții
 Utilizarea metodei Polak – Ribiere, cu o eroare mai mică decît
 Analiza rezultatelor obținute.

Varianta 13
Să se determine minimul global al funcției:
2 2
F(x,y) = e−(x +y ) ∗ (𝑎𝑥 2 + 𝑏𝑦 2 )

a=3
b=1

Listing–ul programului:

#include <iostream>
#include <math.h>

using namespace std;

int a = 3;
int b = 1;
int A[4];//= {2 * a, 2, 2, 2 * b};
float eps = pow(10, -6);
//e^(-(x^2 + y^2)) * (3 * x^2 + 1* y^2)
float f(float x1, float x2)
{
float s;

s = exp(- x1 * x1 - x2 * x2) * (a * x1 * x1 + b * x2 * x2);

return s;
}

float gradient1(float x1, float x2)

{
float s;

s = exp(- x1 * x1 - x2 * x2) * (- 2 * x1 * a * x1 * x1 + b * x2 * x2 + 2 *
x1 * a);
return s;
}

float gradient2(float x1, float x2)

{
float s;

s = exp(- x1 * x1 - x2 * x2) * (- 2 * x2 * a * x1 * x1 + b * x2 * x2 + 2 *
x2 * b);
return s;
}

float modulo2(float x1, float x2)

{
float s;

s = sqrt(pow(x1,2) + pow(x2,2));
return s;
}

void Hesiana(float x1, float x2)

{
double f;
double s;
f = exp(- x1 * x1 - x2 * x2);
s = a * x1 * x1 + b * x2 * x2;
A[0] = f * ( 4 * a * pow(x1, 4) - 10 * a * x1 * x1 + 2 * a + 4 * x1 * x1 *
x2 * x2 * b - 2 * x2 * x2 * b );
A[1] = -2 * x1 * (-2 * f * x2 * s + 2 * b * x2 * f) - 4 * a * x1 * f * x2;
A[2] = -2 * x2 *(-2 * f * x1 * s + 2 * a * x1 * f) - 4 * b * x1 * f * x2;
A[3] = f * ( 4 * a * x1 * x1 * x2 * x2 + 4 * pow(x2, 4) * b - 2 * a * x1 *
x1 - 10 * x2 * x2 * b + 2 * b );
}

void Polak_Ribiere(float x_1, float x_2)

{
float gr1, gr2;
float gr1_1, gr1_2;
float mod_x;
float d_1, d_2;
float A_d[2];
float gr_d;
float Ad_d;
float alpha;
float gr_d_1;
float gr_d_2;
float beta;

int count = 0;
Hesiana(x_1,x_2);
gr1 = gradient1(x_1, x_2);
gr2 = gradient2(x_1, x_2);
mod_x = modulo2(gr1, gr2);
d_1 = - gr1;
d_2 = - gr2;
while(mod_x > eps)
{
A_d[0] = (A[0] * d_1 + A[1] * d_2);
A_d[1] = (A[2] * d_1 + A[3] * d_2);
 gr_d = (gr1 * d_1) + (gr2 * d_2);
Ad_d = (A_d[0] * d_1) + (A_d[1] * d_2);
alpha = - (gr_d/Ad_d);
x_1 = x_1 + alpha * d_1;
x_2 = x_2 + alpha * d_2;
gr1_1 = gradient1(x_1, x_2);
gr1_2= gradient2(x_1, x_2);
mod_x = modulo2(gr1_1, gr1_2);
beta = ((gr1_1 * (gr1_1 - gr1)) + (gr1_2 * (gr1_2 - gr2)))/(mod_x *
mod_x);
d_1 = -gr1_1 + beta * d_1;//-
d_2 = -gr1_2 + beta * d_2;
gr1 = gr1_1;
gr2 = gr1_2;
count++;
}
system("clear");
cout << "Numărul de iterații efectuate " << count << endl;
cout << "x1 = " << x_1 << endl;
cout << "x2 = " << x_2 << endl;
cout << "f(x) = " << f(x_1, x_2) << endl;
system ("read -n1 -p '' key");
}

int main()
{
Polak_Ribiere(0,0);
}

În urma execuției acestui program am obținut:

Fig. 1 Rezultatul execuției programului

Verificarea rezultatelor obținute:

Fig. 2 Rezultatele obținute prin intermediul Wolfram Alpha
Concluzie

Efectuînd această lucrare de laborator am studiat metoda gradientului conjugat propusă de Polak și Ribiere. Cu
ajutorul acestei metode am creat un program pentru minimizarea funcției. În cazul variantei propuse, avind punctele
inițiale de pornire (0,0) algoritmul Polak – Ribiere nu a efectuat nici o iterațiie, deoarece condiția de stopare era inițial
satisfăcută. Pentru verificarea rezultatelor, putem compara datele obținute în urma execuției programului(Fig. 1) cu
datele obținute prin intemediul Wolfram Alpha(Fig. 2).
În cazul funcțiilor pătratice, algoritmul Polak – Ribiere și algoritmul Fletcher – Reevs, pentru calcularea
coeficientilor 𝛽 coincid. În cazul minimizării funcțiilor convexe nepătratice, algoritmul propus de Fletcher și Reevs are
proprietăți de convergență mai slabe, de aceea în acest caz este recomandat algoritmul lui Polak și Ribiere.