MN Cap2

39
Capitolul 2
AP ROXIM ARE, I NTERPO L ARE I OPTIM IZ ARE P AR AM ETR IC Ă
În acest capitol sunt prezentate două clase de algoritmi:

• clasa algoritmilor de aproximare a unei funcţii tabelare printr-o formulă analitică,
unde intră algoritmii de aproximare în sensul celor mai mici pătrate ale erorii şi algoritmii de
calcul al diverselor funcţii de interpolare
• şi clasa algoritmilor de optimizare parametrică, adică de găsire a extremelor unei
funcţii (dată fie analitic, fie tabelar) de unul sau mai mulţi parametri.
2.1 Metoda celor mai mici pătrate
2.1.1 Formularea problemei. Notaţii

Metoda celor mai mici pătrate (ale erorii) este cea mai uzuală metodă de aproximare a
unei dependenţe y=y(x), date tabelar (ca în tabelul 2.1), printr-o funcţie analitică, care se
numeşte funcţie (de obicei polinomială) de regresie. De aceea, metoda celor mai mici pătrate
se mai numeşte şi regresie, cu largă aplicabilitate în estimare, statistică şi prelucrarea datelor.
x x1 x2 ... xn
y y1 y2 ... yn
Tabel 2.1 Dependenţa y=y(x) dată prin tabel
Dependenţa y=y(x) se poate reprezenta grafic în planul (x, y), obţinându-se aşa-numitul
„nor de puncte”. De cele mai multe ori, după alura norului de puncte se poate stabili forma
exactă a funcţiei de regresie: dacă punctele se distribuie în jurul unei drepte, atunci se alege
drept funcţie de regresie un polinom de gradul I (regresie liniară), dacă se distribuie în jurul
unei parabole sau a unei parabole cubice, atunci trebuie aleasă o funcţie polinomială de
gradul al II-lea, respectiv de gradul al III-lea etc. Dacă forma sugerată a norului de puncte nu
corespunde unui caz simplu, atunci se procedează la regresia cu o funcţie polinomială de grad
superior, ales arbitrar în primă fază.
)
Dacă se notează cu y i , i = 1, n , valorile aproximate (estimate) şi cu freg funcţia generală
de regresie, atunci este valabilă relaţia:
(2.1) $y = f ( x )
i reg i
Funcţia freg depinde de un set de m parametri, fie aceştia ai , i = 1, m (în particular, aceştia
sunt coeficienţii polinomului de regresie), care se determină din minimizarea erorii pătratice
)
cumulate dintre valorile reale, yi, şi valorile aproximate, y i :
n 2
(2.2) E (a1, a2 ,...am )
i =1
(
∑ yi − $y i)
40 Metode numerice utilizate în analiza sistemelor – aplicaţii
Funcţia de eroare (2.2) este o expresie a dispersiei valorilor reale de la curba presupusă.
Fiind o sumă de pătrate, această funcţie prezintă un minim pozitiv (în cazul ideal, acesta este
0, corespunzând aproximării exacte), care se obţine din anularea derivatelor sale parţiale în
raport cu fiecare dintre parametrii ai , i = 1, m . Rezultă astfel sistemul de m ecuaţii în
necunoscutele ai , i = 1, m , numit sistemul ecuaţiilor normale:
 ∂E (a1, a2 ,...am )
(2.3)  = 0, i = 1, m
 ∂ai
În cazul în care freg este funcţie polinomială, sistemul (2.3) este liniar şi compatibil
determinat, soluţia lui admiţând o formă generală, care este prezentată în §2.1.5.
O aplicaţie imediată şi intuitivă a metodei celor mai mici pătrate este trasarea grafică a
unei dependenţe de tipul celei din tabelul 2.1, presupunând că datele respective s-au obţinut
în urma măsurării variaţiei variabilei dependente y în funcţie de variaţia variabilei
independente x. Măsurătorile fiind în general afectate de erori, se aplică întâi o metodă de
regresie pentru determinarea unei aproximări analitice a dependenţei respective. Prin
reprezentarea grafică a norului de puncte de coordonate (xi,yi), i=1,2,...n, şi a funcţiei de
regresie $y = $y ( x) în acelaşi sistem de coordonate, se observă că aproximarea prin regresie
corespunde trasării graficului „printre puncte” (figura 2.1).
y
1.5
0.5
x
-3 -2 -1 0 1 2 3 4 5
-0.5
-1
-1.5
Fig. 2.1 Trasarea graficului de regresie printre punctele norului de puncte
Algoritmii de regresie sunt practic înşiruirea relaţiilor de calcul al coeficienţilor de

regresie. De aceea se prezintă direct implementările Matlab ale celor mai uzuale cazuri de
regresie – liniară, parabolică şi exponenţială – şi a cazului general de regresie polinomială.
2.1.2 Aproximarea prin regresie liniară

Regresia liniară constă în aproximarea unui nor de puncte printr-o dreaptă; ca atare,
)
relaţia de calcul al valorilor aproximate (estimate), y i , i = 1, n , este:
(2.4) $y = a ⋅ x + b
i i
Coeficienţii a şi b sunt soluţiile sistemului (2.3), particularizat pentru m=2:

2. Aproximare, interpolare şi optimizare parametrică 41
 n ⋅ S xy − S x ⋅ S y S xx ⋅ S y − S x ⋅ S xy
(2.5) a = , b= ,
 n ⋅ S xx − S x2 n ⋅ S xx − S x2
n n n n
unde s-au făcut notaţiile: S x = ∑ xi , S xx = ∑ xi2 , S y = ∑ yi , S xy = ∑ xi yi . Relaţiile (2.5)
i =1 i =1 i =1 i =1
rezultă din dezvoltarea determinanţilor implicaţi în sistemul (2.3).
Funcţia Matlab de implementare a metodei de regresie liniară trebuie să primească drept
date de intrare cei doi vectori, x şi y, şi să returneze valorile celor doi coeficienţi de regresie,
a şi b. Funcţia Matlab cmmp_lin listată mai jos mai returnează şi şirul de valori aproximate,
)
y i , i = 1, n , în vectorul y_aprox, precum şi valoarea (minimizată) a erorii pătratice globale
(conform relaţiei (2.2)) în variabila E.
function [a,b,y_aprox,E]=cmmp_lin(x,y)
%REGRESIE LINIARĂ pe un set de perechi de date (x,y);
%dreapta de regresie are ecuaţia y=a*x+b;
%x şi y sunt vectori de aceeaşi dimensiune,
%(recomandabil ca x să fie ordonat crescător/descrescător)
n=length(x);
%calculul sumelor
Sx=sum(x);Sxx=sum(x.^2);Sy=sum(y);Syy=sum(x.*y);
%calculul numitorului şi numărătorilor din formulele lui a şi b
d=n*Sxx-Sx^2;da=n*Syy-Sx*Sy;db=Sxx*Sy-Sx*Syy;
%calculul coeficienţilor de regresie, a şi b
a=da/d;b=db/d;
%valorile aproximate
y_aprox=a*x+b;
%eroarea globală
E=sum((y-y_aprox).^2);
Ca o observaţie, se poate folosi şi funcţia det din biblioteca Matlab, care calculează
determinantul unei matrice pătratice.
În exemplul de mai jos se arată o modalitate de verificare a funcţiei cmmp_lin.
Exempl ul 2.1: Dându-se şirul de valori x=[1 1.5 2 2.5 3 3.5 4 4.5 5 5.5 6] (la
cazul general, acestea nu trebuie să fie echidistante), se generează vectorul
y după relaţia y=2*x+7 şi se apelează funcţia cmmp_lin.
x=[1 1.5 2 2.5 3 3.5 4 4.5 5 5.5 6];y=2*x+7;
[a,b,y_aprox,E]=cmmp_lin(x,y)
Rezultatul este conform aşteptărilor:
a =
2
b =
7
y_aprox =
9 10 11 12 13 14 15 16 17 18 19
E =
0
Se perturbă apoi valorile obţinute cu formula y=2*x+7 (de exemplu, cu maxim ±10%),
rezultând y1=[8.1 11 9.9 13.2 11.7 15.4 13.5 17.6 15.3 19.8 17.1]. Apelul
funcţiei cmmp_lin cu argumentele de intrare x şi y1 (existente în spaţiul de lucru):
[a1,b1,y1_aprox,E1]=cmmp_lin(x,y1)
produce următoarele rezultate:
a1 =
1.8757
b1 =
7.3104
y1_aprox =
Columns 1 through 7
9.1860 10.1238 11.0617 11.9995 12.9373 13.8752 14.8130
Columns 8 through 11
15.7508 16.6887 17.6265 18.5643
E1 =
4.5376
Evident, valorile coeficienţilor de regresie, a şi b, vor fi cu atât mai deviate de la valorile
2, respectiv 7, cu cât perturbaţia setului y de la dreapta exactă 2x+7 va fi mai mare.
Rezultatele regresiei se vizualizează grafic prin reprezentarea norului de puncte şi a graficului
dreptei de regresie, ax+b (pentru care se discretizează intervalul de variaţie al variabilei
independente, x, cu un pas suficient de mic – rezultatul se depune în vectorul xx – şi se
calculează variabila dependentă, y, în fiecare valoare astfel obţinută – rezultatul se depune în
vectorul yy).
20
18
16
14
12
10
8
1 1.5 2 2.5 3 3.5 4 4.5 5 5.5 6
Fig. 2.2 Aproximarea unui nor de puncte prin regresie liniară
În urma comenzilor Matlab:

xx=min(x):(max(x)-min(x))/200:max(x);
yy=a*xx+b;
plot(x,y,’o’,xx,yy,’-’);grid;
se obţine graficul din figura 2.2.
2.1.3 Aproximarea prin regresie parabolică

Dacă norul de puncte are alură de parabolă, atunci se poate aplica regresia parabolică.
)
Relaţia de calcul al valorilor aproximate, y i , i = 1, n , este în acest caz:
(2.6) $y = a ⋅ x 2 + b ⋅ x + c
i i i
Coeficienţii a, b şi c sunt soluţiile sistemului (2.3), particularizat pentru m=3:

 ∆a ∆ ∆
(2.7) a = , b= b, c= c ,
 ∆ ∆ ∆
unde ∆ este determinantul sistemului (2.3), iar ∆a, ∆b şi ∆c sunt determinanţii de calcul ai
coeficienţilor. Formele lor compacte, precum şi formulele desfăşurate sunt date mai jos.
S4 x S3 x S xx
∆ = S3 x S xx S x = nS xx S4 x − S x2 S4 x − nS32x + 2S x S xx S3 x − S xx
3
S xx Sx n
S 2 xy S3 x S xx
∆ a = S xy S xx S x = nS xx S 2 xy − S x2 S 2 xy − nS3 x S xy + S x S3 x S y + S x S xx S xy − S xx
2
Sy
Sy Sx n
S4 x S2 xy S xx
2
∆ b = S3 x S xy S x = nS4 x S xy − S x S4 x S y − nS3 x S2 xy + S x S xx S 2 xy + S xx S3 x S y − S xx S xy
S xx Sy n
S4 x S3 x S 2 xy
∆ c = S3 x S xx S xy = S xx S 4 x S y − S x S 4 x S xy − S32x S y + S xx S3 x S xy + S x S3 x S2 xy − S xx
2
S 2 xy
S xx Sx Sy
n n n n n
S-au făcut notaţiile: S x = ∑ xi , S xx = ∑ xi2 , S3 x = ∑ xi3 , S4 x = ∑ xi4 , S y = ∑ yi ,
i =1 i =1 i =1 i =1 i =1
n n
S xy = ∑ xi yi , S2 xy = ∑ xi2 yi .
i =1 i =1
Metoda de regresie parabolică este implementată printr-o funcţie numită cmmp_par, care
primeşte aceleaşi argumente de intrare ca şi cmmp_lin, funcţia destinată regresiei liniare, şi
anume seturile de date x şi y. Pe lângă coeficienţii de regresie, a, b şi c, şi eroarea globală,
funcţia mai returnează şi perechea de vectori (xx,yy), calculaţi pentru reprezentarea grafică a
curbei de regresie (în maniera arătată la regresia liniară, exemplul 2.1).
function [a,b,c,E,xx,yy]=cmmp_par(x,y)
%REGRESIE PARABOLICĂ pe seturile de date (x,y);
% 2
%curba de regresie are ecuaţia y = a*x + b*x + c;
n=length(x);
%calculul sumelor
Sx=sum(x);Sxx=sum(x.^2);S3x=sum(x.^3);S4x=sum(x.^4);
Sy=sum(y);Sxy=sum(x.*y);S2xy=sum((x.^2).*y);
%calculul determinanţilor
d=n*Sxx*S4x-Sx^2*S4x-n*S3x^2+2*Sx*Sxx*S3x-Sxx^3;
da=n*Sxx*S2xy-Sx^2*S2xy-n*S3x*Sxy+Sx*S3x*Sy+ ...
Sx*Sxx*Sxy-Sxx^2*Sy;
db=n*S4x*Sxy-Sx*S4x*Sy-n*S3x*S2xy+Sx*Sxx*S2xy+ ...
Sxx*S3x*Sy-Sxx^2*Sxy;
dc=Sxx*S4x*Sy-Sx*S4x*Sxy-S3x^2*Sy+Sxx*S3x*Sxy+ ...
Sx*S3x*S2xy-Sxx^2*S2xy;
%calculul coeficienţilor de regresie
a=da/d;
b=db/d;
c=dc/d;
%vectori calculaţi în vederea unei eventuale reprezentări grafice

