Erori

Programele vor fi rulate pas cu pas, iar valorile variabilelor vor fi urmărite în fereastra Watch !
Varianta din 2007-01-09 08:16

Metode numerice - Laborator

1. ERORI .................................................................................................................... 3
1.1 Noţiuni teoretice .......................................................................................................................... 3
1.1.1 Conversia din zecimal în binar............................................................................................... 3
1.1.2 Valorile limită şi caracteristicile tipurilor de date .................................................................... 3
1.1.3 Constanta ε a calculatorului................................................................................................... 3
1.1.4 Erori 1 .................................................................................................................................... 4
1.1.5 Erori 2 .................................................................................................................................... 4
1.1.6 Erori 3 .................................................................................................................................... 5
1.1.7 Calculul exponenţialei ............................................................................................................ 5
1.1.8 Calculul funcţiei exponenţiale cu argument negativ (vezi Expn2.cpp) .................................. 5
1.1.9 Calculul polinoamelor Cebişev .............................................................................................. 5
1.1.10 Schema lui Horner ............................................................................................................... 6
2. SISTEME DE ECUAŢII LINIARE - METODE DIRECTE ........................................ 7
2.1 Eliminarea Gauss şi eliminarea Gauss-Jordan........................................................................ 7
2.1.1 Algoritmul eliminării Gauss cu substituţie inversă ................................................................. 7
2.1.2 Programul .............................................................................................................................. 8
2.1.3 Exemplu rulare....................................................................................................................... 9
2.1.4 Algoritmul eliminării Gauss standard cu pivotare .................................................................. 9
2.1.5 Programul ............................................................................................................................ 10
2.1.6 Exemplu rulare..................................................................................................................... 10
3. OPERAŢII MATRICIALE...................................................................................... 11
3.1 Operaţii cu matrici: Adunarea şi scăderea, înmulţirea.......................................................... 11
3.1.1 Programul ............................................................................................................................ 11
3.1.2 Exemplu rulare..................................................................................................................... 13
3.2 Inversa unei matrici................................................................................................................... 14
3.2.1 Explicaţii............................................................................................................................... 14
3.2.2 Programul - Metoda Gauss.................................................................................................. 14
3.3 Determinantul unei matrici ....................................................................................................... 16
3.4 Descompunerea LU................................................................................................................... 16
3.4.1 Algoritmul descompunerii LU............................................................................................... 16
3.4.2 Programul ............................................................................................................................ 18
3.4.3 Exemplu rulare..................................................................................................................... 20
4. SISTEME DE ECUAŢII LINIARE - METODE ITERATIVE ................................... 22
4.1.1 Algoritmul iterativ Jacobi ...................................................................................................... 22
4.1.2 Algoritmul iterativ Gauss - Seidel......................................................................................... 23
4.1.3 Programul - Gauss-Seidel ................................................................................................... 23
4.1.4 Exemplu rulare..................................................................................................................... 24
4.2 Metodele relaxării ...................................................................................................................... 24
5. INTERPOLAREA NUMERICĂ ............................................................................. 25
5.1 PROGRAMUL 3.1. INTERPOLAREA LAGRANGE................................................................... 25
5.1.1 Enunţ.................................................................................................................................... 25
5.1.2 Programul ............................................................................................................................ 25
5.1.3 Exemplu rulare..................................................................................................................... 26
5.1.4 Comentarii............................................................................................................................ 26
5.2 TABELA DIFERENŢELOR ASCENDENTE............................................................................... 27
5.2.1 Explicaţii............................................................................................................................... 27
5.2.2 Programul ............................................................................................................................ 27
5.2.3 Exemplu rulare..................................................................................................................... 28
5.2.4 Comentarii............................................................................................................................ 28
5.3 Tabela diferenţelor divizate. ..................................................................................................... 28
5.3.1 Explicaţii............................................................................................................................... 28

1
Erori
Programele vor fi rulate pas cu pas, iar valorile variabilelor vor fi urmărite în fereastra Watch !
5.3.2 Programul............................................................................................................................. 28
5.3.3 Exemplu rulare ..................................................................................................................... 29
5.3.4 Comentarii ............................................................................................................................ 29
5.4 Interpolare spline cubică .......................................................................................................... 29
5.4.1 Explicaţii ............................................................................................................................... 29
5.4.2 Algoritm spline cubic natural ................................................................................................ 30
5.4.3 Algoritm spline cubic condiţionat la extremităţi .................................................................... 30
5.4.4 Programul spline cubic natural sau condiţionat la extremităţi.............................................. 31
5.4.5 Exemplu rulare 1 .................................................................................................................. 33
5.4.6 Exemplu rulare 2 .................................................................................................................. 34
5.5 Programul 3.5. Funcţii spline tensionate ................................................................................ 34
5.5.1 Explicaţii ............................................................................................................................... 34
5.5.2 Algoritm ................................................................................................................................ 34
5.5.3 Programul............................................................................................................................. 34
5.5.4 Exemplu rulare ..................................................................................................................... 34
6. CUADRATURA NUMERICĂ ................................................................................ 35
6.1 Formula de cuadratură Newton-Cotes închisă....................................................................... 35
6.1.1 Explicaţii ............................................................................................................................... 35
6.1.2 Programul............................................................................................................................. 36
6.1.3 Exemplu rulare ..................................................................................................................... 37
6.1.4 Comentarii ............................................................................................................................ 37
6.2 Formula de cuadratură Newton-Cotes deschisă.................................................................... 37
6.2.1 Explicaţii ............................................................................................................................... 37
6.2.2 Programul............................................................................................................................. 38
6.2.3 Exemplu rulare ..................................................................................................................... 39
6.2.4 Comentarii ............................................................................................................................ 39
6.3 Cuadratură Gauss-Legendre .................................................................................................... 40
6.4 Cuadratură Gauss-Kronrod ...................................................................................................... 40
6.4.1 Explicaţii ............................................................................................................................... 40
6.4.2 Programul - incorect!............................................................................................................ 40
6.4.3 Exemplu rulare ..................................................................................................................... 41
6.5 Cuadratura funcţiilor cu singularităţi ...................................................................................... 41
6.6 Integrale duble ........................................................................................................................... 41
7. REZOLVAREA ECUAŢIILOR NELINIARE .......................................................... 42
7.1 Metoda bisecţiei (înjumătăţirii)................................................................................................. 42
7.1.1 Algoritm ................................................................................................................................ 42
7.2 Metoda secantei (coardei) ........................................................................................................ 42
7.2.1 Algoritm ................................................................................................................................ 42
7.3 Metoda tangentei ....................................................................................................................... 43
7.3.1 Algoritmul ............................................................................................................................. 43
7.4 Programul pentru rezolvarea ecuaţiilor neliniare................................................................... 44
7.4.1 Exemplu rulare ..................................................................................................................... 45
7.5 Metoda aproximaţiilor succesive ............................................................................................. 46
7.5.1 Algoritmul ............................................................................................................................. 46
7.5.2 Programul............................................................................................................................. 47
7.5.3 Exemplu rulare ..................................................................................................................... 47
8. INTEGRAREA ECUAŢIILOR DIFERENŢIALE ORDINARE...................................... 49
8.1 12.4 Metodele Runge-Kutta ...................................................................................................... 49
8.1.1 Programul - incomplet! ......................................................................................................... 49
8.1.2 Exemplu rulare ..................................................................................................................... 50
9. DIVERSE .............................................................................................................. 51
9.1 Metoda celor mai mici pătrate de aproximare a sistemelor de ecuaţii supradeterminate. 51

2
Erori
Programele vor fi rulate pas cu pas, iar valorile variabilelor vor fi urmărite în fereastra Watch !

1. Erori

1.1 Noţiuni teoretice

Dacă A este valoarea exactă a unei cantităţi şi a este o aproximaţie cunoscută a acesteia,
atunci eroarea absolută a aproximaţiei a se consideră de obicei a fi mărimea Δa care satisface
relaţia
|a - A| ≤ Δa (5.1)
Pentru scopuri practice este convenabil să se ia pentru Δa valoarea cea mai mică pentru care
este satisfăcută inegalitatea (5.1) sub circumstanţele date. Numărul exact A poate fi scris
atunci
A = a ± Δa (5.2)
Eroarea relativă δa a unui număr aproximativ a este egală cu raportul dintre eroarea absolută Δa
a numărului şi valoarea sa absolută:
Δa
δa = |a| (a ≠ 0) (5.3)

cout<<"\nFloat:
1.1.1 Conversia din zecimal în binar "<<FMAXPOWTWO<<"\t"<<FMAXEXP<<"\
t"<<FMINEXP\
1.1.2 Valorile limită şi caracteristicile <<"\t"<<_FEXPLEN<<"\t"<<FSIGNIF<
tipurilor de date <"\t"<<MINFLOAT<<"\t"<<MAXFLOAT;
Pentru a vedea semnificaţia constantelor cout<<"\nDouble:
folosite se va folosi Help-ul aplicaţiei "<<DMAXPOWTWO<<"\t"<<DMAXEXP<<"\
t"<<DMINEXP\
//Informatii despre
caracteristicile tipurilor de <<"\t"<<_DEXPLEN<<"\t"<<DSIGNIF<
date din C <"\t"<<MINDOUBLE<<"\t"<<MAXDOUBL
#include <values.h> E;
#include <iostream.h> }
void main(void)
{
1.1.3 Constanta ε a calculatorului
cout<<"\nIntregi: "<<MAXINT;
#include <values.h>

3
Erori
Programele vor fi rulate pas cu pas, iar valorile variabilelor vor fi urmărite în fereastra Watch !
#include <iostream.h> introduse de la tastatură. Erorile absolute
#include <conio.h> ale celor două numere vor fi de asemenea
introduse de la tastatură.
void main(void)
#include<iostream.h>
{
#include<math.h>
float eps=1,eps1=1;
#include<conio.h>
while(eps1>0)
float erorrel(float x, float
{
xabs)
eps=eps/2;
{
eps1=eps*0.98+1;
double xrel=(fabs(xabs)/x)*100;
eps1=eps1-1;
return xrel;
}
}
cout<<"\neps= "<<eps;
getch();
void main()
}
{
clrscr();
float
1.1.4 Erori 1 a,b,aabs,babs,cabs,crel,dabs,dre
Se consideră două numere x = 2.3 şi y = l;
15745.6 şi reprezentările lor aproximative cout<<"a= ";cin>>a;
xapr = 2.2 şi yapr = 15745.5. Să se calculeze cout<<"b= ";cin>>b;
erorile absolute şi relative ale celor două cout<<"aabs= ";cin>>aabs;
numere. cout<<"babs= ";cin>>babs;
cout<<"\nErorile relative
#include<iostream.h>
sunt: "<<erorrel(a,aabs);
#include<conio.h>
cout<<"\nErorile relative
#include<stdio.h>
sunt: "<<erorrel(b,babs);
#include <math.h>
//calculul erorilor la
adunare
void main()
cabs=aabs+babs;
{
float
crel=(erorrel(a,aabs)*a/(a+b))+e
x=2.3,y=15745.6,xapr=2.2,yapr=15
rorrel(b,babs)*b/(a+b);
745.5;
cout<<"\nEroarea absoluta la
double xabs,yabs,xrel,yrel;
adunare: "<<cabs;
xabs=x-xapr; yabs=y-yapr;
cout<<"\nEroarea relativa la
xrel=(fabs(xabs)/x)*100;
adunare: "<<crel;
yrel=(fabs(yabs)/y)*100;
//calculul erorilor la
cout<<"\nErorile absolute
inmultire
sunt:\txabs="<<xabs<<";\tyabs="<
dabs=a*babs+b*aabs;
<yabs;
cout<<"\nErorile relative
drel=erorrel(a,aabs)+erorrel(b,b
sunt:\txrel="<<xrel<<"
abs);
%;\tyrel="<<yrel<<" %";
cout<<"\nEroarea absoluta la
getch();
inmultire: "<<dabs;
}
cout<<"\nEroarea relativa la
inmultire: "<<drel;
getch();
1.1.5 Erori 2
}
Să se studieze propagarea erorilor la
adunarea şi înmulţirea a două numere

4
Erori
Programele vor fi rulate pas cu pas, iar valorile variabilelor vor fi urmărite în fereastra Watch !
1.1.6 Erori 3 cout<<"\n
Să se adune la valoarea a=1, de 1000 de ori exp("<<x<<")="<<exp(x);
valoarea 0.0001 şi să se studieze rezultatul getch();
obţinut în funcţie de tipul variabilei a. }

