metode numerice - laborator - lab.pdf · sisteme de ecuaţii liniare - metode directe 7 2. sisteme...

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


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


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)

1.1.1 Conversia din zecimal în binar

1.1.2 Valorile limită şi caracteristicile tipurilor de date Pentru a vedea semnificaţia constantelor folosite se va folosi Help-ul aplicaţiei

//Informatii despre caracteristicile tipurilor de date din C #include <values.h> #include <iostream.h> void main(void) { cout<<"\nIntregi: "<<MAXINT;

cout<<"\nFloat: "<<FMAXPOWTWO<<"\t"<<FMAXEXP<<"\t"<<FMINEXP\ <<"\t"<<_FEXPLEN<<"\t"<<FSIGNIF<<"\t"<<MINFLOAT<<"\t"<<MAXFLOAT; cout<<"\nDouble: "<<DMAXPOWTWO<<"\t"<<DMAXEXP<<"\t"<<DMINEXP\ <<"\t"<<_DEXPLEN<<"\t"<<DSIGNIF<<"\t"<<MINDOUBLE<<"\t"<<MAXDOUBLE; }

1.1.3 Constanta ε a calculatorului #include <values.h>

3


#include <iostream.h> #include <conio.h> void main(void) { float eps=1,eps1=1; while(eps1>0) { eps=eps/2; eps1=eps*0.98+1; eps1=eps1-1; } cout<<"\neps= "<<eps; getch(); }

1.1.4 Erori 1 Se consideră două numere x = 2.3 şi y = 15745.6 şi reprezentările lor aproximative xapr = 2.2 şi yapr = 15745.5. Să se calculeze erorile absolute şi relative ale celor două numere.

#include<iostream.h> #include<conio.h> #include<stdio.h> #include <math.h> void main() { float x=2.3,y=15745.6,xapr=2.2,yapr=15745.5; double xabs,yabs,xrel,yrel; xabs=x-xapr; yabs=y-yapr; xrel=(fabs(xabs)/x)*100; yrel=(fabs(yabs)/y)*100; cout<<"\nErorile absolute sunt:\txabs="<<xabs<<";\tyabs="<<yabs; cout<<"\nErorile relative sunt:\txrel="<<xrel<<" %;\tyrel="<<yrel<<" %"; getch(); }

1.1.5 Erori 2 Să se studieze propagarea erorilor la adunarea şi înmulţirea a două numere

introduse de la tastatură. Erorile absolute ale celor două numere vor fi de asemenea introduse de la tastatură.

#include<iostream.h> #include<math.h> #include<conio.h> float erorrel(float x, float xabs) { double xrel=(fabs(xabs)/x)*100; return xrel; } void main() { clrscr(); float a,b,aabs,babs,cabs,crel,dabs,drel; cout<<"a= ";cin>>a; cout<<"b= ";cin>>b; cout<<"aabs= ";cin>>aabs; cout<<"babs= ";cin>>babs; cout<<"\nErorile relative sunt: "<<erorrel(a,aabs); cout<<"\nErorile relative sunt: "<<erorrel(b,babs); //calculul erorilor la adunare cabs=aabs+babs; crel=(erorrel(a,aabs)*a/(a+b))+erorrel(b,babs)*b/(a+b); cout<<"\nEroarea absoluta la adunare: "<<cabs; cout<<"\nEroarea relativa la adunare: "<<crel; //calculul erorilor la inmultire dabs=a*babs+b*aabs; drel=erorrel(a,aabs)+erorrel(b,babs); cout<<"\nEroarea absoluta la inmultire: "<<dabs; cout<<"\nEroarea relativa la inmultire: "<<drel; getch(); }

4


1.1.6 Erori 3 Să se adune la valoarea a=1, de 1000 de ori valoarea 0.0001 şi să se studieze rezultatul obţinut în funcţie de tipul variabilei a.

#include<iostream.h> #include<stdio.h> main() { int i; float a=1; /*cu float difera, cu double da corect*/ for(i=1;i<=1000;i++) a+=0.0001; printf("\na=%4e",a); }

1.1.7 Calculul exponenţialei Programul are ca dată de intrare argumentul x pentru care se doreşte evaluarea funcţiei ex şi produce ca date de ieşire valoarea acesteia furnizata de funcţia expn

//Calculul exponetialei #include<iostream.h> #include<math.h> #include<conio.h> double expn(double x) { double eps=1e-10; double f,t;int i; i=0;t=1;f=1; while(fabs(t/f)>eps) { i=i+1; t=x/i*t; f+=t; } return f; } void main() { double x; cout<<"\nx=";cin>>x; cout<<"\nexpn("<<x<<")="<<expn(x);