yy=a*xx.^2+b*xx+c;
%eroarea globală
E=sum((y-a*x.^2-b*x-c).^2);
A se observa modul de plasare pe mai multe rânduri a unei formule neobişnuit de lungi
(terminarea fiecărui rând cu caracterele „...”).
Exempl ul 2.2: Dându-se vectorul x=[0 0.3 1 1.4 1.6 2 2.1 2.4 2.8 3 3.5
3.7 3.9 4] şi vectorul y=x.^2-4*x-10, apelul funcţiei cmmp_par cu
returnarea numai a primelor patru argumente de ieşire:
[a,b,c,E]=cmmp_par(x,y)
va avea drept ecou la ecran:
a =
1.0000
b =
-4.0000
c =
-10.0000
E =
4.3108e-024
Rezultatele confirmă aşteptările; câteva comentarii se impun. Se observă că valoarea
erorii globale este foarte mică, practic 0; totuşi, ea nu a fost afişată ca 0, ceea ce înseamnă că
nu este exact 0, aşa cum s-a obţinut în cazul regresiei liniare pe un set de date perfect „curat”,
neperturbat (exemplul 2.1). Nici coeficienţii de regresie nu corespund exact valorilor curbei
după care a fost generat vectorul y; aceasta se constată reafişând coeficienţii în formatul de
afişare cu 15 zecimale:
format long
a
a =
0.99999999999995
b
b =
-3.99999999999985
c
c =
-9.99999999999946
Rezultatele confirmă o intuiţie firească: erorile de calcul cresc cu cât ordinul regresiei
creşte (cu cât numărul coeficienţilor de regresie este mai mare).
Exempl ul 2.3: Regresia parabolică se aplică acum pe seturi de date legate printr-o lege
liniară; de exemplu, fie cele din exemplul 2.1: x=[1 1.5 2 2.5 3 3.5
4 4.5 5 5.5 6] şi y=2*x+7.
Rezultatul aşteptat în urma apelului funcţiei cmmp_par este ca parabola de regresie să
aibă coeficientul a aproximativ nul (parabola se reduce la o dreaptă). Într-adevăr, comanda:
[a,b,c,E]=cmmp_par(x,y)
are ca rezultat:
a =
0
b =
2
c =
7
E =
0
Rezultatul este de această dată exact, coeficienţii sunt determinaţi fără eroare.
Rămânând în continuare la exemplul 2.1 şi apelând funcţia cmmp_par pentru setul y
perturbat, y1=[8.1 11 9.9 13.2 11.7 15.4 13.5 17.6 15.3 19.8 17.1]:
[a1,b1,c1,E1]=cmmp_par(x,y1)
se obţine:
a1 =
-0.1305
b1 =
2.8592
c1 =
5.7909
E1 =
21.4862
Eroarea globală obţinută prin regresie parabolică (21.4862) este mai mare decât cea prin
regresie liniară (4.5376, din exemplul 2.1), ceea ce arată că respectivul nor de puncte se
aproximează mai bine printr-o dreaptă decât printr-o parabolă.
De aici se desprinde o concluzie generală: în cazul aplicării regresiei polinomiale unui
set dat de date, mai întâi trebuie determinat ordinul regresiei care asigură eroarea minimă. Se
va reveni la această problemă când se va discuta cazul general de regresie polinomială
(§2.1.5).
2.1.4 Aproximarea prin regresie exponenţială

Regresia exponenţială se aplică atunci când variabila dependentă are valori de semn
constant (are fie numai valori pozitive, fie numai valori negative, şi atunci se consideră y ca
variabilă dependentă). Fără a reduce generalitatea se poate, deci, presupune că y conţine
numai valori pozitive. Norul de puncte se aproximează printr-o curbă exponenţială; valorile
)
estimate, y i > 0, i = 1, n , determinându-se cu:
(2.8) $y = C ⋅ eα⋅ xi , C > 0

i
Prin logaritmarea relaţiei (2.8) şi introducerea schimbării de variabilă z$ ln( $y ), z > 0 , se