#include<iostream.h>
#include<stdio.h> 1.1.8 Calculul funcţiei exponenţiale cu
argument negativ (vezi Expn2.cpp)
main()
#include <iostream.h>
{
#include <math.h>
int i; float a=1;
#include <conio.h>
/*cu float difera, cu double da
corect*/
double expn(double x)
for(i=1;i<=1000;i++)
{
a+=0.0001;
int i=0;
printf("\na=%4e",a);
double eps=1e-10,absx,f=1,t=1;
}
absx=fabs(x);
while(fabs(t/f)>eps)
{
1.1.7 Calculul exponenţialei
i=i+1;
Programul are ca dată de intrare argumentul t=absx/i*t;
x pentru care se doreşte evaluarea funcţiei f+=t;
ex şi produce ca date de ieşire valoarea }
acesteia furnizata de funcţia expn if(x>=0)return f;
//Calculul exponetialei else return 1/f;
#include<iostream.h> }
#include<math.h>
#include<conio.h> void main()
{
double expn(double x) double x;
{ cout<<"\nx=";cin>>x;
double eps=1e-10;
double f,t;int i; cout<<"\nexpn("<<x<<")="<<expn(x
i=0;t=1;f=1; );
while(fabs(t/f)>eps)
{ cout<<"\nexp("<<x<<")="<<exp(x);
i=i+1; getch();
t=x/i*t; }
f+=t;
}
return f; 1.1.9 Calculul polinoamelor Cebişev
}
#include<iostream.h>
void main()
#include<math.h>
{
#include<conio.h>
double x;
double ceb(double x,int n)
cout<<"\nx=";cin>>x;
{ double f,t,tm,tp;int i;
cout<<"\nexpn("<<x<<")="<<expn(x
if(n>0)
);
{tm=1;t=x;f=2*x;
for(i=1;i<n-1;i++)

5
Erori
Programele vor fi rulate pas cu pas, iar valorile variabilelor vor fi urmărite în fereastra Watch !
{tp=f*t-tm;
tm=t; t=tp;}}
return t;}

void main()
{double x; int n;
cout<<"x=";cin>>x;
cout<<"\nn=";cin>>n;

cout<<"\nT("<<x<<","<<n<<")="<<c
eb(x,n);}

1.1.10 Schema lui Horner

Sa se calculeze valoarea unui polinom P(x)
utilizând schema lui Horner. Se introduce de
la tastatura ordinul polinomului n si
coeficienţii acestuia a[i] = 1,2,…n.
//Schema lui Horner
#include<iostream.h>
#include<math.h>
#include<conio.h>

double polinom(double
a[10],double x,int n)
{
double b;int i;
b=a[0];
for(i=1;i<n;i++)
b=(b*x)+a[i];
return b;
}

void main()
{
double a[10],x;
int i,n;
cout<<"n=";cin>>n;
for(i=0;i<n;i++)

{cout<<"a["<<i<<"]=";cin>>a[i];}
cout<<"\nx=";cin>>x;

cout<<"P("<<x<<")="<<polinom(a,x
,n);
getch();
}

6
Sisteme de ecuaţii liniare - Metode directe

2. Sisteme de ecuaţii liniare - Metode directe

2.1 Eliminarea Gauss şi eliminarea Gauss-Jordan

2.1.1 Algoritmul eliminării Gauss cu substituţie inversă

Rezolvă un sistem liniar de n ecuaţii cu n necunoscute
DATE DE INTRARE:
• numărul n al necunoscutelor şi ecuaţiilor
• matricea extinsă Ã = (aij) unde 1≤i≤n şi 1≤j≤n+1
DATE DE IEŞIRE:
• soluţia x1,x2,...,xn, sau mesaj: "Sistemul nu are soluţie unică"
(Eliminarea directă:)
Pasul 1. PENTRU k = 1, 2,...,n-1 EFECTUEAZĂ paşii 2-5:
Pasul 2. DETERMINAŢI cel mai mic întreg p, 1≤ p ≤n, astfel încât apk ≠ 0.
Pasul 3. DACĂ nu există un astfel de întreg p atunci SCRIE "Sistemul nu are soluţie
unică" şi EXIT.
Pasul 4. DACĂ p ≠ k ATUNCI SCHIMBAŢI între ele liniile p şi k: (Lp) ↔ (Lk)
Pasul 5. PENTRU i = k+1,...,n (i - indice de linie), EFECTUAŢI pasul 6:
aik
Pasul 6. MODIFICAŢI linia i: (Li) = (Li - mik Lk), unde mik = a
kk

Pasul 7. DACĂ ann = 0 atunci SCRIE mesaj: "Sistemul nu are soluţie unică" şi EXIT.
(Substituţia inversă:)
an n+1
Pasul 8. CALCULEAZĂ: xn = a
nn

Pasul 9. PENTRU i = n-1,...,1

SUMA = 0
Pasul 10 PENTRU j = i+1,…,n CALCULEAZĂ SUMA = SUMA + aijxj
ai n+1 - SUMA
Pasul 11. CALCULEAZĂ xi = aii
Pasul 12. SCRIE (x1,x2, .. ,xn) STOP.
7
Sisteme de ecuaţii liniare - Metode directe

La pasul 2 se schimbă între ele linia k cu prima dintre liniile k+1,...,n care conţine pe coloana p
elementul apk, diferit de zero. Astfel evităm împărţirea cu zero în cazul în care akk = 0.

2.1.2 Programul
//Rezolvarea sistemelor de ecuatii prin metoda Gauss cu substitutie
inversa
#define DIM 3
#include <math.h>
#include <stdio.h>

void main(void)
{
int i,j,k,n=3;
double A[3][3]={{10,-7,0},{5,-1,5},{-3,2,6}},
B[3]={7,6,4}, p, t, S;

/*printf("\nIntroduceti ordinul matricii (max. 10) n=");

scanf("%d",&n);
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{printf("A[%d,%d]= ", i,j); scanf("%lf",&A[i][j]); }
for(i=0;i<n;i++)
{printf("B[%d]= ", i); scanf("%lf",&B[i][1]);}*/

/*Faza eliminarii*/
//Pasul 1
for(i=0;i<n-1;i++) //i indice de linii
{
t=0;
//Pasul 2
for(k=i;k<n;k++) //se cauta pivotul maxim pe coloana k
if(t<fabs(A[k][i]))
{ t=fabs(A[k][i]);p=k; } //p este linia cu pivot maxim
//Pasul 3
if(p!=i) //se inverseaza liniile p si i in A si B
{
for(j=0;j<n;j++) //j indice de coloana
{t=A[p][j]; A[p][j]=A[i][j]; A[i][j]=t; }
{t=B[i]; B[i]=B[p]; B[p]=t; }
}
//Pasul 4
for(j=i+1;j<n;j++)
{
//Pasul 5
t=A[j][i]/A[i][i];
//Pasul 6
for(k=0;k<n;k++)
A[j][k]=A[j][k]-t*A[i][k];
B[j]=B[j]-t*B[i];
8
Sisteme de ecuaţii liniare - Metode directe

}
//Afisare
for(k=0;k<n;k++)
{
for(j=0;j<n;j++)
printf("%6.1lf\t",A[k][j]);
printf("\t%6.1lf \n",B[k]);
}
printf("\n");
}

/*Faza substitutiei inverse*/

//Pasul 8
B[n-1]=B[n-1]/A[n-1][n-1];
//Pasul 9
for(i=n-2;i>=0;i--)
{
S=0;
for(j=i+1;j<n;j++)
S+=A[i][j]*B[j];
B[i]=(B[i]-S)/A[i][i];
}

printf("\n***Solutia***\n");
for(i=0;i<n;i++)
printf("X[%d]= %8.3lf;\n", i,B[i]);
}/*main*/

2.1.3 Exemplu rulare

Sistemul initial
10.0 -7.0 0.0 7.0
5.0 -1.0 5.0 6.0
-3.0 2.0 6.0 4.0
======================================
10.0 -7.0 0.0 7.0
0.0 2.5 5.0 2.5
-0.0 -0.1 6.0 6.1

10.0 -7.0 0.0 7.0

0.0 2.5 5.0 2.5
-0.0 -0.0 6.2 6.2

***Solutia***
X[0]= 0.000;
X[1]= -1.000;
X[2]= 1.000;

2.1.4 Algoritmul eliminării Gauss standard cu pivotare

Rezolvă un sistem liniar de n ecuaţii cu n necunoscute

9
Sisteme de ecuaţii liniare - Metode directe

DATE DE INTRARE:
• aij coeficienţii sistemului. i, j = 1,...,n;
• bi termenii liberi
DATE DE IEŞIRE:
• soluţia x1, x2,.., xn sau mesaj "Sistemul nu are soluţie unică"
(Eliminarea directă:)
Pasul 1. PENTRU k = 1,...,n REPETĂ (k - pasul curent al eliminării directe)
Pasul 2. CAUTĂ aik maxim PENTRU i = k,...,n
Pasul 3. DACĂ aik = 0 ATUNCI: SCRIE "Sistemul nu are soluţie unică" STOP.
Pasul 4. DACĂ akk ≠ max(aik)k = 1…n ATUNCI PERMUTĂ linia k cu linia ce conţine
max(aik)
Pasul 5. DACĂ k ≠ 1
Pasul 6. PENTRU i = k+1,...,n REPETĂ (i - indice de linie)
Pasul 7. PENTRU j = k,...,n+1 CALCULEAZĂ (j - indice coloană)
aij = aij - (aik/akk)⋅akj
(Obs: ai,n+1 = bi; i = 1, ... ,n)
(Substituţia inversă:)
Pasul 8. xn = an,n+1/an,n
Pasul 9. PENTRU i = n-1,n-2, ..., 1 REPETĂ
SUMA = 0
Pasul 10. PENTRU j = i+1, i+2, .. . ,n CALCULEAZĂ SUMA = SUMA+aijxi
Pasul 11. CALCULEAZĂ xi = (ai,n+1 - SUMA)/aii
Pasul 12. SCRIE (x1,x2, . . . ,xn) STOP

2.1.5 Programul

2.1.6 Exemplu rulare

10
Operaţii matriciale

3. Operaţii matriciale

3.1 Operaţii cu matrici: Adunarea şi scăderea, înmulţirea

3.1.1 Programul
//Operatii cu matrici realizate cu functii
#include<iostream.h>
#include<stdio.h>
#define DIM 10

void citire(int nl,int nc,int mat[DIM][DIM])

{
int i,j;
for(i=0;i<nl;++i)
{
cout<<"\n ***** Linia "<<i<<"\n";
for(j=0;j<nc;++j)
{
cout<<"Introduceti elementul ["<<i<<","<<j<<"] :
";cin>>mat[i][j];
}
}
}

int suma(int mat1[DIM][DIM], int mat2[DIM][DIM],int nl,int nc,int

summat[DIM][DIM])
{
int i,j;
for(i=0;i<nl;++i)
{
for(j=0;j<nc;++j)
summat[i][j]=mat1[i][j]+mat2[i][j];
}
return 0;
}

void prod(int mat1[DIM][DIM], int mat2[DIM][DIM], int m,int n,int

p,int prodmat[DIM][DIM])
{
11
Operaţii matriciale

int i,j,k;
for(i=0;i<m;++i)
for(j=0;j<n;++j)
{
prodmat[i][j]=0;
for(k=0;k<p;++k)
prodmat[i][j]=prodmat[i][j]+mat1[i][k]*mat2[k][j];
}
}

void afisare(int nl,int nc,int mat[DIM][DIM])

{
int i,j;
for(i=0;i<nl;++i)
{
for(j=0;j<nc;++j)
cout<<mat[i][j]<<" ";
cout<<"\n";
}
}

void main()
{
int m1[DIM][DIM], m2[DIM][DIM], sum[DIM][DIM];
int a,b,c,d,i,j; char selector;

cout<<"\nIntr. nr-le de linii si coloane pentru prima matrice, m:

";cin>>a;
cout<<" si n:
";cin>>b;
cout<<"\nIntr. nr-le de linii si coloane pentru a doua matrice, m:
";cin>>c;
cout<<" si n:
";cin>>d;
cout<<"\n\nPrima matrice:\n";
citire(a,b,m1);
cout<<"\n\nA doua matrice:\n";
citire(c,d,m2);
printf("Tastati:'s' pentru suma\n 'd' pentru diferenta\n
'p' pentru produs\nAici: ");
cin>>selector;
switch (selector)
{
case's':
{
if ((a==c)&&(b==d))
{
suma(m1,m2,a,b,sum);
afisare(a,b,m1);
cout<<"\n +\n\n";
afisare(c,d,m2);
cout<<"\n=\n";
12
Operaţii matriciale

afisare(c,d,sum);
}
else
cout<<"Nu se poate efectua suma deoarece numerele de linii si
coloane au nereguli";
break;
}
case'd':
{
cout<<"FACETI VOI DIFERENTA";
break;
}
case'p':
{
if(b==c)
{
prod(m1,m2,a,d,b,sum);
afisare(a,b,m1);
cout<<"\n*\n\n";
afisare(c,d,m2);
cout<<"\n=\n\n";
afisare(a,d,sum);
}
break;
}
default: cout<<"Nu s-a introdus una din literele cerute !";
}
}

3.1.2 Exemplu rulare

Intr. nr-le de linii si coloane pentru prima matrice, m: 2
si n: 2

Intr. nr-le de linii si coloane pentru a doua matrice, m: 2

si n: 2

Prima matrice:

***** Linia 0
Introduceti elementul [0,0] : 1
Introduceti elementul [0,1] : 2

***** Linia 1
Introduceti elementul [1,0] : 3
Introduceti elementul [1,1] : 4

A doua matrice

***** Linia 0
Introduceti elementul [0,0] : 5

13
Operaţii matriciale

Introduceti elementul [0,1] : 6

***** Linia 1
Introduceti elementul [1,0] : 7
Introduceti elementul [1,1] : 8
Tastati:'s' pentru suma
'd' pentru diferenta
'p' pentru produs
Aici: p
1 2
3 4

5 6
7 8

19 22
43 50

3.2 Inversa unei matrici

3.2.1 Explicaţii
Programul calculează inversa unei matrici pătrate A. se introduce matricea extinsă Ã rezultată
prin concatenarea matricii A şi a matricii unitate I de acelaşi ordin cu A. Prin rularea programului
rezultă inversa matricii A pe poziţia pe care s-a aflat matricea unitate.
Pentru a se reduce numărul de operaţii am utilizat metoda eliminării Gauss şi nu metoda Gauss
- Jordan deoarece prin metoda Gauss jumătatea din stânga a matricii extinse nu mai este
necesar să fie redusă la matricea unitate. Raţionamentul care ne-a permis implementarea
acestei tehnici este următorul: eliminarea Gauss - Jordan aplicată matricii extinse à (în cazul
unei matrici A de ordin n) este echivalentă cu rezolvarea a n sisteme de ecuaţii liniare având
aceeaşi matrice a coeficienţilor A. Primul sistem are ca termen liber prima coloană a matricii
unitate, al doilea sistem are ca termen liber a doua coloană a matricii unitate, ş.a.m.d.
Soluţia primului sistem devine prima coloană a inversei matricii A, soluţia celui de al doilea
sistem devine a doua coloană a inversei matricii A, ş.a.m.d.
Matricea A şi matricea unitate I se vor scrie în forma extinsă în a:matrice.
Constanta n va conţine ordinul matricii A iar variabila de tip matrice va conţine dimensiunea
matricii extinse Ã

3.2.2 Programul - Metoda Gauss

//Inversa unei matrici - Metoda Gauss
//AV,FP,VA - pg.91
#include<math.h>
#include<stdio.h>
#include<conio.h>

14
Operaţii matriciale

#define DIM 3

void main()
{
clrscr();
int i,j,n=DIM,jc,jr,k,kc,m,nv,pv;
double a[DIM][2*DIM]={{2,1,-3,1,0,0},{-1,3,2,0,1,0},{3,1,-3,0,0,1}},
det,r,temp,tm,va,eps=3.6e-12;
//Afisarea matricii initiale
printf("\tMatricea initiala:\n");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%8.5f\t",a[i][j]);
printf("\n");
}

det=1;
for(i=0;i<n-1;i++)
{
//Stabilirea pivotului
pv=i;
for(j=i+1;j<n;j++)
if(fabs(a[pv][i])<fabs(a[j][i]))
pv=j;
if(pv!=i)
{
for(jc=0;jc<=2*n-1;jc++)
{
tm=a[i][jc];
a[i][jc]=a[pv][jc];
a[pv][jc]=tm;
}
det=-det;
}
if(det==0)
{printf("\n matricea este singulara"); break;}

//Eliminarea directa
for(jr=i+1;jr<n;jr++)
if(a[jr][i]!=0)
{
r=a[jr][i]/a[i][i];
for(kc=i;kc<=2*n-1;kc++)
{
temp=a[jr][kc];
a[jr][kc]=a[jr][kc]-r*a[i][kc];
// if(fabs(a[jr][kc])<eps*temp) a[jr][kc]=0;
}
}
}
//Calculul determinantului
15
Operaţii matriciale

for(i=0;i<n;i++)
det=det*a[i][i];
printf("\nDeterminantul este %8.5f",det);

//Substitutia inversa
if(a[n-1][n-1]!=0)
for(m=n;m<=2*n-1;m++)
{
a[n-1][m]/=a[n-1][n-1];
for(nv=n-2;nv>=0;nv--)
{
va=a[nv][m];
for(k=nv+1;k<n;k++)
va-=a[nv][k]*a[k][m];
a[nv][m]=va/a[nv][nv];
}
}
//Afisarea matricii inverse
printf("\n\tMatricea inversa:\n");
for(i=0;i<n;i++)
{
for(j=n;j<2*n;j++)
printf("%8.5f\t",a[i][j]);
printf("\n");
}
getch();
}

3.3 Determinantul unei matrici

3.4 Descompunerea LU

3.4.1 Algoritmul descompunerii LU

Rezolvă un sistem liniar de n ecuaţii cu n necunoscute, Ax = b, prin descompunerea matricii A
în produsul LU urmată de rezolvarea sistemelor Lz = b şi Ux = z (se consideră lii = 1, i =
1,2,...,n)
DATE DE INTRARE:
• n - dimensiunea sistemului
• aij - elementele metricii A, i şi j = 1/2,.. .,n
• bi - elementele vectorului coloană b, i = 1,2,...,n
DATE DE IEŞIRE:
• x1, x2, ...,xn: soluţia sistemului sau mesaj "Sistemul nu are soluţie unică"
Pasul 1.(Caută pivotul)
Fie p cel mal mic întreg astfel încât 1 ≤ p ≤ n şi |ap1| = max1≤i≤n|ai1|

16
Operaţii matriciale

DACĂ |ap1| = 0 ATUNCI AFIŞEAZĂ mesaj: "Sistemul nu are soluţie unică" şi EXIT.
Pasul 2. DACĂ p ≠ 1, SCHIMBĂ între ele liniile p şi 1 din A şi P (P iniţial este In.)
Pasul 3. l11 = 1, u11 = a11 (Condiţie rezultată din a11 = l11u11)
Pasul 4. PENTRU j = 2,3,...,n:
u1j = a1j, (Prima linie din U); lj1 = aj'1/u11 (Prima coloană din L)
Pasul 5. PENTRU i = 2,..., n-1, EFECTUEAZĂ paşii 6-9:
Pasul 6. CAUTĂ pivotul i
Fie p cel mai mic întreg astfel încât i ≤ p ≤ n şi
⎪ i-1 ⎪ ⎪ i-1 ⎪
⎪api - ∑lpk⋅uki⎪ = maxi≤j≤n ⎪aji - ∑ljk⋅uki⎪
⎪ ⎪ ⎪ ⎪
⎪ k=1 ⎪ ⎪ k=1 ⎪
DACĂ maximum este zero ATUNCI SCRIE mesaj: "Sistemul nu are soluţie unică" STOP.
Pasul 7. DACĂ p ≠ i SCHIMBĂ între ele liniile p şi i din A, L şi P.
i-1
Pasul 8. uii = aii - ∑lik⋅uki
k=1
i-1
Pasul 9. PENTRU j = i+1, i+2,...,n, CALCULEAZĂ: uij = aij - ∑lik⋅ukj (linia i din U)
k=1

⎛ i-1 ⎞
⎜aji - ∑ljk⋅uki⎟
⎜ ⎟
⎝ k=1 ⎠
lji = uii (coloana i din L)

n-1
Pasul 10. unn = ann - ∑lnk⋅ukn . DACĂ unn = 0 SCRIE mesaj: "Sistemul nu are soluţie unică".
k=1
STOP.
(Rezolvă sistemul inferior triunghiular Lz = b)
Pasul 11. REARANJAŢI elementele vectorului coloană liber b: b = Pb
Pasul 12. z1 = b1
i-1
Pasul 13. PENTRU i = 2,...,n CALCULEAZĂ zi = bi - ∑lij⋅zj
j=1
(Rezolvă sistemul superior triunghiular Ux = z)
Pasul 14. xn = zn/unn
n
Pasul 15. PENTRU i = n-1, n-2,...,1, CALCULEAZĂ xi = zi - ∑uij⋅xj
j=i+1
Pasul 16. SCRIE (x1, x2,...,xn) STOP
După cum se observă din algoritm, în cazul în care se schimbă sistemul prin modificarea numai
a termenului liber b, descompunerea matricii A rămâne aceeaşi, calculele reluându-se de la
Pasul 11.

17
Operaţii matriciale

3.4.2 Programul
//Descompunerea LU pg.93
#include<stdio.h>
#include<math.h>
#include<process.h>
#include<conio.h>

#define DIM 4
//typedef float[DIM][DIM] mat
int ip[DIM],unic,ipc;

void pivot(float A[][DIM], float el[][DIM], int ip[],\

int m, int &unic, int &ipc)
{
int jj,j; float t=0;
for(int k=m;k<DIM;k++)
if(fabs(A[k][m])>t)
{jj=k; t=fabs(A[k][m]);}
if(t==0)
{
printf("\nNu exista solutie unica!");
unic=0;
exit;
}
if(jj!=m)
{
ipc++;
for(j=0;j<DIM;j++)
{
t=A[m][j]; A[m][j]=A[jj][j]; A[jj][j]=t;
t=el[m][j]; el[m][j]=el[jj][j]; el[jj][j]=t;
}
int it=ip[m];ip[m]=ip[jj];ip[jj]=it;
printf("Numar de pivotari: %d", ipc);
}
}

void scrie_mat(float v[][DIM])

{
printf("\n");
for(int i=0;i<DIM;i++,printf("\n"))
for(int j=0;j<DIM;j++)
// printf("A[%d][%d]=%8.3f; ",i,j,v[i][j]);
printf("%8.3f ",v[i][j]);
printf("Pentru continuare apasati o tasta!\n");
getch();
}
//================================================
void main()
{
float itmp[DIM][DIM]={{1.,0.333,1.5,-0.333},{-2.01,1.45,0.5,2.95},\
{4.32,-1.95,0.,2.08},{5.11,-4.,3.33,-1.11}},\
b[DIM]={3.,5.4,0.13,3.77};
/* float itmp[DIM][DIM]={{1.,2.,3.,4.},{5.,6.,7.,8.},\
{9.,10.,11.,12.},{13.,14.,15.,16.}},\
b[DIM]={20.,44.,78.,102.};*/
float A[DIM][DIM], el[DIM][DIM], U[DIM][DIM],L[DIM][DIM],\
bt[DIM],z[DIM],x[DIM];
int n,i,j,k,m,np;

18
Operaţii matriciale

float de,s;

clrscr();
n=DIM;
for(i=0;i<DIM;i++)
for(j=0;j<DIM;j++)
A[i][j]=itmp[i][j];
printf("\n\tMatricea originala:\n");
scrie_mat(A);
//Initializare pivot si matricea el
ipc=0;
for(i=0;i<n;i++)
{
ip[i]=i;
for(j=0;j<n;j++)
el[i][j]=0;
}
unic=1;
m=0;
pivot(A,el,ip,m,unic,ipc);
scrie_mat(A);
if(!unic) exit;
for(j=0;j<n;j++)
el[0][j]=A[0][j]; //prima linie
for(i=1;i<n;i++)
el[i][0]=A[i][0]/el[0][0]; //prima coloana
// scrie_mat(el);
for(m=1;m<n;m++)
{
unic=1;
pivot(A,el,ip,m,unic,ipc);
scrie_mat(A);// getch();
if(!unic) exit;
for(j=m;j<n;j++) //linia m
{
s=0;
for(k=0;k<=m-1;k++)
s+=el[m][k]*el[k][j];
el[m][j]=A[m][j]-s;
}
for(i=m+1;i<n;i++)//coloana m
{
s=0;
for(k=0;k<=m-1;k++)
s+=el[i][k]*el[k][m];
el[i][m]=(A[i][m]-s)/el[m][m];
}
}
//Permutari
printf("\tPermutari: ");
for(i=0;i<n;i++)
printf("%d ",ip[i]);
printf("\nMatricea LU in forma compacta\n");
scrie_mat(el);

de=1;
for(i=0;i<n;i++)
de*=el[i][i];
if(ipc!=(ipc%2)*2)
de=-de;
printf("\nDeterminant: %8.3f", de);

19
Operaţii matriciale

printf("\nVectorul termenilor liberi: ");

for(i=0;i<n;i++)
printf("%8.3f",b[i]);
//Matricea U
printf("\nMatricea U: ");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(i>j) U[i][j]=0; else U[i][j]=el[i][j];
scrie_mat(U);
//Matricea L
printf("\nMatricea L: ");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(j>i) L[i][j]=0;
else if(j==i) L[i][j]=1;
else L[i][j]=el[i][j];
scrie_mat(L);
//Permutarea termenilor liberi
for(i=0;i<n;i++)
bt[i]=b[ip[i]];
//Rezolvarea sistemului inferior triunghiular Lz=b
//Pasul 12
z[0]=bt[0]/L[0][0];
//Pasul 13
for(i=1;i<n;i++)
{
s=0;
for(j=0;j<i;j++)
s+=L[i][j]*z[j];
z[i]=(bt[i]-s)/L[i][i];
}
printf("\nVectorul z este: ");
for(i=0;i<n;i++)
printf("%8.3f",z[i]);
//Rezolvarea sistemului superior triunghiular Ux=z
x[n-1]=z[n-1]/U[n-1][n-1];
for(i=n-2;i>=0;i--)
{
s=0;
for(j=i+1;j<n;j++)
s+=U[i][j]*x[j];
x[i]=(z[i]-s)/U[i][i];
}
printf("\nSolutia sistemului este: ");
for(i=0;i<n;i++)
printf("%8.3f",x[i]);
getch();
}

3.4.3 Exemplu rulare

În urma rulării programului se obţin următoarele rezultate:
Matricea originala:
1.000 0.333 1.500 -0.333
-2.010 1.450 0.500 2.950
4.320 -1.950 0.000 2.080
5.110 -4.000 3.330 -1.110
Numar de pivotari: 1
5.110 -4.000 3.330 -1.110
20
Operaţii matriciale

-2.010 1.450 0.500 2.950

4.320 -1.950 0.000 2.080
1.000 0.333 1.500 -0.333
Numar de pivotari: 2
5.110 -4.000 3.330 -1.110
4.320 -1.950 0.000 2.080
-2.010 1.450 0.500 2.950
1.000 0.333 1.500 -0.333
Numar de pivotari: 3
5.110 -4.000 3.330 -1.110
4.320 -1.950 0.000 2.080
1.000 0.333 1.500 -0.333
-2.010 1.450 0.500 2.950
Matricea LU in forma compacta
5.110 -4.000 3.330 -1.110
0.845 1.432 -2.815 3.018
0.196 0.779 3.042 -2.468
-0.393 -0.086 0.515 4.045

Determinant: -90.030
Vectorul termenilor liberi: 3.000 5.400 0.130 3.770
Matricea U:
5.110 -4.000 3.330 -1.110
0.000 1.432 -2.815 3.018
0.000 0.000 3.042 -2.468
0.000 0.000 0.000 4.045
Matricea L:
1.000 0.000 0.000 0.000
0.845 1.000 0.000 0.000
0.196 0.779 1.000 0.000
-0.393 -0.086 0.515 1.000
Vectorul z este: 3.770 -3.057 4.645 4.227
Solutia sistemului este: -0.324 0.331 2.374 1.045

21
Sisteme de ecuaţii liniare - metode iterative

4. Sisteme de ecuaţii liniare - metode iterative

4.1.1 Algoritmul iterativ Jacobi

Rezolvă un sistem liniar Ax = b cu o aproximaţie iniţială dată x(0)
DATE DE INTRARE:
• numărul de ecuaţii şi necunoscute, n
• elementele aij, i şi j = 1,2,...,n ale matricii A
• elementele bi,, i = 1,2,...,n ale termenului liber b;
• toleranţa TOL ;
• numărul maxim de iteraţii M;
• aproximaţia iniţială x1(0), x2(0), …, xn(0)
DATE DE IEŞIRE:
• soluţia aproximativă x1, x2, …, xn, sau mesaj: "S-a depăşit numărul maxim de iteraţii"
Pasul 1. k = 1
Pasul 2. CÂT TIMP k ≤ M EFECTUEAZĂ paşii 3-6:
Pasul 3. PENTRU i = 1,2,...,n CALCULEAZĂ
n
- ∑(aij⋅xi) + bi
j=1;j≠i
xnoui = aii
||xnou - x||∞
Pasul 4. DACĂ ≤ TOL ATUNCI SCRIE(xnou1,xnou2,..., xnoun,) (soluţia) STOP
||xnou||∞
(unde ||x - y||∞ = max1≤i≤n|xi - yi| este "norma infinită a diferenţei vectoriale", iar ||x||∞ =
max1≤i≤n|xi|)
Pasul 5. k = k+1
Pasul 6. PENTRU i = 1,2,...,n: xi = xnoui,
Pasul 7. SCRIE("S-a depăşit numărul maxim de iteraţii") STOP (Procedura a eşuat)
La pasul 3 al algoritmului trebuie să fie îndeplinită condiţia aii ≠ 0. pentru orice i = 1,2,...,n.
Dacă nu este îndeplinită această condiţie sistemul se va reordona. Pentru mărirea vitezei de
convergenţă a soluţiei este indicat ca sistemul să fie ordonat astfel încât aii să fie cât mai mare.

22
Sisteme de ecuaţii liniare - metode iterative

4.1.2 Algoritmul iterativ Gauss - Seidel

Rezolvă un sistem liniar Ax = b cu o aproximaţie iniţială x(0)
DATE DE INTRARE:
• numărul de ecuaţii şi necunoscute n
• elementele aij, i şi j = 1,2,...,n ale matricii A
• elementele bi ale vectorului liber
• aproximaţia iniţială x1(0), x2(0), …, xn(0)
• toleranţa impusă TOL
• numărul maxim de iteraţii M.
DATE DE IEŞIRE:
• soluţia aproximativă x1, x2, …, xn, sau mesaj: "S-a depăşit numărul maxim de iteraţii"
Pasul 1. k = 1
Pasul 2. CÂT TIMP k ≤ M EFECTUEAZĂ paşii 3-6
Pasul 3. PENTRU i = 1,2,...,n CALCULEAZĂ
i-1 n
- ∑(aij⋅xnouj) - ∑(aij⋅xj) + bi
j=1 j=i+1
xnoui = aii
||xnou - x||∞
Pasul 4. DACĂ ≤ TOL ATUNCI
||xnou||∞
(unde ||x - y||∞ = max1≤i≤n|xi - yi| este "norma infinită a diferenţei vectoriale", iar ||x||∞ =
max1≤i≤n|xi|)
SCRIE (xnou1,..., xnoun) (soluţia)
STOP.
Pasul 5. k = k+1
Pasul 6. PENTRU i = 1,2,...,n: xi = xnoui.
Pasul 7. SCRIE("S-a depăşit numărul maxim de iteraţii") STOP (Procedura a eşuat).

4.1.3 Programul - Gauss-Seidel

/*Rezolvarea sistemelor de ecuatii liniare
prin metoda iterativa Gauss-Seidel- MN, pg.101*/
#include<stdio.h>
#include<conio.h>
#include<math.h>
#define DIM 4

void main()
{
double A[DIM][DIM]={{10,-1,2,0},{-1,11,-1,3},{2,-1,10,-1},{0,3,-1,8}},
B[DIM]={6,25,-11,15}, X[DIM], X_nou[DIM],s1,s2,
norma=1,norma_dif=1,ErrAdm=1e-05;
int i,j,k=0,iterMax=20;

clrscr();
for(i=0;i<DIM;i++)//initializare tablouri
{X[i]=0;X_nou[i]=0; }

23
Sisteme de ecuaţii liniare - metode iterative

//Cap tabel
printf("\nIter");
for(i=0;i<DIM;i++)
printf("\tX[%d]",i+1);
printf("\t ERR");

while((k<=iterMax) && (norma_dif/norma)>ErrAdm)

{
k++;//iteratia
printf("\n %2d: ",k-1);
for(i=0;i<DIM;i++)
{
s1=0;s2=0;
for(j=0;j<=i-1;j++)
s1+=A[i][j]*X_nou[j];
for(j=i+1;j<DIM;j++)
s2+=A[i][j]*X[j];
X_nou[i]=(-s1-s2+B[i])/A[i][i];
printf("%8.4lf",X[i]);
}
norma_dif=0; //erori
for(i=0;i<DIM;i++)
if(norma_dif<fabs(X_nou[i]-X[i])) norma_dif=fabs(X_nou[i]-X[i]);
norma=0;
for(i=0;i<DIM;i++)
if(norma<fabs(X_nou[i])) norma=fabs(X_nou[i]);
printf("\t%8.5lf",norma_dif/norma);

for(i=0;i<DIM;i++)
X[i]=X_nou[i];
}
getch();
}

4.1.4 Exemplu rulare

Iter X[1] X[2] X[3] X[4] ERR
0: 0.0000 0.0000 0.0000 0.0000 1.00000
1: 0.6000 2.3273 -0.9873 0.8789 0.21119
2: 1.0302 2.0369 -1.0145 0.9843 0.01666
3: 1.0066 2.0036 -1.0025 0.9984 0.00286
4: 1.0009 2.0003 -1.0003 0.9998 0.00038
5: 1.0001 2.0000 -1.0000 1.0000 0.00004
6: 1.0000 2.0000 -1.0000 1.0000 0.00000

4.2 Metodele relaxării

24
INTERPOLAREA NUMERICĂ

5. INTERPOLAREA NUMERICĂ

5.1 PROGRAMUL 3.1. INTERPOLAREA LAGRANGE

5.1.1 Enunţ
Programul utilizează formula de interpolare Lagrange
n

∑
n
Ln,i(x) =
∏xx -- xx f
i
j
j
i

j=0;j≠i
i=0
pentru a calcula valoarea funcţiei f într-un punct x oarecare.
Setul de date va fi definit de utilizator în tablourile unidimensionale x respectiv f , unde n este
egal cu numărul de puncte (DIM) minus 1. Programul poate fi utilizat şi pentru extrapolare, cu
observaţia că în acest caz va apare şi un mesaj: "AVERTISMENT: x dat se află în afara
domeniului de interpolare !".

5.1.2 Programul
//INTERPOLAREA LAGRANGE (MN-pg.152)
#include<iostream.h>
#include<math.h>
#include<conio.h>
#include<stdio.h>
#define DIM 4

void main()
{
clrscr();
int i,j,kk,n=DIM-1;
double x_dat,y_rasp,z;
char opt;
double x[DIM]={1.0,2.0,3.0,4.0};
double f[DIM]={0.671,0.620,0.567,0.512};

cout<<"\nTabloul valorilor de lucru:";

for(i=0;i<=n;i++)
{
/* cout<<"\ni="<<i;
cout<<"\tx="<<x[i];
cout<<"\tf(x)="<<f[i];
*/ printf("\ni = %d:\tx[%1d] = %6.3f;\tf(x) = %9.5f;",i,i,x[i],f[i]);
25
INTERPOLAREA NUMERICĂ

}
do
{
cout<<"\nIntroduceti x_dat= ";
cin>>x_dat;
if(x_dat<x[0]||x_dat>x[n])
cout<<"\tAVERTISMENT: x_dat in afara intervalului!\n";
y_rasp=0;
for(i=0;i<=n;i++)
{
z=1;
for(j=0;j<=n;j++)
if(i!=j)
z=z*(x_dat-x[j])/(x[i]-x[j]);
y_rasp=y_rasp+z*f[i];
}
printf("g(%6.3f) = %9.5f;",x_dat,y_rasp);
printf("\nContinuati (D/N) ?: ");
opt = getch();
}
while(opt=='d'|| opt=='D');
}

5.1.3 Exemplu rulare

Tabloul valorilor de lucru:
i = 0: x[0] = 1.000; f(x) = 0.67100;
i = 1: x[1] = 2.000; f(x) = 0.62000;
i = 2: x[2] = 3.000; f(x) = 0.56700;
i = 3: x[3] = 4.000; f(x) = 0.51200;
Introduceti x_dat= 1
g( 1.000) = 0.67100;
Continuati (D/N) ?:
Introduceti x_dat= 3.66
g( 3.660) = 0.53092;
Continuati (D/N) ?:
Introduceti x_dat= 4.5
x_dat in afara intervalului!
g( 4.500) = 0.48375;
Continuati (D/N) ?:

5.1.4 Comentarii
Pentru setul de date considerat, programul a fost rulat pentru trei categorii de puncte: x = x1, x2
< x < x3, şi x > x3, (în afara domeniului ).
1
Utilizând funcţia lui Runge: R(x) = 1 + 25x2 definită pe intervalul [-1,1], generaţi un set de date
de forma (xi, Ri), i = 0,1, ...,19 unde x0 = -1; x2 = -0,9; x3 = -0,8; ... ; x19 = 1. Verificaţi în
continuare formula de interpolare Lagrange pentru valori ale lui x în intervalele (-1, -0,726) şi
(0,726, 1). Comentaţi rezultatele.

26
INTERPOLAREA NUMERICĂ

5.2 TABELA DIFERENŢELOR ASCENDENTE

5.2.1 Explicaţii
Fie un set de n+1 date de forma (xi, fi), i = 0,1,...,n. Programul generează tabela diferenţelor
ascendente pe baza formulelor prezentate la curs. Se consideră că abscisele xi sunt egal
depărtate.
Setul de date uniform distribuit se va introduce în blocul de declarare a variabilelor: punctele xi
în tabloul unidimensional i_tmp_0 iar f, în tabloul unidimensional i_tmp_1.

5.2.2 Programul
//TABELA DIFERENTELOR ASCENDENTE (MN-pg.154)
/*programul genereaza tabloul diferentelor
ascendente in cazul punctelor uniform distribuite*/

#include<iostream.h>
#include<math.h>
#include<conio.h>
#include<stdio.h>
# define DIM 6

void main()
{
clrscr();
int i,j,k,i_max=DIM-1,r=0;
double x[DIM],f[DIM][DIM]; //coordonatele punctelor(i=0....i_max)
double xdat,yrasp,z;
//vectorul absciselor punctelor date:
float i_tmp_0[DIM]={1.0,3.0,5.0,7.0,9.0,11.0};
//vectorul ordonatelor punctelor date:
float i_tmp_1[DIM]={1.0,0.5,0.33333,0.25,0.2,0.166666};
cout<<"\nTabloul valorilor de lucru: ";
for(i=0;i<=i_max;i++)
{
/* cout<<"\ni = "<<i;
cout<<"\ti_tmp_0 = "<<i_tmp_0[i];
cout<<"\ti_tmp_1 = "<<i_tmp_1[i];
*/ printf("\ni = %d\ti_tmp_0 = %5.2f;\ti_tmp_1 = %9.5f;",i,i_tmp_0[i],i_tmp_1[i]);
}
for(i=0;i<=i_max;i++)
{
x[i]=i_tmp_0[r];
f[i][0]=i_tmp_1[r];
r=r+1;
}
cout<<"\nTabela diferentelor ascendente: " ;
for(k=1;k<=i_max;k++)
{
j=i_max-k;
for(i=0;i<=j;i++)
f[i][k]=f[i+1][k-1]-f[i][k-1];
}
//diferenta de ordin k pentru punctul i:
cout<<"\n i"<<" x[i]"<<" f[i]"<<" dif de 1"<<" dif de 2"<<" ....";
for(i=0;i<=i_max;i++)
{
// cout<<'\n'<<i<<'\t'<<x[i];
printf("\n%2d%9.4f",i,x[i]);
for(k=0;k<=(i_max-i);k++)
// cout<<'\t'<<f[i][k];
27
INTERPOLAREA NUMERICĂ

printf("%9.4f",f[i][k]);
}
getch();
}

5.2.3 Exemplu rulare

Tabloul diferentelor ascendente:
i x[i] f[i] dif de 1 dif de 2 ....
0 1.0000 1.0000 -0.5000 0.3333 -0.2500 0.2000 -0.1666
1 3.0000 0.5000 -0.1667 0.0833 -0.0500 0.0333
2 5.0000 0.3333 -0.0833 0.0333 -0.0167
3 7.0000 0.2500 -0.0500 0.0167
4 9.0000 0.2000 -0.0333
5 11.0000 0.1667

5.2.4 Comentarii
Tabela diferenţelor ascendente generată de program permite dezvoltarea unui polinom de
interpolare Newton în puncte egal depărtate. De exemplu, polinomul de interpolare care trece
prin punctele 3,4 şi 5 se poate scrie utilizând valorile diferenţelor ascendente situate pe linia a
patra,
N(x) = 0,2500 - 0,0500s + 0,0167s(s-1)/2
x - x3
unde s = h = (x - 0.7)/2

5.3 Tabela diferenţelor divizate.

5.3.1 Explicaţii
Fie un set de date de forma (xi, fi), i = 0,1, ...,n unde abscisele xi sunt inegal distribuite.
Programul generează tabela diferenţelor divizate pe baza formulelor descrise în curs.
Setul de date se va introduce în blocul de declaraţii a variabilelor: xi în vectorul i_tmp iar fi în
i_tmp, unde n este egal cu numărul de puncte minus 1.

5.3.2 Programul
//TABELA DIFERENTELOR DIVIZATE (MN-pg.156)
/* Programul genereaza tabloul diferentelor
divizate in cazul punctelor neuniform distribuite*/
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#define DIM 6

void main()
{
clrscr();
int i,j,k,i_max=DIM-1;//i_max-indice maxim al punctelor
double x[DIM],f[DIM][DIM]; //x[i],f[i][0]coordonatele punctelor(i=0...i_max)
float i_tmp_0[DIM]={0.1,0.2,0.4,0.7,1.0,1.2};
float i_tmp_1[DIM]={0.99750,0.99002,0.96040,0.88120,0.76520,0.67113};

for(i=0;i<DIM;i++)
28
INTERPOLAREA NUMERICĂ

{
x[i]=i_tmp_0[i]; f[i][0]=i_tmp_1[i];
}
cout<<"\nTabloul diferentelor divizate:" ;
for(k=1;k<=i_max;k++)
for(i=0;i<=(i_max-k);i++)
/*diferente divizate de ordin k pentru punctul i*/
f[i][k]=(f[i+1][k-1]-f[i][k-1])/(x[i+k]-x[i]);
printf("\n i x[i] f[i] f(i,i+1) f(i,i+2)\t....");
for(i=0;i<=i_max;i++)
{
j=i_max-i;
// cout<<'\n'<<i<<'\t'<<x[i];
printf("\n%2d%9.4f",i,x[i]);
for(k=0;k<=j;k++)
// cout<<'\t'<<f[i][k];
printf("%9.4f",f[i][k]);
}
getch();
}

5.3.3 Exemplu rulare

Tabloul diferentelor divizate:
i x[i] f[i] f(i,i+1) f(i,i+2) ....
0 0.1000 0.9975 -0.0748 -0.2443 0.0209 0.0148 -0.0024
1 0.2000 0.9900 -0.1481 -0.2318 0.0342 0.0122
2 0.4000 0.9604 -0.2640 -0.2044 0.0463
3 0.7000 0.8812 -0.3867 -0.1674
4 1.0000 0.7652 -0.4703
5 1.2000 0.6711

5.3.4 Comentarii
Pe baza tabelei diferenţelor divizate se poate dezvolta imediat un polinom de interpolare
Newton în puncte inegal distribuite. De exemplu, polinomul de interpolare Newton care trece
prin punctele i = 2, 3 şi 4 este
N(x) = f[x2] + (x-x2) f[x2, x3] + + (x-x2) (x-x3) f[x2,x3,x4] =
= 0,9604 - 0,2640(x-0,4)-0,2044(x-0,4)(x-0,7)
unde s-au utilizat valorile x2 = 0,4, x3 = 0,7 şi diferenţele divizate situate pe linia a treia.

5.4 Interpolare spline cubică

5.4.1 Explicaţii
Acest program realizează interpolarea spline cubică pentru un set de date de forma (xi, fi), i =
0,1,...,n.
Abscisele xi se declară în vectorul x, valorile f, în vectorul a iar constanta n este egală cu
numărul de puncte minus 1. Vectorul xa conţine valorile abscisei în care urmează să se
calculeze valorile funcţiei prin interpolare spline.
Utilizatorul are posibilitatea să aleagă una din următoarele două condiţii la limită:
a) spline cubic natural (S"(x0) = S"(xn) = 0) sau
29
INTERPOLAREA NUMERICĂ

b) spline cubic condiţionat la extremităţi care impune cunoaşterea derivatelor de ordinul unu
în punctele x0 şi xn ale funcţiei care a generat setul de date.