cout<<"\n exp("<<x<<")="<<exp(x); getch(); }

1.1.8 Calculul funcţiei exponenţiale cu argument negativ (vezi Expn2.cpp) #include <iostream.h> #include <math.h> #include <conio.h> double expn(double x) { int i=0; double eps=1e-10,absx,f=1,t=1; absx=fabs(x); while(fabs(t/f)>eps) { i=i+1; t=absx/i*t; f+=t; } if(x>=0)return f; else return 1/f; } void main() { double x; cout<<"\nx=";cin>>x; cout<<"\nexpn("<<x<<")="<<expn(x); cout<<"\nexp("<<x<<")="<<exp(x); getch(); }

1.1.9 Calculul polinoamelor Cebişev

#include<iostream.h> #include<math.h> #include<conio.h> double ceb(double x,int n) { double f,t,tm,tp;int i; if(n>0) {tm=1;t=x;f=2*x; for(i=1;i<n-1;i++)

5


{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<<")="<<ceb(x,n);}

1.1.10 Schema lui Horner nui polinom P(x) Sa se calculeze valoarea u

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

7

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:

Pasul 6. MODIFICAŢI linia i: (Li) = (Li - mik Lk), unde mik = aikakk

Pasul 7. DACĂ ann = 0 atunci SCRIE mesaj: "Sistemul nu are soluţie unică" şi EXIT. (Substituţia inversă:)

Pasul 8. CALCULEAZĂ: xn = an n+1ann

Pasul 9. PENTRU i = n-1,...,1 SUMA = 0 Pasul 10 PENTRU j = i+1,…,n CALCULEAZĂ SUMA = SUMA + aijxj

Pasul 11. CALCULEAZĂ xi = ai n+1 - SUMAaii

Pasul 12. SCRIE (x1,x2, .. ,xn) STOP.


8

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];


9

} //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


10

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

Operaţii matriciale

11

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]) {


12

t i,j,k; in 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";


13

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

entul [0,0] : 1 entul [0,1] : 2

entul [1,1] : 4

entul [0,0] : 5

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

Prima matrice: ***** Linia 0 ntroduceti elemI

Introduceti elem ***** Linia 1 ntroduceti elementul [1,0] : 3 I

Introduceti elem A doua matrice ***** Linia 0 ntroduceti elemI


14

entul [0,1] : 6

troduceti elementul [1,0] : 7 entul [1,1] : 8

8

22 50

3.2

Introduceti elem ***** Linia 1 InIntroduceti elemTastati:'s' pentru suma 'd' pentru diferenta 'p' pentru produsAici: p 1 2 3 4 * 5 67 = 19 43

Inversa unei matrici

3.2.1 Explicaţii Programul calculează inversa unei matrici pătrate A. se introduce matricea extinsă Ã rezultată

a matricii A şi a matricii unitate I de acelaşi ordin cu A. Prin rularea programului prin concatenarerezultă 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

conţine dimensiunea

Metoda Gauss toda Gauss

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 vamatricii extinse Ã

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


15

#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


16

or( <n;i++) f i=0;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 tf("prin \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 b, prin descompunerea matricii A în produsul LU urmată de rezolvarea sistemelor Lz = b şi Ux = z (se consideră lii = 1, i =

şi j = 1/2,.. .,n ectorului coloană b, i = 1,2,...,n

DAul nu are soluţie unică"

g astfel încât 1 ≤ p ≤ n şi |a | = max |a |

ţii cu n necunoscute, Ax =

1,2,...,n) DATE DE INTRARE:

• n - dimensiunea sistemului • aij - elementele metricii A, i • bi - elementele vTE DE IEŞIRE: • x , x , ...,x : soluţia sistemului sau mesaj "1 2 n Sistemsul 1.(Caută pivotul) Pa

Fie p cel mal mic între p1 1≤i≤n i1


17

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

⎪⎪ ⎪⎪api - ∑

k=1lpk⋅uki = maxi≤j≤n ⎪⎪ ⎪⎪

i-1

⎪⎪⎪⎪

⎪⎪⎪⎪aji - ∑

k=1

i-1ljk⋅uki

DACĂ maximum este ro A NC ze TU I 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.

Pasul 8. uii = aii - ∑k=1

lik⋅uki i-1

Pasul 9. PENTRU j = i+1, i+2,...,n, CALCULEAZĂ: uij = aij - ∑k=1

i-1lik⋅ukj (linia i din U)

lji = ⎝⎜ ⎠⎟k=1

⎜⎛ ⎟⎞aji - ∑i-1

ljk⋅uki

uii (coloana i din L)

Pasul 10. unn = a ∑n

lnk⋅ukn . DACĂ nn -k=1

-1 unn = 0 SCRIE mesaj: "Sistemul nu are soluţie unică".

STOP.

1. REARANJAŢI(Rezolvă sistemul inferior triunghiular Lz = b) Pasul 1 elementele vectorului coloană liber b: b = Pb Pasul 12. z1 = b1

Pasul 13. PENTRU i = 2,...,n CALCULEAZĂ zi = bi - ∑j=1

lij⋅zj

Pasul 14. xn = zn/unn

i-1

(Rezolvă sistemul superior triunghiular Ux = z)

Pasul 15. PENTRU i = n-1, n-2,...,1, CALCULEAZĂ xi = zi - ∑j=i+1

nuij⋅xj

Pasul 16. SCRIE (x1, x2,...,xn) STOP bă sDupă cum se observă din algoritm, în cazul în care se schim istemul prin modificarea numai

matricii A rămâne aceeaşi, calculele reluându-se de la a termenului liber b, descompunereaPasul 11.


18

ramul /Descompunerea LU pg.93

3.4.2 Prog/#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;


19

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);