obţine:
(2.9) z$ i = α
{ ⋅ xi + ln(
{ C) ,
A B
care este un model de regresie liniară pentru seturile de date x şi z ln( y ) , cu coeficienţii
A = α şi B = ln(C ) > 0 . Aceştia se pot, deci, determina adaptând formulele (2.5):
 n ⋅ S xz − S x ⋅ S z S ⋅ S − S x ⋅ S xz
(2.10)  A = , B = xx z ,
2 2
 n ⋅ S xx − S x n ⋅ S xx − S x
n n n n  n 
unde s-au făcut notaţiile: S x = ∑ xi , S xx = ∑ xi2 , S z = ∑ zi = ∑ ln( yi ) = ln  ∏ yi  ,
i =1 i =1 i =1 i =1  i =1 
n n
S xz = ∑ xi zi = ∑ xi ln( yi ) . Relaţia (2.8) se poate rescrie sub forma:
i =1 i =1
$y = e A⋅ xi + B , B > 0
i
Având în vedere reducerea de mai sus, funcţia Matlab pentru regresia exponenţială,
numită cmmp_exp, constă în esenţă în apelarea funcţiei cmmp_lin, de regresie liniară.
Semnificaţia argumentelor de ieşire ale funcţiei cmmp_exp este aceeaşi ca în cazul funcţiei
cmmp_par, de regresie parabolică; ea este listată şi comentată mai jos.
function [A,B,E,xx,yy]=cmmp_exp(x,y)
%REGRESIE după o CURBA EXPONENTIALĂ a unui set de date (x,y);
% A*x+B
%curba de regresie are ecuaţia y=e;
%x şi y sunt vectori de aceeaşi dimensiune;
%(recomandabil ca x să fie ordonat crescător/descrescător);
%y conţine valori pozitive
%regresia de acest tip se reduce la regresia liniară prin

%logaritmarea naturală a valorilor din y
z=log(y);
[A,B,E1,y_aprox1]=cmmp_lin(x,z);
%şiruri de valori calculate în vederea unei eventuale reprezentări grafice

yy=exp(A*xx+B);
%eroarea globală
E=sum((y-exp(A*x+B)).^2);
Funcţia returnează coeficienţii A şi B (o modificare minoră, folosind relaţiile introduse în
formula (2.9), este necesară pentru a întoarce valorile coeficienţilor C şi α).
Exempl ul 2.4: Pornind de la seturile de date x=[-3 -2 0 0.5 1.5 3 4] şi

y =[0.2725 0.4493 1.2214 1.5683 2.5857 5.4739 9.0250]
(generat cu relaţia y = e0.5⋅ x + 0.2 : y=exp(0.5*x+0.2)), apelul funcţiei
cmmp_exp: cu primele trei argumente de ieşire:
[A,B,E]=cmmp_exp(x,y)
furnizează rezultatul aşteptat:
A =
0.5000
B =
0.2000
E =
1.6424e-030
Eroarea globală nu este exact 0, din cauza erorilor introduse de logaritmarea iniţială.
Exempl ul 2.5: Se perturbă acum uşor valorile lui y din exemplul 2.4 cu maxim ±25%,
obţinându-se şirul y1=[0.2998 0.4044 1.3435 1.4115 2.8443
4.9266 9.9275 8.9768].
Făcând abstracţie de modul de generare a datelor, alura norului de puncte poate

corespunde la fel de bine şi unei curbe exponenţiale, dar şi unei parabole. Se vor încerca
ambele tipuri de regresie – exponenţială şi parabolică – şi se vor compara erorile globale.
Se apelează întâi funcţia cmmp_exp, pentru regresia exponenţială:
[A,B,E1]=cmmp_exp(x,y1)
obţinându-se:
A =
0.4641
B =
0.1791
E1 =
69.5620
Deci norul de puncte poate fi aproximat prin $y exp = e0.4641⋅ x + 0.1791 , cu eroarea globală
de 69.562.
Apelul funcţiei cmmp_par, pentru regresie parabolică:
[a,b,c,E2]=cmmp_par(x,y1)
conduce la:
a =
0.2457
b =
0.9255
c =
1.1475
E2 =
66.1489
15
10
$y 2
par = 0.2457 ⋅ x + 0.9255 ⋅ x + 1.1475
$y 0.4641⋅ x + 0.1791
exp = e
0
-3 -2 -1 0 1 2 3 4 5
Fig. 2.3 Aproximarea prin regresie parabolică şi exponenţială a unui nor de puncte
Deci norul de puncte mai admite şi aproximarea $y par = 0.2457 ⋅ x 2 + 0.9255 ⋅ x + 1.1475 ,
cu eroarea globală de 66.1489.
Se observă că eroarea globală are valori mari în ambele cazuri, dar că este mai mică în
cazul regresiei parabolice (66.1489) decât în cazul regresiei exponenţiale (69.562). Deci, deşi
datele iniţiale, neperturbate, corespundeau unei dependenţe exponenţiale, perturbarea lor a
fost suficient de semnificativă pentru a modifica tipul dependenţei: datele perturbate ale
variabilei dependente, y, respectă mai degrabă o lege parabolică în raport cu variabila
independentă, x.
Reprezentarea norului de puncte şi trasarea graficelor curbelor de regresie obţinute mai
sus în acelaşi sistem de coordonate se realizează prin următorul bloc de comenzi:
[A,B,E1,xx1,yy1]=cmmp_exp(x,y1);
[a,b,c,E2,xx2,yy2]=cmmp_par(x,y1);
plot(x,y,'ko',xx1,yy1,'k--',xx2,yy2,'k-');grid;
care produce rezultatele din figura 2.3.
2.1.5 Cazul general de regresie polinomială

Dacă alura norului de puncte nu corespunde niciunuia din cazurile de mai sus, atunci se
efectuează regresia după o curbă polinomială de grad cel puţin 3. Notând cu m numărul
)
coeficienţilor de regresie – care este, deci, cel puţin 4 – valorile aproximate, y i , i = 1, n , sunt
date de relaţia generală:
(2.11) $yi = am ⋅ xim −1 + am −1 ⋅ xim − 2 + ... + a2 ⋅ xi + a1
Să observăm că există o cerinţă generală: pentru a face regresie polinomială cu m

parametri este necesar să se dispună de cel puţin m perechi de date (xi,yi). Deci trebuie
îndeplinită condiţia n≥m. Notând cu c = [ ai ]i =1, m vectorul coeficienţilor de regresie,
sistemul (2.3) este liniar pătratic; el se poate pune sub forma compactă:
(2.3’) S ⋅ c = t
unde S =  s ji  este matricea sistemului, iar t = t j  este vectorul

j =1, m, i =1, m j =1, m
termenilor liberi, ale căror elemente se calculează după relaţiile:
n n
(2.12) s ji = ∑ xkj + i − 2 , t j = ∑ yk ⋅ xkj −1
k =1 k =1
Matricea S fiind nesingulară, sistemul (2.3’) este compatibil determinat şi are soluţia:
(2.13) c = S −1 ⋅ t
Mai jos este prezentată funcţia Matlab cmmp_gen, care reprezintă o implementare
posibilă a cazului general de regresie polinomială. Spre deosebire de funcţiile de regresie
prezentate până acum, această funcţie mai primeşte încă un argument de intrare, şi anume pe
m, numărul de parametri de regresie (pe lângă vectorii x şi y). Pentru simplitate, formula
(2.13) s-a realizat prin apelul funcţiei inv din biblioteca Matlab (implementarea de algoritmi
numerici pentru calculul inverselor matriciale va fi discutată pe larg mai târziu în această
lucrare). Primul argument de ieşire al funcţiei de mai jos, coef, este vectorul coeficienţilor
polinomului de regresie, în ordine crescătoare a puterilor variabilei. Celelalte argumente de
ieşire au aceeaşi semnificaţie ca în cazul celorlalte funcţii.
function [coef,E,y_aprox,xx,yy]=cmmp_gen(x,y,m)
%metoda CMMP de aproximare a dependenţei y=f(x)
%printr-un POLINOM DE GRADUL m-1 (altfel spus, regresie cu m parametri);
%coeficienţii polinomului de regresie se returnează în coef,
%care este de dimensiune m, în ordine crescătoare a puterilor variabilei;
%x şi y au aceeaşi dimensiune;
%(recomandabil ca x să fie ordonat crescător/descrescător);
%n>m (numărul de perechi de date trebuie sa fie mai mare
% decât numărul parametrilor de regresie)
n=length(x);
%calculul elementelor matricei şi al termenilor liberi
for j=1:m,
t(j)=0;
for i=1:m,
s(j,i)=0;
for k=1:n,
s(j,i)=s(j,i)+x(k)^(j+i-2);
end;
end;
for k=1:n,
t(j)=t(j)+y(k)*(x(k)^(j-1));
end;
end;
coef=inv(s)*t';
coef=coef';%operaţie de transpunere pentru ca vectorul coef să rezulte de tip linie
%calculul valorilor aproximate ale variabilei dependente

for k=1:n,
y_aprox(k)=0;
for i=1:m,
y_aprox(k)=y_aprox(k)+coef(i)*(x(k)^(i-1));
end;
end;
%eroarea globală
E=(y-y_aprox)*(y-y_aprox)';%echivalent cu E=(y-y_aprox).^2
%generarea vectorilor de valori pentru o eventuală reprezentare grafică

for k=1:length(xx),
yy(k)=0;
for i=1:m,
yy(k)=yy(k)+coef(i)*(xx(k)^(i-1));
end;
end;
O b s e r v a ţ i e : Dacă se doreşte obţinerea coeficienţilor de regresie în ordine
descrescătoare a puterilor variabilei (ceea ce corespunde manierei Matlab de returnare a
rezultatelor de acest tip), atunci se poate folosi funcţia Matlab fliplr (engl. flip left-right,
oglindire stânga-dreapta; alte funcţii din aceeaşi clasă sunt flipud – engl. flip up-down – şi
rot90). Avantajul acestei variante este că y_aprox şi yy se pot calcula mai elegant, şi
anume apelând o altă funcţie din bibliotecă, polyval, de calcul al valorii unui polinom dat
prin vectorul coeficienţilor în ordine descrescătoare a puterilor variabilei într-o valoare dată
(a se vedea şi §1.3.3.8, exerciţiul propus 4). Ultimele trei blocuri de comenzi din funcţia
cmmp_gen se rescriu sub forma:
coef=inv(s)*t';
coef=fliplr(coef');
%calculul valorilor aproximate ale variabilei dependente

for k=1:n,
y_aprox(k)=polyval(coef,x(k));
end;
%eroarea globală
E=(y-y_aprox)*(y-y_aprox)';
%generarea vectorilor de valori pentru o eventuală reprezentare grafică

for k=1:length(xx),
yy(k)=polyval(coef,xx(k));
end;
O problemă anticipată în paragrafele anterioare constă în modul cum se stabileşte gradul
polinomului de regresie, altfel spus numărul parametrilor de regresie, m. Având în vedere
condiţia m≤n, în primă fază se poate considera m=n, adică efectuarea unei regresii de grad
maxim admis de seturile respective de date. Este posibil ca această regresie să nu fie necesară,
caz în care unul sau mai mulţi coeficienţi polinomiali, începând cu cel de rang maxim, m-1,
să fie aproape nuli sau, în orice caz, mult mai mici în valoare absolută decât ceilalţi. În acest
caz, o a doua iteraţie de regresie se va face cu gradul egal cu rangul primului coeficient nenul
(în ordine descrescătoare a puterilor variabilei).
Exempl ul 2.6: Pentru seturile de date x=[3 3.3 3.7 3.9 4.7 4.8 4.9 5 5.25] şi
y=[3 5 10 14 43 49 56 63 84] (de lungime n=9) se efectuează întâi
regresia de gradul n-1, adică de gradul 8:
[coef,E]=cmmp_gen(x,y,length(x)-1)
Rezultatul apelului de mai sus constă în primul rând în afişarea unui mesaj de avertizare
asupra apropierii de singularitate a matricei sistemului (a cărei inversă se calculează),
numărul ei de condiţionare – calculat în RCOND – fiind mic (comparabil cu epsilon maşină).
Interpretorul avertizează astfel că este posibil ca acurateţea rezultatelor să nu fie bună.
Warning: Matrix is close to singular or badly scaled.

Results may be inaccurate. RCOND = 7.158432e-024
Setările implicite din mediul Matlab prevăd ca avertizările de acest gen să fie ignorate de
către interpretor şi să nu oprească execuţia programelor; astfel, după mesajul de eroare se
afişează rezultatele de mai jos:
coef =
1.0e+004 *
Columns 1 through 7
-4.2489 6.7751 -4.4086 1.4564 -0.2303 0.0038 0.0044
Columns 8 through 9
-0.0006 0.0000
E =
816.4324
Se observă că ultimele două elemente, de rang 7 şi 8, din vectorul coef sunt mult mai
mici decât restul coeficienţilor. Deci procedura de regresie se poate repeta cu gradul
polinomului de regresie micşorat cu două unităţi (gradul 6):
Rezultatele sunt din nou însoţite de acelaşi mesaj de eroare, dar eroarea globală are o
valoare mult mai mică:
Warning: Matrix is close to singular or badly scaled.
Results may be inaccurate. RCOND = 1.281806e-019
coef =
1.0e+004 *
0.8818 -1.2970 0.7868 -0.2519 0.0449 -0.0042 0.0002
E =
0.2157
Dacă se scade în continuare gradul polinomului de regresie la 5:
se observă că valoarea erorii globale creşte (rămânând de acelaşi ordin de mărime), dar nu se
mai afişează mesajul de eroare:
coef =
17.9262 -7.4289 -3.7338 3.0191 -0.7671 0.0888
E =
0.3205
Dacă nivelul maxim admisibil al erorii de aproximare o permite, scăderea gradului
regresiei poate continua în aceeşi manieră, ţinând cont că rangul maxim este ocupat de un
coeficient cu un ordin de mărime mai mic în modul decât ceilalţi (0.0888).
Dacă nu se continuă scăderea gradului, se pune problema care dintre ultimele două
rezultate se reţine drept rezultat final. În general, trebuie evitate rezultatele de încredere
diminuată (însoţite de avertizări de genul celor de mai sus); în cazul de faţă, ultimul rezultat
ar trebui ales, cu atât mai mult cu cât eroarea de aproximare faţă de cazul imediat superior nu
este cu mult mai mare. Ca atare, seturile de date x şi y se găsesc aproximativ în dependenţa:
y ≅ $y = 0.0888 x5 − 0.7671x 4 + 3.0191x3 − 3.7338 x 2 − 7.4289 x + 17.9262
În biblioteca Matlab există o funcţie care implementează cazul general de regresie

polinomială, ea se numeşte polyfit. Această funcţie primeşte ca date de intrare cele două
seturi de date, precum şi gradul polinomului de regresie (funcţia cmmp_gen, scrisă mai sus,
primeşte numărul coeficienţilor polinomiali) şi returnează coeficienţii polinomului în ordine
descrescătoare a puterilor variabilei (în timp ce cmmp_gen îi returnează în ordine
crescătoare).
De pildă, pentru aceleaşi seturi de date x=[2 4 5 7 8] şi y=[1 1.4 2.3 1.2 0.4],
pentru ca cele două funcţii să calculeze acelaşi polinom, de exemplu de gradul 3, ele se vor
apela cu:
[coef1]=polyfit(x,y,4);
[coef2]=cmmp_gen(x,y,5);
şi vor furniza rezultatele coef1=[0.0406 -0.8733 6.4739 -19.0567 19.5556] şi
coef2=[19.5556 -19.0567 6.4739 -0.8733 0.0406], care exprimă acelaşi polinom
de regresie, 0.0406 ⋅ x 4 - 0.8733 ⋅ x3 + 6.4739 ⋅ x 2 -19.0567 ⋅ x + 19.5556 .
2.1.6 Exerciţii rezolvate. Exerciţii propuse

Se exemplifică întâi rezolvarea numerică a două probleme de aproximare în sensul celor
mai mici pătrate.
Exempl ul 2.7: [BACH 86] Un satelit este plasat pe o orbită excentrică dată de legea lui
Kepler:
ρ
(2.14) r =
1 + ε cos ϕ
Să se estimeze parametrii ρ şi ε prin metoda celor mai mici pătrate, având la dispoziţie
observaţiile din tabelul 2.2.
ϕ 12° 48° 151° 208° 350°
r 1.04 1.24 9.27 9.69 1.06
Tabel 2.2 Set de observaţii pentru exemplul 2.7
Se observă întâi că dependenţa de aproximat (2.14) nu este polinomială. De aceea, se va

încerca găsirea unei schimbări de variabilă care să transforme această dependenţă într-una
polinomială. Astfel, prin schimbările de variabilă:
1
y= , x = cos ϕ
r
relaţia (2.14) se rescrie ca o dependenţă liniară:
ε 1
(2.14’) y = ⋅x+
ρ
{ ρ
{
a b
x=cosϕ 0.9781 0.6691 -0.8746 -0.8829 0.9848

y=1/r 0.9615 0.8065 0.1079 0.1032 0.9434
Tabel 2.3 Set de observaţii asupra noilor variabile din exemplul 2.7
Problema iniţială, de estimare a parametrilor ρ şi ε, s-a transformat în determinarea

coeficienţilor a şi b, de regresie liniară, pornind de la seturile xi şi yi, i=1,2,…5, din tabelul
2.3, calculate pe baza tabelului 2.2.
Mai departe, coeficienţii a şi b se determină folosind formulele (2.5) prezentate la
regresia liniară.
Rezolvarea numerică a problemei presupune următorii paşi. După introducerea vectorilor
fi şi r conţinând valorile din tabelul 2.2, se generează vectorii x şi y prin comenzile:
x=cos(pi/180*fi);y=1./r;
Vectorii x şi y se folosesc apoi ca date de intrare pentru funcţia cmmp_lin, scrisă în
§2.1.2:
[a,b,y_aprox,E]=cmmp_lin(x,y)
care furnizează drept rezultat:
a =
0.4548
b =
0.5050
y_aprox =
0.9498 0.8092 0.1072 0.1034 0.9528
E =
2.3518e-004
Conform notaţiilor introduse în relaţia (2.14’):
1 a
ρ= , ε= ,
b b
deci, în final, se obţin parametrii ρ=1.9804 şi ε=0.9006.
90
10
120 60
8
6
150 30
4
180 0
210 330
240 300
270
Fig. 2.4 Aproximarea în sensul celor mai mici pătrate a unei traiectorii eliptice
Este sugestivă reprezentarea grafică a dependenţei aproximate în sistem de coordonate

polare, cu ajutorul funcţiei polar, aceasta fiind traiectoria eliptică a satelitului (figura 2.4).
ro=1/b;epsi=a/b;
xx=0:pi/100:2*pi;%generarea unei diviziuni fine a intervalului de variaţie a unghiului ϕ
yy=ro./(1+epsi*cos(xx));%obţinerea valorilor corespondente ale razei r
polar(fi,r,'ko');%punctele iniţiale (din tabelul 2.2)
hold on;%comandă de reţinere a graficului anterior
polar(xx,yy,'k-');%trasarea traiectoriei
Exempl ul 2.8: [BACH 86] Să se determine unghiul de tragere al traiectoriei parabolice

care porneşte din origine şi care se aproximează prin metoda celor mai mici
pătrate dispunând de punctele P1(1,2), P2(2,3), P3(3,3.2), P4(4,3.5) şi
P5(5,2.5). Să se traseze grafic traiectoria.
La prima vedere, rezolvarea problemei ar consta doar în apelarea funcţiei cmmp_par,
scrisă în §2.1.3, dar trebuie remarcat că în cazul de faţă parabola este constrânsă să treacă
prin origine. De aici rezultă că ecuaţia ei este $y = a ⋅ x 2 + b ⋅ x , deci trebuie determinaţi numai
doi parametri, a şi b. Evident, acesta este un caz particular al cazului general de parabolă,
definită de trei parametri (aici al treilea este nul), dar care nu se poate rezolva printr-o
particularizare a apelului funcţiei cmmp_par. În concluzie, trebuie reluat demersul analitic
pentru deducerea noilor formule de calcul pentru coeficienţii de regresie şi scrisă o nouă
funcţie Matlab.
Coeficienţii a şi b se determină ca soluţiile unei forme particulare a sistemului (2.3):
a ⋅ S4 x + b ⋅ S3 x = S2 xy
 ,
a ⋅ S3 x + b ⋅ S xx = S xy
n n n
unde s-au folosit notaţiile introduse în §2.1.3: S xx = ∑ xi2 , S3 x = ∑ xi3 , S4 x = ∑ xi4 ,
i =1 i =1 i =1
n n
S xy = ∑ xi yi , S2 xy = ∑ xi2 yi (este necesar calculul numai a cinci sume în loc de şapte, ca în
i =1 i =1
cazul general de regresie parabolică). Rezultă că:
 S2 xy ⋅ S xx − S xy ⋅ S3 x S4 x ⋅ S xy − S2 xy ⋅ S3 x
a = , b=
 S4 x ⋅ S xx − S32x S4 x ⋅ S xx − S32x
Noua funcţie Matlab, de regresie după o parabolă care trece prin origine, numită
cmmp_par0, este listată şi comentată mai jos.
function [a,b,E,xx,yy]=cmmp_par0(x,y)
%REGRESIE PARABOLICĂ pe seturile de date (x,y);
% 2
%curba de regresie are ecuaţia y = a*x + b*x;
n=length(x);
%calculul sumelor
Sxx=sum(x.^2);S3x=sum(x.^3);S4x=sum(x.^4);
Sxy=sum(x.*y);S2xy=sum((x.^2).*y);
%calculul determinanţilor
d=Sxx*S4x-S3x^2;
da=Sxx*S2xy-Sxy*S3x;
db=S4x*Sxy-S2xy*S3x;
%calculul coeficienţilor de regresie
a=da/d;
b=db/d;
%vectori calculaţi în vederea unei eventuale reprezentări grafice

yy=a*xx.^2+b*xx;
%eroarea globală
E=sum((y-a*x.^2-b*x).^2);
Se construiesc vectorul absciselor şi cel al ordonatelor punctelor P1(1,2), P2(2,3),
P3(3,3.2), P4(4,3.5) şi P5(5,2.5) şi se ţine cont că parabola trece prin origine. Deci datele de
intrare pentru funcţia cmmp_par0 sunt:
x=[0 1 2 3 4 5];y=[0 2 3 3.2 3.5 2.5];
iar apelul ei:
[a,b,E]=cmmp_par0(x,y)
furnizează rezultatele:
a =
-0.3179
b =
2.0807
E =
0.0786
3.5
2.5
1.5
0.5
α
0
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5
Fig. 2.5 Traiectoria parabolică de tragere obţinută prin regresie (exemplul 2.8)
Pentru trasarea grafică a parabolei, se apelează funcţia cmmp_par0 în forma completă:

[a,b,E,xx,yy]=cmmp_par0(x,y);
şi apoi se apelează funcţia plot:
plot(x,y,'o',xx,yy,'-');grid;
care afişează norul de puncte Pi, i=1,2,...5 şi parabola de regresie din figura 2.5.
Pe aceeaşi figură s-a pus în evidenţă unghiul de tragere, α, a cărui tangentă este panta
dreptei tangente la traiectorie în origine. Aşadar tg(α) = y '(0) = 2ax + b x = 0 = b , de unde
rezultă α = arctg(b) = 1.1228 rad=64.3309° .
Exerciţii propuse
1. Să se scrie o funcţie Matlab pentru aproximarea funcţiei y=sin(x) în intervalul [0;π]

printr-o parabolă de forma y = a ⋅ x 2 + b ⋅ x + c , astfel încât valorile lui sin(x) pentru x=0, π/4,
π/2, 3π/4 şi π să fie aproximate în sensul celor mai mici pătrate. Să se traseze grafic parabola.
2. Populaţia unei ţări a variat în perioada 1992-2003 cum se arată în tabelul de mai jos (în
milioane de locuitori).
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
5.695 5.724 5.598 5.612 5.636 5.605 5.635 5.668 5.711 5.703 5.720 5.691
Să se scrie un program Matlab pentru aproximarea prin regresie a curbei de variaţie a

populaţiei. Pe baza rezultatului obţinut (prin extrapolare), să se estimeze populaţia
respectivei ţări în anul 2005.
3. În vederea trasării caracteristicii statice a unui traductor de curent, u=u(i), s-au realizat
măsurările din tabelul de mai jos.
k 1 2 3 4 5 6 7 8
i [A] 0 0.1 0.25 0.3 0.5 0.7 0.8 0.9
u [V] 0.094 0.35 0.65 0.8 1.05 1.3 1.34 1.42
k 9 10 11 12 13 14 15 16
i [A] 1 1.2 1.5 1.7 2 2.4 2.5 2.9
u [V] 1.53 1.73 1.94 2.1 2.5 2.8 2.9 3.1

Tabel 2.4 Măsurări efectuate pentru trasarea caracteristicii unui traductor de curent, u=u(i)
a) Să se calculeze numeric coeficienţii curbei de regresie care aproximează cel mai bine
dependenţa reprezentată în tabelul 2.4.
b) Pe baza aproximării dependenţei u=u(i) printr-o dreaptă, u$ = a ⋅ i + b , pe diferite
intervale de variaţie ale curentului, i, să se indice domeniul maxim de liniaritate al
caracteristicii statice a traductorului, admiţând o eroare relativă de aproximare,
n =16 2 n =16
Er = ∑ uk − uk
k =1
( ) k =1
2
∑ uk , de maxim 5%.
4. Coeficientul de cuplu al unei tubine eoliene cu două pale, CΓ, depinde de o mărime
adimensională, λ, numită viteză specifică. Mai jos se prezintă tabelar dependenţa CΓ(λ), iar
norul de puncte corespunzător este dat în figura 2.6.
k 1 2 3 4 5 6 7 8 9 10 11 12
λ [-] 0 0.5 0.99 1.49 1.99 2.48 2.98 3.47 3.96 4.46 4.96 5.45
CΓ [-] 0.006 0.006 0.013 0.02 0.026 0.037 0.045 0.056 0.062 0.069 0.072 0.075
k 13 14 15 16 17 18 19 20 21 22 23 24
λ [-] 5.95 6.44 6.94 7.43 7.93 8.42 8.92 9.42 9.91 10.4 10.9 11.4
CΓ [-] 0.075 0.072 0.069 0.063 0.056 0.048 0.04 0.032 0.024 0.017 0.011 0.006
Tabel 2.5 Coeficientul de cuplu al unei turbine eoliene în funcţie de viteza specifică, CΓ(λ)
0.08
0.07
0.06
0.05
0.04
0.03
0.02
0.01
0
0 2 4 6 8 10 12
Fig. 2.6 Norul de puncte reprezentând dependenţa CΓ(λ) din tabelul 2.5
Să se determine o formulă analitică polinomială pentru aproximarea dependenţei CΓ(λ)
în sensul celor mai mici pătrate.
5. Metoda celor mai mici pătrate ale erorii are largă aplicabilitate în domeniul
identificării sistemelor.
Ca exemplificare, unui circuit RC serie (filtru de ordinul I) i se aplică la momentul t0 o
 0, t < t0
tensiune de tip treaptă, u (t ) =  , condensatorul fiind iniţial descărcat. Expresia
U 0 t ≥ t0
analitică a variaţiei teoretice a tensiunii pe condensator, uC(t), este în acest caz:
(
uC (t ) = U 0 ⋅ 1 − e− (t − t0 ) RC )
Pentru identificarea produsului T=RC (numit constanta de timp a circuitului), se obţine
experimental forma de variaţie a tensiunii uC, pentru U0=2V (treaptă unitară). Vizualizarea ei
pe osciloscop este dată în figura 2.7, iar setul de date prelevate se găseşte în tabelul 2.6.
k 1 2 3 4 5 6 7 8 9 10
t [s] 3 4 5 6 7 8 9 10 11 12
uC [V] 0 0.45 1.04 1.37 1.59 1.71 1.8 1.84 1.88 1.91
k 11 12 13 14 15 16 17 18 19 20
t [s] 13 14 15 16 17 18 19 20 21 22
uC [V] 1.91 1.91 1.93 1.93 1.94 1.94 1.94 1.94 1.95 1.95
Tabel 2.6 Set de date experimentale asupra dependenţei uC(t), obţinute din figura 2.7
2.5
uC [V]
1.5
0.5
t [s]
0
0 t0 = 3 5 10 15 20 25
Fig. 2.7 Răspunsul la treaptă, uC(t), al unui filtru de ordinul I

Se cere să se determine T, folosind metoda regresiei.
Indicaţie: Trebuie aplicată metoda regresiei pentru aproximarea curbei
(
uC (t ) = 2 ⋅ 1 − e − (t − 3) RC
) . Se observă că valorile variabilei u C sunt pozitive şi strict mai mici
decât 2V. Se poate, deci, face schimbarea de variabilă y=ln(2–uC). Cu o a doua schimbare de
variabilă, x=t-3, curba de aproximat devine y=–x/T, deci se utilizează regresia liniară. De
observat că trebuie determinat un singur parametru al dreptei (deoarece aceasta este
restricţionată să treacă prin origine); trebuie, deci, scrisă o variantă modificată a funcţiei
cmmp_lin din §2.1.2.
2.2 Interpolarea funcţiilor
După cum s-a văzut, funcţia de regresie permite estimarea valorii variabilei dependente
în orice punct din domeniul de variaţie al variabilei independente – operaţie ce se numeşte
generic interpolare – aşa cum ea poate fi folosită şi la calculul de valori dinafara acestui
domeniu – ceea ce se numeşte extrapolare.
Rămânând în cadrul funcţiilor de o singură variabilă reală, interpolarea porneşte de la
aceleaşi date (tabelate) de intrare, (xi, yi), i=1,2,...n, ca şi metoda celor mai mici pătrate şi are
acelaşi scop: determinarea unei funcţii analitice care aproximează dependenţa exprimată prin
tabelul de intrare. Deosebirea faţă de regresie este că, de această dată, funcţia de interpolare
este constrânsă să treacă prin punctele (xi, yi) şi nu printre ele, aşa cum rezulta în cazul
regresiei. Aceste puncte se numesc noduri (de interpolare).
În general se foloseşte interpolarea cu funcţii polinomiale. Acest paragraf este dedicat
implementării în Matlab a celor mai uzuale metode de interpolare unidimensională, prin
funcţii utilizator sau folosind funcţiile disponibile în biblioteca mediului.
2.2.1 Formula de interpolare a lui Newton

Dându-se n noduri de interpolare, (xi, yi), i=1,2,...n, atunci valoarea variabilei y într-un
punct intermediar x este dată de polinomul de interpolare al lui Newton, de gradul n-1, notat
cu N(x):
(2.15) y = y1 + ( x − x1 ) ⋅ ∆y1 + ( x − x1 )( x − x2 ) ⋅ ∆ 2 y1 + ... + ( x − x1 ) ... ( x − xn −1 ) ⋅ ∆ n −1 y1 ,
unde:
y −y ∆y − ∆y1 ∆ n − 2 y2 − ∆ n − 2 y1
∆y1 = 2 1 , ∆ 2 y1 = 2 , … ∆ n −1 y1 =
x2 − x1 x3 − x1 xn − x1
sunt diferenţele finite succesive calculate pentru variabila y, a căror formulă recursivă
generală este:
∆ j −1 yi +1 − ∆ j −1 yi
(2.16) ∆ j yi = , j = 1, n − 1, i = j , n − 1 ,
xi + j − xi
unde s-a notat ∆ 0 yi ≡ yi . Relaţia (2.16) conduce la ideea de a calcula aceste diferenţe ca
elementele triunghiului inferior al unei matrice de n-1 linii şi n-1 coloane, după cum urmează:
 ∆y1 
 2 
 ∆y2 ∆ y1 
 
 ∆y3 ∆ 2 y2 ∆3 y1 
D= .  . ... ... 
 
. . ∆ j yi ... ∆ j y1 
 
. . ... ... ... 
 2 
 ∆yn −1 ∆ yn − 2 ... ∆ j yn − j ... ∆ n −1 y1 
Conform relaţiei (2.15), din matricea D interesează doar elementele de pe diagonala
principală (încercuite cu linie punctată).
Elementele primei coloane a matricei D se calculează exclusiv pe baza nodurilor de
interpolare (xi, yi), i=1,2,...n, pentru restul elementelor se foloseşte formula recursivă (2.16),
care se rescrie în spiritul observaţiilor de mai jos.
Elementul generic ∆ j yi se află pe coloana l=j şi linia k=i+j-1 ale matricei D:
(2.17) Dkl = ∆ j yi , l = 1, n − 1, k = l , n − 1
Se exprimă perechea de indici (i, j) în funcţie de perechea de indici (k, l):

j = l , i = k − j +1 = k − l +1
ceea ce conduce la deducerea următoarelor relaţii:
∆ j yi = Dkl 
 
 j −1 
(2.18) ∆ yi +1 = Dk ,l −1  , l = 2, n − 1, k = l , n − 1
 j −1 
∆ yi = Dk −1,l −1 
Corespondenţele din relaţia (2.18) se înlocuiesc în relaţia (2.16) şi rezultă astfel relaţia de
calcul al elementelor triunghiului inferior al matricei D, ţinând cont că elementele primei
coloane (l=1) se calculează separat:
 yk +1 − yk
 Dk1 = x , k = 1, n − 1
 k +1 − xk
(2.19)  ,
 D = Dk ,l −1 − Dk −1,l −1 , l = 2, n − 1, k = l , n − 1
 kl xk +1 − xk − l +1
În cazul particular în care punctele xi sunt echidistante, adică xi +1 − xi = h, i = 1, n − 1 ,

atunci formula (2.15) a polinomului de interpolare Newton devine:
∆y1 ∆ 2 y1 ∆ n −1 y1
(2.15’) y = y1 + ( x − x1 ) + ( x − x1 )( x − x2 ) + ... + ( x − x1 ) ... ( x − xn −1 )
1!h 2!h 2 (n − 1)!h n −1
Pentru n=1 se obţine interpolarea liniară, pentru n=2 interpolarea pătratică, iar pentru
n=3 interpolarea cubică.
Mai jos se prezintă programul script int_newt care calculează polinomul de interpolare
al lui Newton şi exemplifică trasarea graficului acestuia prin nodurile de interpolare.
%INTERPOLARE CU POLINOM NEWTON
%exemplu de iniţializare
x=[1 5 8 9 10];
y=[2 30 11 4 8];
n=length(x);
%calculul primei coloane din matricea de diferenţe finite, D
for k=1:(n-1),
D(k,1)=(y(k+1)-y(k))/(x(k+1)-x(k));
end;
%calculul restului elementelor din triunghiul inferior al matricei D

for l=2:n-1,
for k=l:n-1,
D(k,l)=(D(k,l-1)-D(k-1,l-1))/(x(k+1)-x(k-l+1));
end;
end;
tt=fliplr(diag(D)');%extragerea diagonalei principale a matricei D

%într-un vector linie şi reaşezarea lui în ordinea inversă a rangurilor
%calculul coeficienţilor polinomului de interpolare al lui Newton

coef=[zeros(1,n-1) y(1)];
for i=1:(n-1),
coef=coef+[zeros(1,i-1) poly(x(1:n-i))*tt(i)];
end;
%construirea vectorilor pentru reprezentările grafice

pas=(max(x)-min(x))/250;
xx=min(x):pas:max(x);
for i=1:length(xx),
yy(i)=polyval(coef,xx(i));
end;
plot(x,y,'mo',xx,yy,'r-');grid;
title('INTERPOLARE PRIN POLINOM NEWTON');
Programul calculează elementele matricei D a diferenţelor finite folosind relaţiile (2.19)
şi construieşte vectorul tt al acelor diferenţe care intervin în calculul coeficienţilor
polinomului lui Newton, şi anume ∆ n −1 y1 , ∆ n − 2 y1 , ... ∆y1 (în această ordine,
corespunzătoare ordinii descrescătoare a rangurilor coeficienţilor în vectorul coef). În
calculul vectorului coef s-a utilizat funcţia poly din biblioteca Matlab. Aceasta primeşte un
vector de dimensiune n şi returnează într-un alt vector, de dimensiune n+1, coeficienţii
polinomului care are drept rădăcini elementele vectorului de intrare.
Pentru iniţializările considerate, polinomul de interpolare Newton are gradul 4 şi este:
N ( x) = 0.1018 ⋅ x 4 − 2.1238 ⋅ x3 + 13.2732 ⋅ x 2 − 22.6798 ⋅ x + 13.4286
2.2.2 Formula de interpolare a lui Lagrange

În cazul general, un polinom de gradul n-1, constrâns să ia pentru x=xi valorile yi,
i=1,2,...n, este dat de formula de interpolare a lui Lagrange:
(2.20) L( x) = ∑ yi ⋅
n ( x − x1 ) ⋅ ( x − x2 ) ⋅ ... ⋅ ( x − xi −1 ) ⋅ ( x − xi +1 ) ⋅ ... ⋅ ( x − xn )
i =1 ( xi − x1 ) ⋅ ( xi − x2 ) ⋅ ... ⋅ ( xi − xi −1 ) ⋅ ( xi − xi +1 ) ⋅ ... ⋅ ( xi − xn )
Observaţie:
Formula (2.20) şi formula (2.15), de interpolare a lui Newton, conduc la acelaşi polinom
de interpolare; acesta poate fi referit ca „polinom Newton” sau ca „polinom Lagrange”, după
cum este obţinut cu una sau cu cealaltă din formule.
Dacă se notează:
(2.21) si ( x) = ( x − x1 ) ⋅ ( x − x2 ) ⋅ ... ⋅ ( x − xi −1 ) ⋅ ( x − xi +1 ) ⋅ ... ⋅ ( x − xn ) , i = 1, n ,
atunci relaţia (2.20) se scrie:

n s ( x) n yi
(2.22) L( x) = ∑ yi ⋅ i = ∑ ⋅ si ( x)
i =1 si ( xi ) i =1 si ( xi )
14243
pi ( x )
Toate polinoamele si au gradul n-1, deci şi polinoamele notate cu pi în relaţia (2.22) au

gradul n-1. Prin urmare, coeficienţii acestor polinoame se pot reprezenta prin vectori de
dimensiune n. Vectorul coeficienţilor polinomului Lagrange se obţine prin sumarea vectorilor
coeficienţilor celor n polinoame pi; algoritmul de calcul este schiţat mai jos.
Date de intrare: {xi}, {yi}, i=1,2,...n (cu {xi} strict monoton)
#0. Se iniţializează vectorul L al coeficienţilor polinomului Lagrange la vectorul nul de
dimensiune n-1.
Pentru i de la 1 la n
#1. Se calculează vectorul cs al coeficienţilor polinomului si.
#2. Se calculează valoarea polinomului si în xi: v ← si(xi).
#3. Se calculează vectorul cp al coeficienţilor polinomului pi: cp ← cs⋅yi/v.
#4. L ← L+cp
Repetă
Mai jos este listat un program Matlab care realizează calculul polinomului Lagrange şi
evaluează polinomul într-o valoare intermediară dată de utilizator. S-a introdus o secvenţă de
comenzi prin care se îndeplineşte condiţia ca valorile xi să fie ordonate monoton (folosirea
funcţiei sort).
%Interpolarea funcţiilor prin POLINOMUL DE INTERPOLARE LAGRANGE
%exemplu de iniţializare
x=[1 5 8 9 10];
y=[2 30 11 4 8];
[m n]=size(x);
%sortarea datelor: ordonarea crescătoare a valorilor lui x

% şi ordonarea corespunzătoare a valorilor lui y
[xsort,ind]=sort(x);
l=1;
for i=1:n,
ysort(l)=y(ind(i));
l=l+1;
end;
x=xsort;
y=ysort;
%calculul coeficienţilor polinomului de interpolare

L=zeros(1,n);
for i=1:n,
cs=poly([x(1:i-1) x(i+1:n)]);
cp=cs*y(i)/polyval(cs,x(i));
L=L+cp;
end;
pas=(max(x)-min(x))/250;
xx=min(x):pas:max(x);
for i=1:length(xx),
yy(i)=polyval(L,xx(i));
end;
val=input('Introduceti valoarea in care doriti interpolarea:');

yval=polyval(L,val);
%grafic
plot(xx,yy,'r-',x,y,'g*',xv,yv,'m--');grid;
s1=sprintf('INTERPOLARE PRIN POLINOM LAGRANGE');
title(s1);
xlabel('x');
ylabel('y');
S-a utilizat acelaşi exemplu de iniţializare ca şi în programul int_newt, de calcul al
polinomului de interpolare Newton (din §2.2.1); se obţine următorul polinom Lagrange:
L( x) = 0.1018 ⋅ x 4 − 2.1238 ⋅ x3 +13.2732 ⋅ x 2 − 22.6798 ⋅ x + 13.4286

Se observă identitatea polinoamelor Newton şi Lagrange.
2.2.3 Funcţii de interpolare din biblioteca Matlab

Interpolarea unidimensională se realizează în Matlab cu ajutorul funcţiei interp1; o altă
funcţie, interpft, este dedicată interpolării funcţiilor periodice, cu ajutorul transformatei
Fourier rapide. Funcţia Matlab spline implementează interpolarea unidimensională cu
funcţii spline cubice (pentru definirea funcţiilor spline, a se vedea, de exemplu, [TĂNĂ 02]).
Funcţiile interp2, griddata şi meshgrid realizează interpolare bidimensională.
Funcţia interp1 primeşte trei argumente de intrare: doi vectori de aceeaşi dimensiune,
reprezentând respectiv abscisele şi ordonatele nodurilor de interpolare, şi un al treilea vector,
conţinând abscisele în care se doreşte interpolarea. Funcţia returnează un vector de aceeaşi
dimensiune cu al treilea argument de intrare, care conţine valorile interpolate. Abscisele
nodurilor trebuie să fie monotone (ordonate crescător sau descrescător).
În mod implicit, interp1 realizează interpolare liniară între oricare două noduri cu
abscise succesive. O a doua formă de apel a acestei funcţii prevede furnizarea unui al patrulea
argument de intrare, de tip şir de caractere, prin care se specifică metoda de interpolare:
’linear’ (implicit), ’spline’ (folosind funcţii spline cubice) şi ’cubic’ (interpolare
cubică).
10
6 interpolare cu
funcţii spline
4
2
interpolare liniară
0
-2
interpolare cubică
-4
-6
-8
-2 0 2 4 6 8 10 12
Fig. 2.8 Trei metode de interpolare aplicate aceloraşi date de intrare
O aplicaţie tipică a interpolării este creşterea preciziei de trasare a graficelor; blocul de

comenzi de mai jos exemplifică aceasta cu folosirea funcţiei interp1.
x=[-2 0 5 7 7.5 9 12];
y=[-3 2.5 -5 4.8 7.3 6 2.1];
xx=min(x):0.05:max(x);
yy1=interp1(x,y,xx);%metoda implicită este cea liniară
yy2=interp1(x,y,xx,’spline’);
yy3=interp1(x,y,xx,’cubic’);
plot(x,y,’ko’,xx,yy1,’k-’,xx,yy2,’k-—’‚xx,yy3,’k:’);grid
Figura 2.8 (rezultată în urma apelului funcţiei plot) arată deosebirile între diferitele
metode de interpolare folosite de interp1.
2.2.4 Exerciţii rezolvate. Exerciţii propuse

Exempl ul 2.9: [BACH 88] Despre o funcţie se cunosc valorile din tabelul de mai jos.
xi -2 -1 1 4
yi 0 -2 0 60
a) Să se determine polinomul Lagrange de interpolare.
b) Să se aproximeze aria de sub graficul funcţiei între -2 şi 4 prin aria de sub curba de
interpolare. Pentru calculul numeric al integralei definite se va folosi metoda trapezelor:
b n −1 h
(2.23) ∫ f ( x)dx ≈ ∑ ⋅ ( f ( xk ) + f ( xk +1 ) ) ,
a k =1 2
unde h este pasul de discretizare al abscisei, n este numărul de puncte rezultate prin
discretizare (inclusiv capetele intervalului), iar xk = a + (k − 1) ⋅ h, k = 1, n − 1 .
c) Prin extrapolare liniară în punctul x=4, să se aproximeze valoarea funcţiei în x=5.
Rezolvarea punctului a) necesită executarea programului de calcul al polinomului
Lagrange, scris în §2.2.2, în care secţiunea de iniţializare se înlocuieşte cu:
x=[-2 -1 1 4];y=[0 -2 0 60];
Dacă programul astfel modificat se salvează cu numele int_lagr, el se va apela în linie
de comandă:
int_lagr
Se vizualizează conţinutul variabilei L, care conţine coeficienţii polinomului Lagrange:
L
L =
0.4667 1.9333 0.5333 -2.9333
deci acesta este:
L( x) = 0.4667 ⋅ x3 + 1.9333 ⋅ x 2 + 0.5333 ⋅ x − 2.9333
La punctul b) se propune întâi scrierea unei funcţii utilizator de calcul numeric al
integralei definite, conform formulei de aproximare (2.23). La cazul general, funcţia trebuie
să primească trei argumente de intrare, şi anume numele funcţiei de integrat ca şir de
caractere şi cele două capete ale intervalului de integrare (numere reale). O implementare
posibilă este dată mai jos.
function I=met_trpz(nume_f,a,b)
%calcul de integrale definite prin METODA TRAPEZELOR
n=500;%se alege numărul de puncte de discretizare a abscisei, n, ca fiind 500
h=abs(b-a)/(n-1);
I=0;
for k=1:n-1,
x1=a+(k-1)*h;x2=x1+h;
I=I+h/2*(feval(nume_f,x1)+feval(nume_f,x2));
end;
Funcţia Matlab feval evaluează valoarea unei funcţii – date prin numele ei ca şir de
caractere – într-un şir specificat al argumentelor ei de intrare; rezultă, deci, că numărul
argumentelor de intrare ale lui feval este cu unul mai mult decât cel al funcţiei pe care o
evaluează. Mai sus apelul feval(nume_f,a) este echivalent cu nume_f(a). Funcţia
feval s-a folosit pentru ca, la schimbarea funcţiei de integrat, să nu fie necesară schimbarea
codului funcţiei met_trpz, ci doar transmiterea unui alt prim argument de intrare.
În cazul de faţă, funcţia de integrat va fi funcţia polinomială descrisă de coeficienţii din
vectorul L mai sus obţinut, care trebuie transmis ca variabilă globală; implementarea ei este
dată mai jos.
function y=pollagr(x)
global L;
y=polyval(L,x);
Această funcţie trebuie să existe ca funcţie Matlab (în fişierul pollagr.m) în momentul
apelului funcţiei met_trpz, în acelaşi director cu aceasta. Valoarea aproximativă a ariei
cuprinse între abscisele -2 şi 4 sub curba de interpolare rezultă din următoarea comandă:
aria=met_trpz(’pollagr’,-2,4)
aria =
60.0005
Punctul c) se poate rezolva şi fără a apela la o maşină de calcul. Extrapolarea liniară a
funcţiei în 4 (ultimul nod) presupune interpolarea liniară între ultimele două noduri şi apoi
calculul valorii funcţiei de interpolare în abscisa 5. Aceasta se poate realiza tot cu funcţia
int_lagr, unde secvenţa de iniţializare devine:
x=[1 4];y=[0 60];
Evident, funcţia de interpolare este polinomială de gradul I, L( x) = 20 ⋅ x − 20 , iar
valoarea ei în 5 este L(5)=80.
Exerciţii propuse
1. Să se determine polinomul de interpolare (folosind o formulă la alegere, Newton sau

Lagrange) pentru setul de date prezentat în exerciţiul propus 4 din §2.1.6.
a) Folosind valorile interpolate pe o diviziune a abscisei cu un pas convenabil ales, să se
determine valoarea variabilei independente, λ, pentru care se obţine maximul curbei CΓ(λ).
Să se compare cu valoarea rezultată folosind interpolarea cu funcţii spline prin apelul funcţiei
Matlab spline.
b) În aplicaţiile de timp real, complexitatea calculelor poate deveni critică. Care dintre
cele două metode de aproximare, regresie sau interpolare, ar trebui folosită într-o aplicaţie de
timp real, dacă se admite o eroare relativă de aproximare – definită ca în exerciţiul propus 3
din §2.1.6 – de maxim 1%?
Indicaţie: Se determină polinomul de regresie de grad minimal care asigură ca eroarea
relativă să fie mai mică decât 1% şi se compară cu gradul polinomului de interpolare (care
este 23); evident, se alege formula mai simplă.
2. Asupra caracteristicii de intrare – curentul de bază în funcţie de tensiunea bază-emitor,
iB=iB(uBE) – a unui tranzistor bipolar în montaj cu emitor comun se dispune de măsurările din
tabelul 2.7. Caracteristicile statice de ieşire – curentul de colector în funcţie de tensiunea
colector-emitor, iC=iC(uCE) – sunt date, pentru 6 valori cunoscute ale curenţilor de bază, doar
prin câte două măsurători, aşa cum se descrie în tabelul 2.8.
uBE [V] 0 0.2 0.3 0.4 0.6
iB [µA] 0 0 0.4 20 150
Tabel 2.7 Măsurări privind caracteristica de intrare a unui tranzistor bipolar, iB=iB(uBE)
iB1=20µA iB2=40µA iB3=60µA iB4=80µA iB5=100µA iB6=120µA
uCE [V] 1 15 1 13 1 10 1 10 1 5 1 5
iC [mA] 3 4 6.5 8.5 10.5 13 14 17.5 17 19 21 24
Tabel 2.8 Măsurări privind caracteristica de ieşire a unui tranzistor bipolar, iC=iC(uCE)
Ştiind că aceste caracteristici sunt liniare în plaja normală de funcţionare a tranzistorului,
să se afle caracteristicile punctului static de funcţionare, PSF(iB0, iC0), pentru care uBE0=0.5V
şi uCE0=6V.
Indicaţie: Se recomandă întâi reprezentarea grafică a punctelor din cele două tabele
pentru a se percepe alura curbelor. Se calculează polinomul de interpolare al caracteristicii de
intrare şi se deduce valoarea curentului de bază, iB0, pentru care uBE0=0.5V. Cu această
valoare se stabileşte pe care dintre cele 6 caracteristici de ieşire se află PSF şi, folosind
interpolarea liniară, se deduce valoarea curentului de colector, iC0, pentru care uCE0=6V.
2.3 Metode de optimizare parametrică
Problemele de optimizare vizează extremizarea (maximizarea sau minimizarea) unui