5.4.2 Algoritm spline cubic natural

Construieşte un interpolant spline cubic S pentru funcţia f, definit în punctele x0 < x1 <...< xn şi
îndeplinind condiţiile S"(x0) = S"(xn) = 0
DATE DE INTRARE:
• n, x0,x1,…,xn. Se generează ai = f(xi) pentru i = 0,1,...,n sau se introduc valorile ai =
0,1,…,n date tabelar
DATE DE IEŞIRE:
• aj, bj, cj, dj pentru j = 0,1,...,n-1
(Obs : S(x) = Sj(x) = aj + bj(x - xj) + cj(x - xj)2 + dj(x - xj)3 pentru xj < x < xj+1)
Pasul 1. PENTRU i = 0,1,...,n-1 CALCULEAZĂ hi = xi+1 - xi
Pasul 2. PENTRU i = 1,2,...,n-1 CALCULEAZĂ (elementele vectorului termenilor liberi b)
3[ai+1hi-1 - ai(xi+1 - xi-1) + ai-1hi]
αi = hi-1hi
Pasul 3. (Paşii 3,4,5 şi parţial Pasul 6 rezolvă un sistem liniar tridiagonal)
l0 = 1; μ0 = 0; z0 = 0.
Pasul 4. PENTRU i = 1,2,...,n-1 CALCULEAZĂ
li = 2(xi+1 - xi-1) - hi-1μi-1; μi = hi/li; zi = (αi - hi-1zi-1)/li
Pasul 5. IMPUNE
ln = 1; μn = 0; zn = 0.
Pasul 6. PENTRU j = n-1,n-2,... ,0 CALCULEAZĂ
cj = zj - μjcj+1; bj = (aj+1 - aj)/hj - hj(cj+1 + 2cj)/3 ; dj = (cj+1 - cj)/(3hj)
Pasul 7. PENTRU j = 0,1,...,n-1SCRIE (aj, bj, cj, dj) STOP