20

ermenilor liberi: "); printf("\nVectorul t 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 rma rulării programului se obţin următoarele rezultate:

Matricea originala: 1.500 -0.333

2.080

În u

1.000 0.333 -2.010 1.450 0.500 2.950 4.320 -1.950 0.000 5.110 -4.000 3.330 -1.110 Numar de pivotari: 1 5.110 -4.000 3.330 -1.110


21

.500 -0.333

.500 -0.333

.500 2.950

.045

5.400 0.130 3.770

5.110 -4.000 3.330 -1.110 815 3.018

.000 0.000 4.045

.086 0.515 1.000 .057 4.645 4.227 .331 2.374 1.045

-2.010 1.450 0.500 2.950 4.320 -1.950 0.000 2.080 1.000 0.333 1Numar 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 1Numar 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 0Matricea 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 Determinant: -90.030 Vectorul termenilor liberi: 3.000 Matricea U: 0.000 1.432 -2. 0.000 0.000 3.042 -2.468 0.000 0Matricea 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 -0Vectorul z este: 3.770 -3Solutia sistemului este: -0.324 0

Sisteme de ecuaţii liniare - metode iterative

22

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Ă

xnoui =

- ∑j=1;j≠i

n(aij⋅xi) + bi

aii

Pasul 4. DACĂ ||xnou - x||∞||xnou||∞

≤ TOL ATUNCI SCRIE(xnou1,xnou2,..., xnoun,) (soluţia) STOP

(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.


23

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Ă

xnoui =

-∑j=1

i-1(aij⋅xnouj) - ∑

j=i+1

n(aij⋅xj) + bi

aii

Pasul 4. DACĂ ||xnou - x||∞||xnou||∞

≤ TOL ATUNCI

(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; }


24

/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 [2] X[3] X[4] ERR

0

4.2

Iter X[1] X

0: 0.0000 0.0000 0.0000 0.0000 1.0000

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

Metodele relaxării

INTERPOLAREA NUMERICĂ

25

5. INTERPOLAREA NUMERICĂ

5.1 PROGRAMUL 3.1. INTERPOLAREA LAGRANGE

5.1.1 Enunţ Programul utilizează formula de interpolare Lagrange

Ln,i(x) = ∑i=0

n

∏j=0;j≠i

nx - xjxi - xj

fi

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]);


26

} 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 ).

Utilizând funcţia lui Runge: R(x) = 11 + 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.


27

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];


28

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

5.2.3 Exemplu rulare Tabloul diferentelor ascendente:

f de 2 .... 0.2000 -0.1666

r ascendente generată de program permite dezvoltarea unui polinom de

N(x) = 0,2500 - 0,0500s + 0,0167s(s-1)/2

unde s = x - x3

i x[i] f[i] dif de 1 di 0 1.0000 1.0000 -0.5000 0.3333 -0.2500 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ţelointerpolare 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,

h = (x - 0.7)/2

5.3 Tabela diferenţelor divizate.

5.3.1 Explicaţii ate de forma (xi, fi), i = 0,1, ...,n unde abscisele xi sunt inegal distribuite.

p iar fi în

TELOR DIVIZATE (MN-pg.156)

Fie un set de dProgramul 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_tmi_tmp, unde n este egal cu numărul de puncte minus 1.