criteriu de performanţă. Acesta din urmă poate fi o funcţie – caz în care este vorba despre
optimizarea parametrică – sau o funcţională (o funcţie de funcţii), când este vorba despre
optimizarea dinamică. Acest paragraf este dedicat ilustrării comparative a principalilor
algoritmi de optimizare parametrică.
2.3.1 Formularea problemei. Definiţii

Criteriul de performanţă care trebuie extremizat se mai numeşte funcţie scop, funcţie
obiectiv sau funcţie criteriu fără impuneri de legături sau/şi restricţii. Aceasta este o funcţie
de n argumente reale, f ( x1, x2 ,...xn ) , a cărei extremizare înseamnă găsirea unui vector
T
x* =  x1* x2* ... xn*  ∈ n , corespunzător unui punct din spaţiul n-dimensional, pentru
 
care funcţia este optimă (maximă sau minimă). Maximizarea şi minimizarea unei funcţii nu
se deosebesc formal, întrucât maximul lui f se obţine pentru minimul lui –f.
Pentru n≤2, funcţia obiectiv admite o reprezentare geometrică, şi anume:

• bidimensională: y = f ( x1 ) este ecuaţia unei curbe în planul ( x1, y ) ;
• tridimensională: y = f ( x1, x2 ) este ecuaţia unei suprafeţe în sistemul de coordonate
( x1, x2 , y ) (suprafaţa de răspuns).
Generalizarea acestor reprezentări pentru o funcţie obiectiv de n variabile independente
necesită un sistem de n+1 axe independente, perpendiculare două câte două într-un sistem
cartezian. Pentru n≥3 aceasta este evident imposibil de realizat în spaţiul tridimensional şi de
aceea dezvoltările teoretice – cu introducerea noţiunilor de „hiperplan”, „hipersuprafaţă”,
„hiperspaţiu” – sunt uneori mai dificil de urmărit.
Este utilă reluarea a două definiţii cunoscute din matematică.
D e f i n i ţ i a 2 . 1 : Fie funcţia scalară continuă şi derivabilă de variabilă vectorială f ( x) ,
x ∈ n . Se numeşte gradientul funcţiei f funcţia vectorială de variabilă
vectorială notată cu ∇f ( x) , care conţine derivatele parţiale de ordinul întâi
ale lui f în raport cu fiecare dintre componentele lui x :
T
 ∂f ( x) ∂f ( x) ∂f ( x) 