5.4.3 Algoritm spline cubic condiţionat la extremităţi

Construieşte un interpolant spline cubic S pentru funcţia f, definit în punctele x0 < x1 <...< xn şi
îndeplinind condiţiile S'(x0) = f'(x0) şi S'(xn) = f'(xn)
DATE DE INTRARE:
• n, x0,x1,…,xn. Se generează ai = f(xi) pentru i = 0,1,...,n sau se introduc valorile ai =
0,1,…,n date tabelar.
• D0 = f'(x0), DN = f'(xn)
DATE DE IEŞIRE:
• aj, bj, cj, dj pentru j = 0,1,...,n-1
(Obs : S(x) = Sj(x) = aj + bj(x - xj) + cj(x - xj)2 + dj(x - xj)3 pentru xj < x < xj+1)
Pasul 1. PENTRU i = 0,1,...,n-1 CALCULEAZĂ hi = xi+1 - xi
Pasul 2. CALCULEAZĂ

30
INTERPOLAREA NUMERICĂ

α0 = 3(a1 - a0)/h0 - 3D0; αn = 3DN - 3(an.- an-1)/hn-1

Pasul 3. PENTRU i = 1,2,...,n-1 CALCULEAZĂ
3[ai+1hi-1 - ai(xi+1 - xi-1) + ai-1hi]
αi = hi-1hi
Pasul 4. (Paşii 4,5,6 şi parţial Pasul 7 rezolvă un sistem liniar tridiagonal)
l0 = 2h0; μ0 = 0,5; z0 = α0/l0
Pasul 5. PENTRU i = 1,2,...,n-1 CALCULEAZĂ
li = 2(xi+1 - xi-1) - hi-1μi-1; μi = hi/li; zi = (αi - hi-1zi-1)/li
Pasul 6.
ln = hn-1(2 - μn-1); zn = (αn - hn-1zn-1)ln; cn = zn
Pasul 7. PENTRU j = n-1,n-2,... ,0 CALCULEAZĂ
cj = zj - μjcj+1; bj = (aj+1 - aj)/hj - hj(cj+1 + 2cj)/3 ; dj = (cj+1 - cj)/(3hj)
Pasul 8. PENTRU j = 0,1,...,n-1SCRIE (aj, bj, cj, dj) STOP

