Documente Academic
Documente Profesional
Documente Cultură
MetNum - Lab PDF
MetNum - Lab PDF
Programele vor fi rulate pas cu pas, iar valorile variabilelor vor fi urmărite în fereastra Watch !
Varianta din 2007-01-09 08:16
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
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);}
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
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
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;
/*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");
}
printf("\n***Solutia***\n");
for(i=0;i<n;i++)
printf("X[%d]= %8.3lf;\n", i,B[i]);
}/*main*/
***Solutia***
X[0]= 0.000;
X[1]= -1.000;
X[2]= 1.000;
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
10
Operaţii matriciale
3. Operaţii matriciale
3.1.1 Programul
//Operatii cu matrici realizate cu functii
#include<iostream.h>
#include<stdio.h>
#define DIM 10
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 main()
{
int m1[DIM][DIM], m2[DIM][DIM], sum[DIM][DIM];
int a,b,c,d,i,j; char selector;
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 !";
}
}
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
***** 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.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 Ã
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.4 Descompunerea LU
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;
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
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
22
Sisteme de ecuaţii liniare - metode iterative
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");
for(i=0;i<DIM;i++)
X[i]=X_nou[i];
}
getch();
}
24
INTERPOLAREA NUMERICĂ
5. INTERPOLAREA NUMERICĂ
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};
}
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.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.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.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.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.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.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.
30
INTERPOLAREA NUMERICĂ
#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Ă
//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.5.1 Explicaţii
5.5.2 Algoritm
5.5.3 Programul
34
Cuadratura numerică
6. Cuadratura numerică
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
35
Cuadratura numerică
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ă
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.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
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ă
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.4.1 Explicaţii
#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};
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;
}
41
Rezolvarea ecuaţiilor neliniare
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.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.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
//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();
}
//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;
}
45
Rezolvarea ecuaţiilor neliniare
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
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);}
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
double y[2],f[2];
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];
}
49
INTEGRAREA ECUAŢIILOR DIFERENŢIALE ORDINARE
hh/=2;
func(x);
for(i=0;i<n;i++)
yy[i]=y0[1]+hh*f1[i];
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
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).
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.
Am calculat matricea sistemului. Mai avem nevoie şi de o procedura Gauss pentru rezolvarea
generica a sistemelor de aceasta forma.
52