(2.24) f '( x) = ∇f ( x)  ... 
 ∂x1 ∂x2 ∂xn 
Funcţia −∇f ( x) se numeşte antigradientul funcţiei f. Punctele de extrem, x* , ale unei

funcţii de variabilă vectorială sunt caracterizate de anularea gradientului: ∇f ( x* ) = 0 .
Direcţia vectorului gradient indică spre maximul unei funcţii concave, iar a antigradientului
indică spre minimul unei funcţii convexe.
D e f i n i ţ i a 2 . 2 : Se numeşte (matricea) hessian a funcţiei de variabilă vectorială f ( x)
funcţia matricială de variabilă vectorială notată cu H ( x) , obţinută printr-o
nouă derivare a gradientului în raport cu componentele vectorului x :
 ∂ 2 f ( x) ∂ 2 f ( x) ∂ 2 f ( x) 
 ... 
2 ∂x1∂x2 ∂x1∂xn 
 ∂x1
 2 
 ∂ f ( x) ∂ 2 f ( x) ∂ 2 f ( x) 
 ∂x ∂x ...
(2.25) f "( x) = H ( x) ∂x22 ∂x2∂xn 
 2 1 
 ... ... ... ... 
 
 ∂ 2 f ( x) ∂ 2 f ( x) ∂ 2 f ( x) 
 ∂x ∂x ... 
 n 1 ∂xn ∂x2 ∂xn2 