5.4.4 Programul spline cubic natural sau condiţionat la extremităţi

//Program IntSpline - MN pg 157;
/*
x[i] -abscisele punctelor
a[i] -valorile functiei
h[i] -distanta dintre punctele 1 si i+1
n -numarul de puncte din x[] mai putin unul
kbc -tipul de conditii la limita
xa[i] -abscisele punctelor in care se vor determina valorile functiei
*/

#include<stdio.h>
#include<conio.h>
#include<math.h>

#define DIM 11
//typedef float[DIM+1] vector;

void main()
{
const float x[DIM]={0.0, 0.1, 0.78539, 1.57079, 2.35619, 3.14159,\
3.92699, 4.71239, 5.4978, 6.18318, 6.28318};
float a[DIM]={0.0, 0.099833, 0.707106, 1.0, 0.707106, 0.0,\
-0.707106, -1.0, -0.707106, -0.099833, 0.0};
float xa[DIM-1]={0.0, 0.698131, 1.396262, 2.094393, 2.792525,\
3.490656, 4.188787, 4.886918, 5.585049, 6.28318};
int n,i,j,k,kbc;
float fpo,fpn,aux;
float alfa[DIM], b[DIM], c[DIM], d[DIM], l[DIM],\
miu[DIM], dd[DIM], h[DIM], s[DIM], z[DIM];

clrscr();
//se alege tipul de conditii la limita
/* printf("\nTastati:\n 0 daca specificati derivatele de ordinul unu la extremitati
sau,");
printf("\n 1 pentru spline cubic natural:");
scanf("%d",&kbc);
31
INTERPOLAREA NUMERICĂ

if(kbc==0)
{
printf("Introduceti valoarea derivatei de ordinul unu\
\nla extremitatea din stinga: ");
scanf("%f",&fpo);
printf("Introduceti valoarea derivatei de ordinul unu\
\nla extremitatea din dreapta: ");
scanf("%f",&fpn);
}
*/
kbc=1,fpo=1,fpn=1;
n=DIM-1;
//Determinarea functiei spline:
for(i=0;i<=n-1;i++)
h[i]=x[i+1]-x[i];
if(kbc==0)
{
alfa[0]=3*(a[1]-a[0])/h[0]-3*fpo;
alfa[n]=3*fpn-3*(a[n]-a[n-1])/h[n-1];
l[0]=2*h[0];miu[0]=0.5; z[0]=alfa[0]/l[0];
}
if(kbc==1)
{
l[0]=1; miu[0]=0; z[0]=0;
}
for(i=1;i<=n-1;i++)
{
alfa[i]=3*(a[i+1]*h[i-1]-a[i]*(x[i+1]-x[i-1])+a[i-1]*h[i]);
alfa[i]=alfa[i]/h[i-1]/h[i];
l[i]=2*(x[i+1]-x[i-1])-h[i-1]*miu[i-1];
miu[i]=h[i]/l[i];
z[i]=(alfa[i]-h[i-1]*z[i-1])/l[i];
}
if(kbc==0)
{
l[n]=h[n-1]*(2-miu[n-1]);
z[n]=(alfa[n]-h[n-1]*z[n-1])/l[n];
c[n]=z[n];
}
if(kbc==1)
{
l[n]=1; z[n]=0; c[n]=0;
}
for(j=n-1;j>=0;j--)
{
c[j]=z[j]-miu[j]*c[j+1];
b[j]=(a[j+1]-a[j])/h[j]-h[j]*(c[j+1]+2*c[j])/3;
d[j]=(c[j+1]-c[j])/(3*h[j]);
}
//Interpolarea
j=0;
for(k=0;k<=n-1;k++)
{
if((xa[k]<x[0])||(xa[k]>x[n]))
{
printf("\nxa[%d]= %6.3f in afara domeniului",k,xa[k-1]);
break;
}
while((xa[k]>=x[j])&&(xa[k]<=x[j+1]))
{
if(j>n)
{

32
INTERPOLAREA NUMERICĂ

printf("\nj= %d in afara domeniului",j);

break;
}
aux=xa[k]-x[j];
s[k]=a[j]+b[j]*aux+c[j]*pow(aux,2)+d[j]*pow(aux,3);
j++;
}
}

//spline
// textcolor(YELLOW);
printf("\n\tInterpolare spline cubica");
printf("\n i a[i] b[i] c[i] d[i]");

for(i=0;i<=n-1;i++)
printf("\n%2d%12.5f%12.5f%12.5f%12.5f",i,a[i],b[i],c[i],d[i]);
printf("\n\tApasa orice tasta!");getch();
printf("\n\n xdat\tf(x)\ts(x)\tErr:f(x)-s(x)");
for(i=0;i<=n-1;i++)
printf("\n%12.5f%12.5f%12.5f%12.5f",xa[i],sin(xa[i]),s[i],sin(xa[i])-s[i]);
printf("\n\tApasa orice tasta!"); getch();
}