5.3.2 Programul //TABELA DIFEREN/* 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++)


29

{ 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]); f("\n i x[i] f[i] f(i,i+1) f(i,i+2)\t....print "); 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 lor divizate: i] f(i,i+1) f(i,i+2) ....

0.2443 0.0209 0.0148 -0.0024 22

ţelor divizate se poate dezvolta imediat un polinom de interpolare inegal distribuite. De exemplu, polinomul de interpolare Newton care trece

604 - 0,2640(x-0,4)-0,2044(x-0,4)(x-0,7) unde s-au utilizat val ia a treia.

5.4

Tabloul diferente i x[i] f[ 0 0.1000 0.9975 -0.0748 - 1 0.2000 0.9900 -0.1481 -0.2318 0.0342 0.01 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 diferenNewton în puncte 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,9

orile x2 = 0,4, x3 = 0,7 şi diferenţele divizate situate pe lin

Interpolare spline cubică

5.4.1 Explicaţii ă interpolarea spline cubică pentru un set de date de forma (xi, fi), i =

de puncte minus 1. Vectorul xa conţine valorile abscisei în care urmează să se

a) spline cubic natural (S"(x0) = S"(xn) = 0) sau

Acest program realizeaz0,1,...,n. Abscisele xi se declară în vectorul x, valorile f, în vectorul a iar constanta n este egală cu numărul calculeze valorile funcţiei prin interpolare spline. Utilizatorul are posibilitatea să aleagă una din următoarele două condiţii la limită:


30

de ordinul unu l de date.

onstruieşte un interpolant spline cubic S pentru funcţia f, definit în punctele x0 < x1 <...< xn şi

f(xi) pentru i = 0,1,...,n sau se introduc valorile ai = elar

j j - xj) + cj(x - xj)2 + dj(x - xj)3 pentru xj < x < xj+1) Pa

b) spline cubic condiţionat la extremităţi care impune cunoaşterea derivatelor în punctele x0 şi xn ale funcţiei care a generat setu

5.4.2 Algoritm spline cubic natural Cîndeplinind condiţiile S"(x0) = S"(xn) = 0 DATE DE INTRARE:

• n, x0,x1,…,xn. Se generează ai =0,1,…,n date tab

DATE DE IEŞIRE: • aj, bj, cj, dj pentru j = 0,1,...,n-1

a + b (x(Obs : S(x) = Sj(x) =sul 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. (P olvă un sistem liniar tridiagonal)

0 ; μ0 = 0; z0

aşii 3,4,5 şi parţial Pasul 6 rez

l = 1 = 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Ă

- aj)/hj - hj(cj+1 + 2cj)/3 ; dj = (cj+1 - cj)/(3hj) cj = zj - μjcj+1; bj = (aj+1

Pasul 7. PENTRU j = 0,1,...,n-1SCRIE (aj, bj, cj, dj) STOP

onstruieşte un interpolant spline cubic S pentru funcţia f, definit în punctele x0 < x1 <...< xn şi

tru i = 0,1,...,n sau se introduc valorile ai = elar.

) DA

-1 j j j) + cj(x - xj)2 + dj(x - xj)3 pentru xj < x < xj+1)

Pa

5.4.3 Algoritm spline cubic condiţionat la extremităţi Cîndeplinind condiţiile S'(x0) = f'(x0) şi S'(xn) = f'(xn) DATE DE INTRARE:

• n, x0,x1,…,xn. Se generează ai = f(xi) pen0,1,…,n date tab