2.3.2 Clasificarea metodelor de optimizare parametrică

Principalele metode de optimizare parametrică sunt sintetizate în tabelul 2.9; ele sunt
detaliate în paragrafele următoare. Cele două mari clase de metode – indirecte şi directe – se
deosebesc atât principial, cât şi din punctul de vedere al performanţelor (viteza de
convergenţă, timpul de calcul şi memoria necesară algoritmilor rezultaţi). Astfel, metodele
directe sunt în general mai lent convergente decât metodele indirecte, dar necesită un volum
de memorie mai mic. Nivelul admisibil al compromisului acceptat în ce priveşte

performanţele este un factor în alegerea uneia sau alteia dintre metode.
A. indirecte A.1 metode de gradient (Cauchy)
(folosesc valorile funcţiei A.2 metode Newton (de gradient de ordinul al II-lea)
f ( x ) şi pe cele ale
A.3 metode ale direcţiilor conjugate
derivatelor ei)
B.1 metoda explorării exhaustive
B. directe unidimensională
B.2 metode de eliminare
(folosesc numai valorile multidimensională
funcţiei f ( x ) , fără a le B.3 metode de căutare pe bază de hiperpoliedre (simplexuri)
exploratoare
utiliza pe cele ale
B.4 metode de căutare aleatoare (Monte Carlo)
derivatelor ei)
B.5 metode de căutare unidirecţională (unidimensională) ≡
metode de relaxare (Gauss)
Tabel 2.9 Clasificarea metodelor de optimizare parametrică
2.3.3 Metode indirecte