5.4.5 Exemplu rulare 1

Tastati:
0 - daca specificati derivatele de ordinul unu la extremitati sau,
1 - pentru spline cubic natural:0
Introduceti valoarea derivatei de ordinul unu
la extremitatea din stinga: 1
Introduceti valoarea derivatei de ordinul unu
la extremitatea din dreapta: 1

Interpolare spline cubica

i a[i] b[i] c[i] d[i]
0 0.00000 1.00000 0.00145 -0.18146
1 0.09983 0.99485 -0.05299 -0.15433
2 0.70711 0.70471 -0.37033 -0.06635
3 1.00000 0.00021 -0.52666 0.06566
4 0.70711 -0.70556 -0.37195 0.15786
5 0.00000 -0.99769 -0.00000 0.15786
6 -0.70711 -0.70556 0.37196 0.06565
7 -1.00000 0.00020 0.52664 -0.06633
8 -0.70711 0.70472 0.37036 -0.15437
9 -0.09983 0.99484 0.05294 -0.18103
Apasa orice tasta!

xdat f(x) s(x) Err:f(x)-s(x)

0.00000 0.00000 0.00000 0.00000
0.69813 0.64279 0.64290 -0.00011
1.39626 0.98481 0.98427 0.00053
2.09439 0.86603 0.86515 0.00088
2.79253 0.34202 0.34154 0.00048
3.49066 -0.34202 -0.34155 -0.00047
4.18879 -0.86602 -0.86515 -0.00088
33
INTERPOLAREA NUMERICĂ

4.88692 -0.98481 -0.98428 -0.00053

5.58505 -0.64279 -0.64290 0.00011
6.28318 -0.00001 0.00000 -0.00001
Apasa orice tasta!

5.4.6 Exemplu rulare 2

Tastati:
0 - daca specificati derivatele de ordinul unu la extremitati sau,
1 - pentru spline cubic natural:1

Interpolare spline cubica

i a[i] b[i] c[i] d[i]
0 0.00000 1.00009 0.00000 -0.17630
1 0.09983 0.99480 -0.05289 -0.15440
2 0.70711 0.70472 -0.37035 -0.06634
3 1.00000 0.00021 -0.52665 0.06566
4 0.70711 -0.70556 -0.37196 0.15786
5 0.00000 -0.99769 -0.00000 0.15787
6 -0.70711 -0.70555 0.37196 0.06565
7 -1.00000 0.00020 0.52663 -0.06631
8 -0.70711 0.70473 0.37038 -0.15443
9 -0.09983 0.99480 0.05285 -0.17615
Apasa orice tasta!

xdat f(x) s(x) Err:f(x)-s(x)

0.00000 0.00000 0.00000 0.00000
0.69813 0.64279 0.64290 -0.00011
1.39626 0.98481 0.98427 0.00053
2.09439 0.86603 0.86515 0.00088
2.79253 0.34202 0.34154 0.00048
3.49066 -0.34202 -0.34155 -0.00047
4.18879 -0.86602 -0.86515 -0.00088
4.88692 -0.98481 -0.98428 -0.00053
5.58505 -0.64279 -0.64290 0.00011
6.28318 -0.00001 0.00000 -0.00001
Apasa orice tasta!

5.5 Programul 3.5. Funcţii spline tensionate

5.5.1 Explicaţii

5.5.2 Algoritm

5.5.3 Programul

5.5.4 Exemplu rulare

34
Cuadratura numerică

6. Cuadratura numerică

6.1 Formula de cuadratură Newton-Cotes închisă

6.1.1 Explicaţii
Formulele Newton-Cotes închise utilizează nodurile xi = x0 + ih pentru i = 0,1,...,n, unde x0 = a şi
xn = b, h = (b - a)/n şi pot fi scrise în forma:
b
⌡f(x) dx = αh[w0f0 + w1f1 + … + wnfn] + E
⌠ (4.22)
a

unde α şi w sunt constante (vezi Tabelul 6.1) şi fi = f(xi) pentru i = 0,1,...,n

Tabelul 6.1 Constante pentru formule Newton-Cotes închise
n α wi, i= 1,…n E
0,
1 1/2 1 1 -1/12 h3
f"
2 1/3 1 4 1 -1/90 h5
fiv
3 3/8 1 3 3 1 -3/80 h5
fiv
4 2/45 7 32 12 32 7 -8/945 h7
fiv
5 5/288 19 75 50 50 75 19 -
275/1209
6 h7 fiv
6 1/140 41 216 27 272 27 216 41 -9/1400
h9 fviii
7 7/17280 751 3577 1323 2989 -
8183/518
400 h9 fviii
8 8/14175 989 5888 -928 10496 - 10496 - -
45 928 2368/467
40 775 h11 fx
5888 989

35
Cuadratura numerică

Programul implementează formula de cuadratură Newton-Cotes închisă; conţine constantele

necesare pentru aplicarea formulei până la n = 10.
Înainte de a rula programul utilizatorul trebuie să definească funcţia care urmează să fie
integrată în funcţia f, limitele domeniului de integrare putând fi specificate interactiv.

6.1.2 Programul
//Program cuadratura Newton Cotes inchisa, MN pg 215
/*
n- ordinul formulei Newon-Cotes inchisa adica numarul
de puncte in care se aplica formula (2..10)
a, b- limitele domeniului de integrare
w[n,i]- ponderea i pentru formula de ordin n
q, r- constante predefinite functie de ordinul formulei Newton-Cotes
alfa- q/r va intra in formula de calcul
ras- rezultatul integrarii
*/

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

double f(double x)
{ return sin(x); }

void main()
{
int n,i; char c;
double q, r, alfa, a, ras, b, h, x, y;
int w[10][13]={\
{ 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0,
0},\
{ 1, 4, 1, 1, 3, 0, 0, 0, 0, 0, 0, 0,
0},\
{ 1, 3, 3, 1, 3, 8, 0, 0, 0, 0, 0, 0,
0},\
{ 7, 32, 12, 32, 7, 2, 45, 0, 0, 0, 0, 0,
0},\
{ 19, 75, 50, 50, 75, 19, 5, 288, 0, 0, 0, 0,
0},\
{ 41, 216, 27, 272, 27, 216, 41, 1, 140, 0, 0, 0,
0},\
{ 751, 3577, 1323, 2989, 2989, 1323, 3577, 751, 7, 17280, 0, 0,
0},\
{ 989, 5888, -928, 10496, -4540,10496, -928, 5888, 989, 4,14175, 0,
0},\
{ 2857, 15741, 1080, 19344, 5788, 5788, 19344, 1080, 15741, 2857, 9,89600,
0},\
{16067,106300,-48925,272400,-260550,42736,-260550,272400,-48525,106300,16067,
5,299376}};

do
{
cout<<"\nIntroduceti numarul de puncte (2..10): "; cin>>n;
cout<<"Introduceti limita inferioara a= "; cin>>a;
cout<<"Introduceti limita superioara b= "; cin>>b;
// se calculeaza coeficientul alfa
q=w[n-2][n]; //penultimul element diferit de 0
r=w[n-2][n+1]; //ultimul element diferit de 0
alfa=q/r;
h=(b-a)/(n-1);
cout<<"\nQ= "<<q<<"\tR= "<<r<<"\talfa= "<<alfa<<"\th= "<<h;

36
Cuadratura numerică

cout<<"\ni\t x\t f(x)\t\tw";

ras=0;
for(i=0;i<=n-1;i++)
{
x=a+i*h;
y=f(x);
ras=ras+y*w[n-2][i];
cout<<"\n"<<i<<"\t"<<x<<"\t"<<y<<"\t"<<w[n-2][i];
}
ras=ras*h*alfa;
cout<<"\nI= "<<ras;
cout<<"\nContinuati? (d/n): ";
cin>>c;
}
while(c!='n');
}

6.1.3 Exemplu rulare

Introduceti numarul de puncte (2..10): 9
Introduceti limita inferioara a= 0
Introduceti limita superioara b= 2

Q= 4 R= 14175 alfa= 0.000282 h= 0.25

i x f(x) w
0 0 0 989
1 0.25 0.247404 5888
2 0.5 0.479426 -928
3 0.75 0.681639 10496
4 1 0.841471 -4540
5 1.25 0.948985 10496
6 1.5 0.997495 -928
7 1.75 0.983986 5888
8 2 0.909297 989
I= 1.416147
Continuati? (d/n):

6.1.4 Comentarii
2
Am ales ca exemplu de rulare a programului integrala I = ⌠
⌡sin(x) dx care a fost rezolvată
0
aplicând formula Newton-Cotes închisă în 9 puncte. Programul afişează abscisele (egal
depărtate), valorile funcţiei In punctele respective, ponderile corespunzătoare formulei Newton -
Cotes aleasă şi evident, rezultatul integrării. Se observă că funcţia este evaluată şi în punctele
extreme x = 0 şi x = 2.

6.2 Formula de cuadratură Newton-Cotes deschisă

6.2.1 Explicaţii
Formulele Newton-Cotes deschise se obţin prin extinderea domeniului de integrare cu un
subinterval la stânga primului punct dat şi cu un subinterval la dreapta ultimului punct al
domeniului de integrare. Aceste formule sunt de forma:
37
Cuadratura numerică

b
⌡f(x) dx = αh[w0f0 + w1f1 + … + wn+2fn+2] + E
⌠ (4.23)
a

unde h = (b-a)/(n+2). Dintre constantele α şi wi (vezi Tabelul 6.2) w0 şi wn+2 sunt întotdeauna
egale cu zero deoarece corespund extremităţilor domeniului extins. Din acest motiv f0 şi fn+2 nu
sunt necesare.
Tabelul 6.2 Constante pentru formule Newton-Cotes deschise