• D0 = f'(x ), DN = f'(x0 nTE DE IEŞIRE: • aj, bj, cj, dj pentru j = 0,1,...,n

a + b (x - x(Obs : S(x) = Sj(x) =sul 1. PENTRU i = 0,1,...,n-1 CALCULEAZĂ hi = xi+1 - xi

Pasul 2. CALCULEAZĂ


31

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

Pasul 3. PENTRU i = 1,2,...,n-1 CALCULEAZĂ ) + ai-1hi] α = 3[ai+1hi-1 - ai(xi+1 - xi-1

i hi-1hi

Pasul 4. (P r 7 olvă un sistem liniar tridiagonal)

0 h0; μ0 = 0,5 α0/l0

aşii 4,5,6 şi pa ţial Pasul rez

l = 2 ; z0 =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

cn = zn ENTRU

Pasul 6. ln = hn-1(2 - μn-1); zn = (αn - hn-1zn-1)ln; Pasul 7. P j = n-1,n-2,... ,0 CALCULEAZĂ

j)/ (cj+1 j) cj = zj - μjcj+1; bj = (aj+1 - a hj - hj(cj+1 + 2cj)/3 ; dj = - cj)/(3hPasul 8. PENTRU j = 0,1,...,n-1SCRIE (aj, bj, cj, dj) STOP

extremităţi /Program IntSpline - MN pg 157;

5.4.4 Programul spline cubic natural sau condiţionat la //* 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);


32

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 -a[j])/h[j h[j]*(c[j++1] ]- 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) {


33

j); printf("\nj= %d in afara domeniului", break; } aux=xa[k]-x[j]; =a[j]+b[j]*aux+c[j]*pow(aux,2)+d[j]*pow(auxs[k] ,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 T 0astati: - daca specificati derivatele de ordinul unu la extremitati sau,

cubic natural:0 ea derivatei de ordinul unu

] .00145 -0.18146

299 -0.15433

x)

0.64290 -0.00011

1 - pentru spline i valoarIntroducet

la extremitatea din stinga: 1 rdinul unu Introduceti valoarea derivatei de o

la extremitatea din dreapta: 1 Interpolare spline cubica

c[i] d[i i a[i] b[i] 0 0.00000 1.00000 0

1 0.09983 0.99485 -0.05 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(

0.00000 0.00000 0.00000 0.00000 0.69813 0.64279

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


34

tele de ordinul unu la extremitati sau, 1

terpolare spline cubica

00 -0.17630 0.09983 0.99480 -0.05289 -0.15440

035 -0.06634

x)

0.64290 -0.00011 1.39626 0.98481 0.98427 0.00053

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 deriva 1 - pentru spline cubic natural: In i a[i] b[i] c[i] d[i] 0 0.00000 1.00009 0.000 1 2 0.70711 0.70472 -0.37 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( 0.00000 0.00000 0.00000 0.00000 0.69813 0.64279 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

ulare

5.5.3 Programul

5.5.4 Exemplu r

Cuadratura numerică

35

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:

⌡⌠a

bf(x) dx = αh[w0f0 + w1f1 + … + wnfn] + E (4.22)

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 = 0,

1,…n E

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/518400 h9 fviii

8 8/14175 989 5888 -928 10496 -4540

10496 -928

-2368/467775 h11 fx

5888 989


36

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;


37

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

Am ales ca exemplu de rulare a programului integrala I = ⌡⌠0

2sin(x) dx care a fost rezolvată

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:


38

⌡⌠a

bf(x) dx = αh[w0f0 + w1f1 + … + wn+2fn+2] + E (4.23)

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 = 0,1

,...,n+2 E

3/2 0 1 1 0 1/4 h3 f" 4/3 0 2 -1 2 0 28/90 h5 fiv5/24 0 11 1 1 11 0 95/144 h5

fiv 6/20 0 11 -

14 26 -14 11 0 41/140 h7

fiv 7/1440 0 611 -

453

562 562 -453 611 0 5257/8640 h7 fiv

8/945 0 460 -954

2196 -2459 2196 -954

460 0 3956/14175 h9 fviii

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;


39

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

Am ales ca exemplu de rulare aceeaşi integrală ca şi la programul 4.1.: I = ⌡⌠0

2sin(x) dx care a

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.


40

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;


41

;i<15;i++) for(i=1{ 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.5 Cuadratura funcţiilor cu singularităţi

6.6 Integrale duble

Rezolvarea ecuaţiilor neliniare

42

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:


43

• a, b {capetele intervalului} • ε {eroarea maximă admisibilă}


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}


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


44

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;


45

} 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


46

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.0Metoda bisectiei: solutia x= 0.73877 din 12 pasi

0066; f(x)= -0.00053

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.Metoda secantei: solutia x= 0.73909 din 19 pasi

00000; f(x)= 0.00000

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Ă


47

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;


48

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

INTEGRAREA ECUAŢIILOR DIFERENŢIALE ORDINARE

49

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];

INTEGRAREA ECUAŢIILOR DIFERENŢIALE ORDINARE

50

hh/=2; func(x); for(i=0;i<n;i++) yy[i]=y0[1]+hh*f1[i]; }


Diverse

51

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À0(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À1(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À2(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À3(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Ài(A1,...,Ak,B) 2[X0,i.(A1.X1,1+...+Ak.X1,k +B-Y1)+...+Xn,i.(A0.Xn,1+...+Ak.Xn,k +B-Yn)] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

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

52

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.

metode numerice - laborator - lab.pdf · sisteme de ecuaţii liniare - metode directe 7 2. sisteme...

Documents