Metodele indirecte se mai numesc şi metode de urcare (coborâre); pentru simplificare,
pintr-un lejer abuz de limbaj, termenul de „metode de gradient” denotă în mod generic
întreaga clasă a metodelor indirecte. Esenţa lor constă în găsirea punctului de anulare a
gradientului (acesta fiind punctul de extrem căutat), pornind dintr-un punct iniţial dat. În
calculul aproximativ, termenul de „anulare” înseamnă, de fapt, situarea valorii absolute sub o
anume limită (toleranţă) dată, considerată ca suficientă.
Metodele de gradient (Cauchy) şi cele de gradient de ordinul al II-lea (Newton) se
bazează pe aproximări de ordinul I, respectiv de ordinul al II-lea, ale dezvoltării în serie
Taylor a funcţiei obiectiv f ( x) în jurul punctului de optim, x* :
T
( ) ( ) (
(2.26) f ( x ) ≅ f x* + f ' x* ⋅ x − x* )
T 1 T T
( ) ( ) ( ) ( ) ( ) (
(2.27) f ( x ) ≅ f x* + f ' x* ⋅ x − x* + ⋅ x − x* ⋅ f " x* ⋅ x − x*
2
)
Metodele Newton au o convergenţă mai bună decât cele de gradient simplu, dar prezintă
inconvenientul unui timp de calcul şi al unui volum de memorie mai mari, pentru că necesită
calculul matricei hessian la fiecare iteraţie de căutare.
În formula (2.26) gradientul arată direcţia ratei maxime de creştere a funcţiei f. Pe
această formulă se bazează metoda celei mai mari pante (dacă optimul este un maxim) sau
metoda celei mai abrupte coborâri (dacă optimul este un minim). Mai jos se prezintă
descrierea în meta-limbaj a celui mai simplu algoritm de gradient (notaţia ||⋅|| semnifică
norma vectorială).
Date de intrare: ε (toleranţa suficientă), x(0) (punctul iniţial)
i←0
Repetă
#1. Se determină direcţia de căutare la pasul i (dată de versorul asociat gradientului):
(2.28) d (i )
=±
( ) , unde „+/–” corespund maximizării/minimizării
∇f x ( i )
∇f ( x ( i ) )
#3. Se alege arbitrar p(i), pasul de deplasare pe direcţia d(i).

#2. Se calculează noul punct de evaluare a gradientului:
(2.29) x(i +1) = x (i ) + p (i ) ⋅ d (i )

i ← i+1
( )
Până când ∇f x (i ) ≤ ε .
Se observă că algoritmul de mai sus necesită cunoaşterea a priori a tipului de extrem

căutat (maxim sau minim). Implementarea în Matlab se poate face sub forma unei funcţii care
primeşte punctul de start al căutării, x0 (la cazul general acesta este un vector) şi toleranţa
dorită, epsilon, şi returnează valoarea de extrem a unei funcţii (la cazul general, vectoriale)
cunoscute, x, şi numărul de iteraţii în care s-a obţinut aceasta, nr_it. S-a utilizat o variabilă
locală, itermax, pentru a forţa ieşirea din ciclare dacă extremul nu poate fi găsit.
function [x,nr_it]=opt_grad(x0,epsilon)
nr_it=1;x_curent=x0;itermax=1500;%număr maxim de iteraţii
h=0.001; %variaţie utilizată în calculul gradientului
p=0.001;%se alege un pas constant de deplasare
for k=1:n,
v=zeros(1,n);v(k)=1;
grad_curent(k)=(f1(x0+h/2*v)-f1(x0-h/2*v))/h;
end;
while (norm(grad_curent)>=epsilon)&(nr_it<=itermax),
%implementarea formulei (2.29) folosind (2.28);
%pentru o funcţie de maximizat „–” se înlocuieşte cu „+”
x_viitor=x_curent-p*grad_curent/norm(grad_curent);
for k=1:n,
grad_viitor(k)=(f1(x_viitor+h/2*v)-f1(x_viitor-h/2*v))/h;
end;
x_curent=x_viitor;
grad_curent=grad_viitor;
nr_it=nr_it+1;
end;
x=x_curent;
Funcţia de mai sus face uz de apelul funcţiei Matlab norm, care calculează norma
vectorială sau matricială; ea realizează minimizarea unei funcţii care trebuie să se afle în
fişierul f1.m; în particular ea poate fi o funcţie scalară:
function y=f1(x)
y=5*x^2+2*x+13;
Valoarea în care se atinge minimul acestei funcţii este –0.2, care se obţine după un
număr de iteraţii mai mic sau mai mare, depinzând de condiţia iniţială şi de pasul de
deplasare ales. Într-adevăr, apelul:
[x,nr_it]=opt_grad(1,1e-3)
produce rezultatele:
x =
-0.2000
nr_it =
1201
iar apelul:
[x,nr_it]=opt_grad(-1,1e-3)
are drept rezultat:
x =
-0.2000
nr_it =
801
Numărul mare de iteraţii se datorează folosirii unui pas foarte mic (p=0.001); folosirea
unui astfel de pas se justifică în cazul extremelor abrupte („creste” ascuţite sau „văi”
abrupte), unde componentele gradientului au variaţii mari.
Algoritmul Fletcher-Reeves (metoda gradienţilor conjugaţi) este o procedură puternică
de determinare a minimului local al unei funcţii generale, f(x). De această dată, la fiecare
iteraţie i se defineşte o nouă direcţie de căutare, p(i), ca o combinaţie liniară între vectorul
gradient la iteraţia curentă, ∇f(x(i)), şi direcţiile de la iteraţiile anterioare, {p }(i )
j j = 0,i −1
.
Etapele algoritmului sunt listate mai jos [CEAN 84].

1. Se alege un punct iniţial caracterizat de vectorul x(0).
2. Se stabileşte direcţia iniţială drept direcţia negativă a gradientului în x(0):
( ( ))
p (0) = −∇ f x (0)
3. La fiecare iteraţie i se determină minimul în raport cu parametrul α al funcţiei obiectiv
în direcţia p(i), conform relaţiei:
( ) (
(2.30) f x(i +1) = f x (i ) + α ⋅ p (i ) )
Se determină astfel punctul x(i+1).
4. Se determină noua direcţie de căutare, p(i+1), din punctul x(i+1):
2
(
∇f x(i +1) )
(
(2.31) p (i +1) = −∇f x(i +1) +) 2
⋅ p (i )
( )
∇f x ( i )
( ) ( )
5. Dacă f x(i +1) ≥ f x (i ) , atunci punctul de minim a fost găsit: x* ← x(i), STOP;
altfel se reia de la etapa 3.
În cele ce urmează este dat programul Matlab (fletreev.m) care implementează

algoritmul Fletcher-Reeves; acesta va fi testat pentru aceeaşi funcţie scalară de gradul al II-
lea conţinută în fişierul f1.m, cu un minim la –0.2.
%iniţializări
i=1;x(i,:)=x0;n=length(x0);itermax=1000;%număr maxim de iteraţii
h=0.0001;%variaţie utilizată în calculul gradientului
for k=1:n,
%la fiecare pas gradientul este un vector de dimensiune n
grad(i,k)=(f1(x0+h/2*v)-f1(x0-h/2*v))/h;
end;
p(i,:)=-grad(i,:);
stop=0;%variabilă booleană care arată găsirea minimului local căutat
while (~stop)&(i<=itermax),
alfa=0:0.01:10;
y_min=f1(x(i,:));
%se determină minimul funcţiei când alfa variază în intervalul (ales arbitrar) [0;10]
%cu pasul 0.01
stop=1;
for j=1:length(alfa),
y=f1(x(i,:)+alfa(j)*p(i));%formula (2.30)
if y<y_min,
y_min=y;
x(i+1,:)=x(i,:)+alfa(j)*p(i);
stop=0;
end;
end;%în acest moment noul punct de căutare este x(i+1)
if (~stop)
for k=1:n,
grad(i+1,k)=(f1(x(i+1,:)+h/2*v)-f1(x(i+1,:)-h/2*v))/h;
end;
%noua direcţie de căutare se determină cu formula (2.31)
p(i+1,:)=-grad(i+1,:)+...
norm(grad(i+1,:))^2/norm(grad(i,:))^2*p(i,:);
end;
i=i+1;
end;
[nr_it n]=size(x);nr_it
minim=x(nr_it,:)
Execuţia programului din linie de comandă necesită iniţializarea variabilei x0, punctul de
start al căutării. De exemplu, pentru:
x0=1;fletreev
rezultatul:
nr_it =
2
minim =
-0.2000
arată o convergenţă mai rapidă decât cea a metodei de gradient anterioare, implementată prin
funcţia utilizator opt_grad.
Observaţie:
Pentru o funcţie de n variabile care nu este pătratică, după fiecare n iteraţii se
reiniţializează direcţia de căutare la direcţia antigradientului, ca la primul pas. Scopul este
eliminarea erorilor datorate faptului că funcţia se poate aproxima bine cu o funcţie pătratică
numai în stricta vecinătate a optimului.
2.3.4 Metode directe. Metode de relaxare

Din clasa metodelor directe de căutare a optimului, cea mai simplă, dar şi cea mai
costisitoare ca timp, este cea a explorării exhaustive. Metodele de eliminare se folosesc când
funcţia obiectiv are un singur optim (funcţie unimodală); ele se bazează pe eliminarea unei
regiuni a domeniului de variaţie a variabilelor independente care nu conţine optimul.
Căutarea aleatoare (metoda Monte Carlo) constă în evaluarea funcţiei obiectiv într-un
set de puncte generate pseudoaleator la fiecare iteraţie a algoritmului. Domeniul de explorare
din jurul optimului aflat la fiecare iteraţie se restrânge, până când el devine mai mic decât cel
impus; astfel, optimul de la ultima iteraţie se declară drept optim global.
Spre deosebire de metodele de gradient – care efectuează modificări simultane ce produc
deplasări în spaţiul n-dimensional – metodele de căutare unidimensională (Gauss) se
fondează pe modificarea succesivă a componentelor vectorului x. Aceste metode se mai
numesc şi metode de relaxare sau de optimizare ciclică de-a lungul axelor de coordonate
(engl. cyclic coordinate search). Căutarea multidimensională este astfel transformată într-o
succesiune de căutări unidimensionale, fără a prospecta direcţia înaintării, ci doar prin
relaxarea rând pe rând a tuturor direcţiilor axelor de coordonate. Există mai mulţi algoritmi
bazaţi pe metoda relaxării, care diferă după modul în care se face varierea pasului de căutare.
Metodele de relaxare sunt în general mai lent convergente decât metodele obişnuite de
gradient, fiindcă pot conţine mai multe iteraţii de căutare unidimensională, în funcţie de
alegerea punctului de start şi a pasului. Ele pot deveni ineficiente sau cel puţin foarte lent
convergente dacă funcţia obiectiv prezintă o vale (sau o creastă) care nu are direcţia paralelă
cu axele de coordonate.
Se prezintă mai jos etapele unui algoritm de relaxare [CEAN 84], în care pasul este
menţinut constant pe durata unui ciclu de explorare a tuturor direcţiilor, după care pasul este
micşorat în progresie geometrică de raţie r, până când devine mai mic decât un prag dat, ε.
1. Se alege un punct iniţial caracterizat de vectorul x(0) =  x1(0) x2(0) ... xn(0)  ,
 
valoarea iniţială a pasului de căutare, p, şi pragul ε.
2. Se iniţializează indexul coordonatei de relaxat: k ← 1.
3. Se iniţializează contorul de iteraţii din optimizarea în raport cu coordonata k: i ← 0.
4. La o iteraţie i se relaxează coordonata de index k, obţinându-se vectorul:
 
 
x(i +1) =  x1(i ) ... xk(i ) + p ... xn(i ) 
 1
424 3 
( i +1)
 xk 
Dacă ( ) ( )
f x(i +1) ≤ f x (i ) , atunci i ← i+1 şi se reia etapa 4;
altfel dacă i=1 (prima iteraţie), atunci se face relaxarea în sens opus:
x(i +1) =  x1(i ) ... xk(i +1) − 2 p ... xn(i ) 
 
p←–p
i ← i+1
şi se reia etapa 4;
altfel
( ) ( )
dacă f x(i ) ≤ f x(i −1) , atunci valoarea de optim a coordonatei k este:
xkopt = xk(i −1)

k ← k+1
şi se reia etapa 3 (se relaxează următoarea coordonată, k+1).
5. Se modifică pasul p, înmulţindu-l cu raţia r<1: p ← p⋅r.
Dacă p ≤ ε, atunci s-a obţinut extremul funcţiei, STOP; altfel se reia de la etapa 2.
Funcţia Matlab de mai jos implementează algoritmul anterior pentru o funcţie scop de o
variabilă vectorială de o dimensiune oarecare (numele fişierului ce conţine funcţia scop este
transmis ca parametru de intrare, iar valorile funcţiei se evaluează cu feval).
function [x_opt,nr_it]=opt_rlx(fct_scop,x0,pas_init,r,tol)
%optimizare parametrică prin METODA RELAXĂRII
%fct_scop - şirul de caractere ce desemnează funcţia de optimizat

%x0 - punctul de start (vector de dimensiunea variabilei funcţiei de optimizat, n)
%pas_init - pasul iniţial de căutare
%r - raţia subunitară de modificare a pasului după fiecare ciclu de relaxare a tuturor
% celor n coordonate
%tol - valoarea de prag a pasului, când căutarea se opreşte
%iniţializări
i=1;x(i,:)=x0;p=pas_init;
n=length(x0);
while (p>tol),
p0=p*r;p=p0;
k=1;d=zeros(1,n);
stop_global=0;inapoi=0;
while (~stop_global),
d(k)=1;j=0;
stop=0;
while (~stop)
if inapoi,
p=p/2;
inapoi=0;
end;
x(i+1,:)=x(i,:)+p*d;
j=j+1;
if feval(fct_scop,x(i+1,:))>feval(fct_scop,x(i,:)),
if j==1,
p=-2*p;
i=i+1;
x(i+1,:)=x(i,:)+p*d;
inapoi=1;
else stop=1;
x(i+1,:)=[];
i=i-1;
d(k)=0;
k=k+1;
p=p0;
end;
end;
i=i+1;
end;
if k<=n,
stop_global=0;
else stop_global=1;
end;
end;
end;
[nr_it n]=size(x);
x_opt=x(nr_it,:);
Pentru exemplificare, s-a folosit o funcţie de două argumente reale:
function y=f(x)
y=4+6*x(1)-4*x(2)+x(1)^2+2*x(2)^2-...
6*x(1)*x(2)+x(1)^4+2*x(1)^2*x(2);
care descrie o suprafaţă (figura 2.9), şi care are trei minime locale, calculabile analitic, situate
aproximativ în punctele de coordonate (0;1), (0.3117;1.419) şi (–4.8117;–17.794).
Cele două apeluri de mai jos arată că, din acelaşi punct de start, (–1;3), dar cu alt pas
iniţial (p=1, respectiv p=0.5), metoda relaxării poate furniza rezultate semnificativ diferite.
[x_opt,nr_it]=opt_rlx('f',[-1 3],1,0.5,1e-6)
x_opt =
0.0000 1.0000
nr_it =
84
[x_opt,nr_it]=opt_rlx('f',[-1 3],0.5,0.5,1e-6)
x_opt =
0.3118 1.4191
nr_it =
407
f(x1,x2)
x2
x1
Fig. 2.9 O suprafaţă cu trei minime locale:

f ( x1, x2 ) = 4 + 6 x1 − 4 x2 + x12 + 2 x22 − 6 x1x2 + x14 + 2 x12 x2
Dintr-un alt punct de start se poate obţine un alt punct de minim local:
[x_opt,nr_it]=opt_rlx('f',[-3 -7],2,0.5,1e-5)
x_opt =
-4.8158 -17.8200
nr_it =
3577
2.3.5 Evaluarea comparativă a performanţelor metodelor uzuale. Exemplu

Performanţele metodelor de optimizare parametrică se exprimă prin compromisul dintre
viteza de convergenţă şi consumul de resurse (timp – sau număr de operaţii – şi memorie de
calcul).
consum de resurse
(timp şi memorie de calcul)
metode INDIRECTE
metode
de gradient
Metode de ord. al II-lea
ale direcţiilor (Newton)
conjugate
metode
de gradient
metode simplu
DIRECTE
viteza de convergenţă
Fig. 2.10 Performanţele metodelor de optimizare parametrică

Asupra acestor caracteristici ale algoritmilor prezentaţi în secţiunile anterioare s-au făcut
referiri succinte; un grafic sintetic de apreciere calitativă este dat în figura 2.10.
Mai jos se studiază comparativ performanţele unei metode directe şi ale unei metode
indirecte, respectiv ale metodei relaxării (funcţia opt_rlx) şi ale metodei gradienţilor
conjugaţi, Fletcher-Reeves (programul script fletreev) pe două exemple de funcţii
obiectiv, una având două argumente, cealaltă patru argumente reale.
 
 
(2.32) f3  [ x1 x2 ]  = 10 x14 − 20 x2 x12 + 10 x22 + x12 − 2 x1 + 5
1 424 3
 x 
 
  2
 144 4 2444 3 
2
( ) 4
(2.33) f 4  [ x1 x2 x3 x4 ]  = ( x1 + 5 x2 ) + 8 x3 − x42 + 2 ( x2 − 5 x3 ) + 8 ( x1 − x4 )
4
 x 
Funcţiile obiectiv sunt respectiv implementate de funcţiile Matlab f3 şi f4, date mai jos.
function y=f3(x)
y=10*x(1)^4-20*x(1)^2*x(2)+10*x(2)^2+x(1)^2-2*x(1)+5;
function y=f4(x)
y=(x(1)+5*x(2))^2+8*(x(3)-x(4)^2)^2+...
2*(x(2)-5*x(3))^4+8*(x(1)-x(4))^4;
De observat că scriptul fletreev scris în §2.3.4 trebuie modificat în sensul înlocuirii
apelului funcţiei f1 pe rând cu cel al funcţiilor f3 şi f4. Dimpotrivă, în cazul lui opt_rlx
nu trebuie modificat codul, ci numai apelul funcţiei, transmiţând în fiecare caz ca argument
de intrare numele fişierului (ca şir de caractere) unde se găseşte funcţia obiectiv.
Tabelul 2.10 conţine rezultatele aplicării celor două metode asupra celor două funcţii de
optimizat, din aceleaşi condiţii de start.
Apel Rezultat Obs.
Algoritmul Fletcher-Reeves (gradienţi conjugaţi) nr_it = Funcţia are
x0=[1.5 0.5]; 19
fletreev
un singur
minim =
f3(x) 1.0000 1.0000 minim,
Metoda relaxării x_opt = calculabil
(2.32)
x0=[1.5 0.5]; 0.9693 0.9396 analitic:
[x_opt,nr_it1]=opt_rlx('f3',x0,1,0.9,1e-5) nr_it1 =
(1,1)
3614
Algoritmul Fletcher-Reeves (gradienţi conjugaţi) nr_it = itermax a
x0=[0.3 2.2 -0.5 5.0000]; 101
fletreev
fost setată la
minim =
0.0729 -0.0146 0.0034 0.0591 100 şi a fost
f4(x)
depăşită
(2.33) Metoda relaxării x_opt =
x0=[0.3 2.2 -0.5 5.0000] 0.1093 -0.0218 0.0061 0.0801
[x_opt,nr_it1]=opt_rlx('f4',x0,1,0.9,1e-5) nr_it =
2008
Tabel 2.10 Metoda gradienţilor conjugaţi în comparaţie cu metoda relaxării – două exemple
Cele două exemple rezumate în tabelul 2.10 sugerează superioritatea metodei indirecte a
gradienţilor conjugaţi în raport cu metoda directă a relaxării. În cazul primei funcţii obiectiv
calitatea soluţiilor numerice se poate aprecia prin referire la soluţia exactă, care se poate
calcula analitic; viteza de convergenţă este mai bună pentru algoritmul Fletcher-Reeves.
Totuşi, nu trebuie uitat că, de fapt, fiecare iteraţie a algoritmului (contorizată în variabila
nr_it) conţine o optimizare în raport cu parametrul α, iar limitele domeniului de variaţie ale
acestui parametru şi pasul de căutare sunt alese arbitrar, depinzând de la caz la caz. Deci
numărul real de iteraţii poate fi uneori foarte mare.
În cazul celei de a doua funcţie obiectiv soluţia exactă este dificil de calculat (presupune
rezolvarea unui sistem de ecuaţii neliniare); trebuie, deci, comparate rezultatele evaluării
funcţiei f4 respectiv în punctele de extrem găsite prin cele două metode:
f4(minim)
ans =
2.3554e-006
f4(x_opt)
ans =
2.1664e-005
de unde rezultă că şi în acest caz metoda gradienţilor conjugaţi ar fi mai avantajoasă.
Merită făcută încă o observaţie, şi anume că implementările Matlab prezentate calculează
numeric gradientul, aceasta deoarece nu întotdeauna se dispune de expresia analitică exactă a
funcţiei scop (ea poate fi dată uneori tabelar) pentru a i se putea calcula analitic gradientul. O
altă soluţie este aproximarea funcţiei scop cu o expresie analitică (fie prin regresie, fie prin
interpolare, după cum s-a prezentat în secţiunile anterioare), urmată de calculul analitic al
gradientului respectivei expresii. Un exemplu în acest sens este prezentat mai jos.
Exempl ul 2.10: Fie dependenţa unidimensională y=y(x) în legătură cu care se dispune de

datele din tabelul de mai jos; din forma ei de variaţie (figura de mai jos)
se vede că are cel puţin două minime şi cel puţin un maxim.
x -4 -2 0 2 4
y 0.0004 -0.35 3 0.35 0.0004
y
3
2.5
1.5
0.5
x
-4 -3 -2 -1 0 1 2 3 4
-0.5
Să se estimeze aceste extreme, aproximând întâi dependenţa prin regresie polinomială de

gradul 4 şi aplicând funcţiei obţinute algoritmul Fletcher-Reeves.
Într-adevăr, gradul 4 de regresie se justifică prin existenţa a patru variaţii de semn, şi
anume pe intervalele [-4;-2], [-2;0], [0;2] şi [2;4] (funcţia polinomială de regresie trebuie,
deci, să aibă cel puţin patru rădăcini reale). Pentru determinarea coeficienţilor de regresie se
poate folosi funcţia cmmp_gen, scrisă în §2.1.5:
x=[-4 -2 0 2 4]; y=[0.0004 -0.35 3 0.35 0.0004];
[coef,E]=cmmp_gen(x,y,5)
care furnizează rezultatele:
coef =
3.0000 0.0000 -1.0542 0.0000 0.0542
E =
4.4407e-029
Pentru a aplica algoritmul Fletcher-Reeves funcţiei polinomiale descrise de vectorul
coef este necesar gradientul acestei funcţii (în cazul de faţă, derivata ei în raport cu singura
variabilă de care depinde), de data aceasta sub formă analitică.
În cazul unei funcţii polinomiale de o singură variabilă reală de grad n, derivata ei este
tot o funcţie polinomială, de grad n-1. Dacă funcţia este dată prin coeficienţii polinomiali
{ai }i = 0, n , atunci se pot deduce algoritmic coeficienţii polinomiali ai derivatei acesteia,
{b j } j =0,n −1 , conform cu relaţia:
b j = ( j + 1) ⋅ a j +1, j = 0, n -1
În scrierea funcţiei Matlab pentru calculul polinomului derivat al unui polinom dat
trebuie avut în vedere ca vectorii de coeficienţi să fie daţi în ordine descrescătoare a puterilor
variabilei. Astfel, pentru un polinom de grad n, între rangurile coeficienţilor, i, şi poziţiile lor,
k, există relaţia i=n–k+1. Funcţia Matlab este următoarea:
function [coef_der]=der_pol(coef)
m=length(coef);%m=n+1
for k=1:m-1,
coef_der(k)=(m-k)*coef(k);
end;
Funcţia der_pol va fi apelată de scriptul grco_pol, prezentat în continuare, care este o
variantă modificată a programului fletreev din §2.3.3. De remarcat că grco_pol este
destinat exclusiv optimizărilor funcţiilor scop polinomiale de o singură variabilă reală.
I=1;
x(i)=x0;n=length(x0);
[coef_der]=der_pol(coef);
h=0.0001;itermax=100;
grad(i)=polyval(coef_der,x0);
p(i)=-grad(i);
stop=0;
while (~stop)&(i<=itermax),
alfa=0:0.0001:1;
y_min=polyval(coef,x(i));
stop=1;
for j=1:length(alfa),
y=polyval(coef,x(i)+alfa(j)*p(i));
if y<y_min,
y_min=y;
x(i+1)=x(i)+alfa(j)*p(i);
stop=0;
end;
end;
if (~stop)
grad(i+1)=polyval(coef_der,x(i+1));
p(i+1)=-grad(i+1)+grad(i+1)^2/grad(i)^2*p(i);
end;
i=i+1;
end;
nr_it=length(x);nr_it
minim=x(nr_it)
Variabila coef existând deja în spaţiul de lucru, testarea programului presupune
introducerea punctului de start, x0. Mai jos sunt date două apeluri ale programului pentru
două puncte diferite de start şi rezultatele furnizate în fiecare din cazuri (este bine ca după
fiecare apel cu un nou punct de start să se dea comanda clear x).
X0=-1;grco_pol
nr_it =
5
minim =
-0.4192
clear x
x0=2;grco_pol
nr_it =
4
minim =
0.4192
După cum şi tabelul iniţial de date sugerează, poziţiile punctelor de minim sunt simetrice
faţă de origine.
Pentru determinarea punctului de maxim al funcţiei, se poate folosi în principiu acelaşi
program, dar pentru minus funcţia scop (vectorul coef va fi, de fapt, –coef); aceste adaptări
sunt lăsate cititorului ca exerciţiu.
2.3.6 Probleme propuse

1. Să se compare rezultatele obţinute prin metoda relaxării (funcţia Matlab opt_rlx) şi
prin metoda Fletcher-Reeves (scriptul Matlab fletreev) pentru extremizarea următoarelor
funcţii obiectiv:
a) f ( x1, x2 , x3 ) = 2 x12 + x22 + 2 x32 + 2 x1x2 + x1x3 − 200 x1 − 140 x2 + 120 x3 + 200 ;
b) f ( x1, x2 ) = 5 x12 + 0.5 x22 + x1x2 ;
10 x12 − 4 x1x2 + 2 x22