α wi, i= ,...,n+2 E
0,1
3/2 0 1 1 0 1/4 h3 f"
4/3 0 2 -1 2 0 28/90 h5 fiv
5/24 0 11 1 1 11 0 95/144 h5
fiv
6/20 0 11 - 26 -14 11 0 41/140 h7
14 fiv
7/1440 0 611 - 562 562 -453 611 0 5257/8640
45 h7 fiv
3
8/945 0 460 - 2196 -2459 2196 - 460 0 3956/14175
95 954 h9 fviii
4

Programul implementează formula de cuadratură Newton - Cotes deschisă şi conţine

constantele necesare aplicării formulei în 2-7 puncte.
Utilizatorul trebuie să definească integrantul în funcţia f şi trebuie să specifice interactiv limitele
domeniului de integrare şi numărul de puncte în care urmează să fie evaluată funcţia.

6.2.2 Programul
//Program cuadratura Newton-Cotes deschisa, MN pg 217

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

double f(double x)
{ return sin(x); }

void main()
{
int n,i; char c;
double q,r,alfa,a,ras,b,h,x,y;
int w[6][9]={\
{ 1, 1, 3, 2, 0, 0, 0, 0, 0},\
{ 2, -1, 2, 4, 3, 0, 0, 0, 0},\
{ 11, 1, 1, 11, 5, 24, 0, 0, 0},\
{ 11, -14, 26, -14, 11, 6, 20, 0, 0},\
{611,-453, 562, 562,-453, 611, 7,1440, 0},\
{460,-954,2196,-2459,2196,-954,460, 8,945}};

do
{
cout<<"\nIntroduceti nr de puncte (2...7): ";cin>>n;
cout<<"Introduceti limita inferioara a= ";cin>>a;

38
Cuadratura numerică

cout<<"Introduceti limita superioara b= ";cin>>b;

//se calculeaza coeficientul alfa
q=w[n-2][n];//penultimul element diferit de 0
r=w[n-2][n+1];//ultimul element diferit de 0
alfa=q/r;
h=(b-a)/(n+1);
cout<<"Q= "<<q<<"\tR= "<<r<<"\talfa= "<<alfa<<"\th= "<<h;
cout<<"\ni\t x\t f(x)\t\tw";
ras=0;
for(i=1;i<=n;i++)
{
x=a+(i*h);
y=f(x);
ras=ras+y*w[n-2][i-1];
cout<<'\n'<<i<<'\t'<<x<<'\t'<<y<<'\t'<<w[n-2][i-1];
}
ras=ras*h*alfa;
cout<<"\nI="<<ras;
cout<<"\nContinuati (d/n) ?: ";cin>>c;
}
while(c!='n');
}

6.2.3 Exemplu rulare

Introduceti nr de puncte (2...7): 7
Introduceti limita inferioara a= 0
Introduceti limita superioara b= 2
Q= 8 R= 945 alfa= 0.008466 h= 0.25
i x f(x) w
1 0.25 0.247404 460
2 0.5 0.479426 -954
3 0.75 0.681639 2196
4 1 0.841471 -2459
5 1.25 0.948985 2196
6 1.5 0.997495 -954
7 1.75 0.983986 460
I=1.416146
Continuati (d/n) ?: n

6.2.4 Comentarii
2
Am ales ca exemplu de rulare aceeaşi integrală ca şi la programul 4.1.: I = ⌠
⌡sin(x) dx care a
0
fost rezolvată aplicând formula Newton-Cotes deschisă în 7 puncte.
Programul afişează aceleaşi elemente ca şi programul 4.1. Se observă că nu sunt utilizate
valorile extreme x = 0 şi x = 2 ale domeniului de integrare. Rezultatul final al integrării este mai
apropiat de rezultatul exact I = 1 - cos(2) = 1,4161468.

39
Cuadratura numerică

6.3 Cuadratură Gauss-Legendre

6.4 Cuadratură Gauss-Kronrod

6.4.1 Explicaţii

6.4.2 Programul - incorect!

//Program Cuadratura Gauss-Kronrod - MN pg 222;
/*
xgk - abscisele celor 15 puncte Kronrod
wgk - ponderile celor 15 punte Kronrod
wg - ponderile celor 7 puncte Gauss
a, b - limitele domeniului de integrare
ik - aproximarea integralei prin punctele Kronrod
ig - aproximarea integralei prin punctele Gauss
*/

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

double f(double x)
{
double f=sin(x)/cos(x);
return f;
}

void main()
{
double xgk8[8]={0.9914553711208126, 0.9491079123427585 , 0.8648644233597691,
0.7415311855993944, 0.5860872354676911, 0.4058451513773972, 0.2077849550078985, 0.0};
double wgk8[8]={0.02293532201052922, 0.06309209262997855, 0.1047900103222502,
0.1406532597155259, 0.1690047266392679, 0.1903505780647854, 0.2044329400752989,
0.2094821410847278};
double wg4[4]={0.1294849661688697, 0.2797053914892767, 0.3818300505051189,
0.4179591836734694};

double xgk[15], wgk[15], wg[7], a, b, ig, ik, er;

int i;
cout<<"a="; cin>>a;
cout<<"b="; cin>>b;
for(i=7;i>1;i--)
{
xgk[i]=xgk8[i];
xgk[15+1-i]=-xgk8[i];
wgk[i]=wgk8[i];
wgk[15+1-i]=wgk8[i];
}
xgk[8]=xgk8[8];
wgk[8]=wgk8[8];
for(i=3;i>1;i--)
{
wg[i]=wg4[i];
wg[7+1-i]=wg4[i];
}
wg[4]=wg4[4];
ik=0;
ig=0;
40
Cuadratura numerică

for(i=1;i<15;i++)
{
xgk[i]=(xgk[i]*(b-a)+a+b)/2;
ik=ik+wgk[i]*f(xgk[i]);
}
ik=ik*(b-a)/2;
for(i=1;i<7;i++)
{
xgk[i]=(xgk[2*i]*(b-a)+a+b)/2;
ig=ig+wg[i]*f(xgk[2*i]);
}
ig=ig*(b-a)/2;
er=200*abs(ig-ik)*sqrt(200*abs(ig-ik));
cout<<"I="<<ik;
cout<<"Eroarea"<<er;
}

6.4.3 Exemplu rulare

6.5 Cuadratura funcţiilor cu singularităţi

6.6 Integrale duble

41
Rezolvarea ecuaţiilor neliniare

7. Rezolvarea ecuaţiilor neliniare

7.1 Metoda bisecţiei (înjumătăţirii)

Să se calculeze soluţia ecuaţiei f(x) = 0 pentru funcţia

f(x) = x - cos(x)
prin metoda: înjumătăţirii şi coardei.

7.1.1 Algoritm
DATE DE INTRARE:
• a, b {capetele intervalului}
• ε {eroarea maximă admisibilă}
DATE DE IEŞIRE:
• x {rădăcina}
• zero {variabilă logică de control}
Pasul 1 : CITEŞTE a, b, ε
Pasul 2. zero = adevărat {există o rădăcină}
Pasul 3. x = a; fa = f(x);
DACĂ |fa| ≤ ε ATUNCI EXIT {rădăcina este x=a}
Pasul 4. x = b; fb = f(x);
DACĂ |fb| ≤ ε ATUNCI EXIT {rădăcina este x=b}
Pasul 5.
DACĂ fa ⋅ fb < 0 ATUNCI {există rădăcină în intervalul (a,b)}
REPETĂ
x = (a+b)/2; fx = f(x) {f((a+b)/2)}
DACĂ fa ⋅fx < 0 ATUNCI b = x ALTFEL a = x
dx = b-a; DACĂ x ≠0 ATUNCI dx = dx/x {eroarea}
PÎNĂ CÂND |dx|≤ ε sau |fx|≤ ε {testează convergenţa}
ALTFEL zero = fals {nu există rădăcină}
Pasul 6. STOP

7.2 Metoda secantei (coardei)

7.2.1 Algoritm
DATE DE INTRARE:
42
Rezolvarea ecuaţiilor neliniare

• a, b {capetele intervalului}
• ε {eroarea maximă admisibilă}
DATE DE IEŞIRE:
• x {rădăcina}
• zero {variabilă logică de control}
Pasul 1. CITEŞTE a, b, ε
Pasul 2. zero = adevărat {există o rădăcină}
Pasul 3. x = a; fa = f(x);
DACĂ ⏐fa⏐≤ ε ATUNCI EXIT {rădăcina este x=a}
Pasul 4. x = b; fb = f(x);
DACĂ ⏐fb⏐≤ ε ATUNCI EXIT {rădăcina este x=b}
Pasul 5.
DACĂ fa ⋅ fb < 0 ATUNCI {există rădăcină în intervalul (a,b)}
REPETĂ
x = (a⋅fb - b⋅fa)/(fb - fa); fx = f(x) {f(x)}
DACĂ fa⋅fx < 0
ATUNCI b = x, fb = fx
ALTFEL a = x, fa = fx
dx = b-a; DACĂ x ≠0 ATUNCI dx = dx/x {eroarea}
PÎNĂ CÂND |dx| ≤ ε sau |fx| ≤ ε {testează convergenţa}
ALTFEL zero = fals {nu există rădăcină}
Pasul 6. STOP

7.3 Metoda tangentei

7.3.1 Algoritmul
DATE DE INTRARE:
• x {aproximaţie iniţială pentru rădăcină}
• ε {eroarea maximă admisibilă}
• imax {număr maxim de iteraţii}
DATE DE IEŞIRE:
• x {rădăcina}
• zero {variabilă logică de control}
Pasul 1. CITEŞTE x, ε, imax
Pasul 2. zero = adevărat {se admite că există o rădăcină}
Pasul 3. i = 0 {iniţializează contorul iteraţiilor}
Pasul 4.
REPETĂ
i = i+1 {incrementează contorul}
dx = f(x); DACĂ f'(x) ≠ 0 ATUNCI dx = dx/f'(x) {corecţia}
x = x - dx {noua aproximaţie pentru rădăcină}
DACĂ x ≠0 ATUNCI dx = dx/x {eroarea relativă}
PÎNĂ CÂND |dx|≤ ε SAU i ≥ imax {testează convergenţa}
DACĂ i ≥ imax ATUNCI zero = fals {nu există rădăcină}
Pasul 5. STOP

43
Rezolvarea ecuaţiilor neliniare

7.4 Programul pentru rezolvarea ecuaţiilor neliniare

//Rezolvarea ecuatiilor neliniare

#include <iostream.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

//Variabile globale
int i,ok;
double x,fx,dx; float eps=1e-03;

double f(double);
double df(double);
double bisect(double, double, double, double (*)(double));
double secant(double, double, double, double (*)(double));
double tangenta(double, double, double (*)(double) , double (*)(double));

void main()
{
clrscr();
x=bisect(0,2,eps,f); getch();
x=secant(0,2,eps,f); getch();
x=tangenta(2,eps,f,df);
// else printf("\nNu exista solutie");
getch();
}

//Functia din ecuatie

double f(double x)
{return x-cos(x);}

//Derivata de ord 1 a functiei din ecuatie

double df(double x)
{return 1+sin(x);}

//Metoda bisectiei
double bisect(double a, double b, double eps, double (*f)(double))
{
double fa,fb;
i=0; ok=1;
x=a;fa=(*f)(a);
if (fabs(fa)<=eps) return x;
x=b;fb=(*f)(b);
if (fabs(fb)<=eps) x=b;
if((fa*fb)<0)
{
do
{i++;
x=(a+b)/2;fx=(*f)(x);
if((fa*fx)<0) b=x;
else a=x;
dx=b-a;
if(x!=0) dx=dx/x;
printf("\ni=%2d: a= %9.5lf; x= %9.5lf; b= %9.5lf; dx= %9.5lf; f(x)=
%9.5lf",i,a,x,b,dx,fx);
}
while((fabs(dx)>eps)||(fabs(fx)>eps));
printf("\nMetoda bisectiei: solutia x= %9.5lf din %2d pasi", x,i);
return x;

44
Rezolvarea ecuaţiilor neliniare

}
else
{ok=0; printf("\nNu exista solutie"); return 0; }
}

//Metoda secantei
double secant(double a, double b, double eps, double (*f)(double))
{
double fa,fb;
i=0; ok=1;
x=a;fa=(*f)(a); if (fabs(fa)<=eps) return a;
x=b;fb=(*f)(b); if (fabs(fb)<=eps) return b;
if((fa*fb)<0)
{
do
{i++;
x=(a*fb-b*fa)/(fb-fa);fx=(*f)(x);
if(fa*fx<0)
{b=x;fb=fx;}
else {a=x;fa=fx;};
dx=b-a;
if(x!=0) dx=dx/x;
printf("\ni=%2d: a= %9.5lf; x= %9.5lf; b= %9.5lf; dx= %9.5lf; f(x)=
%9.5lf",i,a,x,b,dx,fx);
}
while((fabs(dx)>eps)||(fabs(fx)>eps));
printf("\nMetoda secantei: solutia x= %9.5lf din %2d pasi", x,i);
return x;
}
else
{ok=0; printf("\nNu exista solutie"); return 0; }
}

//Metoda tangentei
double tangenta(double x, double eps, double (*f)(double), double (*df)(double))
{
double dfx;
i=0; ok=1;
do
{
i++;
dx=f(x);
dfx=df(x);
if(dfx)
dx/=dfx;
x-=dx;
if(x!=0) dx/=x;
printf("\ni=%2d:\t\t x= %9.5lf;\t\t dx= %9.5lf; f(x)= %9.5lf",i,x,dx,(*f)(x));
}
while((fabs(dx)>eps)||(fabs(fx)>eps));
printf("\nMetoda tangentei: solutia x= %9.5lf din %2d pasi",x,i);
return x;
}

7.4.1 Exemplu rulare

i= 1: a= 0.00000; x= 1.00000; b= 1.00000; dx= 1.00000; f(x)= 0.45970
i= 2: a= 0.50000; x= 0.50000; b= 1.00000; dx= 1.00000; f(x)= -0.37758
i= 3: a= 0.50000; x= 0.75000; b= 0.75000; dx= 0.33333; f(x)= 0.01831
i= 4: a= 0.62500; x= 0.62500; b= 0.75000; dx= 0.20000; f(x)= -0.18596

45
Rezolvarea ecuaţiilor neliniare

i= 5: a= 0.68750; x= 0.68750; b= 0.75000; dx= 0.09091; f(x)= -0.08533

i= 6: a= 0.71875; x= 0.71875; b= 0.75000; dx= 0.04348; f(x)= -0.03388
i= 7: a= 0.73438; x= 0.73438; b= 0.75000; dx= 0.02128; f(x)= -0.00787
i= 8: a= 0.73438; x= 0.74219; b= 0.74219; dx= 0.01053; f(x)= 0.00520
i= 9: a= 0.73828; x= 0.73828; b= 0.74219; dx= 0.00529; f(x)= -0.00135
i=10: a= 0.73828; x= 0.74023; b= 0.74023; dx= 0.00264; f(x)= 0.00192
i=11: a= 0.73828; x= 0.73926; b= 0.73926; dx= 0.00132; f(x)= 0.00029
i=12: a= 0.73877; x= 0.73877; b= 0.73926; dx= 0.00066; f(x)= -0.00053
Metoda bisectiei: solutia x= 0.73877 din 12 pasi
i= 1: a= 0.58545; x= 0.58545; b= 2.00000; dx= 2.41615; f(x)= -0.24801
i= 2: a= 0.71713; x= 0.71713; b= 2.00000; dx= 1.78888; f(x)= -0.03656
i= 3: a= 0.73626; x= 0.73626; b= 2.00000; dx= 1.71645; f(x)= -0.00473
i= 4: a= 0.73873; x= 0.73873; b= 2.00000; dx= 1.70736; f(x)= -0.00060
i= 5: a= 0.73904; x= 0.73904; b= 2.00000; dx= 1.70621; f(x)= -0.00008
i= 6: a= 0.73908; x= 0.73908; b= 2.00000; dx= 1.70607; f(x)= -0.00001
i= 7: a= 0.73908; x= 0.73908; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i= 8: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i= 9: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=10: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=11: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=12: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=13: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=14: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=15: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=16: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=17: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=18: a= 0.73909; x= 0.73909; b= 2.00000; dx= 1.70605; f(x)= -0.00000
i=19: a= 0.73909; x= 0.73909; b= 0.73909; dx= 0.00000; f(x)= 0.00000
Metoda secantei: solutia x= 0.73909 din 19 pasi
i= 1: x= 0.73454; dx= 1.72281; f(x)= -0.00761
i= 2: x= 0.73909; dx= -0.00616; f(x)= 0.00001
i= 3: x= 0.73909; dx= 0.00001; f(x)= 0.00000
Metoda tangentei: solutia x= 0.73909 din 3 pasi

7.5 Metoda aproximaţiilor succesive

7.5.1 Algoritmul
Date de intrare:
• x {aproximaţie iniţială pentru rădăcină}
• ε {eroarea maximă admisibilă}
• imax {număr maxim de iteraţii}
Date de ieşire:
• x {rădăcina}
• zero {variabilă logică de control}
Pasul 1 : CITEŞTE x, ε, imax
Pasul 2. zero = adevărat {se admite că există o rădăcină}
Pasul 3. i = 0 {iniţializează contorul iteraţiilor}
Pasul 4.
REPETĂ
46
Rezolvarea ecuaţiilor neliniare

i = i+1 {incrementează contorul}

dx = f(x) {corecţia}
x = x - dx {noua aproximaţie pentru rădăcină}
DACĂ x ≠0 ATUNCI dx = dx/x {eroarea relativă}
PÎNĂ CÂND |dx| < ε SAU i > imax {testează convergenţa}
DACĂ i ≥ imax ATUNCI zero = fals {nu există rădăcină}
Pasul 5. STOP

7.5.2 Programul
//Metoda iteratiilor sucesive
#include <stdio.h>
#include<math.h>
int ok;

double f(double);
double iter(double ,double ,int,double (*)(double));

main()
{
double sol;
sol=iter(50,1e-06,50,f);
if(ok) printf ("\nsolutia e x=%lf",sol);
else printf("\nnu e solutie");
}

double f(double x)
{return x-sin(x)-0.25;}

double df(double x)
{return 1-cos(x);}

double iter(double x,double eps,int imax,double (*f)(double))

{
int i=0; double fx,dx; ok=1;
do
{
i++;
dx=f(x);
x-=dx;
if (x!=0) dx=dx/x;
printf("\ni=%2d; x=%lf; dx=%lf;",i,x,dx);
}
while ((fabs (dx)>eps)&&(i<imax));
if (i>=imax) ok=0;
return x;
}

7.5.3 Exemplu rulare

S-a considerat ecuaţia f(x) = 0, unde f(x) = x - sin(x) - 0.25, şi deci f'(x) = 1- cos(x).
i= 1; x=-0.012375; dx=-4041.451806;
i= 2; x=0.237625; dx=-1.052077;
i= 3; x=0.485395; dx=-0.510450;
i= 4; x=0.716558; dx=-0.322601;
i= 5; x=0.906793; dx=-0.209789;
i= 6; x=1.037532; dx=-0.126009;
47
Rezolvarea ecuaţiilor neliniare

i= 7; x=1.111152; dx=-0.066256;
i= 8; x=1.146210; dx=-0.030586;
i= 9; x=1.161209; dx=-0.012917;
i=10; x=1.167285; dx=-0.005205;
i=11; x=1.169688; dx=-0.002054;
i=12; x=1.170629; dx=-0.000804;
solutia e x=1.170629

48
INTEGRAREA ECUAŢIILOR DIFERENŢIALE ORDINARE

8. INTEGRAREA ECUAŢIILOR DIFERENŢIALE ORDINARE

8.1 12.4 Metodele Runge-Kutta

8.1.1 Programul - incomplet!

//Sist de ec diferentiale - Met RK4
#include<stdio.h>
//#include<math.h>
#define DIM 3

double y[2],f[2];

double func(double x,double y);

void RK4(double x, double h, double y0[], double y[],int n);

void main()
{
int k;
/* double K1,K2,K3,K4,x[7],y[7],h=0.001;
x[0]=0.0; y[0]=120;
for(k=1;k<7;k++)
{
x[k]=0.001*k;
K1=h*f(x[k-1],y[k-1]);
K2=h*f(x[k-1]+h/2,y[k-1]+K1/2);
K3=h*f(x[k-1]+h/2,y[k-1]+K2/2);
K4=h*f(x[k-1]+h,y[k-1]+K3);
y[k]=y[k-1]+(K1+2*K2+2*K3+K4)/6;
printf("\nx=%7.3lf; K1=%7.3lf; K2=%7.3lf; K3=%7.3lf; K4=%7.3lf;
y=%7.3lf",x[k],K1,K2,K3,K4,y[k]);
} */
}

void func(double x)
{
f[0]=y[1];
f[1]=-y[0];
}

void RK4(double x, double h, double y0[], double y[],int n)

{
int i;
double hh;
double f1[DIM],f2[DIM],f3[DIM],yy[DIM];

49
INTEGRAREA ECUAŢIILOR DIFERENŢIALE ORDINARE

hh/=2;
func(x);

for(i=0;i<n;i++)
yy[i]=y0[1]+hh*f1[i];

8.1.2 Exemplu rulare

50
Diverse

9. Diverse

9.1 Metoda celor mai mici pătrate de aproximare a sistemelor de ecuaţii supradeterminate

Să considerăm cazul cel mai simplu când se cere dreapta minimală ce uneşte un sistem de n
puncte în spaţiul k-dimensional Rk.
Avem:
A0.x0,0 + A1.x0,1 + A2.x0,2 + ..... + Ak-1.x0,k-1 + B
= y0
A0.x1,0 + A1.x1,1 + A2.x1,2 + ..... + Ak-1.x1,k-1 + B
= y1
.........................................................................................................................................................
A0.xi,0 + A1.xi,1 + A2.xi,2 + ..... + Ak-1.xi,k-1 + B
= yi
........................................................................................................................................................
A0.xn-1,0 + A1.xn-1,1 + A2.xn-1,2 + ..... + Ak-1.xn-1,k-1 + B = yn

Se cere minimizarea funcţiei:

F(A0,A1,...,An-1,B) = (A0.x0,0 + A1.x0,1 + A2.x0,2 +...+ Ak-1.x0,k-1 + B - y0)2 + ...+ (A0.xn-1,0
+ A1.xn-1,1 + A2.xn-1,2 +...+ Ak-1.xn-1,k-1 + B - yn-1)2
Pentru aceasta trebuie găsit punctul în care toate derivatele parţiale se anulează iar hessiana este
pozitiv definită.
F`A0(A1,...,Ak,B) = 2[X0,0.(A1.X1,1+...+Ak.X1,k +B-Y1)+...+Xn,1.(A0.Xn,1+...+Ak.Xn,k +B-Yn)]
F`A1(A1,...,Ak,B) 2[X0,1.(A1.X1,1+...+Ak.X1,k +B-Y1)+...+Xn,1.(A0.Xn,1+...+Ak.Xn,k +B-Yn)]
F`A2(A1,...,Ak,B) 2[X0,2.(A1.X1,1+...+Ak.X1,k +B-Y1)+...+Xn,2.(A0.Xn,1+...+Ak.Xn,k +B-Yn)]
F`A3(A1,...,Ak,B) 2[X0,3.(A1.X1,1+...+Ak.X1,k +B-Y1)+...+Xn,3.(A0.Xn,1+...+Ak.Xn,k +B-Yn)]
....... ................
....... ................
F`Ai(A1,...,Ak,B) 2[X0,i.(A1.X1,1+...+Ak.X1,k +B-Y1)+...+Xn,i.(A0.Xn,1+...+Ak.Xn,k +B-Yn)]
....... ................
....... ................
51
Diverse

F`An(A1,...,Ak,B) 2[X0,n.(A1.Xn,1+...+Ak.Xn,k +B-Yn)+...+Xn,k.(A0.Xn,1+...+Ak.Xn,k +B-Yn)]

F`B(A1,...,Ak,B) 2[(A0.Xn,1+...+Ak.Xn,n +B-Yn) +...+ (A0.Xn,1+...+Ak.Xn,k +B-Yn)]

Pentru ca gradientul sa fie nul trebuie rezolvat un sistem de (n+1) ecuaţii cu (n+1) necunoscute,
iar matricea necunoscutelor este egala cu hessiana funcţiei F in punctul (A1,A2,...,Ad,B).

Sa notam aceasta matrice cu H. Avem:

2.[ X1,i.X1,j + X2,i.X2,j +...+ Xn,i.Xn,j ], dacă i,j=1,k

H[i][j] = 2.[ X1,i + X2,i +...+ Xn,i], dacă i=1,k; j=k+1
2.[ X1,j + X2,j +...+ Xn,j], dacă i=k+1; j=1,k
2.n, dacă i=k+1,j=k+1

Se demonstrează ca aceasta matrice este nu nedegenerata, ci, mai mult, pozitiv definita.
Aceasta înseamnă ca sistemul este compatibil determinat şi se poate rezolva prin metoda lui
Gauss.
De asemenea fiind pozitiv definita rezulta ca punctul de extrem relativ este de minim.

Vectorul termenilor liberi, fie acesta V, este următorul:

V[i] = X1,i.y1 + X2,i.y2 + ... + Xn,i.yn dacă i=1,n

y1 + y2 + ... + yn dacă i=n+1

Am calculat matricea sistemului. Mai avem nevoie şi de o procedura Gauss pentru rezolvarea
generica a sistemelor de aceasta forma.

52