c) f ( x1, x2 ) = .
5 x12 − 4 x1x2 + 5 x22
2. Nivelul lichidului într-un rezervor, h, este menţinut de un debit de intrare, Q. Cele

două mărimi sunt măsurate de un traductor de nivel, respectiv de unul de debit. Dependenţa
nivelului de debit este:
2
(2.34) h(Q) = δh + β ⋅ ( Q − δQ )
unde δh este eroarea statică a traductorului de nivel, δQ este eroarea statică a traductorului de
debit, iar β este o constantă dependentă de proces. Pentru determinarea celor trei parametri
(identificarea experimentală a procesului) s-au efectuat măsurătorile din tabelul 2.11.
h Q
1 0.45 2.10
2 0.45 3.00
3 0.65 3.60
4 1.70 4.20
5 3.00 4.90
6 4.20 5.50
7 5.20 5.90
8 6.10 6.30
9 7.00 6.50
Tabel 2.11 Măsurări în vederea identificării parametrilor dependenţei h(Q) (relaţia (2.34))
a) Să se aplice regresia parabolică pentru identificarea parametrilor procesului descris

prin relaţia (2.34) (se poate folosi funcţia cmmp_par, scrisă în §2.1.3, sau funcţia polyfit
din biblioteca Matlab).
b) Să se calculeze analitic minimul funcţiei din (2.34), ai cărei parametri au fost
determinaţi la punctul a), apoi să se afle numeric acest minim prin două metode (metoda
relaxării şi metoda gradienţilor conjugaţi; pentru ultima metodă se poate folosi funcţia
grco_pol). Care dintre cele două metode oferă un rezultat numeric mai apropiat de cel
analitic? Care metodă este mai rapid convergentă?

MN Cap2

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

MN Cap2

Încărcat de

Drepturi de autor:

Formate disponibile

39

AP ROXIM ARE, I NTERPO L ARE I OPTIM IZ ARE P AR AM ETR IC Ă

În acest capitol sunt prezentate două clase de algoritmi:

2.1 Metoda celor mai mici pătrate

2.1.1 Formularea problemei. Notaţii

Fig. 2.1 Trasarea graficului de regresie printre punctele norului de puncte

Algoritmii de regresie sunt practic înşiruirea relaţiilor de calcul al coeficienţilor de

2.1.2 Aproximarea prin regresie liniară

Coeficienţii a şi b sunt soluţiile sistemului (2.3), particularizat pentru m=2:

Fig. 2.2 Aproximarea unui nor de puncte prin regresie liniară

În urma comenzilor Matlab:

2.1.3 Aproximarea prin regresie parabolică

Coeficienţii a, b şi c sunt soluţiile sistemului (2.3), particularizat pentru m=3:

%vectori calculaţi în vederea unei eventuale reprezentări grafice

2.1.4 Aproximarea prin regresie exponenţială

(2.8) $y = C ⋅ eα⋅ xi , C > 0

Prin logaritmarea relaţiei (2.8) şi introducerea schimbării de variabilă z$ ln( $y ), z > 0 , se

%regresia de acest tip se reduce la regresia liniară prin

%şiruri de valori calculate în vederea unei eventuale reprezentări grafice

Exempl ul 2.4: Pornind de la seturile de date x=[-3 -2 0 0.5 1.5 3 4] şi

Făcând abstracţie de modul de generare a datelor, alura norului de puncte poate

2.1.5 Cazul general de regresie polinomială

(2.11) $yi = am ⋅ xim −1 + am −1 ⋅ xim − 2 + ... + a2 ⋅ xi + a1

Să observăm că există o cerinţă generală: pentru a face regresie polinomială cu m

unde S =  s ji  este matricea sistemului, iar t = t j  este vectorul

%calculul valorilor aproximate ale variabilei dependente

%generarea vectorilor de valori pentru o eventuală reprezentare grafică

%calculul valorilor aproximate ale variabilei dependente

%generarea vectorilor de valori pentru o eventuală reprezentare grafică

Warning: Matrix is close to singular or badly scaled.

În biblioteca Matlab există o funcţie care implementează cazul general de regresie

2.1.6 Exerciţii rezolvate. Exerciţii propuse

Se observă întâi că dependenţa de aproximat (2.14) nu este polinomială. De aceea, se va

x=cosϕ 0.9781 0.6691 -0.8746 -0.8829 0.9848

Problema iniţială, de estimare a parametrilor ρ şi ε, s-a transformat în determinarea

Este sugestivă reprezentarea grafică a dependenţei aproximate în sistem de coordonate

Exempl ul 2.8: [BACH 86] Să se determine unghiul de tragere al traiectoriei parabolice

%vectori calculaţi în vederea unei eventuale reprezentări grafice

Pentru trasarea grafică a parabolei, se apelează funcţia cmmp_par0 în forma completă:

1. Să se scrie o funcţie Matlab pentru aproximarea funcţiei y=sin(x) în intervalul [0;π]

Să se scrie un program Matlab pentru aproximarea prin regresie a curbei de variaţie a

i [A] 0 0.1 0.25 0.3 0.5 0.7 0.8 0.9

u [V] 0.094 0.35 0.65 0.8 1.05 1.3 1.34 1.42

i [A] 1 1.2 1.5 1.7 2 2.4 2.5 2.9

u [V] 1.53 1.73 1.94 2.1 2.5 2.8 2.9 3.1

Fig. 2.7 Răspunsul la treaptă, uC(t), al unui filtru de ordinul I

2.2 Interpolarea funcţiilor

2.2.1 Formula de interpolare a lui Newton

(2.15) y = y1 + ( x − x1 ) ⋅ ∆y1 + ( x − x1 )( x − x2 ) ⋅ ∆ 2 y1 + ... + ( x − x1 ) ... ( x − xn −1 ) ⋅ ∆ n −1 y1 ,

Se exprimă perechea de indici (i, j) în funcţie de perechea de indici (k, l):

În cazul particular în care punctele xi sunt echidistante, adică xi +1 − xi = h, i = 1, n − 1 ,

%calculul restului elementelor din triunghiul inferior al matricei D

tt=fliplr(diag(D)');%extragerea diagonalei principale a matricei D

%calculul coeficienţilor polinomului de interpolare al lui Newton

%construirea vectorilor pentru reprezentările grafice

N ( x) = 0.1018 ⋅ x 4 − 2.1238 ⋅ x3 + 13.2732 ⋅ x 2 − 22.6798 ⋅ x + 13.4286

2.2.2 Formula de interpolare a lui Lagrange

atunci relaţia (2.20) se scrie:

Toate polinoamele si au gradul n-1, deci şi polinoamele notate cu pi în relaţia (2.22) au

%sortarea datelor: ordonarea crescătoare a valorilor lui x

%calculul coeficienţilor polinomului de interpolare

val=input('Introduceti valoarea in care doriti interpolarea:');

L( x) = 0.1018 ⋅ x 4 − 2.1238 ⋅ x3 +13.2732 ⋅ x 2 − 22.6798 ⋅ x + 13.4286