Tehnici de Programare Master

3
TEHNICI DE PROGRAMARE N C
3.2 Structura programului. Functii

Un program C colectie de functii.
Functia main este obligatorie controleaza ntreaga executie a programului.
Concepte de construire a aplicatiilor stiintifice:
modularizarea descompunerea programului n unitati de program (functii sau
subrutine), care interactioneaza doar prin intermediul unor interfete clar definite
(liste de argumente).
ncapsularea controlul domeniului de vizibilitate al obiectelor n afara unitatilor
de program n care acestea sunt declarate.
Modularizare judicioas
a creste lizibilitatea programului, simplifica depanarea si
modificarea, face posibila reutilizarea functiilor de interes general n alte programe (construirea bibliotecilor de subrutine).
Modularizare excesiv
a programe disfunctionale si ineficiente.
Exemplu factorialul unui numar natural

Codificare cu variabile globale:
#include <stdio.h>
float f;
int n;
/* variabile globale */
/*=========================================================================*/
void Factorial(void)
{
int i;
f = 1.0;
for (i=2; i<=n; i++) f *= i;
}
/*=========================================================================*/
void main()
{
printf("n = "); scanf("%i",&n);
Factorial();
printf("factorial = %g\n",f);
}
Variabilele globale f si n pot fi modificate de orice functie a programului pot rezulta

efecte colaterale greu de controlat (nu este n spiritul programarii modulare).
Implementarea optim
a:
#include <stdio.h>
/*=========================================================================*/
float Fact(int n)
/*--------------------------------------------------------------------------Returneaza factorialul numarului intreg n (rezultat de tip float)
---------------------------------------------------------------------------*/
{
float f;
int i;
f = 1.0;
for (i=2; i<=n; i++) f *= i;
return f;
}
/*=========================================================================*/
void main()
{
int n;
printf("factorial = %g\n",Fact(n));
}
Functia Fact primeste valoarea n prin lista de argumente si returneaza factorialul prin
nume comunica strict prin antet.
Implementare folosind recursivitatea:

/*=========================================================================*/
float Fact(int n)
/*--------------------------------------------------------------------------Returneaza factorialul numarului intreg n utilizand recursivitatea
---------------------------------------------------------------------------*/
{
return ((n > 1) ? n * Fact(n-1) : 1.0);
}
Orice autoapel provoaca stocarea n heap (pe stiva) a unui nou set al variabilelor locale.
Trebuie asigurata iesirea din recursivitate n ordine inversa a nivelelor.
Eficienta scazuta.
3.4 Pointeri si liste de argumente

Pointer tip special de variabila, care are ca valori adrese.
&x
&x
FIGURA 3.1. Pointerii contin adresele variabilelor catre care pointeaza.
Pointerii pot fi utilizati pentru a face referire la variabile prin intermediul adreselor.
Operatorul adres
a & adresa unui obiect din memorie:
p = &x;
atribuie pointerului p adresa variabilei x p pointeaza catre x.

Operatorul de indirectare * acceseaza obiectul catre care pointeaza pointerul
*p reprezinta valoarea variabilei x.
Sintaxa declaratiei unui pointer: tip *nume .
tip indica tipul de variabile catre care poate sa pointeze pointerul respectiv (informatie
esentiala n procesul de indirectare).
int *p;
pointerul p pointeaza catre variabile de tip int.

Operatii cu pointeri:
Incrementarea unui pointer (p++) adresa urmatoarei locatii de memorie.
Decrementare (p--) adresa locatiei de memorie anterioare.
Incrementarea variabilei catre care pointeaza pointerul: ++(*p).
Utiliz
ari importante ale pointerilor n programarea stiintifica:
mecanismul returnarii variabilelor din functii prin lista de argumente
alocarea dinamica de memorie pentru tablouri.
Returnarea variabilelor din functii prin lista de argumente

n C argumentele functiilor sunt transmise prin valoare numai catre functia apelata.:
Functie apelanta date Functie apelata
Functia apelata nu poate modifica direct variabile din functia apelanta si deci sa returneze
valori.
Exemplu: functia Swap ar trebui sa interschimbe valorile celor doua argumente:
/*=========================================================================*/
void Swap(float x, float y)
/* nu returneaza nimic */
{
float temp;
temp = x;
x = y;
y = temp;
}
/*=========================================================================*/
void main()
{
float a, b;
...........
Swap(a,b);
...........
}
La intrare n Swap ax si by se interschimba nsa doar copii ale lui a si b.

Pentru ca Swap sa opereze direct asupra variabilelor a si b, trebuie sa primeasca adresele
lor, &a si &b:
/*=========================================================================*/
void Swap(float *x, float *y)
{
float temp;
temp = *x;
*x = *y;
*y = temp;
}
/*=========================================================================*/
void main()
{
float a, b;
...........
Swap(&a,&b);
...........
}
n Swap se opereaza asupra valorilor variabilelor a si b din programul principal prin

indirectarea pointerilor x si y.
5
3.5 Alocarea dinamica a tablourilor

Strnsa legatura ntre tablouri si pointeri orice operatie asupra elementelor unui tablou
poate fi realizata si cu ajutorul unui pointer.
int a[10];
defineste un tablou 10 locatii consecutive de memorie a[0], a[1],... ,a[9] (oset nul).
Tabloul a este alocat static, n faza de compilare a programului.
Prin definitie:
a
&a[0]
a[0]
a[1]
a[9]
&a[0]
FIGURA 3.2. Numele unui tablou este un pointer care contine adresa primului element al
tabloului.
Conform aritmeticii pointerilor:

a+1 echivalent cu &a[1] *(a+1) echivalent cu a[1]
a+i echivalent cu &a[i] *(a+i) echivalent cu a[i]
(compilatorul C face intern automat conversia).
Alocarea dinamic
a a tablourilor de oset arbitrar si lungime arbitrara:
W.H. Press, S.A. Teukolsky, W.T. Vetterling si B.P. Flannery, Numerical Recipes in C:
The Art of Scientific Computing (Cambridge University Press, Cambridge, 1992).
Functia malloc definita n stdlib.h
void *malloc((size_t) n)
returneaza un pointer catre un bloc contiguu neinitializat de n octeti din heap, sau NULL
daca cererea nu poate fi satisfacuta datorita indisponibilitatii n heap a unui bloc contiguu
de dimensiunea ceruta.
size_t tipul utilizat de limbajul C pentru dimensiunea obiectelor din memorie
(size_t) n conversia lui n la tipul size_t.
Pentru a returna un pointer catre un bloc de n componente de tipul float:
(float*) malloc((size_t) (n*sizeof(float)));
sizeof(tip ) returneaza lungimea n octeti a reprezentarii interne a tipului tip .

(float*) conversia pointerul ntr-un pointer catre locatii de tip real.
6
Alocarea dinamica n heap a unui bloc de n locatii reale:

float *Vector(int n)
{
float *p;
p = (float*) malloc((size_t) (n*sizeof(float)));
if (!p) {
printf("Vector: eroare de alocare !\n");
exit(1);
}
return p;
}
Context tipic de utilizare:

int i, n;
float *a;
n = . . . ;
a = Vector(n);
/* numele matricii este declarat ca pointer */

/* a devine pointer catre blocul alocat */
for (i=0; i<=n-1; i++) a[i] = . . . ;
/* a este folosit ca tablou */
Alocarea dinamica a unui tablou de oset imin, cu indicii ntre imin si imax:
numarul relevant de componente este imax-imin+1
prin atribuirea a=Vector(...), originea blocului alocat este asociata lui a[0], nu
lui a[imin] cum ar trebui trebuie sa se returneze o adresa anterioara cu imin
locatii fata de originea reala a blocului
/*=========================================================================*/
float *Vector(int imin, int imax)
/*--------------------------------------------------------------------------Aloca memorie pentru un vector cu componente de tip float, cu indicii in
intervalul [imin,imax]
---------------------------------------------------------------------------*/
{
float *p;
p = (float*) malloc((size_t) ((imax-imin+1)*sizeof(float)));
if (!p) {
printf("Vector: eroare de alocare !\n");
exit(1);
}
return p - imin;
}
Functie pereche pentru a elibera blocul din heap alocat de functia Vector.
/*=========================================================================*/
void FreeVector(float *p, int imin)
/*--------------------------------------------------------------------------Dealoca memoria alocata de functia Vector pentru un vector cu componente de
tip float cu offsetul imin
---------------------------------------------------------------------------*/
{
free((void*) (p+imin));
}
Context tipic de utilizare (nu trebuie folosite componentele a[0],..., a[imin-1]):

int i, imin, imax;
float *a;
imin = . . . ;
imax = . . . ;
a = Vector(imin,imax);
for (i=imin; i<=imax; i++) a[i] = . . . ;
FreeVector(a,imin);
Tablouri bidimensionale
Numele unui tablou bidimensional este un pointer catre un tablou de pointeri de linie,
fiecare dintre acestia indicnd primul element din linia corespunzatoare.
a
&a[0]
a[0]
&a[0][0]
a[0][0]
a[0][1]
a[0][2]
a[0][3]
a[1][0]
a[1][1]
a[1][2]
a[1][3]
a[2][0]
a[2][1]
a[2][2]
a[2][3]
a[1]
&a[1][0]
a[2]
&a[2][0]
FIGURA 3.3. Schema de stocare n memorie a unei matrici 3 4. Numele tabloului este un
pointer catre un tablou de pointeri de linie.
Declaratia tabloului: float **a.

Referirea la tablou n ansamblu a.
Referirea la o ntreaga linie a[i].
Referirea la un element a[i][j].
Functia Matrix aloca un tablou bidimensional cu elemente reale:

/*=========================================================================*/
float **Matrix(int imin, int imax, int jmin, int jmax)
/*--------------------------------------------------------------------------Aloca memorie pentru o matrice cu componente de tip float, cu indicii de
linie in intervalul [imin,imax] si indicii de coloana in intervalul
[jmin,jmax]
---------------------------------------------------------------------------*/
{
int i, ni = imax-imin+1, nj = jmax-jmin+1;
float **p;
/* aloca pointerul catre pointerii de linie */
p = (float**) malloc((size_t)(ni*sizeof(float*)));
if (!p) {
printf("Matrix: eroare de alocare de nivel 1 !\n");
exit(1);
}
p -= imin;
/* aloca pointerul pentru prima linie */
p[imin] = (float*) malloc((size_t)(ni*nj*sizeof(float)));
if (!p[imin]) {
printf("Matrix: eroare de alocare de nivel 2 !\n");
exit(2);
}
p[imin] -= jmin;
/* aloca pointerii pentru restul liniilor */
for (i = imin+1; i <= imax; i++) p[i] = p[i-1] + nj;
return p;
}
Functia pereche care elibereaza blocul de memorie alocat:

/*=========================================================================*/
void FreeMatrix(float **p, int imin, int jmin)
/*--------------------------------------------------------------------------Dealoca memoria alocata de functia Matrix pentru o matrice avand componente
de tip float, cu offsetul de linie imin si offsetul de coloana jmin
---------------------------------------------------------------------------*/
{
free((void*) (p[imin]+jmin));
free((void*) (p+imin));
}
Context tipic de utilizare:

int i, imin, imax, j, jmin, jmax;
float **a;
imin = . . . ; imax = . . . ;
jmin = . . . ; jmax = . . . ;
a = Matrix(imin,imax,jmin,jmax);
for (i=imin; i<=imax; i++)
for (j=jmin; j<=jmax; j++)
a[i][j] = . . . ;
FreeMatrix(a,imin,jmin);
Fisierul header memalloc.h contine functii de alocare si dealocare pentru tablouri uni- si
bidimensionale pentru tipuri uzuale.
9
3.6 Operatii simple cu matrici

(A B)T BT AT = 0,
#include <stdio.h>
#include "memalloc.h"
/*=========================================================================*/
void MatRead(float **a, int n, int m)
/*--------------------------------------------------------------------------Citeste de la tastatura componentele matricii a[][], cu n linii si m coloane
---------------------------------------------------------------------------*/
{
int i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
printf("[%i][%i]=",i,j); scanf("%f",&a[i][j]);
}
}
/*=========================================================================*/
void MatPrint(float **a, int n, int m)
/*--------------------------------------------------------------------------Tipareste pe ecran componentele matricii a[][], cu n linii si m coloane
---------------------------------------------------------------------------*/
{
int i, j;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) printf("%10.2e",a[i][j]);
printf("\n");
}
}
/*=========================================================================*/
void MatTrans(float **a, int n)
/*--------------------------------------------------------------------------Inlocuieste matricea patrata a[][] de ordinul n cu transpusa ei
---------------------------------------------------------------------------*/
{
float t;
int i, j;
for (i = 1; i <= n-1; i++)
for (j = i+1; j <= n; j++) {
t = a[i][j]; a[i][j] = a[j][i]; a[j][i] = t;
}
}
/*=========================================================================*/
void MatDiff(float **a, float **b, float **c, int n, int m)
/*--------------------------------------------------------------------------Calculeaza diferenta matricilor a[][] si b[][] cu n linii si m coloane si o
returneaza in matricea c[][]
---------------------------------------------------------------------------*/
{
int i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) c[i][j] = a[i][j] - b[i][j];
}
/*=========================================================================*/
void MatProd(float **a, float **b, float **c, int l, int m, int n)
10
/*--------------------------------------------------------------------------Calculeaza produsul dintre matricea a[][] cu l linii si m coloane si matricea

b[][] cu m linii si n coloane, si returneaza rezultatul in matricea c[][]
---------------------------------------------------------------------------*/
{
float t;
int i, j, k;
for (i = 1; i <= l; i++)
for (j = 1; j <= n; j++) {
t = 0.0;
for (k = 1; k <= m; k++) t += a[i][k] * b[k][j];
c[i][j] = t;
}
}
/*=========================================================================*/
void main()
/*--------------------------------------------------------------------------Verifica identitatea matriciala (A B)_trans = B_trans A_trans
---------------------------------------------------------------------------*/
{
float **a, **b, **c, **d;
int n;
a
b
c
d
=
=
=
=
Matrix(1,n,1,n);
Matrix(1,n,1,n);
Matrix(1,n,1,n);
Matrix(1,n,1,n);
/* aloca matricile */
printf("matricea a\n");
MatRead(a,n,n);
printf("matricea b\n");
MatRead(b,n,n);
/* citeste matricile */
MatProd(a,b,c,n,n,n);
MatTrans(c,n);
/* (A B)_trans */
MatTrans(a,n);
MatTrans(b,n);
MatProd(b,a,d,n,n,n);
/* B_trans A_trans */
MatDiff(c,d,d,n,n);
MatPrint(d,n,n);
/* (A B)_trans - B_trans A_trans */
FreeMatrix(a,1,1);
FreeMatrix(b,1,1);
FreeMatrix(c,1,1);
FreeMatrix(d,1,1);
/* dealoca matricile */
11
Bibliography
[1] W.H. Press, S.A. Teukolsky, W.T. Vetterling si B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Second Edition (Cambridge University Press,
Cambridge, 1992).
[2] B.W. Kernighan si D.M. Ritchie, The C Programming Language, Second Edition
(Prentice-Hall, Englewood Clis, NJ, 1988).
[3] E. Yourdon, Techniques of Program Structure and Design (Prentice-Hall, Englewood
Clis, NJ, 1975).
5
S
ELEMENTE DE GRAFICA
TIIN
TIFICA
5.1 Dispozitive grafice

dispozitive cu reprezentare discreta (prin puncte) monitoare si imprimante
dispozitive cu reprezentare continua plotter.
Monitoare
Pixel (picture element) elementul grafic de baza.
Imagine raster senzatia vizuala de ansamblu creata de pixeli reprezentarea desfasurata (maparea) memoriei grafice.
Imagine monocrom starea 1/0 a unui bit starea aprins/stins a unui pixel.
Imagine color 8, 16, 24, 32 biti/pixel informatia de culoare, luminozitate etc.
Rezolutia m n nr. maxim de pixeli pe directia orizontala verticala
Rezolutia marimea memoriei grafice (640 480, 800 600, 1024 768, 1200 1024,
1600 1200).
Imprimante
Imprimante cu jet de cerneala imprimare (lenta) linie-cu-linie, memorie proprie mica.
Imprimante laser imprimare (rapida) pe ntregul suport, memorie mare, limbajul PS.
Rezolutia n dpi nr. maxim de puncte pe inch (dots per inch).
Rezolutii tipice: 300, 600, 1200 dpi (Hewlett-Packard) sau 360, 720, 1440 dpi (Cannon).
Plotter
Sistem de motoare pas-cu-pas care realizeaza deplasarea pe directiile x si y.
Sistem electric care comanda ridicarea/coborrea/schimbarea penitelor.
Avantajos reprezentari color de dimensiuni mari la rezolutii foarte mari.
5.2 Functii grafice ale mediului Borland C++

Fisierul header GRAPHICS.H biblioteca cu peste 80 de functii grafice elementare
utilizare simpla n aplicatii DOS.
Interfata grafica BGI (Borland Graphics Interface); driver grafic uzual EGAVGA.BGI.
(0,0)
(getmaxx(),0)
(x,y)
(0,getmaxy())
(getmaxx(),getmaxy())
FIGURA 5.1. Sistemul coordonatelor ecran al interfetei grafice BGI.
Coordonatele ecran
Ecranul grafic zona dreptunghiulara cu originea n coltul stnga-sus.
Valoarea coordonatei ecran x (pe directia orizontala) creste spre dreapta.
Valoarea coordonatei ecran y (pe directia verticala) creste de sus n jos.
Valorile maxime ale coordonatelor ecran functiile getmaxx() si getmaxy().
Functiunile grafice deplasarea cursorului grafic pe ecran analog unui creion pe hrtie.
void far cleardevice(void);
void far closegraph(void);
int far getmaxx(void);
int far getmaxx(void);
void far initgraph(int far *driver, int far *mode, char far *path);
void far line(int x1, int y1, int x2, int y2);
void far lineto(int x, int y);
void far moveto(int x, int y);
void far outtextxy(int x,int y,char far *textstring);
void far rectangle(int left, int top, int right, int bottom);
void far settextjustify(int horiz, int vert);
void far settextstyle(int font, int direction, int charsize);
2
5.3 Reprezentarea functiilor de o variabila

Se cere reprezentarea grafica a unei functii:
f : [xmin , xmax ] [ymin , ymax ],
data sub forma tabelara:
f (xi ) = yi , i = 1, 2, ..., n.
y
y max
yn
ymax
y1
(xi ,yi )
(xi ,yi )
ymin
xmin
y min
xmin
xmax
xmax x
FIGURA 5.2. Corespondenta dintre coordonatele utilizator (xi , yi ) si coordonatele ecran (

xi , yi )
este liniara.
Nu pot fi utilizate direct coordonate utilizator, (xi , yi ), ca argumente pt. functiile

grafice.
Trebuie transformate n coordonate ecran, (
xi , yi ), prin scalare cu o relatie liniara
(reprezentare proportionata):
x = Ax x + Bx ,
y = Ay y + By .
Coeficientii de scalare (Ax , Bx , Ay , By ):
Ax = (
xmin = Ax xmin + Bx ,
xmax xmin )/(xmax xmin )
xmax = Ax xmax + Bx ,
Bx = xmin Ax xmax .
ymin = Ay ymin + By ,
ymax ymin )/(ymax ymin )
Ay = (
ymax = Ay ymax + By ,
By = ymin Ay ymin .
Asimetrie n tratarea axelor x si y coordonatele yi nu sunt ordonate.

Coordonatele ecran corespunzatoare celor n puncte de tabelare:
xi = Ax xi + Bx , i = 1, 2, ..., n
yi = Ay yi + By .
/*------------------------------- graphlib.h ------------------------------*/

/*--------------------------------------------------------------------------Contine rutine pentru realizarea pe display a graficelor functiilor de
o variabila utilizand biblioteca grafica BGI a mediului Borland C++
---------------------------------------------------------------------------*/
#ifndef GRAPHLIB
#define GRAPHLIB
#include <graphics.h>
/*=========================================================================*/
void InitGraph(void)
/*--------------------------------------------------------------------------Initializeaza modul grafic
---------------------------------------------------------------------------*/
{
int gdriver = DETECT, gmode;
initgraph(&gdriver,&gmode,"c:/progra~1/borlandc/bgi");
}
/*=========================================================================*/
void Plot0(float x[], float y[], int n,
float fxmin, float fxmax, float fymin, float fymax)
/*--------------------------------------------------------------------------Realizeaza reprezentarea grafica a unei functii tabelate de o variabila si o
incadreaza in fereastra [fxmin,fxmax] x [fymin,fymax], specificata prin
coordonate fractionare din intervalul [0,1]
x[]
- abscisele punctelor
y[]
- ordonatele punctelor
n
- numarul punctelor
fxmin - abscisa relativa minima a ferestrei (0 < fxmin < fxmax< 1)
fxmax - abscisa relativa maxima a ferestrei
fymin - ordonata relativa minima a ferestrei (0 < fymin < fymax < 1)
fymax - ordonata relativa maxima a ferestrei
---------------------------------------------------------------------------*/
{
#define Nint(x) (int)floor(x + 0.5)
float ax, bx, ay, by, xmin, xmax, ymin, ymax;
int i, ixmin, ixmax, iymin, iymax;
/* coordonatele ferestrei */
ixmin = Nint(fxmin*getmaxx()); iymin = Nint((1.0-fymin)*getmaxy());
ixmax = Nint(fxmax*getmaxx()); iymax = Nint((1.0-fymax)*getmaxy());
rectangle(ixmin,iymax,ixmax,iymin);
/* chenarul */
xmin = x[1]; xmax = x[n];
ax = (ixmax-ixmin)/(xmax-xmin);
bx = ixmin - ax*xmin;
/* AXA X */
/* coeficienti de scalare */
ymin = y[1]; ymax = y[1];

/* AXA Y
for (i=2; i<=n; i++) {
/* ymin si ymax
if (ymin > y[i]) ymin = y[i];
if (ymax < y[i]) ymax = y[i];
}
if (ymin == ymax) { ymin *= 0.9; ymax *= 1.1; }
ay = (iymax-iymin)/(ymax-ymin);
/* coeficienti de scalare
by = iymin - ay*ymin;
/* traseaza axele
if (xmin*xmax < 0) line(Nint(bx),iymin,Nint(bx),iymax);
if (ymin*ymax < 0) line(ixmin,Nint(by),ixmax,Nint(by));
/* uneste punctele reprezentarii
moveto(Nint(ax*x[1]+bx),Nint(ay*y[1]+by));
/* primul punct
for (i=2; i<=n; i++) lineto(Nint(ax*x[i]+bx),Nint(ay*y[i]+by));
}
#endif
*/
*/
*/
*/
*/
*/
Functiei Plot0 i se transmit coordonatele relative ale colturilor ferestrei de desenare.

Coordonatele ecran absolute cu ajutorul functiilor getmaxx() si getmaxy().
Directiva #ifndef GRAPHLIB permite includerea fisierului o singura data ntr-o aplicatie.
Exemplu de utilizare a functiei Plot0:
/*--------------------------------------------------------------------------Reprezentarea grafica a unei functii de o variabila
---------------------------------------------------------------------------*/
#include
#include
#include
#include
#include
<stdio.h>
<conio.h>
<math.h>
"memalloc.h"
"graphlib.h"
/*=========================================================================*/
float Func(float x)
{
return pow(x,3) * exp(-x);
}
/*=========================================================================*/
void main()
{
float h, xmin, xmax, *x, *y;
int i, n;
printf("xmin = "); scanf("%f",&xmin);
printf("xmax = "); scanf("%f",&xmax);
printf("n
= "); scanf("%i",&n);
x = Vector(1,n);
y = Vector(1,n);
h = (xmax-xmin)/(n-1);
for (i=1; i<=n; i++) {
x[i] = xmin + (i-1)*h;
y[i] = Func(x[i]);
}
InitGraph();
Plot0(x,y,n,0.2,0.8,0.2,0.8);
getch();
closegraph();
FreeVector(x,1);
FreeVector(y,1);
}
FIGURA 5.3. Reprezentarea grafica a functiei x3 ex cu ajutorul functiei Plot0 (xmin=-0.8,

xmax=7.8 si n=51).
Functie mai elaborata n fisierul GRAPHLIB.H:

/*=========================================================================*/
void Plot(float x[], float y[], int n, int style,
float fxmin, float fxmax, float fymin, float fymax,
char xtext[], char ytext[], char title[])
/*---------------------------------------------------------------------------
Apelul concret:
Plot(x,y,n,1,0.2,0.8,0.2,0.8,"x","x^3 * exp(-x)","2D Plot");
FIGURA 5.4. Reprezentarea grafica a functiei x3 ex cu ajutorul functiei Plot.
Bibliography
[1] Borland International, Inc., Borland C++ 3.1 Programming Guide (Borland International, Scotts Valley, CA, 1992).
[2] Microsoft Corporation, Microsoft Visual C++ 1.0 Programmers Guide (Microsoft
Corporation, 1993).
[3] T.A. Beu, Analiza numerica n Turbo Pascal (Microinformatica, Cluj-Napoca, 1992).
7
ECUA
TII ALGEBRICE S
I TRANSCENDENTE
7.1 Separarea radacinilor

f (x) = 0
Ecuatie algebric
a daca f (x) este polinom.
Ecuatia transcendent
a n caz contrar.
R
ad
acin
a aproximativ
a valoare 0 apropiata de valoarea exacta .
Definitii neechivalente:
numarul 0 cu proprietatea | 0 | < ( > 0)
numarul 0 cu proprietatea |f ( 0 )| < .
f( 0)
f( 0)
0
(a)
(b)
FIGURA 7.1. Cazuri de radacini aproximative care nu satisfac simultan criteriile | 0 | < si
|f ( 0 )| < .
Determinarea r
ad
acinilor reale:
1. separarea r
ad
acinilor stabilirea unei partitii xmin = x1 , x2 , . . . , xM = xmax
orice [xm , xm+1 ] sa contina cel mult o radacina;
2. calculul r
ad
acinilor separate prin procedee iterative de rafinare.
Teorema 7.1 Daca o functie continua f (x) admite valori de semn opus la capetele unui
interval [a, b], adica f (a)f (b) < 0, atunci acel interval contine cel putin o radacina
a
ecuatiei f (x) = 0.
f(b )
f(b)
f(a)
a
b
f(a)
(a)
(b)
FIGURA 7.2. Exemple de radacini neseparate.
Separarea r
ad
acinilor:
Determinarea semnelor functiei f (x) n punctele unei partitii {xm }.
Daca [xm , xm+1 ] sunt suficient de mici, fiecare subinterval va contine cel mult o
radacina.
n intervalele cu f (xm )f (xm+1 ) > 0 nu va exista nici o radacina.
n intervalele cu f (xm )f (xm+1 ) 0 va exista o singura radacina.
7.2 Metoda bisectiei (metoda njumatatirii)

Fie f (x) continua pe [a, b] si fie ecuatia:
f (x) = 0.
Presupunem ca n urma separarii radacinilor exista cel mult o radacina [a, b].
mpartim [a, b] n mod repetat n parti egale, pastrnd semiintervalul [ai , bi ] la capetele
caruia functia are semne opuse.
y
f(a0)
x0
b = b0
x
a = a0
f(a1)
a1
b1
x
x1
f(b1)
f(a2)
b2
x
a2
f(b2)
FIGURA 7.3. Procesul de njumatatire a intervalului de cautare n cazul metodei bisectiei.
Dupa i pasi rezulta [ai , bi ] astfel nct

f (ai )f (bi ) < 0.
Lungimea intervalului [ai , bi ] este:
bi ai =
ba
.
2i
njumatatind [ai , bi ] prin

ai + bi
2
rezulta fie radacina exacta = xi , fie un nou interval [ai+1 , bi+1 ].
xi =
Procesul se ncheie, considernd ca radacina aproximativa 0 = xi , cnd
bi ai
sau
|f (xi )| .
xi
3
/*---------------------------- Metoda bisectiei ---------------------------*/

#include <stdio.h>
#include <math.h>
/*=========================================================================*/
float func(float x)
{
return (x+2)*(x+1)*x*(x-1)*(x-2);
}
/*=========================================================================*/
int Bisect(float Func(float), float a, float b, float *x)
/*--------------------------------------------------------------------------Determina un zero real al unei functii reale prin metoda bisectiei
Func - functia utilizator
a, b - limitele intervalului de cautare
*x
- zeroul gasit (iesire)
Returneaza indicele de eroare: 0 - executie normala
1 - nr. maxim de iteratii depasit
2 - intervalul nu contine o radacina
---------------------------------------------------------------------------*/
{
const float eps = 1e-6;
/* criteriu relativ de precizie */
const int itmax = 100;
/* nr. maxim de iteratii */
float fa, fx;
int it;
/* zeroul este unul din capete ? */
fa = Func(*x=a); if (fabs(fa) <= eps) return 0;
fx = Func(*x=b); if (fabs(fx) <= eps) return 0;
if (fa*fx > 0) return 2;
/* intervalul nu contine o radacina */
for (it=1; it<=itmax; it++) {
*x = (a + b)/2;
/* noua aproximatie */
fx = Func(*x);
if (fa*fx > 0) a = *x; else b = *x;
/* alege noul interval */
if (((b-a) <= eps*fabs(*x)) || (fabs(fx) <= eps)) return 0;
}
printf("Bisect: nr. maxim de iteratii depasit !\n");
return 1;
}
/*=========================================================================*/
void main()
{
float a, b, h, x, xmin, xmax;
printf("h
= "); scanf("%f",&h);
a = xmin;
while (a < xmax) {
b = a + h;
if ((Bisect(func,a,b,&x) == 0) && (x != b)) printf(" x = %f \n",x);
a = b;
}
}
n main este partitionat intervalul de cautare [xmin , xmax ] n subintervale de lungime h

pentru separarea radacinilor.
7.3 Metoda pozitiei false (metoda corzii)

n general mai eficienta dect metoda bisectiei.
Avantajoasa nsa tot numai pentru determinarea grosiera a radacinilor reale.
y
f(bi )
ai
xi
f(ai )
bi
y = f(x)
FIGURA 7.4. mpartirea intervalului de cautare prin intermediul corzii care uneste punctele
(ai , f (ai )) si (bi , f (bi )) n cazul metodei pozitiei false.
Se nlocuieste functia cu coarda punctul de intersectie xi cu axa absciselor:

xi ai
f (ai )
=
bi ai
f (bi ) f (ai )
xi =
ai f (bi ) bi f (ai )
.
f (bi ) f (ai )
Dupa un anumit numar de pasi:

fie o radacina exacta = xi , astfel nct f (xi ) = 0
fie o secventa de intervale [a0 , b0 ], [a1 , b1 ], . . . , [ai , bi ], . . . cu
ai+1 = ai , bi+1 = xi , daca f (ai )f (xi ) < 0
ai+1 = xi , bi+1 = bi , daca f (ai )f (xi ) > 0,
astfel nct
f (ai+1 )f (bi+1 ) < 0.
/*=========================================================================*/
int FalsPos(float Func(float), float a, float b, float *x)
/*--------------------------------------------------------------------------Determina un zero real al unei functii reale prin metoda pozitiei false
a, b - limitele intervalului de cautare
*x
- zeroul gasit (iesire)
2 - intervalul nu contine o radacina
---------------------------------------------------------------------------*/
{
float dx, fa, fb, fx;
int it;
/* zeroul este unul din capete ? */
fa = Func(*x=a); if (fabs(fa) <= eps) return 0;
fb = Func(*x=b); if (fabs(fb) <= eps) return 0;
if (fa*fb > 0) return 2;
/* intervalul nu contine o radacina */
*x = (a*fb - b*fa)/(fb - fa);
fx = Func(*x);
if (fa*fx > 0) {
/* alege noul interval */
dx = *x - a; a = *x; fa = fx;
} else {
dx = b - *x; b = *x; fb = fx;
}
if ((fabs(dx) <= eps*fabs(*x)) || (fabs(fx) <= eps)) return 0;
}
printf("FalsPos: nr. maxim de iteratii depasit !\n");
return 1;
}
Dupa fiecare partitionare a intervalului se reactualizeaza nu numai capetele intervalului,

ci si valorile corespunzatoare ale functiei, f (ai ) si f (bi ).
7.4 Metoda aproximatiilor succesive

Una dintre metode numerice foarte importante utilizabila pt. rafinarea radacinilor.
Presupunem ca f (x) este continua pe [a, b] si se cere rezolvarea ecuatiei:
f (x) = 0,
Se pune sub forma echivalenta:
x = (x).
Pornind de la aproximatia initiala x0 pentru radacina sirul de aproximatii succesive:
xi+1 = (xi ),
i = 0, 1, 2, . . .
Daca sirul este convergent = lim xi .

Daca (x) este continua = () radacina ecuatiei
y
y
y = (x)
y = (x)
x2 x3
x0
x1
x0
x1
(a)
x2
(b)
y
y = (x)
x2 x0
y = (x)
x1
x3
(c)
x0 x1 x2 x3
(d)
FIGURA 7.5. Procese iterative n metoda aproximatiilor succesive aplicata ecuatiei x = (x)
pentru: a) 1 < 0 (x) < 0; b) 0 < 0 (x) < 1; c) 0 (x) < 1; d) 0 (x) > 1.
Radacina reala pt. x = (x) abscisa punctului de intersectie dintre y = (x) si y = x.

Procesul este convergent (metoda aplicabila) numai n intervalele unde
|0 (x)| < 1.
7
Teorema 7.2 Fie ecuatia

x = (x),
cu functia (x) definita si derivabila pe [a, b]. Daca este satisfacuta inegalitatea
|0 (x)| < 1
pentru orice x [a, b], atunci sirul de iterare definit de relatia
xi+1 = (xi ),
i = 0, 1, 2, . . .
converge ca
tre radacina (unica daca exista) [a, b] a ecuatiei, indiferent de valoarea
initiala x0 .
Cu ct e mai mic , cu att mai rapid converge procesul catre radacina
f (x) = 0 poate fi nlocuita cu ecuatia echivalenta:
x = x f (x) adica (x) = x f (x).
Procesul iterativ:
xi+1 = xi f (xi ),
i = 0, 1, 2, . . .
Conditie de convergenta
:
i |xi /xi+1 | sau |xi | |xi+1 |
Corectia r
ad
acinii:
xi xi+1 xi = f (xi ).
Exemplu:
x ex = 0.
Daca se alege f (x) = x ex
(x) = ex
|0 (x)| = ex < 1.
Procesul converge catre x = 0.567143.
Daca se alege f (x) = ex x
(x) = 2x ex
|0 (x)| = 2 + ex > 1.
Procesul diverge rapid.
/*-------------------- Metoda aproximatiilor succesive --------------------*/

#include <stdio.h>
#include <math.h>
/*=========================================================================*/
float func(float x)
{
return x - exp(-x);
}
/*=========================================================================*/
int Iter(float Func(float), float *x)
/*--------------------------------------------------------------------------Determina un zero real al unei functii reale prin metoda aproximatiilor
succesive
*x
- aproximatie initiala (la intrare), zeroul gasit (la iesire)
2 - proces divergent
---------------------------------------------------------------------------*/
{
float dx, f;
int it;
dx = -Func(*x);
/* initializeaza corectia
f = Func(*x);
if (fabs(f) > fabs(dx)) goto divergent;
/* compara noua corectie
dx = -f;
/* actualizeaza corectia
*x += dx;
/* noua aproximatie
if (fabs(dx) <= eps*fabs(*x)) return 0;
/* testeaza convergenta
}
printf("Iter: nr. maxim de iteratii depasit !\n");
return 1;
*/
*/
*/
*/
*/
divergent:
printf("Iter: proces divergent !\n");
return 2;
}
/*=========================================================================*/
void main()
{
float x;
/* Caz test:
x - exp(-x) = 0, x0 = 0
Zeroul: 0.567143
*/
printf("x0 = "); scanf("%f",&x);
if (Iter(func,&x) == 0) printf("x = %f \n",x);
}
7.5 Metoda lui Newton

Metoda Newton-Raphson sau metoda tangentei eficienta deosebita.
Presupunem f (x) continu
a pe [a, b] si
f (x) = 0
are o radacina reala [a, b], iar f 0 (x) si f 00 (x) sunt continue si p
astreaz
a semnul.
y
y = f(x)
y = f(x)
x0 = a
x2
x1 x0 = b
x1 x
(a)
(b)
FIGURA 7.6. Determinarea aproximatiilor succesive n metoda Newton-Raphson. n cazul (b)

f (x0 )f 00 (x0 ) < 0 si convergenta este mai lenta.
Aproximatie initiala x0 pt. .

Aproximatie mbunatatita x1 ducnd tangenta la y = f (x) n (x0 , f (x0 )):
f 0 (x0 ) =
Procesul iterativ:
f (x0 )
x0 x1
xi+1 = xi
f (xi )
,
f 0 (xi )
x1 = x0
f (x0 )
.
f 0 (x0 )
i = 0, 1, 2, . . .
Functia de iterare:
(x) = x
f (x)
.
f 0 (x)
Conditia de convergenta
(ca n metoda aproximatiilor succesive):
|0 (x)| < 1.
Criteriu de convergenta
:
i |xi /xi+1 | sau |xi | |xi+1 |.
Corectia r
ad
acinii:
xi xi+1 xi = f (xi )/f 0 (xi ).
10
/*=========================================================================*/
int Newton(float Func(float,float *), float *x)
/*--------------------------------------------------------------------------Determina un zero real al unei functii reale prin metoda Newton-Raphson
utilizand derivata analitica
---------------------------------------------------------------------------*/
{
float df, dx, f;
int it;
f = Func(*x,&df);
/* functia si derivata
dx = (fabs(df) > eps) ? -f/df : -f;
/* corectia radacinii
*x += dx;
/* noua aproximatie
/* test convergenta
}
printf("Newton: nr. maxim de iteratii depasit !\n");
return 1;
*/
*/
*/
*/
}
/*=========================================================================*/
int NewtonNumDeriv(float Func(float), float *x)
/*--------------------------------------------------------------------------Determina un zero real al unei functii reale prin metoda Newton-Raphson
utilizand derivarea numerica
---------------------------------------------------------------------------*/
{
float df, dx, f;
int it;
f = Func(*x);
dx = *x ? 1e-4*fabs(*x) : 1e-4;
/* pasul de derivare
df = (Func(*x+dx)-f)/dx;
/* derivata numerica
*x += dx;
/* noua aproximatie
/* test convergenta
}
printf("NewtonNumDeriv: nr. maxim de iteratii depasit !\n");
return 1;
*/
*/
*/
*/
*/
Exemplu:
x ex = 0.
float func(float x, float *df)
{
*df = 1 + exp(-x);
return x - exp(-x);
}
Metoda lui Newton converge

indiferent de semnul lui f (x).
catre radacina x = 0.567143

x
0
x
x 2
n ambele cazuri | (x)| = e (x e )/ (1 + e ) < 1 pentru orice x pozitiv.
Metoda lui Newton converge n general mai rapid dect metoda aproximatiilor succesive.
11
7.6 Metoda secantei

Asemanatoare metodei Newton-Raphson nu necesita evaluarea derivatei functiei.
y
x2 x1
x0 = b
y = f(x)
FIGURA 7.7. Determinarea aproximatiilor succesive n metoda secantei.
Tangenta este aproximata de coarda care uneste punctele pt. doua estimari anterioare.
Dezavantaj radacina nu ramne izolata. Nu este garantata convergenta.
Din formula metodei Newton-Raphson:
xi+1 = xi
f (xi )
,
f 0 (xi )
f 0 (xi )
f (xi ) f (xi1 )
xi xi1
Relatia de recurenta
(implica trei aproximatii succesive ale radacinii):
xi+1 = xi f (xi )
xi xi1
,
f (xi ) f (xi1 )
x1 se poate obtine din x0 aplicnd metoda aproximatiilor succesive:

x1 = x0 f (x0 ),
/*=========================================================================*/
int Secant(float Func(float), float *x)
{
float df, dx, f, f0, x0;
int it;
x0 = *x; f0 = Func(x0);
*x = x0 - f0;
/* prima aproximatie
f = Func(*x);
df = (f-f0)/(*x-x0);
/* derivata aproximativa
x0 = *x; f0 = f;
/* memoreaza abscisa si functia
*x += dx;
/* noua aproximatie
/* test convergenta
}
printf("Secant: nr. maxim de iteratii depasit !\n");
return 1;
}
12
*/
*/
*/
*/
*/
*/
Bibliography
[1] J. Ortega si W. Rheinboldt, Iterative Solution of Nonlinear Equations in Several Variables (Academic Press, New York, 1970).
[2] N.S. Bakhvalov, Numerical Methods (MIR Publishers, Moskow, 1977).
[3] Gh. Dodescu, Metode numerice n algebra
, Editura tehnica, Bucuresti, 1979).
[4] M. Toma si I. Odagescu, Metode numerice si subroutine, Editura tehnica, Bucuresti,
1980).
[5] B.P. Demidovich si I.A. Maron, Computational Mathematics (MIR Publishers,
Moskow, 1981).
[6] R.L. Burden si J.D. Faires, Numerical Analysis, Third Edition (Prindle, Weber &
Schmidt, Boston, 1985).
Cambridge, 1992).
6
EVALUAREA FUNC
TIILOR
6.1 Evaluarea polinoamelor. Schema lui Horner

Polinom de grad n :
P (x) = a0 xn + a1 xn1 + + an1 x + an .
Valoarea pentru x = :
P () = ( ((a0 + a1 ) + a2 ) + + an1 ) + an .
Schema lui Horner:
p0 = a0
pi = pi1 + ai ,
i = 1, 2, . . . , n
P () = pn .
Orice fractie rationala, R(x) = P (x)/Q(x), poate fi evaluata utiliznd schema lui Horner.
/*=========================================================================*/
float Polinom(float x, float a[], int n)
/*--------------------------------------------------------------------------Evalueaza un polinom de ordinul n cu coeficienti reali a[] in punctul x
---------------------------------------------------------------------------*/
{
float p;
int i;
p = a[0];
for (i=1; i<=n; i++) p = p*x + a[i];
return p;
}
6.2 Evaluarea functiilor analitice

f (x) analitica n daca ntr-o vecinatate |x | < R
f (x) = f () +
f ()
f ()
(x ) +
(x )2 +
1!
2!
Suma partiala (polinomul Taylor) de ordinul n:

Fn (x) =
n

f (i) ()
i=0
i!
(x ) =
n
ti (x).
i=0
Estimari practice pentru eroarea absoluta (n) si cea relativa (n) :

tn (x)
(n)
(n)
.
= |tn (x)|, =
Fn (x)
Exemplu functia exponentiala:
xi
x2
e =1+x+
+ =
,
2!
i!
i=0
x
Polinomul Taylor de ordinul n:

Fn (x) =
n
ti (x),
ti (x) =
i=0
xi
.
i!
Schema recurenta:
t0 = 1,
F0 = 1
ti = (x/i) ti1 , Fi = Fi1 + ti ,
i = 1, 2, . . . , n, . . .
Criteriu de oprire:
|tn /Fn | sau |tn | |Fn |.
/*=========================================================================*/
float Exp0(float x)
/*--------------------------------------------------------------------------Evalueaza exponentiala in punctul x din dezvoltarea ei in serie
---------------------------------------------------------------------------*/
{
float f, t;
int i;
i = 1;
f = t = 1.0;
while (fabs(t/f) > eps) {
t *= x/(i++);
f += t;
}
return f;
Pt. x < 0 termenii seriei alternativ pozitivi si negativi acumulare de erori prin scadere.
Definitie convenabila:
|x|
daca x 0
e
x
,
e =
|x|
1/e
daca x < 0
/*=========================================================================*/
float Exp(float x)
/*--------------------------------------------------------------------------Evalueaza exponentiala in punctul x din dezvoltarea ei in serie
---------------------------------------------------------------------------*/
{
float absx, f, t;
int i;
i = 1;
f = t = 1.0;
absx = fabs(x);
while (fabs(t/f) > eps) {
t *= absx/(i++);
f += t;
}
return (x >= 0.0 ? f : 1.0/f);
6.3 Fractii continue

b1 b2
bi
a0 ; , , . . . , , . . .
a1 a2
ai
b1
a0 +
b2
a2 +
ai si bi numere reale, complexe, sau functii.
a1 +
Convergentii fractiei continue:

b1
,
a1
R1 = a0 +
R2 = a0 +
b1
b2
a1 +
a2
,...
Fractia continua este convergent

a daca exista limita
A = lim Ri .
i
Teorema 6.1 (Legea formarii convergentilor) Numerele

Pi = ai Pi1 + bi Pi2 , i = 1, 2, . . .
Qi = ai Qi1 + bi Qi2 ,
cu
P0 = a0 , P1 = 1
Q0 = 1, Q1 = 0
sunt respectiv numaratorii si numitorii convergentilor Ri ai fractiei continue

Ri =
Pi
,
Qi
i = 1, 2, 3, . . .
Demonstratie (metoda inductiei). Pentru i = 1:

R1 =
P1
a1 P0 + b1 P1
b1
=
= a0 +
Q1
a1 Q0 + b1 Q1
a1
Din ipoteza:
Ri =
Pi
ai Pi1 + bi Pi2
=
.
Qi
ai Qi1 + bi Qi2
Ri+1 rezulta din Ri nlocuind ai ai + bi+1 /ai+1 :

Ri+1 =
ai+1 Pi + bi+1 Pi1

Pi+1
=
ai+1 Qi + bi+1 Qi1
Qi+1
Fractiile continue mai rapid convergente dect orice reprezentare infinita a functiilor.
Exemplu:
Elementele fractiei:

x x2 x2
x2
tan x = 0; ,
,
,...,
,... .
1 3
5
2i 1
Valorile initiale:
Relatii de recurenta:
ai = ai1 + 2
a0 = 0, a1 = 1,
b1 = x, bi = x2 , i = 2, 3, . . .
P0 = 0, P1 = x, a1 = 1
Q0 = 1, Q1 = 1, b = x2 .
ai = ai1 + 2, i = 2, 3, . . .
Pi = ai Pi1 + bPi2
Qi = ai Qi1 + bQi2 .
Conditie de convergenta:

Q
R
P
i1
i1
i
= 1
.
1

Ri
Qi1 Pi
/*=========================================================================*/
float Tan(float x)
/*--------------------------------------------------------------------------Evalueaza tangenta in punctul x utilizand reprezentarea cu fractii continue
---------------------------------------------------------------------------*/
{
float a, b, p, pm, pp, q, qm, qp;
if (x == 0.0) return 0.0;
pm = 0.0; p = x ; a = 1.0;
qm = 1.0; q = 1.0; b = -x*x;
while (fabs(1.0 - (pm*q)/(p*qm)) > eps) {
a += 2.0;
pp = a*p + b*pm; pm = p; p = pp;
qp = a*q + b*qm; qm = q; q = qp;
}
return p/q;
}
6.4 Polinoame ortogonale

{fn (x)} sistem ortogonal pe [a, b] n raport cu functia de pondere w(x) > 0 daca
b
w(x)fn (x)fm (x)dx = Nn nm (n, m = 0, 1, 2, . . .).
a
Relatii generale
ecuatia diferentiala de ordinul doi:
g2 (x)fn (x) + g1 (x)fn (x) + hn fn (x) = 0.
relatia de recurenta n raport cu ordinul n:
an fn (x) = (bn + cn x)fn1 (x) dn fn2 (x).
prima derivata:
g2 (x)fn (x) = g1 (x)fn (x) + g0 (x)fn1 (x).

TABELUL 6.1.
fn (x)
Tn (x)
Pn (x)
Ln (x)
Hn (x)
nume
Cebsev
de speta I
Legendre
Laguerre
Hermite
w(x)
(1 x2 )1/2
1 1
0
e
2
ex
Nn
daca n = 0
/2 daca n = 0
2/(2n + 1)
1
n
2 n!
TABELUL 6.2.
fn (x) an
Tn (x) 1
Pn (x) n
Ln (x) n
Hn (x) 1
bn
cn
dn
f0 (x) f1 (x)
0
2
1
1
x
0
2n 1
n1
1
x
2n 1
1
n1
1
1x
0
2
2(n 1)
1
2x
TABELUL 6.3.
fn (x) g2 (x)
Tn (x) 1 x2
Pn (x) 1 x2
Ln (x)
x
Hn (x)
1
g1 (x) g0 (x)
nx
n
nx
n
n
n
0
2n
Evaluarea polinomului ortogonal fn (x) pentru x = :

1. se evalueaza f0 () si f1 ()
2. se aplica pentru i = 2, 3, . . . , n relatia de recurenta
1
fi () = [(bi + ci )fi1 () di fi2 ()].
ai
Polinoamele Cebsev de speta ntia
Convergenta rapida a dezvoltarilor n serie pe [1, 1].
Relatii de recurenta:
Ti (x) = 2xTi1 (x) Ti2 (x), i = 2, 3, . . . , n
Tn (x) = n [xTn (x) Tn1 (x)] /(x2 1),
T0 (x) = 1, T1 (x) = x
/*=========================================================================*/
float Cebisev(int n, float x, float *d)
/*--------------------------------------------------------------------------Evalueaza polinomul Cebisev de ordinul n in punctul x, returnand derivata
in *d
---------------------------------------------------------------------------*/
{
float f, fm1, fm2, x2;
int i;
1.0
T1
0.5
Tn(x)
if (n == 0) {
f = 1.0; *d = 0.0;
} else {
f = x; fm1 = 1.0; x2 = 2*x;
for (i=2; i<=n; i++) {
fm2 = fm1; fm1 = f;
f = x2*fm1 - fm2;
}
*d = (x*x-1.0) ? n*(x*f-fm1)/(x*x-1.0) : n*n*f/x;
}
return f;
T2
0.0
T3
-0.5
T4
-1.0
-1.0
-0.5
0.0
FIGURA 6.1.
0.5
1.0
/*=========================================================================*/
float Legendre(int n, float x, float *d)
/*-------------------------------------------------------------------------*/
{
float f, fm1, fm2;
int i;
if (n == 0) {
f = 1.0; *d = 0.0;
} else {
f = x; fm1 = 1.0;
for (i=2; i<=n; i++) {
fm2 = fm1; fm1 = f;
f = ((2*i-1)*x*fm1 - (i-1)*fm2)/i;
}
*d = (x*x-1.0) ? n*(x*f-fm1)/(x*x-1.0) : 0.5*n*(n+1)*f/x;
}
return f;
/*=========================================================================*/
float Laguerre(int n, float x, float *d)
/*-------------------------------------------------------------------------*/
{
float f, fm1, fm2;
int i;
if (n == 0) {
f = 1.0; *d = 0.0;
} else {
f = 1.0 - x; fm1 = 1.0;
for (i=2; i<=n; i++) {
fm2 = fm1; fm1 = f;
f = ((2*i-1-x)*fm1 - (i-1)*fm2)/i;
}
*d = x ? n*(f-fm1)/x : -n*f;
}
return f;
/*=========================================================================*/
float Hermite(int n, float x, float *d)
/*-------------------------------------------------------------------------*/
{
float f, fm1, fm2, x2;
int i;
if (n == 0) {
f = 1.0; *d = 0.0;
} else {
f = 2*x; fm1 = 1.0; x2 = 2*x;
for (i=2; i<=n; i++) {
fm2 = fm1; fm1 = f;
f = x2*fm1 - 2*(i-1)*fm2;
}
*d = 2*n*fm1;
}
return f;
Armonice sferice. Functii Legendre asociate

Metoda separarii variabilelor n coordonate sferice pentru anumite ecuatii diferentiale:
ecuatia undelor, ecuatia lui Schrdinger, ecuatia lui Laplace.
Ecuatia armonicelor sferice:

1
Ylm
1 2 Ylm
+ l(l + 1)Ylm = 0,
sin
+
sin
sin2 2
l = 0, 1, 2, . . . , l m l
Armonicele sferice:
Ylm (, ) =
2l + 1 (l m)! m
P (cos )eim
4 (l + m)! l
Yl,m (, ) = (1)m Ylm

(, ),
Relatia de ortonormare:
2

d
0
m0
Yl m (, )Ylm (, ) sin d = l l m m
{Ylm (, )} sistem ortonormat complet pe sfera de raza unitate L2 (S1 ).

Orice f L2 (S1 ) dezvoltare unica n serie Fourier:
f (, ) =
l

alm Ylm (, )
l=0 m=l
Ecuatia functiilor Legendre asociate:

d2 Plm
dPlm
m2
(1 x )
2x
+ l(l + 1)
Pm = 0
dx2
dx
1 x2 l
2
Functiile Legendre asociate (Pl (x) polinoame Legendre):

Plm (x)
2 m/2
= (1) (1 x )
Relatia de ortonormare:
1
m
Plm
(x)Pl (x)dx =
1
dm
Pl (x).
dxm
2
(l + m)!
l l .
(2l + 1) (l m)!
{Plm
(x)} sistem ortonormat complet pe L2 [1, 1]
Orice f L2 [1, 1] dezvoltare unica n serie Fourier:
f (x) =

l
l=0 m=l
alm Plm (x).
10
P0
Pl (x)
P1
-5
P2
-10
P3
-15
-20
-1.0
-0.5
0.0
0.5
1.0
FIGURA 6.2. Functiile Legendre asociate P30 (x), P31 (x), P32 (x) si P33 (x) calculate cu ajutorul
rutinei FLegendre.
n raport cu ordinul inferior:
m
m
(i m)Pim (x) = (2i 1)xPi1
(x) (i + m 1)Pi2
(x),
i = m + 1, . . . , l
Valori de pornire:
m
Pm1
= 0
Pmm (x) = (1)m (2m 1)!!(1 x2 )m/2

m

(2i 1) 1 x2
=
i=1
/*=========================================================================*/
float FLegendre(int l, int m, float x)
/*--------------------------------------------------------------------------Evalueaza functia Legendre asociata de ordine l si m in punctul x
---------------------------------------------------------------------------*/
{
float p, pm1, pm2, sqx;
int i;
if (l < m) return 0.0;
p = 1.0; pm1 = 0.0;
if (m) {
sqx = -sqrt(1.0-x*x);
for (i=1; i<=m; i++) p *= (2*i-1) * sqx;
}
for (i=m+1; i<=l; i++) {
pm2 = pm1; pm1 = p;
p = ((2*i-1)*x*pm1 - (i+m-1)*pm2)/(i-m);
}
return p;
}
10
/* P(m,m,x), P(m-1,m,x) */
/* recurenta */
Functiile Bessel sferice

Solutii ale ecuatiei cuantice radiale a mprastierii.
Ecuatia functiilor Bessel sferice:

x2 fn (x) + 2xfn (x) + x2 n(n + 1) fn (x) = 0,
n = 0, 1, 2, . . .
Solutia regulata functia Bessel sferic

a jn (x)
Solutia neregulata functia Neumann sferic
a yn (x).
:
fi (x) =
2i 1
fi1 (x) fi2 (x)
x
Functiile Neumann sferice yn (x) recurenta ascendenta stabila:

y0 (x) =
cos x
,
x
y1 (x) =
1
[y0 (x) sin x]
x
/*=========================================================================*/
float SBessy(int n, float x)
/*--------------------------------------------------------------------------Evalueaza functia Neumann sferica y_n(x) de ordinul n in punctul x
---------------------------------------------------------------------------*/
{
float y, y0, y1;
int i;
y0 = -cos(x)/x; if (n == 0) return y0;
y1 = (y0 - sin(x))/x; if (n == 1) return y1;
for (i=2; i<=n; i++) {
y = (2*i-1)/x*y1 - y0;
y0 = y1; y1 = y;
}
return y;
}
0.4
0.3
y0
0.2
yn(x)
0.1
y1
0.0
y2
-0.1
y3
-0.2
-0.3
-0.4
10
12
14
FIGURA 6.3. Functiile Neumann sferice yn (x) pentru ordinele n = 0, 1, 2 si 3, calculate cu

ajutorul rutinei SBessy.
11
Functiile Bessel sferice jn (x) recurenta ascendenta conditional stabila.

Daca n > |x| se acumuleaza erorile de trunchiere la recurenta ascendenta.
Algoritmului lui Miller recurenta descendenta cu valori de pornire arbitrare:
2i + 3
ji+1 (x) ji+2 (x)
x
= 0, jN+1 = 1, N > n
ji (x) =
jN+2
Rezulta functiile corecte nmultite cu un factor necunoscut

jn = kjn
Factorul se determina din:
k = j0 /j0
Functia Bessel sferica jn :
jn = (j0 /j0 ) jn
Recurenta ascendenta este ntotdeauna stabila pentru n < |x|.

n ce conditii trebuie aplicata recurenta descendenta?
Care este ordinul N de la care trebuie nceputa recurenta?
Pentru n > |x| se retine doar primul termen n relatia de recurenta
ji (x)
2i 1
ji1 (x),
x
i = n, n + 1, . . . , N
Factorul net de crestere a functiei jN fata de jn :

f=
2i 1
i=n
Daca f > 108 recurenta ascendenta este instabila se aplica recurenta descendenta.
1.0
0.8
j0
jn(x)
0.6
j1
0.4
j2
j3
0.2
0.0
-0.2
-0.4
10
12
14
FIGURA 6.4. Functiile Bessel sferice jn (x) pentru ordinele n = 0, 1, 2 si 3, calculate cu ajutorul
rutinei SBessj.
12
/*=========================================================================*/
float SBessj(int n, float x)
/*--------------------------------------------------------------------------Evalueaza functia Bessel sferica j_n(x) de ordinul n in punctul x
---------------------------------------------------------------------------*/
{
float j, j0, j1, j2, jn;
int i, nmax;
if (x == 0.0) return (n == 0 ? 1.0 : 0.0);
j0 = sin(x)/x; if (n == 0) return j0;
j1 = (j0 - cos(x))/x; if (n == 1) return j1;
nmax = 0;
/* determina sensul recurentei stabile */
if ((float)n >= fabs(x)) {
jn = 1.;
for (i=n; i<=(n+50); i++) {
jn *= (2*i-1)/x;
/* factorul net de crestere */
if (jn >= 1e8) {nmax = i + 10; break;}
}
}
if (nmax == 0) {
for (i=2; i<=n; i++) {
j = (2*i-1)/x*j1 - j0;
j0 = j1; j1 = j;
}
return j;
} else {
j2 = 0.; j1 = 1e-20;
for (i=nmax; i>=0; i--) {
j = (2*i+3)/x*j1 - j2;
j2 = j1; j1 = j;
if (i == n) jn = j;
}
return (j0/j)*jn;
}
/* recurenta ascendenta */
/* recurenta descendenta */
/* memoreaza jn nenormat */
/* normeaza jn */
13
Bibliography
[1] M. Abramowitz si I. Stegun, Handbook of Mathematical Functions (Dover Publications, New York, 1972).
[2] D.E. Knuth, The Art of Computer Programming, vol. 2: Seminumerical Algorithms
(Addison-Wesley, Reading, MA, 1981).
[3] F.S. Acton, Numerical Methods That Work (Mathematical Association of America,
Washington, 1990).
8
SISTEME DE ECUA
TII ALGEBRICE LINIARE
8.1 Introducere
Rezolvarea sistemelor de ecuatii liniare joaca un rol central n analiza numerica.
Metode directe algoritmi finiti, erori de rotunjire Gauss, Crout, Choleski,
Metode iterative procese infinite, erori de trunchiere Jacobi, Gauss-Seidel.
8.2 Metoda de eliminare a lui Gauss

Ideea de baza aducerea sistemului prin transformari elementare la o forma echivalenta,
cu matrice superior triunghiular
a.
Transformarea sistemului faza elimin
arii.
Rezolvarea sistemului cu matrice triunghiulara faza substitutiei inverse.
Exemplificare:
a11 x1 + a12 x2 + a13 x3 = b1

a21 x1 + a22 x2 + a23 x3 = b2
a31 x1 + a32 x2 + a33 x3 = b3 ,
sau
a11 a12 a13

x1
b1
a21 a22 a23 x2 = b2
a31 a32 a33
x3
b3
Faza elimin
arii:
Pasul 1: Eliminam x1 din toate ecuatiile sistemului, cu exceptia primei ecuatii.
mpartim prima linie la elementul pivot a11 .
Scadem prima ecuatie nmultita cu primul coeficient din celelalte ecuatii:
(1)
(1)
(1)
(1)
(1)
(1)
x1
b
1 a12 a13
x1 + a12 x2 + a13 x3 = b1
1(1)
(1)
(1)
(1)
(1)
(1)
=
sau
a22 x2 + a23 x3 = b2
0 a22 a23 x2 b2 .
(1)
(1)
(1)
(1)
(1)
(1)
a32 x2 + a33 x3 = b3 ,
0 a32 a33
x3
b3
cu
(1)
a1j
(1)
b1
(1)
aij
(1)
bi
=
=
=
=
a1j /a11 , j = 1, 2, 3
b1 /a11
(1)
aij ai1 a1j , j = 1, 2, 3, i = 2, 3
(1)
bi ai1 b1 .
Pasul 2: Eliminam x2 din ultima ecuatie.

(1)
(1)
mpartim a doua ecuatie la elementul pivot a22 si o scadem nmultita cu a32 din ecuatia
a treia:
(1)
(1)
(1)
b
x1
1 a12 a13
1(2)
(2)
0 1 a23 x2 = b2 ,
(2)
(2)
0 0 a33
x3
b3
cu
(2)
(1)
(1)
a2j = a2j /a22 , j = 2, 3
(2)
(1)
(1)
b2 = b2 /a22
(2)
(1)
(1) (2)
aij = aij ai2 a2j , j = 2, 3, i = 3
(2)
(1)
(1) (2)
= bi ai2 b2 .
bi
(2)
Pasul 3: mpartim cea de a treia ecuatie la elementul pivot a33 :
(1)
(1)
(1)
b1
x
1 a12 a13
1
(2)
0 1 a x = b(2)
2
2 ,
23
(3)
0 0
1
x3
b3
cu
(3)
(2)
(2)
b3 = b3 /a33 .
Faza substitutiei inverse:
(3)
x3 = b3
(2)
(2)
x2 = b2 a23 x3
x = b(1) (a(1) x + a(1) x ).

1
1
12 2
13 3
Calculul determinantului:
Datorita mpartirii succesive cu elementele pivot:
detA(3) =
detA
(1) (2)
a11 a22 a33
rezulta:
= 1,
(1) (2)
detA = a11 a22 a33 .
Generalizare sistem de n ecuatii cu n necunoscute A = [aij ]nn , b = [bi ]n si

x = [xi ]n :
A x = b.
Faza elimin
arii:
naintea pasului k
(1)
1 a12
0 1
.
..
..
.
0 0
0 0
..
..
.
.
0 0
(k = 1, 2, . . . n 1):
...
(1)
a1k
(2)
a2k
..
.
(k1)
(1)
a1k+1
(2)
a2k+1
..
.
(k1)
(k1)
akk+1 akn
akk
(k1)
(k1)
(k1)
ak+1k ak+1k+1 ak+1n
..
..
..
...
.
.
.
(k1)
(k1)
(k1)
ank+1 ann
ank
La pasul k se elimina xk din ecuatiile de
(1)
(1)
(1)
1 a12 a1k
a1k+1
(2)
0 1 a(2)
a2k+1
2k
.
..
..
..
...
..
.
.
.
(k)
0 0 1
akk+1
(k)
0 0 0 ak+1k+1
..
..
..
..
.
.
.
.
(k)
0 0 0
ank+1
x1
x2
..
.
xk
xk+1
..
.
xn
sub ecuatia k:
(1)
a1n
(2)
a2n
..
(k)
akn
(k)
ak+1n
...
..
(k)
ann
Noile elemente ale liniei pivot k:
(k)
akk = 1
(k)
(k1)
(k1)
akj = akj /akk ,
(k)
(k1)
(k1)
bk = bk /akk .
Noile elemente ale
(k)
aik
(k)
aij
(k)
bi
(1)
a1n
(2)
a2n
..
.
x1
x2
..
.
xk
xk+1
..
.
xn
(1)
b1
(2)
b2
..
.

(k1)
= bk
(k1)
bk+1

..
.
(k1)
bn
(1)
b1
(2)
b2
..
.

(k)
= bk
(k)
bk+1

..
.
(k)
bn
j = k + 1, . . . , n
liniilor de sub linia pivot:

= 0
(k1)
(k1) (k)
= aij
aik akj ,
(k1)
(k1) (k)
= bi
aik bk .
j = k + 1, . . . , n, i = k + 1, . . . , n
La pasul k se modifica doar elementele delimitate de linia si coloana k.

Nu trebuie considerat j = k, deoarece pe coloana pivot k se genereaza numai 1 sau 0.
La pasul k = n se mparte
(1)
1 a12
0 1
..
..
...
.
.
0 0
0 0
.
..
..
.
0 0
sau
(n1)
ultima ecuatie la ultimul pivot, ann :

(1)
(1)
(1)
x
a1k a1k+1 a1n
1

(2)
(2)
(2)
x2
a2k a2k+1 a2n

..
..
..
...
.
.
.

(k)
(k)
=
1 akk+1 akn xk

(k+1)
0
1
ak+1n xk+1

..
..
.. ..
...
.
.
.
.
0
0
1
xn
(n)
xn = bn
xk =
(k)
bk
(1)
b1
(2)
b2
..
.
(k)
bk
(k+1)
bk+1
..
.
(n)
bn
A(n) x = b(n) .
n
X
(k)
aki xi ,
i=k+1
k = n 1, . . . , 1.
Calculul determinantului:
Datorita mpartirii succesive cu elementele pivot:
detA(n) =
detA
(1)
a11 a22
rezulta:
(n1)
ann
=1
(1)
(n1)
detA = a11 a22 ann
.
Generalizare ecuatie matricial

a B = [bij ]nm si X = [xij ]nm :
AX=B
Faza elimin
arii
(k)
akj
b(k)
kj
(k)
aij
(k)
bij
(k = 1, . . . , n):
=
=
=
=
(k1)
(k1)
akj /akk , j = k + 1, . . . , n
(k1)
(k1)
bkj /akk , j = 1, . . . , m
(k1)
(k1) (k)
aij
aik akj , j = k + 1, . . . , n, i = k + 1, . . . , n,
(k1)
(k1) (k)
bij
aik bkj , j = 1, . . . , m.
(n)
xnj = bnj , j n= 1, . . . , m
X (k)
(k)
aki xij , j = 1, . . . , m, k = n 1, . . . , 1.
xkj = bkj
i=k+1
Inversarea matricilor ca matrice a termenilor liberi se ia matricea unitate:

B = En [ij ]nn
X = A1 .
Pivotarea rearanjarea liniilor pt. a avea la fiecare pas al eliminarii un pivot maxim.
Se minimizeaza erorile de rotunjire si se evita mpartirile cu 0
(k1)
pivotarea partiala pe coloane la pasul k se cauta elementul maxim alk

coloana k si liniile l k si se interschimba liniile l si k.
pe
metoda elementului principal se cauta elementul pivot pe toate liniile si coloanele

matricii A(k1) pe care nu s-a pivotat.
/*=========================================================================*/
int Gauss(float **a, float **b, int n, int m, float *det)
/*--------------------------------------------------------------------------Rezolva ecuatia matriciala a x = b prin metoda Gauss, inlocuind la iesire b
cu x (utilizeaza pivotarea partiala pe coloane).
a
- matricea (n x n) a sistemului
b
- matricea (n x m) a termenilor liberi; solutia x la iesire
*det - determinantul matricii sistemului (iesire)
1 - matrice a singulara
---------------------------------------------------------------------------*/
{
#define Swap(a,b) { t = a; a = b; b = t; }
float amax, sum, t;
int i, imax, j, k;
/* ELIMINARE */
*det = 1.0;
for (k=1; k<=n; k++) {
amax = 0.0;
/* determina linia pivot avand */
for (i=k; i<=n; i++)
/* elementul maxim pe coloana k */
if (amax < fabs(a[i][k])) {amax = fabs(a[i][k]); imax = i;}
if (amax == 0.0)
{printf("Gauss: matrice singulara !\n"); return 1;}
/* interschimba liniile imax si k */
if (imax != k) {
/* pt. a pune pivotul pe diagonala */
*det = -(*det);
for (j=k; j<=n; j++) Swap(a[imax][j],a[k][j])
for (j=1; j<=m; j++) Swap(b[imax][j],b[k][j])
}
*det *= a[k][k];
/* inmulteste determinantul cu pivotul */
t = 1.0/a[k][k];
for (j=k+1; j<=n; j++) a[k][j] *= t;
for (j= 1; j<=m; j++) b[k][j] *= t;
/* imparte linia pivot */
for (i=k+1; i<=n; i++) {

/* reduce liniile nepivot */
t = a[i][k];
for (j=k+1; j<=n; j++) a[i][j] -= a[k][j]*t;
for (j= 1; j<=m; j++) b[i][j] -= b[k][j]*t;
}
}
/* SUBSTITUTIE INVERSA */
for (k=n-1; k>=1; k--)
for (j=1; j<=m; j++) {
sum = b[k][j];
for (i=k+1; i<=n; i++) sum -= a[k][i]*b[i][j];
b[k][j] = sum;
}
return 0;
}
8.7 Sisteme de ecuatii liniare cu matrice tridiagonala

Matrici tridiagonale matrici rare cu majoritatea elementelor extradiagonale 0.
Metodele generale nu sunt eficiente.
n mod tipic prin discretizarea ecuatiilor diferentiale prin scheme cu diferente finite.
Fie sistemul:
A x = d,
sau
b1 c1
a2 b2 c2
0
... ... ...
ai1 bi1 ci1
ai
bi
ci
.
.
...
..
..
0
an1 bn1 cn1
an
bn
Se factorizeaza A:
x1
x2
..
.
xi1
xi
.
..
xn1
xn
d1
d2
..
.

di1
=
di
.
..

dn1
dn
A = L U,
cu
1
2 2
0
... ...
i1 i1
LU=
i i
... ...
0
n1 n1
n n
1 1
1 2
0
... ...
1 i1
1
i
... ...
0
1 n1
1
Prin identificare:
b1 = 1 ,
c1 = 1 1
ai = i , bi = i i1 + i , ci = i i ,
an = n , bn = n n1 + n .
i = 2, 3, . . . , n 1
Elementele matricilor L si U (presupunnd i 6= 0):

i = ai ,
i = 2, 3, . . . , n,
1 = c1 / 1
1 = b1 ,
i = bi ai i1 , i = ci / i ,
n = bn an n1 .
i = 2, 3, . . . , n 1
Diagonala matricii L estei identica cu diagonala matricii A.

6
Sistemul initial devine :

L (U x) = d
sau
si
Ly = d
U x = y.
1
a2 2
0
.
.
..
..
ai1 i1
ai i
... ...
0
an1 n1
an n
1 1
1 2
0
.
.
.. ..
1 i1
1
i
... ...
0
1 n1
1
y1
y2
..
.
yi1
yi
.
..
yn1
yn
x1
x2
..
.
xi1
xi
.
..
xn1
xn
d1
d2
..
.

di1
=
di
.
..

dn1
dn
y1
y2
..
.

yi1
=
yi
.
..

yn1
yn
Prin identificarea elementelor:
y1 = d1 / 1
yi = (di ai yi1 )/ i , i = 2, 3, . . . , n
xn = yn
xi = yi i xi+1 , i = n 1, . . . , 1.
Faza factoriz
arii:
1 = c1 / 1 , y1 = d1 / 1
1 = b1 ,
i = bi ai i1 , i = ci / i , yi = (di ai yi1 )/ i
i = 2, 3, . . . , n 1.
xn = (dn an yn1 )/(bn an n1 )

xi = yi i xi+1 , i = n 1, . . . , 1.
n implementare sunt suficiente patru tablouri a, b, c si d, asociate cu ai , bi , ci si di .

Elementele i pot fi stocate n tabloul c, peste marimile ci .
Pentru di , yi si x se poate utiliza acelasi tablou, d, care n final contine solutia sistemului.
7
/*=========================================================================*/
void TriDiag(float a[], float b[], float c[], float d[], int n)
/*--------------------------------------------------------------------------Rezolva un sistem liniar cu matrice tridiagonala prin factorizare
a[]
- codiagonala inferioara (i=2..n)
b[]
- diagonala principala
c[]
- codiagonala superioara (i=1..n-1)
d[]
- vectorul termenilor liberi; la iesire contine solutia x
n
- ordinul sistemului
---------------------------------------------------------------------------*/
{
float beta;
int i;
/* factorizare */
c[1] /= b[1]; d[1] /= b[1];
for (i=2; i<=(n-1); i++) {
beta = b[i] - a[i]*c[i-1];
c[i] /= beta;
d[i] = (d[i] - a[i]*d[i-1])/beta;
}
d[n] = (d[n] - a[n]*d[n-1])/(b[n] - a[n]*c[n-1]);
/* substitutie inversa */
for (i=(n-1); i>=1; i--) d[i] -= c[i]*d[i+1];
}
Nu se efectueaza pivotare dominanta diagonala a matricii sistemului asigura succesul.
Bibliography
[1] Gh. Dodescu, Metode numerice n algebra

, Editura tehnica, Bucuresti, 1979).
Moskow, 1981).
Cambridge, 1992).
9
PROBLEME DE VALORI S
I VECTORI PROPRII
8.1 Introducere
Problema de valori proprii a unui operator liniar A:
Ax = x
x vector propriu, valoare proprie.
n reprezentarea unei baze din <n problema matriciala cu A = [aij ]nn , x = [xi ]n :
A x = x, sau (A E) x = 0
a11 a12 a1n

a21 a22 a2n
..
.. . .
..
.
.
.
.
an1 an2 ann
x1
x2
..
.
xn
x1
x2
..
.
xn
det(A E) determinant caracteristic (secular).

Sistem liniar omogen solutii netriviale daca si numai daca:
det(A E) = 0
Ecuatia caracteristic
a (secular
a):
a11
a12
a21
a22
..
..
.
.
an1
an2
=0
ann
...
a1n
a2n
..
.
n radacini reale sau complexe 1 , 2 , ..., n . spectrul matricii A.

= j n ecuatia de valori proprii solutia x(j) vectorul propriu corespunzator.
8.2 Diagonalizarea matricilor prin transformari similare

Fie X matricea avnd pe coloane vectorii proprii x(j) matrice modal
a.
Cele n ecuatii de valori proprii sub forma matriciala ecuatie modal
a:
AX=X
unde
(1)
(2)
x1 x1
(1) (2)
x
x2
X= 2
(1)
(2)
xn xn
(n)
x1
(n)
x2
,
(n)
xn
1 0
0 2
=
0 0
0
0
Teorema 9.1 Daca matricea modala

X corespunzatoare unei matrici A este formata din
n coloane liniar independente (vectorii proprii ai matricii A sunt liniar independenti),
atunci exista X1 si ecuatia modala
se scrie sub forma
X1 A X = .
Matricile asociate aceluiasi operator relativ la doua baze diferite matrici similare.
Teorema 9.2 Doua matrici cu elemente reale, A, B Mnn
si nu< , sunt similare daca
mai daca exista o matrice nesingulara S Mnn
,
astfel
ca
<
B = S1 A S,
operatie care se numeste transformare similara a matricii A.
Teorema 9.3 Doua matrici similare au aceleasi valori proprii. Vectorii proprii corespunzatori rezulta unii din altii cu ajutorul matricii transformarii.
Ecuatia modala X1 A X = A si sunt similare.
Matricile similare cu o matrice diagonala se numesc matrici diagonalizabile.
Importanta procesului de diagonalizare
Daca se poate gasi o transformare care diagonalizeaza matricea:
valorile proprii se afla pe diagonala principala a matricii transformate
vectorii proprii corespunzatori sunt coloanele matricii transformarii.
8.3 Metoda lui Jacobi

Probleme de valori si vectori proprii pentru matrici reale simetrice.
Vectorii proprii reali si ortogonali diagonalizare cu ajutorul unei matrici ortogonale:
R RT = RT R = E sau R1 = RT
Diagonalizarea prin transformarea de similitudine:
RT A R =
Ideea:
Transformari similare ortogonale succesive anuleaza cte doua elemente simetrice.
Transformarile distrug zerourile anterioare, dar diagonalizeaza treptat matricea.
Produsul transformarilor matricea modala pe coloane vectorii proprii.
Cazul 22 transformare ortogonala matrice de rotatie plan
a:
cos sin
R=
sin cos
Rotire de unghi a sistemului vectorilor de baza.
rezulta din conditia ca R sa diagonalizeze matricea A.
Transformarea ortogonal
a:
Elementele:
A0 = RT A R
0
a11 = a11 cos2 + 2a21 sin cos + a22 sin2
a0 = a11 sin2 2a21 sin cos + a22 cos2
22
a021 = a21 (cos2 sin2 ) + (a22 a11 ) sin cos = a012 ,
Transformarea conserva caracterul simetric al matricii.
Conditia de anulare a elementelor nediagonale ale matricii A0 :

a22 a11
cot 1 = 0
cot2 +
a21
Rezolvare n raport cu cot :
1
s
2
a11 a22
a11 a22
tan =
+ 1
2a21
2a21
Se determina cos = (1 + tan )1/2 si sin = tan cos .
Valorile si vectorii proprii:

1 = a011 , x(1)
2 = a022 , x(2)
cos
=
sin
sin
=
cos
Diagonalizare exact
a printr-o singura transformare ortogonala.
3
Cazul n n
R(i, j) =
..
..
1
.
.
cos sin
..
..
...
.
.
sin cos
..
..
0
.
.
coloana i
coloana j
linia i

linia j
1
Transformarea ortogonal
a anuleaza elementele extradiagonale a0ij si a0ji :
A0 = RT (i, j) A R(i, j)
Singurele elemente diferite de ale matricii A pe liniile si coloanele i si j.
Rescriem:
= A R(i, j),
A
Detaliat:
a1i
..
.
a1j
..
.
a
ki
..
.
a
kj
..
.
a
ni
a
nj
A0 = RT (i, j) A
a1i
..
.
a1j
..
.
aki
..
.
akj
..
.
ani
anj
..
..
1
.
.
0
cos sin
..
..
...

.
.
sin
cos
..
..
0
.
.
1
Elementele relevante de pe coloanele i si j:
aki = aki cos + akj sin , k = 1, 2, ..., n

akj = aki sin + akj cos .

..
..
..
..
.
1
.
.
.
0
0
0
0
ai1 aik ain cos sin ai1 aik ain

..
..
..
..
...
=
.
.
.
.

a0 a0 a0 sin cos a
jk ajn
j1 a
j1
jn
jk
..
..
..
..
.
0
.
.
1
.
Elementele relevante de pe liniile i si j:
0
aik = aik cos + a
jk sin ,
0
ajk = aik sin + a
jk cos .
k = 1, 2, ..., n
Elementele modificate ale matricii A0

0
aik = a0ki = aik cos + ajk sin , k = 1, 2, ..., n
0
0
ajk = akj = aik sin + ajk cos , k 6= i, j

a0ii = aii cos2 + 2aji sin cos + ajj sin2
a0jj = aii sin2 2aji sin cos + ajj cos2
0
aij = a0ji = aji (cos2 sin2 ) + (ajj aii ) sin cos .
4
Conditia de anulare a elementelor nediagonale ale matricii A0 :

cot2 +
ajj aii
cot 1 = 0
aji
Rezolvare n raport cu cot :
Se determina:
tan =
aii ajj
2aji
1
,
cos = p
1 + tan2
aii ajj
2aj i
+ 1
sin = cos tan
S
ir de matrici similare avnd acelasi sistem de valori proprii:
A0 = A,
Al = RTl Al1 Rl ,
l = 0, 1, 2, . . .
S
ir de matrici ortogonale
X0 R0 E,
Xl = R0 R1 Rl ,
l = 0, 1, 2, . . .
S
irul de matrici similare:
A0 = A,
Al = XTl A Xl ,
l = 0, 1, 2, . . .
La limita:
lim Al = ,
lim Xl = X
Relatie de recurenta
:
Xl = Xl1 Rl (i, j)
Elementele modificate ale matricii Xl :
0
xki = xki cos + xkj sin ,
x0kj = xki sin + xkj cos .
k = 1, 2, ..., n,
:
max |a0ij |
i6=j
Diagonala lui Al valorile proprii, coloanele lui Xl vectorii proprii.

Stabilitatea metodei rotatie a vectorilor de baza de unghi minim ( /4).
Maximizarea valorii absolute a numitorului expresiei tan :
1
s

2
aii ajj aii ajj
aii ajj
+
tan = sign
+ 1
2aji
2aji
2aji
5
/*=========================================================================*/
int Jacobi(float **a, float **x, float d[], int n)
/*--------------------------------------------------------------------------Rezolva problema de valori si vectori proprii pt. o matrice reala simetrica
a - matricea reala simetrica (jumatatea inferioara este distrusa)
x - matricea modala: coloanele sunt vectorii proprii (iesire)
d - tabloul valorilor proprii
n - ordinul matricii a
---------------------------------------------------------------------------*/
{
/* criteriu de precizie */
float aii, aji, ajj, amax, c, s, t;
int i, it, j, k;
for (i=1; i<=n; i++) {
for (j=1; j<=n; j++) x[i][j] = 0.0;
x[i][i] = 1.0;
d[i] = a[i][i];
}
/*
/*
/*
/*
initializeaza matricea
modala x cu matricea E
si valorile proprii d
cu elementele diag.

amax = 0.0;
for (j=2; j<=n; j++)
for (i=1; i<=(j-1); i++) {
/* salveaza elementele diag.
aii = d[i]; ajj = d[j]; aji = fabs(a[j][i]);
if (amax < aji) amax = aji;
/* elem. extradiag. maxim
if (aji > eps) {
/* efectueaza rotatia
c = 0.5*(aii-ajj)/a[j][i];
t = 1.0/(fabs(c) + sqrt(1.0+c*c));
/* tangenta
if (c < 0.0) t = -t;
/* semnul corect
c = 1.0/sqrt(1.0+t*t); s = c*t;
/* cos, sin
for (k=1; k<=(i-1); k++) {
/* 1 <= k < i
t
= a[i][k]*c + a[j][k]*s;
a[j][k] = a[j][k]*c - a[i][k]*s; a[i][k] = t;
}
for (k=(i+1); k<=(j-1); k++) {
/* i < k < j
t
= a[k][i]*c + a[j][k]*s;
a[j][k] = a[j][k]*c - a[k][i]*s; a[k][i] = t;
}
for (k=(j+1); k<=n; k++) {
/* j < k <= n
t
= a[k][i]*c + a[k][j]*s;
a[k][j] = a[k][j]*c - a[k][i]*s; a[k][i] = t;
}
for (k=1; k<=n; k++) {
/* matricea modala
t
= x[k][i]*c + x[k][j]*s;
x[k][j] = x[k][j]*c - x[k][i]*s; x[k][i] = t;
}
t = 2 * s * c * a[j][i];
/* actualizeaza
d[i] = aii*c*c + ajj*s*s + t;
/* elementele
d[j] = aii*s*s + ajj*c*c - t;
/* diagonale si
a[j][i] = 0.0;
/* extradiagonale
}
}
if (amax<=eps) return 0;
/* testeaza convergenta
}
printf("Jacobi: nr. maxim de iteratii depasit !\n");
return 1;
}
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
*/
11
INTEGRAREA FUNC
TIILOR
11.1 Introducere
Daca pt. f (x) continua pe [a, b] este cunoscuta primitiva F (x) formula Newton-Leibnitz:
I=
f (x)dx = F (b) F (a).
Calculul numeric al integralelor simple cuadratur

a.
Aproximarea integralei printr-o suma ponderata de valori f (xi ) pt. anumite argumente xi
din domeniul de integrare:
Z b
n
X
f (x)dx
wi f (xi ).
a
i=1
Calculul numeric al integralelor duble cubatur

a.
11.2 Formulele de cuadratura Newton-Cotes

Se cere:
I=
f (x)dx.
Fie nodurile echidistante xi [a, b]:
xi = a + (i 1)h,
i = 1, 2, . . . , n
h = (b a)/(n 1).
Aproximam functia f (x) prin polinomul de interpolare Lagrange (fi f (xi )):
n Qn
X
(x xj )
Qnj6=i
Pn1 (x) =
fi .
j6=i (xi xj )
i=1
Definim variabila adimensionala:
q = (x a)/h,
q [0, n 1].
Variabila initiala se scrie x = a + qh.
Produsele din expresia polinomului de interpolare Lagrange:

n
n
Y
Y
(x xj ) = hn1 [q (j 1)]
j6=i
j6=i
n
Y
j6=i
n1
(xi xj ) = h
n
i1
n
Y
Y
Y
ni n1
(i j) = (1) h
(i j)
(j i) = (1)ni hn1 (i 1)!(n i)!
j=1
j6=i
Polinomul Lagrange:
Pn1 (x) =
n
X
i=1
Aproximatie a integralei:
Z
f (x)dx
Ai =
Qn
j=i+1
Qn
j6=i [q (j 1)]
(1)ni (i 1)!(n i)!
Pn1 (x)dx =
n
X
fi
Ai fi ,
i=1
j6=i [q (j 1)]dx
(1)ni (i 1)!(n i)!
R n1 Qn
j6=i [q (j 1)]dq
.
(1)ni (i 1)!(n i)!
0
a Newton-Cotes:
Punem Ai = (b a)Hi formula de cuadratur
Z b
n
X
f (x)dx (b a)
Hi fi ,
a
Coeficientii Cotes:
Hi =
Proprietati:
i=1
R n1 Qn
(j 1)]dq
,
(1)ni (i 1)!(n i)!(n 1)
0
j6=i [q
n
X
Hi = 1,
i = 1, 2, . . . , n.
Hi = Hni+1 .
i=1
11.3 Formula trapezelor

Coeficientii Cotes pt. n = 2:
H1 =
Formula trapezului:
1
(q 1)dq = ,
2
x2
x1
f (x)dx
H2 =
1
qdq = .
2
h
(f1 + f2 ).
2
y
y = f(x)
y = P1(x)
f2
f1
h
x1
x2
FIGURA 11.1. Formula trapezului aproximeaza functia prin dreapta care trece prin punctele
(x1 , f1 ) si (x2 , f2 ).
Restul formulei trapezului presupunnd f (x) C (2) [a, b]:

Z x1 +h
h
f (x)dx [f (x1 ) + f (x1 + h)].
R(h) =
2
x1
Derivam de doua ori n raport cu h:
1
h
[f (x1 + h) f (x1 )] f 0 (x1 + h)
2
2
h
R00 (h) = f 00 (x1 + h).
2
R0 (h) =
Integram de doua ori n raport cu h (R(0) = R0 (0) = 0) si utilizam teorema mediei:

Z h
Z h
1 00
h2
0
0
00
R (t)dt = f ( 1 )
tdt = f 00 ( 1 ), 1 (x1 , x1 + h)
R (h) = R (0) +
2
4
0
0
Z h
Z h
1
h3
R(h) = R(0) +
R0 (t)dt = f 00 ()
t2 dt = f 00 (), (x1 , x1 + h)
4
12
0
0
Restul:
R=
h3 00
f (),
12
3
(x1 , x2 ).
Generalizare formula de interes practic.

Utilizam aditivitatea integralei fata de intervalul de integrare.
y
fi
fn
f1
h
x1 x2 x3
h
xi
xn x
FIGURA 11.2. Formula trapezelor aproximeaza integrandul cu linia poligonala definita de abscisele echidistante si valorile corespunzatoare ale functiei.
Divizam [a, b] prin punctele echidistante:

xi = a + (i 1)h,
i = 1, 2, . . . , n.
h = (b a)/(n 1)
Aplicam formula trapezului fiecarui subinterval [x1 , x2 ],..., [xn1 , xn ]:
Z b
h
h
h
f (x)dx (f1 + f2 ) + (f2 + f3 ) + . . . + (fn1 + fn ).
2
2
2
a
Formula trapezelor:
Z
Restul:
R=
#
n1
f1 X
fn
+
.
f (x)dx h
fi +
2
2
i=2
"
(n 1)h3 00
(b a)h2 00
f () =
f (),
12
12
[a, b].
/*=========================================================================*/
float Trapez(float Func(float), float a, float b, int n)
/*--------------------------------------------------------------------------Calculeaza integrala functiei Func pe intervalul [a,b] utilizand formula
trapezelor cu n puncte de integrare
---------------------------------------------------------------------------*/
{
float h, s;
int i;
h = (b-a)/(n-1);
s = 0.5*(Func(a) + Func(b));
for (i=1; i<=(n-2); i++) s += Func(a+i*h);
return h*s;
}
Controlul automat al preciziei de integrare.

Calculul integralei pt. un pas h (n de puncte de integrare).
Compararea cu valoarea integralei pt. h/2 ((2n 1) puncte de integrare).
njumatatirea lui h pna cnd eroarea relativa a integralei scade sub un .
n0 =1
h0
h1
n1 =2
h2
n2 =4
n3 =8
h3
FIGURA 11.3. Schema de njumatatire a intervalelor n metoda trapezelor cu control automat

al pasului. Prin cerculete sunt figurate valorile care trebuie calculate n fiecare etapa.
Primele aproximatii ale formulei trapezelor:
f (a) f (b)
+
, h0 = b a
T0 = h0
2
2
f (a)
f (b)
T1 = h1
+ f (a + h1 ) +
, h1 = h0 /2
2
2
f (a)
f (b)
T2 = h2
+ f (a + h2 ) + f (a + 2h2 ) + f (a + 3h2 ) +
,
2
2
h2 = h1 /2
Proces recurent:
h0
[f (a) + f (b)], h0 = b a, n0 = 1
2"
#
nk1
X
1
Tk1 + hk1
=
f (a + (i 1/2)hk1 ) ,
2
i=1
T0 =
Tk
hk = hk1 /2,
nk = 2nk1 ,
k = 1, 2, . . .
hk = (b a)/nk lungimea subintervalelor dupa etapa k

nk = 2k numarul de subintervale dupa etapa k (numarul noilor puncte de integrare).
:
|Tk Tk1 | |Tk | .
/*=========================================================================*/
float TrapezControl(float Func(float), float a, float b)
/*--------------------------------------------------------------------------Calculeaza integrala functiei Func pe intervalul [a,b] utilizand formula
trapezelor cu controlul automat al pasului de integrare
---------------------------------------------------------------------------*/
{
/* precizia relativa a integralei */
const int kmax = 30;
/* numar maxim de injumatatiri */
float h, sum, t, t0;
long i, n;
int k;
h = b-a; n = 1;
t0 = 0.5*h*(Func(a) + Func(b));
/* aproximatie initiala */
for (k=1; k<=kmax; k++) {

/* ciclul injumatatirii pasului */
sum = 0.0;
for (i=1; i<=n; i++) sum += Func(a+(i-0.5)*h);
t = 0.5*(t0 + h*sum);
if (fabs(t - t0) <= eps*fabs(t)) break;
/* testeaza convergenta */
h *= 0.5; n *= 2;
/* injumatateste pasul */
t0 = t;
}
if (k >= kmax) printf("TrapezControl: nr. maxim de iteratii depasit !\n");
return t;
}
11.4 Formula lui Simpson

Coeficientii Cotes pentru n = 3:
H1
H2
H3
1
=
4
1
(q 1)(q 2)dq = ,
6
0
Z 2
1
2
=
q(q 2)dq = ,
2
3
Z 20
1
1
=
q(q 1)dq = .
4 0
6
Formula lui Simpson (x3 x1 = 2h):

Z x3
h
f (x)dx (f1 + 4f2 + f3 ).
3
x1
nlocuirea curbei y = f (x) cu parabola y = P2 (x) definita de (x1 , f1 ), (x2 , f2 ) si (x3 , f3 ).
Restul:
R=
h5 (4)
f (),
90
[a, b]
Generalizare formula de interes practic.

Utilizam aditivitatea integralei fata de intervalul de integrare.
Divizam [a, b] printr-un numar impar, n = 2m + 1, de puncte echidistante:
xi = a + (i 1)h,
i = 1, 2, . . . , n,
ba
ba
=
,
n1
2m
Aplicam formula trapezului fiecarui subinterval [x1 , x2 ],..., [xn1 , xn ]:
Z b
h
h
h
f (x)dx (f1 + 4f2 + f3 ) + (f3 + 4f4 + f5 ) + . . . + (fn2 + 4fn1 + fn ).
3
3
3
a
h=
Formula lui Simpson generalizat

a,
Z b
h
f (x)dx (f1 + 4 2 + 2 1 + fn ) ,
3
a
(n3)/2
1 =
(n1)/2
f2i+1 ,
i=1
2 =
f2i .
i=1
Restul admitnd ca f (x) C (4) [a, b]:

R=
(b a)h4 (4)
mh5 (4)
f () =
f (),
90
180
8
[a, b].
/*=========================================================================*/
float Simpson0(float Func(float), float a, float b, int n)
/*--------------------------------------------------------------------------Calculeaza integrala functiei Func pe intervalul [a,b] utilizand formula lui
Simpson cu n puncte de integrare
---------------------------------------------------------------------------*/
{
float h, s1, s2;
int i, par = 0;
if ((n/2)*2 == n) n++;
/* incrementeaza n daca este par */
h = (b-a)/(n-1);
s1 = s2 = 0.0;
for (i=1; i<=(n-2); i++) {
if (par) s1 += Func(a+i*h); else s2 += Func(a+i*h);
par = ~par;
/* paritatea urmatorului termen */
}
return (h/3)*(Func(a) + 4*s2 + 2*s1 + Func(b));
}
Codificare mai eficienta:

(n3)/2
1 =
f (x2i+1 ),
x2i+1 = a + i(2h)
i=1
2 = f (x2 ) +
(n3)/2
f (x2(i+1) ),
x2(i+1) = x2i+1 + h,
i=1
/*=========================================================================*/
float Simpson(float Func(float), float a, float b, int n)
Simpson cu n puncte de integrare
---------------------------------------------------------------------------*/
{
float h, h2, s1, s2, x;
int i;
if ((n/2)*2 == n) n++;
/* incrementeaza n daca este par */
h = (b-a)/(n-1); h2 = 2*h;
s1 = 0.0; s2 = Func(a+h);
for (i=1; i<=(n-3)/2; i++) {
x = a + i*h2;
s1 += Func(x); s2 += Func(x+h);
}
return (h/3)*(Func(a) + 4*s2 + 2*s1 + Func(b));
}
Controlul automat al preciziei de integrare.

Primele aproximatii ale formulei lui Simpson:
h1
4T1 T0
[f (a) + 4f (a + h1 ) + f (b)] =
3
3
h2
4T2 T1
S2 = [f (a) + 4f (a + h2 ) + 2f (a + 2h2 ) + 4f (a + 3h2 ) + f (b)] =
3
3
S1 =
Generaliznd:
Sk =
4Tk Tk1
.
3
Proces recurent:
h0
[f (a) + f (b)], h0 = b a, n0 = 1
2"
#
nk1
X
1
Tk1 + hk1
f (a + (i 1/2)hk1 ) ,
Tk =
2
i=1
T0 =
Sk =
4Tk Tk1
,
3
hk = hk1 /2,
k = 1, 2, . . .
nk = 2nk1 .
:
|Sk Sk1 | |Sk | .
/*=========================================================================*/
float SimpsonControl(float Func(float), float a, float b)
Simpson cu controlul automat al pasului de integrare
---------------------------------------------------------------------------*/
{
/* precizia relativa a integralei */
const int kmax = 30;
/* numar maxim de injumatatiri */
float h, s, s0, sum, t, t0;
long i, n;
int k;
h = b-a; n = 1;
s0 = t0 = 0.5*h*(Func(a) + Func(b));
/* aproximatie initiala */
for (k=1; k<=kmax; k++) {

/* ciclul injumatatirii pasului */
sum = 0.0;
for (i=1; i<=n; i++) sum += Func(a+(i-0.5)*h);
t = 0.5*(t0 + h*sum);
s = (4*t - t0)/3;
if (fabs(s - s0) <= eps*fabs(s)) break;
/* testeaza convergenta */
h *= 0.5; n *= 2;
/* injumatateste pasul */
s0 = s; t0 = t;
}
if (k >= kmax) printf("SimpsonControl: nr. maxim de iteratii depasit!\n");
return s;
}
10
11.8 Integrale multidimensionale

Complicatii:
cresterea rapida a numarului de evaluari ale functiei nd
n nr. de evaluari pt. o schema unidimensionala, d dimensiunea integralei
dificultatea descrierii frontierei (d 1)-dimensionale a domeniului de integrare.
Optiuni pt. integranzi netezi:
frontiere complicate, precizie redusa metoda Monte Carlo
(lent convergenta n raport cu numarul de puncte de integrare).
frontiere simple, precizie ridicata descompunerea n integrale 1D repetate
aplicarea unui integrator 1D cu control automat al pasului pt. fiecare dimensiune.
Integrala bidimensionala:
Z xmax Z ymax (x)
Z
f (x, y)dxdy =
xmin
ymin (x)
xmax
Fx (x)dx,
Fx (x) =
ymax (x)
f (x, y)dy,
ymin (x)
xmin
integrala exterioara n raport cu x, al carei integrand este integrala n raport cu y pe o

anumita linie cu x fixat.
y
ymax(xi)
ymin(xi)
xmin
xi
xmax
FIGURA 11.4. n metoda descompunerii n integrale unidimensionale, integrarea interioara

dupa y are loc pe o retea de puncte independenta pentru fiecare argument xi al integrarii
exterioare.
Pt. fiecare xi se calculeaza

Fx (xi ) =
ymax (xi )
f (xi , y)dy
ymin (xi )
pe o retea determinata de particularitatile locale ale integrandului.

11
Exemplu:
1x2
1 x2 y 2 dy = 0.523599.
6
0
0
Domeniul de integrare primul cadran al cercului de raza 1.
Rezultatul volumul primului octant al sferei de raza 1.
I=
dx
#include <stdio.h>
#include <math.h>
float xconst;
/*=========================================================================*/
float func(float x, float y)
{
return sqrt(fabs(1. - x*x - y*y));
}
/*=========================================================================*/
float ymin(float x) { return 0.0; }
/*=========================================================================*/
float ymax(float x) { return sqrt(1. - x*x); }
/*=========================================================================*/
{
. . . . . . . . . .
}
/*=========================================================================*/
float Fy(float y)
/* functie interfata de o variabila */
{
/* pt. functia utilizator func(x,y) */
return func(xconst,y);
/* xconst este variabila globala */
}
/*=========================================================================*/
float Fx(float x)
{
xconst = x;
return SimpsonControl(Fy,ymin(x),ymax(x));
}
/*=========================================================================*/
void main()
{
float xmin = 0.0, xmax = 1.0;
printf("Integrala = %f\n",SimpsonControl(Fx,xmin,xmax));
}
Pt. a fi integrata n raport cu y, func este apelata prin functia interfata

Fy.
Parametrul global xconst si primeste valoarea n functia Fx.
Integrala tripla:
Z
xmax
xmin
ymax (x)
zmax (x,y)
f (x, y, z)dxdydz =
ymin (x)
zmin (x,y)
Z ymax (x)
Fx (x) =
Fy (x, y)dy,
Fy (x, y) =
ymin (x)
xmax
zmin (x,y)
12
Fx (x)dx,
xmin
zmax (x,y)
f (x, y, z)dz.
Exemplu:
I=
dx
1x2
dy
Z 1x2 y2
0
dz =
0.523599,
6
#include <stdio.h>
#include <math.h>
float xconst, yconst;
/*=========================================================================*/
float func(float x, float y, float z)
{
return 1.0;
}
/*=========================================================================*/
float ymin(float x) { return 0.0; }
/*=========================================================================*/
float ymax(float x) { return sqrt(1. - x*x); }
/*=========================================================================*/
float zmin(float x, float y) { return 0.0; }
/*=========================================================================*/
float zmax(float x, float y) { return sqrt(fabs(1. - x*x - y*y)); }
/*=========================================================================*/
{
. . . . . . . . . .
}
/*=========================================================================*/
float Fz(float z)
/* functie interfata de o variabila
*/
{
/* pt. functia utilizator func(x,y,z) */
return func(xconst,yconst,z);
/* xconst, yconst - variabile globale */
}
/*=========================================================================*/
float Fy(float y)
{
yconst = y;
return SimpsonControl(Fz,zmin(xconst,y),zmax(xconst,y));
}
/*=========================================================================*/
float Fx(float x)
{
xconst = x;
return SimpsonControl(Fy,ymin(x),ymax(x));
}
/*=========================================================================*/
void main()
{
float xmin = 0.0, xmax = 1.0;
printf("Integrala = %f\n",SimpsonControl(Fx,xmin,xmax));
}
Pt. a fi integrata n raport cu z, func este apelata prin functia interfata

Fz.
Parametrii globali xconst si yconst si primesc valorile n functia Fx, respectiv Fy.
13
Bibliography
[1] M. Abramowitz si I. Stegun, Handbook of Mathematical Functions (Dover Publications, New York, 1972).
[2] A.H. Stroud si D. Secrest, Gaussian Cuadrature Formulas (Prentice-Hall, Englewood
Clis, 1966).
[3] A.H. Stroud, Approximate Calculation of Multiple Integrals (Prentice-Hall, Englewood
Clis, 1971).
[4] A. Ralston si P. Rabinowitz, A First Course in Numerical Analysis (McGraw-Hill,
New York, 1978).
Moskow, 1981).
Cambridge, 1992).
13
ECUA
TII DIFEREN
TIALE ORDINARE
11.1 Introducere
Importanta multe legi ale fizicii au formulari diferentiale.
Ecuatiile de miscare ale mecanicii clasice, ecuatiile difuziei si transportului de caldura,
ecuatia lui Schrdinger etc.
Exemplu: ecuatia de miscare a unei particule de masa m ntr-un cmp de forte F (x):
m
d2 x
= F (x).
dt2
Definind impulsul particulei

dx
,
dt
ecuatia de miscare doua ecuatii de ordinul nti (ecuatiile lui Hamilton):
p=m
p
dx
= ,
dt
m
dp
= F (x).
dt
Este suficienta considerarea metodelor de rezolvare pt. ecuatii sau sisteme de ecuatii de
ordinul nti.
Sistem de ecuatii diferentiale de ordinul nti:

yi0 (x) = fi (x, y1 (x), y2 (x), . . . , yn (x)),
i = 1, 2, . . . , n.
Ecuatie diferentiala de ordinul n,

y (n) = f (x, y, y 0 , . . . , y (n1) ),
Considernd ca necunoscute
y1 y(x), y2 y 0 (x), . . . yn y (n1) (x)
sistem de n ecuatii diferentiale de ordinul nti:
0
yi (x) = yi+1 (x), i = 1, 2, . . . , n 1
yn0 (x) = f (x, y1 (x), y2 (x), . . . , yn (x)).
Sistemul sub forma matriciala
y 0 (x) = f (x, y),
cu
y=
y1 (x)
y2 (x)
..
.
yn (x)
f (x, y) =
f1 (x, y1 (x), . . . , yn (x))

f2 (x, y1 (x), . . . , yn (x))
..
.
fn (x, y1 (x), . . . , yn (x))
Tipuri de probleme:
probleme cu conditii initiale sau probleme Cauchy conditii suplimentare ntr-un
punct initial x0 ,
y(x0 ) = y0 .
Rezolvarea determinarea progresiva a solutiei pe o retea de puncte x0 , x1 , x2 , . . .,
xmax .
Tipuri de metode:
metode directe (pas cu pas, sau unipas) solutia la un pas xm numai pe baza
informatiilor din nodul anterior, xm1 , si, eventual, din intervalul [xm1 , xm ].
metodele Euler si Runge-Kutta
metode indirecte (sau multipas) solutia la un pas xm pe baza informatiilor
de la mai multi pasi anteriori xm1 , xm2 , . . .
metodele Adams-Moulton, Milne, Fox-Goodwin si Numerov.
probleme cu conditii la limita bilocale sau problemele de tip Dirichlet conditii
asupra valorilor solutiei si derivatelor la capetele unui interval [xmin , xmax ].
13.2
Metoda dezvoltarii n serie Taylor
Importanta furnizeaza criterii pentru evaluarea preciziei metodelor de interes practic.

Fie problema Cauchy:
y 0 = f (x, y),
y(x0 ) = y0 .
Dezvoltarea solutiei n serie Taylor n vecinatatea lui x0 :
y(x) = y(x0 ) +
x x0 0
(x x0 )2 00
y (x0 ) +
y (x0 ) + . . .
1!
2!
Propagarea solutiei de la punctul de retea xm la punctul xm+1 :

0
ym+1 = ym + hym
+
h2 00
y + ...,
2 m
cu
h = xm+1 xm .
Cu ct h este mai mic, seria converge mai rapid si ym+1 aproximeaza mai bine valoarea
exacta y(xm+1 ) a solutiei.
Din ecuatia diferentiala
0
= f (xm , ym ).
ym
Derivnd ambii membri ai ecuatiei diferentiale
f
f f y
f
00
ym =
+
+f
=
.
x y x xm ,ym
x
y xm ,ym
Rezulta formula de propagare
ym+1
h2 f
f
= ym + hf (xm , ym ) +
+ O(h3 ).
+f
2 x
y xm ,ym
Metoda directa, de tip explicit.

Definitia 13.1 O metoda este de ordinul p daca furnizeaza o solutie echivalenta cu dezvoltarea Taylor a solutiei exacte pna la termeni de ordinul hp .
13.3 Metoda lui Euler (metoda liniilor poligonale)

Aproximatia liniara a metodei dezvoltarii n serie Taylor:
ym+1 = ym + hf (xm , ym ),
m = 0, 1, 2, . . . ,
cu
h = xm+1 xm .
Metoda directa de ordinul 1, de tip explicit
y
y = y(x)
ym
y1
y0
ym +1
h
x0
x1
...
xm
xm +1 x
FIGURA 13.1. n metoda Euler se aproximeaza solutia exacta cu o linie poligonala.
Erorile de trunchiere si de rotunjire se propaga de la un pas la altul.

Algoritmul predictor-corector al lui Euler (metoda de ordinul 2):
p
din formula predictor:
1. se calculeaza valoarea predictor ym+1
p
= ym + hf (xm , ym ),
ym+1
c
din formula corector
2. se calculeaza recurent valoarea corector ym+1
c
= ym +
ym+1
h
p
) .
f (xm , ym ) + f (xm+1 , ym+1
2
p
c
cu valoarea anterioara ym+1
, pna cnd se obtine
nlocuind de fiecare data ym+1
precizia dorita
c
p
ym+1 ym+1
, > 0.
13.4 Metodele Runge-Kutta

Proprietati:
metode directe (pas cu pas) posibilitatea autopornirii.
solutia prin metoda Runge-Kutta de ordinul p este echivalenta cu dezvoltarea n
serie Taylor pna n hp .
necesita numai evaluarea functiei f (x, y), nu si a derivatelor.
Fie ecuatia:
y 0 = f (x, y).
Propagarea solutiei prin metoda dezvoltarii n serie Taylor:
f
h2 f
+f
+ ...
ym+1 = ym + hf (xm , ym ) +
2 x
y xm ,ym
Se cauta o formula de propagare care sa depinda de f (x, y), dar nu si de derivatele sale:
ym+1 = ym +
p
X
wi ki ,
i=1
ki = hf ( i , i )
i = xm + i h
i1
X
ij kj .
i = ym +
j=1
Se alege:
1 = 0,
11 = 0,
1 = xm ,
1 = ym .
Rezulta:
k1 = hf (xm , ym )
k2 = hf (xm + 2 h, ym + 21 k1 )
k = hf (xm + 3 h, ym + 31 k1 + 32 k2 )
Metoda Runge-Kutta p = 1:
ym+1 = ym + hf (xm , ym )
metoda lui Euler.
Metoda Runge-Kutta p = 2:
ym+1 = ym + w1 k1 + w2 k2 ,
sau
k1 = hf (xm , ym )
k2 = hf (xm + 2 h, ym + 21 k1 ),
ym+1 = ym + w1 hf (xm , ym ) + w2 hf (xm + 2 h, ym + 21 hf (xm , ym )).

Dezvoltam dupa puterile lui h:
ym+1
f
f
= ym + (w1 + w2 )hf (xm , ym ) + h w2 2
.
+ w2 21 f
x
y xm ,ym
2
Comparnd cu dezvoltarea n serie rezulta:
w1 + w2 = 1
w2 2 = 1/2
w2 21 = 1/2.
Nu are solutie unica solutie posibilia:
2 = 21 = 1
w1 = w2 = 1/2.
Formulele metodei Runge-Kutta de ordinul doi:
1
ym+1 = ym + (k1 + k2 ),
2
unde
sau
k1 = hf (xm , ym )
k2 = hf (xm + h, ym + k1 ),
h
ym+1 = ym + [f (xm , ym ) + f (xm + h, ym + hf (xm , ym ))].
2
algoritmul predictor-corector al lui Euler (formula predictor nlocuita n cea corector).
Metoda Runge-Kutta p = 4 (varianta cea mai importanta):
1
ym+1 = ym + (k1 + 2k2 + 2k3 + k4 ),
6
cu
Eroarea de trunchiere:
k1
k2
k
3
k4
m = 0, 1, 2, . . . ,
= hf (xm , ym )
= hf (xm + h/2, ym + k1 /2)
= hf (xm + h/2, ym + k2 /2)
= hf (xm + h, ym + k3 ).
T = Kh5 .
6
Sisteme de ecuatii diferentiale de ordinul nti:

yi0 (x) = fi (x, y1 (x), y2 (x), . . . , yn (x)),
i = 1, 2, . . . , n,
Formulele Runge-Kutta p = 4:
i
hh
f1,i + 2(f2,i + f3,i ) + f4,i , i = 1, 2, . . . , n,
ym+1,i = ym,i +
6
cu

f1,i = fi (xm , {ym,i })

f2,i = fi (xm + h/2, {ym,i + (h/2)f1,i })
f = fi (xm + h/2, {ym,i + (h/2)f2,i })
3,i
f4,i = fi (xm + h, {ym,i + hf3,i }).
/*=========================================================================*/
void RungeKutta(float x, float h, float y0[], float y[], int n,
void Func(float,float[],float[]))
/*--------------------------------------------------------------------------Utilizeaza metoda Runge-Kutta de ordinul 4 pentru a propaga solutia unui
sistem de ecuatii diferentiale ordinare de ordinul 1
y[i] = f[i](x,y[1],...,y[n]), i = 1..n
x
h
y0[]
y[]
n
Func
punctul initial
distanta pe care este propagata solutia
valorile componentelor solutiei in punctul initial x
valorile solutiei propagate in punctul x + h
numarul ecuatiilor diferentiale
rutina utilizator care returneaza membrii drepti f[i](...) ai
ecuatiilor; definitie:
void Func(float x, float y[], float f[]);
---------------------------------------------------------------------------*/
{
int i;
float h2, h6;
float *f1, *f2, *f3, *f4;
f1
f2
f3
f4
=
=
=
=
Vector(1,n);
Vector(1,n);
Vector(1,n);
Vector(1,n);
h2 = 0.5*h;
Func(x,y0,f1);
for (i=1; i<=n; i++) y[i] =
Func(x+h2,y,f2);
for (i=1; i<=n; i++) y[i] =
Func(x+h2,y,f3);
for (i=1; i<=n; i++) y[i] =
Func(x+h,y,f4);
h6 = h/6.0;
for (i=1; i<=n; i++)
y[i] = y0[i] + h6*(f1[i]
y0[i] + h2*f1[i];
y0[i] + h2*f2[i];
y0[i] + h *f3[i];
+ 2*(f2[i] + f3[i]) + f4[i]);
FreeVector(f1,1);
FreeVector(f2,1);
FreeVector(f3,1);
FreeVector(f4,1);
}
Exemplu:
y 00 + y = 0
cu conditiile initiale:
y(x0 ) = y0
y 0 (x0 ) = y00 .
Solutia generala: y(x) = A sin x + B cos x.

Forma echivalenta a ecuatiei sistem de doua ecuatii de ordinul nti:
0
y1 = y2
y20 = y1 ,
cu conditiile initiale:
Caz particular:
y1 (x0 ) = y0
y2 (x0 ) = y00 .
y1 (0) = 0,
y2 (0) = 1,
solutia
y1 (x) = sin x,
y2 (x) = cos x.
/*--------------------------------------------------------------------------Rezolva un sistem de ecuatii diferentiale ordinare de ordinul 1 prin metoda

Runge-Kutta de ordinul 4
---------------------------------------------------------------------------*/
#include <math.h>
/*=========================================================================*/
void Func1(float x, float y[], float f[])
/*--------------------------------------------------------------------------Returneaza membrii drepti ai sistemului de ecuatii diferentiale
---------------------------------------------------------------------------*/
{
f[1] = y[2];
f[2] = -y[1];
}
/*=========================================================================*/
void RungeKutta(float x, float h, float y0[], float y[], int n,
void Func(float,float[],float[]))
{
. . . . . . . . . .
}
/*=========================================================================*/
void main()
{
int i, n;
float h, x, xmin, xmax;
float *y, *y0;
/* ordinul sistemului */
y0 = Vector(1,n);
y = Vector(1,n);
/* domeniul de integrare */
for (i=1; i<=n; i++)
/* conditiile initiale */
{ printf("y0[%i] = ",i); scanf("%f",&y0[i]); }
printf("h = "); scanf("%f",&h);
/* pasul */
printf("
x
y\n");
x = xmin;
while (x < xmax) {
RungeKutta(x,h,y0,y,n,Func1);
x += h;
for (i=1; i<=n; i++) y0[i] = y[i];
printf("%10f",x);
for (i=1; i<=n; i++) printf("%10f",y[i]);
printf("\n");
}
FreeVector(y0,1);
FreeVector(y ,1);
}
/* ciclul de propagare */
/* actualizeaza
*/
/* conditiile initiale */
Bibliography
[1] C.W. Gear, Numerical Initial Value Problems in Ordinary Dierential Equations
(Prentice-Hall, Englewood Clis, NJ, 1971).
[2] L.Gr. Ixaru, Metode numerice pentru ecuatii diferentiale cu aplicatii (Editura Academiei, Bucuresti, 1979).
[3] J. Stoer si R. Bulirsch, Introduction to Numerical Analysis (Springer-Verlag, New
York, 1980).
[4] M. Toma si I. Odagescu, Metode numerice si subroutine, Editura tehnica, Bucuresti,
1980).
Cambridge, 1992).
14
ECUA
TII CU DERIVATE PAR
TIALE
14.3 Probleme cu conditii initiale pentru ecuatii de tip parabolic

Prototip ecuatia unidimensional
a a difuziei.
Tehnicile de discretizare si analiza de stabilitate ramn valabile.
Solutii analitice geometrii simple, coeficient de difuzie constant.
Metode numerice:
restrngerea solutiei la un set de puncte de retea, convenabil distribuite
aproximarea derivatelor prin scheme discrete
rezolvarea sistemului liniar rezultat valorile solutiei n nodurile retelei.
Ecuatia 1D a difuziei pentru coeficient de difuzie D constant:
u
2u
= D 2.
t
x
Consideram conditia initial
a:
u(x, t0 ) = u0 (x),
x [0, L],
(profilul de concentratie este dat la t0 , pe ntreaga grosime a stratului).

Conditii la limit
a (de tip Dirichlet):
u(0, t) = u00 ,
u(L, t) = u0L .
(concentratia pe suprafetele exterioare ale stratului este constanta pentru orice t t0 ).
14.0.1
Metoda explicit
a cu diferente finite
Aproximarea prin scheme cu diferente finite a derivatelor implicate.

Retea de discretizare spatiu-timp regulata:
xi = (i 1)h, i = 1, 2, . . . , M,
tn = nt, n = 0, 1, 2, . . .
(14.1)
(14.2)
t pasul temporal, h pasul spatial:

h = L/(M 1),
(14.3)
M numarul punctelor de retea spatiale.

Derivata temporal
a a lui uni u(xi , tn )
2

1
u
u
n+1
n
2
ui = ui + t
+ (t)
+ ,
t i,n 2
t2 i,n
Aproximatia liniara schem
a cu diferente progresive:

u
un+1 uni
= i
+ O(t).
t i,n
t
Derivata spatial
a
uni1
uni+1
=
=
uni
uni
1!
h
+
1!
u
x
u
x
h2
+
2!
i,n
h2
+
2!
i,n
2u
x2
2u
x2
h3
3!
i,n
h3
+
3!
i,n
3u
x3
3u
x3
i,n
+ ,
i,n
Retinnd termenii n h3 , prin adunare schem

a cu diferente centrale:
2
uni+1 2uni + uni1
u
=
+ O(h2 ),
x2 i,n
h2
Aproximatie O(h2 ) deoarece termenii neglijati sunt de ordinul h4 .
Aproximatie discretizata de ordinul O(h2 + t) a ecuatiei difuziei n (xi , tn ):

un 2uni + uni1
un+1
uni
i
.
= D i+1
t
h2
Solutia propagata la tn+1 pentru fiecare xi interior poate fi explicitata:
= uni1 + (1 2) uni + uni+1 ,
un+1
i
i = 2, 3, . . . , M 1,
cu
Dt
.
h2
Schema cu diferente progresive pentru derivata temporala metod
a explicit
a.
=
Pentru punctele de pe frontiera:

un+1
= un1 = u00 ,
1
n+1
uM = unM = u0L .
Cu notatii matriciale:
un+1 = B un ,
n = 0, 1, 2, . . .
1
0
0
1 2
...
...
...
B =
,
1 2
0
0
1
explicit
CrankNicholson
un1
un2
..
.
un =
n
uM1
unM
implicit
n+1 n+1 n+1

u i+1
u i -1 u i
tn+1
t
tn
u i -1
ui
u i+1
t1
t0
x1 = 0
xi -1 xi xi+1
xM =L
FIGURA 14.1. Reteaua de discretizare spatiu-timp pentru ecuatia unidimensionala a difuziei,

punnd n evidenta schemele de discretizare explicita, implicita si Crank-Nicholson.
/*=========================================================================*/
void PropagExplicit(float D, float u0[], float u[], float dt, float h, int m)
/*--------------------------------------------------------------------------Propaga solutia u0[] a ecuatiei difuziei cu coeficient constant D,
du/dt = D d2u/dx2,
pe intervalul temporal dt, utilizand schema de discretizare explicita pe o
retea spatiala cu m puncte si pasul h. Returneaza solutia in u[].
---------------------------------------------------------------------------*/
{
float lambda;
int i;
lambda = D * dt/(h*h);
u[1] = u0[1];
u[m] = u0[m];
for (i=2; i<=(m-1); i++)
u[i] = lambda*u0[i-1] + (1-2*lambda)*u0[i] + lambda*u0[i+1];
}
D coeficientul de difuzie (constant)

u0[] solutia initiala
u[] solutia propagata u0[]
dt pasul temporal
h pasul spatial
m numarul punctelor spatiale.
Secventa de program principal:
for (i=1; i<=m; i++) u0[i] = ...;
/* conditia initiala */
t = 0.0;
while (t <= tmax) {
PropagExplicit(D,u0,u,dt,h,m);
for (i=1; i<=m; i++) u0[i] = u[i];
t += dt;
}
/* ciclul temporal */
/* propaga solutia */
Metoda explicita instabilitate numeric

a
Se dezvolta oscilatii care cresc exponential n timp.
Comportamentul critic apare daca t depaseste o anumita limita corelata cu h, si se
datoreaza dominantei crescnde a erorilor de rotunjire.
Aplicatie: D = 1:
2u
u
= 2,
t
x
x [0, 1],
t > 0,
conditii la limita:
u(0, t) = u(1, t) = 0,
t > 0,
conditie initiala:
u(x, 0) = sin(x),
x [0, 1].
Solutia analitica:
u(x, t) = exp( 2 t) sin(x).
Crestere aparent nesemnificativa a lui t schimbare calitativa a solutiei.
a: pentru 1/2 propagarea solutiei este stabila,
t/h2 = 1/2 este o valoare critic
pentru > 1/2 propagarea devine instabila.
14.0.2
Analiza de stabilitate von Neumann
Analiz
a local
a se presupune ca coeficientii ecuatiei cu diferente pot fi considerati
constanti
Modurile proprii (solutiile independente) ale ecuatiei cu diferente:
uni = n exp kxi = c n exp(kih),
unitatea imaginara
k numarul de unda spatial
(k) factor de amplificare, care este o functie complexa de k.
Orice solutie a ecuatiei discretizate poate fi reprezentata ca o combinatie liniara a modurilor proprii.
Criteriul de stabilitate von Neumann propagare temporala stabila a solutiei daca:
|(k)| < 1.
Factorul de amplificare pentru metoda explicita:
= exp(kh) + (1 2) + exp(kh).
Combinnd exponentialele si utiliznd 1 cos x = 2 sin2 (x/2):
= 1 4 sin2 (kh/2).
Deoarece 0 sin2 (kh/2) 1, criteriului de stabilitate von Neumann conduce la:
0 < < 1/2,
Avnd n vedere Dt/h2 rezulta:
t <
1 h2
.
2D
(14.4)
Pasul temporal t care asigura stabilitatea algoritmului este limitat superior de o valoare
proportionala cu timpul de difuzie pe distanta h. metoda explicita este conditional
stabil
a, iar valoarea = 1/2 este critica.
0.16
exact
numeric
0.14
0.12
t = 2.0
0.10
t = 2.5
0.08
0.06
t = 3.0
0.04
0.02
0.00
0.0
0.2
0.4
0.6
0.8
1.0
FIGURA 14.2. Solutii exacte si solutii numerice prin metoda explicita (cu h = 0.05 si
t = 0.00125) pentru problema de difuzie (14.44)(14.46).
0.16
exact
numeric
0.14
0.12
t = 2.0
0.10
t = 2.5
0.08
0.06
0.04
t = 3.0
0.02
0.00
0.0
0.2
0.4
0.6
0.8
1.0
FIGURA 14.3. Solutii exacte si solutii numerice prin metoda explicita (cu h = 0.05 si
t = 0.0013) pentru problema de difuzie (14.44)(14.46).
14.0.3
Metoda implicit
a si metoda Crank-Nicholson
Pentru a obtine un algoritm neconditionat stabil schema de discretizare regresiv

a
pentru derivata temporala.
Se aproximeaza ecuatia difuziei n (xi , tn+1 ):
+ un+1
un+1 2un+1
un+1
uni
i
i1
i
.
= D i+1
t
h2
Rezulta sistemul de ecuatii liniare ( = Dt/h2 ):
n+1
n
un+1
un+1
i1 + (1 + 2) ui
i+1 = ui ,
i = 2, 3, . . . , M 1.
Componentele solutiei propagate rezolvarea sistemului + conditii la limita schema

cu diferente regresive este implicita.
Procesul de propagare sub forma matriciala:
A un+1 = un ,
cu
n = 0, 1, 2, . . . ,
1
0
1 + 2
...
...
...
A =
1 + 2
0
1
(conditii la limita de tip Dirichlet).

Deoarece > 0, matricea A este pozitiv definita si diagonal dominanta.
Factorul de amplificare:
=
1
,
1 + 4 sin2 (kh/2)
si
|(k)| < 1
pentru orice t metoda implicita este neconditionat stabil

a si tot de ordinul O(h2 +
t).
/*=========================================================================*/
void PropagImplicit(float D, float u0[], float u[], float dt, float h, int m)
du/dt = D d2u/dx2,
pe intervalul temporal dt, utilizand schema de discretizare implicita
pe o retea spatiala cu m puncte si pasul h. Returneaza solutia in u[].
---------------------------------------------------------------------------*/
{
float *a, *b, *c;
float lambda;
int i;
a = Vector(1,m);
b = Vector(1,m);
c = Vector(1,m);
lambda = D * dt/(h*h);
b[1] = 1.0; c[1] = 0.0; u[1] = u0[1];
for (i=2; i<=(m-1); i++) {
a[i] = -lambda;
b[i] = 1.0 + 2*lambda;
c[i] = -lambda;
u[i] = u0[i];
}
a[m] = 0.0; b[m] = 1.0; u[m] = u0[m];
TriDiag(a,b,c,u,m);
FreeVector(a,1);
FreeVector(b,1);
FreeVector(c,1);
}
Metoda de ordinul O((t)2 + h2 ) aproximarea ecuatiei difuziei la tn+1/2 tn + t/2

si utilizarea unei scheme cu diferente centrale pentru derivata temporala.
Consideram dezvoltarile n jurul momentului tn+1/2 ,
2

u
u
1
n+1/2
n+1
2
ui
= ui
+ (t/2)
+ (t/2)
+ ,
t i,n+1/2 2
t2 i,n+1/2
2

1
u
u
n+1/2
n
2
(t/2)
+ (t/2)

ui = ui
t i,n+1/2 2
t2 i,n+1/2
Prin scadere schema de ordinul doi cu diferente centrale:

u
un+1 uni
+ O((t)2 ).
= i
t i,n+1/2
t
Derivata spatiala la tn+1/2 media schemelor cu diferente pentru tn si tn+1 .
Ecuatia discretizata schema de discretizare Crank-Nicholson:
n
n+1
n+1
n+1
n
n
n
2u
+
u
2u
+
u
+
u
u
u
un+1
D
i+1
i
i1
i+1
i
i1
i
i
=
.
t
2
h2
sau
n+1
n
n
n
un+1
un+1
i1 + (1 + 2) ui
i+1 = ui1 + (1 2) ui + ui+1 ,
i = 2, 3, . . . , M 1,
cu
=
1 Dt
.
2 h2
Reprezentarea matriciala:
A un+1 = B un ,
n = 0, 1, 2, . . . ,
A, B matrici tridiagonale
A pozitiv definita, dominant diagonala si nesingulara.
Factorul de amplificare
=
1 4 sin2 (kh/2)
1 + 4 sin2 (kh/2)
Metoda Crank-Nicholson este neconditionat stabil

a si are ordin de precizie nalt, O((t)2 +
h2 ).
10
/*=========================================================================*/
void CrankNicholson(float D, float u0[], float u[], float dt, float h, int m)
du/dt = D d2u/dx2,
pe intervalul temporal dt, utilizand schema de discretizare Crank-Nicholson
pe o retea spatiala cu m puncte si pasul h. Returneaza solutia in u[].
---------------------------------------------------------------------------*/
{
float *a, *b, *c;
float lambda;
int i;
a = Vector(1,m);
b = Vector(1,m);
c = Vector(1,m);
lambda = 0.5 * D * dt/(h*h);
b[1] = 1.0; c[1] = 0.0; u[1] = u0[1];
for (i=2; i<=(m-1); i++) {
a[i] = -lambda;
b[i] = 1.0 + 2*lambda;
c[i] = -lambda;
u[i] = lambda*u0[i-1] + (1.0 - 2*lambda)*u0[i] + lambda*u0[i+1];
}
a[m] = 0.0; b[m] = 1.0; u[m] = u0[m];
TriDiag(a,b,c,u,m);
FreeVector(a,1);
FreeVector(b,1);
FreeVector(c,1);
}
0.08
0.06
0.04
exact
implicit
Crank-Nicholson
0.02
0.00
0.0
0.2
0.4
0.6
0.8
1.0
FIGURA 14.4. Solutia exacta si solutiile numerice prin metoda implicita si prin metoda
Crank-Nicholson (cu h = 0.05 si t = 0.025) la momentul t = 3.0 pentru problema de difuzie (14.44)(14.46).
11
Bibliography
[1] N. Racoveanu, Gh. Dodescu, I. Mincu, Metode numerice pentru ecuatii cu derivate
partiale de tip parabolic (Editura Tehnica, Bucuresti, 1977).
[2] W.F. Ames, Numerical Methods for Partial Dierential Equations, (Academic Press,
New York, 1977).
[3] A. Samarski, V. Andreev, Mthodes aux dirences pour quations elliptiques (MIR,
Moscou, 1978).
[4] L.Gr. Ixaru, Metode numerice pentru ecuatii diferentiale cu aplicatii (Editura Academiei, Bucuresti, 1979).
[5] R.L. Burden, J.D. Faires, Numerical Analysis, Third Edition (Prindle, Weber &
[6] S.E. Koonin, D.C. Meredith, Computational Physics, Fortran Version (AddisonWesley, Redwood CA, 1990).
[7] W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P Flannery, Numerical Recipes in C,
Second Edition (Cambridge University Press, Cambridge, 1992).
10
APROXIMAREA FUNC
TIILOR TABELATE
10.1 Interpolare si regresie

Problema aproxim
arii functiilor tabelate:
Fie o functie
f : [, ] <, [, ] <,
specificata prin valorile pe o retea de puncte xi [, ]:
f (xi ) = yi ,
i = 1, 2, . . . , n.
Dependenta trebuie adesea modelata printr-o functie continua pe [, ] functie model:

F = F (x; a1 , . . . , am ).
Functia model F si valorile parametrilor aj se aleg astfel nct f sa fie aproximata optim.
Alegerea functiei model:
dintr-o clasa convenabila de functii (polinoame, gaussiene etc.), care pot fi usor
manipulate analitic,
dintr-o teorie, n care parametrii de model au o semnificatie bine stabilita,
dintr-un compromis ntre constrngerile si avantajele optiunilor anterioare.
Gradul n care functia model F aproximeaza functia tabelata f distanta:
d(f, F ) =
( n
X
i=1
[f (xi ) F (xi ; a)]
)1/2
Aproximarea n medie p
atratic
a utilizata n: interpolare si regresie.
y
M1
M1
y = F (x;a)
y1
y = F (x;a)
Mi
y1
yi
x1
Mi
yi
Mn
yn
yn
xn x
xi
x1
(a)
xi
Mn
xn x
(b)
FIGURA 10.1. Functia model trece n cazul interpolarii prin toate punctele de tabelare (a), iar
n cazul regresiei minimizeaza functia de merit (b). Alura celor doua curbe poate fi cu totul
diferita chiar si pentru acelasi set de date.
Interpolarea
Valorile tabelate yi sunt considerate exacte se impune:
d(f, F ) = 0.
Functia model trebuie sa satisfaca conditiile de interpolare:
F (xi ; a) = yi ,
i = 1, 2, . . . , n.
F (x; a) functie de interpolare sau interpolant

xi puncte de interpolare.
Cea mai utilizata interpolarea polinomial
a (Lagrange, spline, Akima).
Regresia
Valorile tabelate yi provin din observatii erori de masura deviatii standard i .
Functia model F = F (x; a) este stabilita n general pe baza unei teorii.
Se impune minimizarea distantei d(f, F ):
d(f, F ) = minim.
aj
n practica se utilizeaza una din functiile de merit::

S=
n
X
i=1
[yi F (xi ; a)]2 .
n
X
1
[yi F (xi ; a)]2 .
=
2
i=1 i
2
Minimul lui 2 n raport cu parametrii aj :

2
= 0,
aj
j = 1, 2, . . . , m.
Procedeul: regresie (ajustare, fitare) prin metoda celor mai mici p

atrate.
2
10.2 Polinomul de interpolare Lagrange

Una dintre cele mai vechi si generale formule importante consecinte teoretice.
Sta la baza unor ntregi clase de formule de integrare si derivare numerica.
Presupunem ca pentru f (x) sunt cunoscute valorile:
f (xi ) = yi ,
i = 1, 2, . . . , n.
Construim un polinom Pm (x) care ia n punctele de tabelare xi aceleasi valori:

Pm (xi ) = yi ,
i = 1, 2, . . . , n.
Definim o familie de polinoame pi (x) care se anuleaza n toate punctele de tabelare cu

exceptia lui xi :
Q
(x xj )
j6=i
.
pi (xj ) = ij pi (x) = Q
(xi xj )
j6=i
Polinomul
Pn1 (x) =
n
X
pi (x)yi
i=1
satisface conditiile de interpolare:

Pn1 (xj ) =
n
X
pi (xj )yi =
i=1
n
X
ij yi = yj ,
j = 1, 2, . . . , n.
i=1
Polinomul de interpolare Lagrange:
Pn1 (x) =
n
X
i=1
n
Q
(x xj )
j6=i
n
Q
yi .
(xi xj )
j6=i
Unicitatea: presupunem contrariul exista Pn1 (x) diferit de Pn1 (x) astfel nct:
Pn1 (xi ) = yi ,
i = 1, 2, . . . , n.
Atunci
Pn1 (xi ) Pn1 (xi ) = 0,
i = 1, 2, . . . , n.
Fiind un polinom de ordinul (n 1), este identic nul. Pn1 (x) Pn1 (x).
Cazuri particulare
n = 2:
P1 (x) =
n = 3:
P2 (x) =
x x2
x x1
y1 +
y2
x1 x2
x2 x1
(x x2 )(x x3 )
(x x1 )(x x3 )
(x x1 )(x x2 )
y1 +
y2 +
y3 .
(x1 x2 )(x1 x3 )
(x2 x1 )(x2 x3 )
(x3 x1 )(x3 x2 )
3
/*=========================================================================*/
float Lagrange(float xi[], float yi[], int ni, float x)
/*--------------------------------------------------------------------------Evalueaza polinomul de interpolare Lagrange
xi[] - abscisele punctelor interpolate
yi[] - ordonatele punctelor interpolate
ni
- numarul punctelor interpolate
x
- argumentul polinomului
---------------------------------------------------------------------------*/
{
float p, y;
int i, j;
y = 0.0;
for (i=1; i<=ni; i++) {
p = 1.0;
for (j=1; j<=ni; j++)
if (j != i) p *= (x-xi[j])/(xi[i]-xi[j]);
y += p*yi[i];
}
return y;
}
7
6
date interpolate
interpolant Lagrange
interpolant spline
4
3
2
1
0
0.0
0.2
0.4
0.6
0.8
1.0
1.2
1.4
1.6
1.8
FIGURA 10.2. Exemplu n care interpolarea cu ajutorul polinomului lui Lagrange conduce la
oscilatii. Datele interpolate provin din esantionarea functiei f (x) = 1/x.
Interpolarea invers
a gasirea argumentului pentru care polinomul Lagrange are o
anumita valoare:
Q
(y yj )
n
X j6=i
Q
x=
xi .
(y
y
)
i
j
i=1
j6=i
Aplicatie: determinarea unei radacini aproximative a ecuatiei f (x) = 0.

Se calculeaza yi pentru n argumente xi apropiate de radacina si se ia y = 0.
4
10.5 Regresia liniara

Cea mai simpla aplicatie de ajustare a functiilor model prin metoda celor mai mici patrate.
Functia model:
F (x; a, b) = ax + b.
y
i
yn
tan = a
yi
y1
x1
xi
xn x
FIGURA 10.3. Semnificatia parametrilor functiei model n cazul regresiei liniare: a este panta
dreptei, iar b este ordonata n origine.
Functia de merit:
n
X
1
(a, b) =
(y axi b)2 .
2 i
i=1 i
2
Valorile parametrilor de model a si b care realizeaza minimul functionalei 2 :
n
X
2
1
(yi axi b)xi = 0
a 2
2
i=1 i
n
X
1
2
(y axi b) = 0,
2 i
b
i
i=1
sau
cu
sxx a + sx b = sxy
sx a + s b = sy ,
n
n
n
X
X
X
xi
x2i
1
s
=
,
s
=
,
s
=
xx
2
2
x
2
i=1 i
i=1 i
i=1 i
n
n
X
X
yi
, sxy =
xi yi .
sy =
2
i
i=1
i=1
Expresiile parametrilor ajustati:

s sxy sx sy
sy sxx sx sxy
a=
, b=
,
cu
= s sxx s2x .
5
Variantele (impreciziile probabile patratice) asociate parametrilor (admitnd ca datele

sunt independente):
2
n
n
X
X
a
b
2
2
2
2
i
, b =
i
.
a =
y
y
i
i
i=1
i=1
Au loc derivatele:
a
s xi sx
,
=
yi
2i
b
sxx sx xi
.
=
yi
2i
Pentru 2a :
2a
n
X
s2 x2i 2s xi sx + s2x
s2 sxx 2s s2x + s s2x
s(s sxx s2x )
s
=
=
=
= .
2 2
2
2
i
i=1
Impreciziilor probabile ale parametrilor:

r
s
a =
,
b =
sxx
.
Exemplu de utilizare a regresiei liniare pt. dependente liniarizabile:

y = beax .
Prin logaritmare (y 0 = ln y si b0 = ln b):
y 0 = ax + b0 .
a si b0 se ajusteaza n raport cu setul de date transformat (xi , ln yi ), i = 1, 2, . . . , n.
6
2
date observate
regresie cu S
2
regresie cu
0
0
FIGURA 10.4. Exemplu care evidentiaza diferenta calitativa ntre dreptele de regresie obtinute
cu ajutorul functiilor de merit S si, respectiv, 2 .
Pt. functia de merit S rezulta a = 0.9100 si b = 0.0900.

Pt. functia de merit 2 rezulta a = 0.9983 si b = 0.1681.
6
/*=========================================================================*/
void LinFit(float x[], float y[], float sigmy[], int ndat, int iopt,
float *a, float *b, float *sigma, float *sigmb, float *chi2)
/*--------------------------------------------------------------------------Determina prin regresie "hi-patrat" coeficientii a si b si impreciziile
asociate, sigma si sigmb, pentru un model liniar, F(x;a,b) = a x + b,
relativ la un set de date observate
x[]
y[]
sigmy[]
ndat
iopt
abscisele punctelor observate

ordonatele punctelor observate
deviatiile standard asociate ordonatelor observate
numarul punctelor observate
pt. iopt = 0 se initializeaza sigmy[i] = 1.0, i=1..ndat
(util pt. cazul in care nu sunt cunoscute sigmy[i])
- parametrii modelului liniar (iesire)
- impreciziile probabile ale parametrilor determinati (iesire)
a, b
sigma
sigmb
chi2
- functia de merit pentru parametrii determinati (iesire)
---------------------------------------------------------------------------*/
{
float f, s, sx, sy, sxx, sxy;
int i;
if (iopt == 0) for (i=1; i<=ndat; i++) sigmy[i] = 1.0;
s = sx = sy = sxx = sxy = 0.0;
for (i=1; i<=ndat; i++) {
f = 1.0/(sigmy[i]*sigmy[i]);
s += f;
sx += x[i]*f; sxx += x[i]*x[i]*f;
sy += y[i]*f; sxy += x[i]*y[i]*f;
}
f = 1.0/(s*sxx - sx*sx);
*a = (s *sxy - sx*sy )*f; *sigma = sqrt(s*f);
*b = (sy*sxx - sx*sxy)*f; *sigmb = sqrt(sxx*f);
*chi2 = 0.0;
for (i=1; i<=ndat; i++)
*chi2 += pow((y[i] - (*a)*x[i] - (*b))/sigmy[i],2);
}
Daca iopt=0 se utilizeaza functia de merit

n
X
(yi axi b)2 .
S=
i=1
Bibliography
[1] D.W. Marquardt, Journal of the Society for Industrial and Applied Mathematics, vol.
11, p. 431-441 (1963).
[2] C.L. Lawson si R. Hanson, Solving Least Squares Problems (Prentice-Hall, Englewood
Clis, NJ, 1974).
Moskow, 1981).
[4] C. Iacob, D. Homentcovschi, N. Marcov si A. Nicolau, Matematici clasice si moderne,
vol. 4 (Editura tehnica, Bucuresti, 1983).
Cambridge, 1992).
CALCUL NUMERIC
anul II
specializarea: Fizica Informatica
semestrul II
Iasi2003
Cuprins
Sisteme de ecuatii liniare
1.1
Preliminarii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2
Eliminarea Gauss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3
Factorizarea LU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4
Metode iterative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Calculul valorilor s i vectorilor proprii
2.1
Preliminarii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2
Metoda lui Jacobi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
Rezolvarea numerica a ecuatiilor neliniare
13
3.1
Introducere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
3.2
Metoda njumatatirii intervalului . . . . . . . . . . . . . . . . . . . . . . . .
14
3.3
Metoda tangentei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
3.4
Metoda secantei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
Aproximarea functiilor
17
4.1
Introducere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
4.2
Polinomul de interpolare Lagrange . . . . . . . . . . . . . . . . . . . . . . .
18
4.3
Functii spline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
Bibliografie
21
1
Sisteme de ecuatii liniare
Atunci cand un program

ruleaza fara greseala devine
inutil
Murphy
1.1 Preliminarii
acest capitol cateva din cele mai utilizate metode pentru rezolvarea sistemelor de
In
ecuatii liniare de tipul:
a
x
+
a
x
+
.
.
.
+
a
x
=
b
11 1
12 2
1n n
1
a21 x1 + a22 x2 + . . . + a2n xn = b2

..
.. Ax = b
..
..
..

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

a x

+
a
x
+
.
.
.
+
a
x
=
b
nn
n
n
n2 2
n1 1
(1.1)
unde s-a notat cu A matricea sistemului, cu x vectorul necunoscutelor si cu b vectorul

format din termenii liberi ai sistemului (elementele matricii A si a vectorului b sunt numere reale):
a11
a12
a21 a22
A=
..
.
...
an1 an2

b
1

. . . a2n
b
x
, x = 2 si b = 2
.
.
..
..
..
.
..
.

bn
xn
. . . ann
. . . a1n
x1
matrice sistem
termen liber
(1.2)
1. SISTEME DE ECUATII LINIARE

Se stie ca sistemul (1.1) are solutie unica daca si numai daca matricea A este nesingulara,
matrice
adica:
det A 6= 0
nesingulara
(1.3)
1.2 Eliminarea Gauss

Metoda eliminarii Gauss permite rescrierea matricii sistemului sub forma triunghiulara astfel ncat, n final se obtine solutia aproximativa a sistemului de ecuatii liniare
printr-o substitutie iterativa a necunoscutelor.
Algoritmul eliminarii Gauss

Vom nota cu A matricea extinsa a unui sistem de ecuatii liniare formata din matricea sistemului A completata cu nca o coloana a termenilor liberi b. (ec. (1.2)). Fara a
restrange generalitatea vom aplica algoritmul eliminarii Gauss pentru un sistem de 3
ecuatii cu 3 necunoscute:
eliminare Gauss
a11 a12 a13 b1
1
a11
( a21 )
( a31 )
A = a21 a22 a23 b2 +
a31 a32 a33 b3

+
(1)
1 a12
(1)
a13
(1)
b1
(1)
(1)
(1)
(1)
0 a22
a23 b2 | (11) (a32
)
a22
(1)
(1)
(1)
0 a32 a33 b3
+
(1.4)
(1)
1 a12
0 1
0 0
(1)
1 a12
0 1
0 0
(1)
(1)
a13
b1
(2)
a23
(2)
b2
(2)
b3
(1)
b1
(2)
(2)
b2
.
(3)
b3
a33
a13
a23
1
(2)
(1)
(1.5)
1
(2)
a33
(1.6)
relatiile de mai sus s-a considerat ca toate elementele de pe diagonala principala sunt
In
diferite de zero. Daca acest lucru nu se ntampla se realizeaza operatia de pivotare pana
se obtin coeficienti nenuli pe diagonala principala. Asupra operatiei de pivotare vom
reveni n sectiunea urmatoare.
1.2. ELIMINAREA GAUSS
cazul unui sistem de n ecuatii liniare cu n necunoscute formulele de calcul pentru

In
pasul fiecare element al matricii extinse sunt:
matrice extinsa
pentru linia pivot:
(k)
a
= 1
kk
( k 1)
(k)
( k 1)
akj = akj /akk , j = k + 1, n
b(k) = b(k1) /a(k1)

k
k
kk
pentru liniile de sub linia pivot:
(k)
a
= 0
ik
(k)
( k 1)
( k 1) ( k 1)
aij = aij
aik akj , i, j = k + 1, n
b ( k ) = b ( k 1) a ( k 1) b ( k )
i
ik
(1.7)
(1.8)
Dupa realizarea eliminarii Gauss se obtine un sistem de ecuatii liniare cu o matrice sistem triunghiulara (elementele de sub diagonala principala sunt egale cu 0) si calculul
necunoscutelor se realizeaza printr-o operatie de substitutie inversa:
xn = bn(n)
n
(k)
(k)
xk = bk aki xi , k = n 1, 1
substitutie inversa
(1.9)
i = k +1
Este de remarcat faptul ca determinantul matricii sistemului poate fi calculat foarte

usor:
(1)
( n 1)
det A = a11 a22 ann
(1.10)
Tehnici de pivotare
cursul efectuarii operatiilor din eliminarea Gauss la fiecare pas k se mparte linia
In
( k 1)
pivot la elementul diagonal akk
. Este posibil ca acest element sa fie 0 si trebuie ca sa
se realizeze o rearanjare a elementelor din matricea sistemului astfel ncat sa se evite o

asemenea situatie. Aceasta operatie se numeste pivotare. Mai mult, daca este necesar sa
se realizeze pivotarea este bine ca noul element pivot sa fie cel mai mare pentru ca erorile
de rotunjire la mpartire sunt mai mici. De obicei se utilizeaza metoda pivotarii partiale pe
coloane astfel ncat la pasul k se cauta elementul maxim al matricii A(k1) situat pe coloana
k si liniile l k (pe si sub diagonala principala) si se schimba liniile l si k ntre ele.
pivotare
1.3 Factorizarea LU
metoda factorizarii LU matricea sistemului A se scrie sub forma unui produs de
In
factorizare
doua matrici:
A = LU
matrice
triunghiulara
(1.11)
unde L este o matrice triunghiulara inferioara:
1
0 ...
0
0
21 1 . . .
L=
..
.
.
. . . ..
0
n1 n2 . . . n,n1
si U este o matrice triunghiulara superioara:
12 . . . 1,n1
11
.
0 22 .. 2,n1
U=
..
..
..
0
.
.
.
...
...
(1.12)
1n
2n
..
.
nn
(1.13)
Cu aceste notatii sistemul de ecuatii liniare devine (1.1) este echivalent cu rezolvarea
a doua sisteme de ecuatii cu matrici triunghiulare:
Ly = b
(1.14)
Ux = y
(1.15)
S-au dezvoltat mai multe metode de factorizare LU: Khaletski, Choleski, Crout, etc.
cele ce urmeaza va fi discutata metoda Crout.
In
Factorizarea LU. Metoda Crout

metoda Crout se efectueaza operatia de nmultire ntre matricile L (ec. (1.12)) si U
In
(ec. (1.13)) si elementele matricii produs sunt identificate cu elementele matricii sistemului A. Se obtin astfel formulele pentru calculul matricilor L si U:
i 1
ij = aij
ik kj ,
i = 1, j
(1.16)
k =1
ij =
1
jj
i 1
aij
ik kj
k =1
!
, i = j + 1, n
(1.17)
1.4. METODE ITERATIVE
metoda Crout elementele celor doua matrici triunghiulare sunt memorate drept noi
In
elemente ale matricii A:
A f inal
...
11
.
21 . .
=
..
.
...
1n
..
2n
..
.
nn
n1 . . . n,n1
(1.18)
Determinantul matricii sistem A este egal cu produsul elementelor de pe diagonala

principala a matricii A f inal :
n
det A =
jj
(1.19)
j =1
Pentru aflarea valorilor necunoscute trebuie sa se rezolve cele doua sisteme de ecuatii
triunghiulare (1.14) si (1.15) prin metoda substitutiei:
y1 = b1
i 1
yi = bi ij y j , i = 2, n
(1.20)
j =1
si:
xn =
yn
nn
xi =
1
ii
yi ij x j
!
, i = n 1, 1
(1.21)
j = i +1
1.4 Metode iterative

calculul numeric se cauta de obicei o metoda de tip iterativ n care se pleaca de
In
la o aproximare de ordin zero a solutiei problemei si prin transformari (care nu schimba
metoda iterativa
natura sau valoarea solutiei) sa se obtina un sir de solutii care sa convearga catre solutia
exacta.
Metoda iterativa Jacobi

cazul metodei Jacobi sistemul de n ecuatii liniare cu n necunoscute (1.1) se rescrie
In
sub forma1 :
1 Acest
sistem se mai numeste si sistem redus
sistem redus
x1 = t1 + s12 x2 + . . . + s1n xn
x2 = s21 x1 + t2 + . . . + s1n xn
..
.
............
x = s x +s x +...+t
n
2
n2 2
n1 1
(1.22)
sau rescris matriceal:

x = Sx+t
(1.23)
unde matricea S si vectorul t se calculeaza astfel:
s = 0, i = 1, n
ii
sij = aij /aii , j = 1, n, j 6= i
(1.24)
ti = bi /aii
Drept aproximatie de ordin 0 pentru solutia sistemului se alege, de obicei, coloana

termenilor liberi:
x (0) = t
(1.25)
si conform (1.23) se calculeaza termenii din sirul aproximatiilor succesive:

x ( k ) = S x ( k 1) + t
(1.26)
Daca acest sir este convergent, atunci limita s-a este solutia sistemului (1.1).
practica, metoda lui Jacobi urmeaza urmatorul algoritm de calcul:
In
i(k) =
x (k) =
i
( k 1)
sij x j
j =1
( k 1)
xi
+ ti
(1.27)
(k)
+ i , i = 1, n
Procedeul iterativ se continua pana cand eroarea relativa maxima a componentelor solutiei
devine mai mica decat o eroare maxima admisa:

(k) (k)
max i /xi
i
(1.28)
Singura problema care a ramas de rezolvat este gasirea unor criterii pentru convergenta
sirului de solutii aproximative x(k) . Exista cateva cazuri cu n care se pot da conditii
suficiente pentru convergenta catre solutia exacta. Astfel daca este valabila una din
1.4. METODE ITERATIVE
urmatoarele relatii:
n
sij

< 1, i = 1, n
(1.29)
sij
< 1, j = 1, n
(1.30)
j =1
n
i =1
atunci procesul iterativ converge indiferent de alegerea aproximatiei initiale. Totusi,

metoda Jacobi este convergenta chiar daca nu sunt ndeplinite conditiile de mai sus si,
uneori, este suficient ca matricea sistemului sa fie dominant diagonala:

| aii | > max aij , i = 1, n
(1.31)
j 6 =i
Metoda Gauss-Seidel
Metoda Gauss-Seidel difera fata de metoda iterativa Jacobi doar prin faptul ca suma
(k)
care intra n calculul valorilor pentru i

(k)
xj
(ec. (1.27)) este rescrisa prin folosirea valorilor
cunoscute deja la momentul calculului din iteratia anterioara.
(k) =
i
(k)
xi
i 1
(k)
j =1
( k 1)
xi
j =i
(k)
+ i , i
( k 1)
sij x j + sij x j
+ ti
(1.32)
= 1, n
Unul din avantajele metodei Gauss-Seidel este si acela ca aceasta metoda converge
ntotdeauna pentru un sistem normal2 , indiferent de alegerea aproximatiei initiale. Mai
sistem normal
mult, orice sistem nmultit la stanga cu A T :

AT A x = AT b
(1.33)
devine un sistem normal.
2 Un
sistem liniar Ax = b se numeste normal daca matricea coeficientilor A este simetrica si pozitiv
definita:
AT
xAx
>
0 x din spatiul vectorial respectiv
2
Calculul valorilor si vectorilor proprii
Daca un program functioneaza

de la prima compilare s-a gresit
ntr-un numar par de locuri
Programator anonim
2.1 Preliminarii
fizica apar foarte des probleme de vectori proprii si valori proprii. Cel mai cunoscut
In
exemplu este rezolvarea ecuatiei lui Schrodinger:

H = E
(2.1)
unde H este hamiltonianul sistemului, E este energia iar functia de unda care descrie
starea respectiva. Problema se poate generaliza astfel ncat se defineste notiunea de vector
propriu al unui operator liniar A ca fiind un vector x nenul care prin actiunea operatorului
A se transforma ntr-un vector proportional cu x:
Ax = x
vector propriu
(2.2)
acest caz scalarul se numeste valoare proprie corespunzatoare vectorului propriu x.

In
Pentru cazul unui spatiu vectorial n-dimensional cu scalari reali (sau din multimea numerelor complexe) operatorul A poate fi structurat ca o matrice n n si ecuatia (2.2)
9
valoare proprie
10
2. CALCULUL VALORILOR SI VECTORILOR PROPRII

poate fi rescrisa sub forma:
( A I ) x = 0
sistem omogen
(2.3)
care este un sistem omogen de n ecuatii cu n necunoscute. Un astfel de sistem admite

solutii nebanale daca si numai daca determinantul sistemului este egal cu zero, adica:

a11
a12
...
a1n

a22 . . .
a2n
a21

(2.4)
det( A I ) = .
.. = 0
..
.
.

.
.
.
.
.

an1
an2
. . . a2n
Ecuatia (2.4) este o ecuatie algebrica n de grad n si are n radacini complexe. Pentru
fiecare valoare proprie j sistemul (2.3) admite solutia x( j) . Toti vectorii proprii pot fi
matrice modala
organizati ca o matrice X (numita matrice modala):
(1)
(2)
(n)
x
x1
. . . x1
1
(1)
(2)
(n)
x
x
.
.
.
x
2
2
2
X=
..
..
..
.
.
...
.
(1)
(2)
(n)
xn
xn
. . . xn
(2.5)
astfel ncat vectorii proprii sunt coloane ale acestei matrici si ecuatia (2.4) se rescrie:
AX = X
cu:
0
=
..
.
(2.6)
...
...
.
. . . ..
0
..
.
. . . n
(2.7)
Daca matricea X este nesingulara (det X 6= 0) atunci exista X 1 si relatia (2.6) devine:
X 1 A X =
(2.8)
Se observa ca matricea valorilor proprii se obtine din matricea A printr-o transformare

plus, doua matrici similare admit aceleasi valori proprii.
similara1 . In
transformare
similara
1 Dou
a
matrici A si B se numesc similare daca exista o matrice nesingulara S astfel ncat:

B = A1 A S.
2.2. METODA LUI JACOBI
11
Toate metodele pentru aflarea valorilor proprii si vectorilor proprii folosesc transformarile similare pentru a realiza diagonalizarea matricilor iar elementele de pe diagonala principala sunt chiar valorile proprii.
2.2 Metoda lui Jacobi

Metoda lui Jacobi se foloseste pentru diagonalizarea matricilor simetrice ( A T = A) si
foloseste transformari similare prin utilizarea unor matrici ortogonale2
matrice ortogonala
RT A R =
(2.9)
Transformarile similare cu matrici ortogonale se numesc transformari de similitudine. Matricile

ortogonale care se folosesc n metoda Jacobi generalizeaza matricile de rotatie si au forma:
transformari de
similitudine
col. i col. j
...
R(i, j) =
...
0
..
.
...
..
.
cos
..
.
...
..
.
sin
..
.
sin
..
.
...
cos
..
.
...
. . . | linia i
| linia j
...
matrice de rotatie
(2.10)
Se realizeaza transformarea de similitudine:

A0 = R T (i, j) AR(i, j)
(2.11)
acest fel se
si se impune ca elementele extradiagonale ale matricii A0 sa se anuleze. In
obtine:
aik
a0
jk
aii0
a0jj
0
aij
2o
= a0ki = aik cos + a jk sin , k = 1, n

= a0kj = aik sin + a jk cos , k 6= i, j
= aii cos2 + 2a ji sin cos + a jj sin2
= aii sin2 2a ji sin cos + a jj cos2

= a0ji = a ji cos2 sin2 + a jj aii sin cos
matrice ortogonala R este o matrice inversabila definita de relatia:

R R T = R T R = I R 1 = R T
(2.12)
12
2. CALCULUL VALORILOR SI VECTORILOR PROPRII

si impunand ca elementele aij0 = a0 ji sa se anuleze rezulta valoarea unghiului de rotatie
:
aii a jj
tan =
2a ji
s
aii a jj
2a ji
2
+ 1
(2.13)
de unde se calculeaza:
cos = q
, sin = cos tan
(2.14)
1 + tan2
La fiecare pas de calcul n algoritmul Jacobi se efectueaza transformarile de similitudine

prin nmultirea cu matricea Rl = R(il , jl ) astfel ncat sa anuleze elementele extradiagonale de la intersectia liniilor si coloanelor il , jl . Definim astfel matricile ortogonale:
Xl = R0 R1 Rl , l = 0, 1, 2, . . .
(2.15)
Sirul transformarilor ortogonale va fi:

A0 = A, A1 = X1T A X1 , . . . , Al = XlT A Xl , . . .
(2.16)
Conform relatiei de recurenta :
se obtine:
Xl = Xl 1 Rl (i, j)
(2.17)
x 0 = x cos + x sin , k = 1, n
ki
kj
ki
x 0 = x sin + x cos
ki
kj
kj
(2.18)
Sirul iteratiilor este ntrerupt cand valoarea absoluta a elementelor extradiagonale ale
matricii Al sunt mai mici decat > 0 ales:

max aij0
i6= j
(2.19)
3
Rezolvarea numerica a ecuatiilor neliniare
Nu conteaza cat de mult lucrezi

la un program. Profu va veni
exact cand joci Tetris
Un student suparat
3.1 Introducere
multe probleme de fizica se poate ajunge la o etapa de rezolvare n care se cere
In
rezolvarea unei ecuatii neliniare (numita uneori si ecuatie transcendenta) pentru care nu
exista o solutie analitica. Vom nota cu x0 solutia exacta pentru care are loc:
f ( x0 ) = 0
ecuatie
transcendenta
(3.1)
unde f ( x ) este o functie analitica cunoscuta de o variabila reala f : [ a, b] R. Solutia

calculata numeric este o solutie aproximativa (notata cu x a ) si trebuie sa fie cuprinsa n
intervalul de definitie a functiei f , deci x a [ a, b] si:
f (xa ) 0
aproximativa
(3.2)
Se poate considera ca solutia aproximativa x a este o buna aproximatie a solutiei exacte x0

daca:
| x a x0 | <
13
solutie
(3.3)
A ECUATIILOR NELINIARE
3. REZOLVAREA NUMERICA
14
cu > 0 o valoare reala care este considerata eroarea maxima admisibila pentru calculul
solutiei aproximative1 . Deoarece nu se cunoaste valoarea exacta x0 pentru solutia ecuatiei
n locul relatiei (3.3) se foloseste alt criteriu si se considera ca x a este solutie aproximativa
daca:
| f ( x a )| <
(3.4)
Problema existentei si unicitatii solutiei x0 este o problema care se poate discuta de

la caz la caz dupa forma analitica a functiei f ( x ) si intervalul de definitie [ a, b]. De cele
mai multe ori functia f ( x ) este o functie continua pe intervalul [ a, b] si se poate enunta
un criteriu de suficienta pentru existenta solutiei pe acest interval dar nu si de necesitate
sau unicitate. Exista cel putin o radacina x0 [ a, b] daca f ( a) f (b) < 0 si f este continua
pe acelasi interval (altfel spus: exista o radacina pe intervalul de definitie daca functia
este continua si si schimba semnul pe acest interval). Reprezentarea grafica a functiei
cele ce
f ( x ) permite o determinare rapida existentei solutiilor si a numarului acestora. In
urmeaza se v-a considera n toate metodele ca x0 exista si este unica solutie pe [ a, b].
3.2 Metoda njumatatirii intervalului

Metoda njumatatirii intervalului se mai numeste si metoda bisectiei a lui Boltzano.
Deoarece f ( a) f (b) < 0 atunci se calculeaza punctul aflat la jumatatea intervalului [ a, b]:
metoda Bolzano
c=
a+b
2
(3.5)
si se analizeaza urmatoarele cazuri:

daca f ( a) si f (c) au semne opuse atunci x0 se afla n intervalul [ a, c];
daca f (b) si f (c) au semne opuse atunci x0 se afla n intervalul [c, b];
daca f (c) = 0 atunci x0 = c.
Se observa ca prin njumatatiri succesive se poate ajunge la o valoare aproximativa x a = c
a radacinii ecuatiei (3.1) atunci cand are loc relatia (3.4). De obicei metoda lui Bolzano
este utilizata doar pentru obtinerea aproximatii de ordin zero pentru alte metode mai
rapide si mai exacte.
1 De
multe ori eroarea este aleasa functie de erorile de masura pentru datele experimentale culese,
daca x si y = f ( x ) reprezinta marimi fizice experimentale sau care rezulta din calcule bazate pe masuratori
experimentale.
3.3. METODA TANGENTEI
15
3.3 Metoda tangentei

Metoda tangentei este denumita si metoda Newton-Raphson. Aceasta metoda poate
fi aplicata n cazul cand atunci cand se cunosc derivatele functiei f ( x ) pe intervalul [ a, b]
si, n plus, f 0 ( x ) si f 00 ( x ) sunt functii continue care si pastreaza semnul pe acest interval.
Metoda
Newton-
Raphson
Se alege o aproximatie de ordin 0 pentru radacina ecuatiei (3.1) pe care o notam chiar
cu x0 . Se cauta punctul de intersectie a tangentei la graficul functiei f ( x ) n punctul de
coordonate ( x0 , f ( x0 )) si se calculeaza punctul x1 n care aceasta tangenta intersecteaza
axa Ox:
x0 = x0
f ( x0
f 0 ( x0 )
(3.6)
care este o noua aproximatie pentru radacina ecuatiei si ducand acum tangenta n ( x1 , f ( x1 ))
se gaseste o noua aproximatie x2 , etc. Astfel se obtine un sir de numere care se poate demonstra ca, n conditiile date, are limita egala cu valoarea exacta a ecuatiei (3.1).
Functia g( x ) definita prin formula:
g( x ) = x
f (x)
f 0 (x)
(3.7)
se numeste functia de iteratie Newton-Raphson si s-a constatat ca cea mai buna alegere penfunctie de iteratie
tru x0 (n sensul ca sunt necesare mai putini pasi de calcul) satisface conditia:
f ( x0 ) f 00 ( x0 ) > 0
(3.8)
3.4 Metoda secantei

Atunci cand se aplica metoda Newton-Raphson trebuie cunoscuta prima derivata
f 0 ( x ) a functiei f ( x ) ceea ce poate fi destul de dificil de obtinut pentru o functie f destul
de complicata (mai mult formula analitica a derivatei poate contine multe operatii algebrice care sa introduca erori numerice mari). O solutie de a scapa de aceasta complicatie
este de a alege doua valori initiale x0 si x1 si se cauta punctul x2 la intersectia dreptei ce
trece prin punctele de coordonate ( x1 , f ( x1 )) si ( x0 , f ( x0 )) cu axa Ox. Se va obtine n final
o formula de iteratie:
x k +1 = x k
f ( xk )
f ( xk ) f ( xk1 )
x k x k 1
= xk
f ( xk )( xk xk1 )
f ( x k ) f ( x k 1 )
(3.9)
A ECUATIILOR NELINIARE
3. REZOLVAREA NUMERICA
16
Se observa ca metoda secantei semana mult cu metoda tangentei n care se nlocuieste

derivata f 0 ( x ) cu
f ( xk ) f ( xk1 )
x k x k 1
care este acelasi lucru atunci cand xk1 xk .
4
Aproximarea functiilor
Daca n sfarsit am scris codul

sursa, fie nu poate fi compilat n
memoria calculatorului, fie nu
mai este spatiu pe disc
Un student nervos
4.1 Introducere
aproape toate lucrarile experimentale de fizica se pune problema masurarii sau
In
determinarii prin calcul a unor marimi fizice ntr-un numar finit de puncte. Pentru simplitate vom considera ca se cunosc doua siruri de numere reale xi si yi cu i = 1, n ntre
care exista o dependenta functionala, adica exista o functie de variabila o variabila reala
pentru care are loc:
yi f ( xi )
(4.1)
Conditiile experimentale, de obicei, nu permit cunoasterea functiei f : [ a, b] R n

mod analitic ncat sa se cunoasca valoarea n orice punct xc din intervalul de definitie.
Din acest motiv, pe baza masuratorilor experimentale, si prin alegerea convenabila a
tipului de functie f (clasa de continuitate, derivabilitate, model teoretic, etc.) se poate
determina valoarea yc f ( xc ) n orice punct din [ a, b].
17
18
4. APROXIMAREA FUNCT
IILOR
Daca datele experimentale xi si yi sunt considerate ca fiind exacte (nu sunt afectate de
erori) atunci punctele de coordonate ( xi , yi ) apartin graficului functiei f si procedeul de
interpolare
a gasi valoarea yc poarta numele de interpolare daca xi , xc [ a, b] i = 1, n sau extrapolare

daca xc nu este cuprins n intervalul [ a, b].
acest caz
De cele mai multe ori, nsa, datele experimentale sunt afectate de erori. In
extrapolare
graficul functiei f nu trece obligatoriu prin punctele experimentale fara a depasi intervalul de eroare corespunzatoare fiecarui punct. Acest procedeu se numeste regresie sau
regresie
ajustare numerica. Cel mai cunoscut exemplu de regresie numerica este dreapta de regresie
cunoscuta si ca metoda celor mai mici patrate pentru o dependenta liniara ntre xi si yi .
4.2 Polinomul de interpolare Lagrange

cazul interpolarii cu un polinom functia f ( x ) este o functie polinomiala de grad m
In
astfel ncat:
Pm ( xi ) = yi , i = 1, n
(4.2)
Problema interpolarii polinomiale se rezuma la calculul coeficientilor fiecarui termen de

grad j = 1, m a caror suma formeaza polinomul de interpolare. Totusi, n interpolarea
Lagrange se evita calculul efectiv al acestor coeficienti. Pentru aceasta se scrie polinomul
de interpolare de grad m = n 1 ca o suma de produse de factori de monoame de tipul:
pi ( x ) = Ci ( x xi )
(4.3)
j 6 =i
unde Ci sunt constante care se determina din conditia ca pi ( xi ) = 1 de unde rezulta:

(x xj )
pi ( x ) =
j 6 =i
(4.4)
( xi x j )
j 6 =i
Pe baza acestor termeni se construieste polinomul de interpolare Lagrange:

Pn1 ( x ) =
i =1
i =1
pi ( x ) yi =
(x xj )
j 6 =i
( xi x j )
yi
(4.5)
j 6 =i
Se remarca faptul ca polinomul Lagrange satisface relatiile:

Pn1 ( xi ) = yi , i = 1, n
(4.6)
4.3. FUNCTII SPLINE
19
acelasi timp se poate demonstra, prin reducere la absurd, ca polinomul de interpolare

In
Lagrange este unic.
Atunci cand se cere valoarea yc calculata prin interpolare polinomiala Lagrange se
calculeaza valoarea Pn1 ( xc ) conform relatiei (4.5).
4.3 Functii spline

Functiile spline sunt functii care au anumite proprietati de continuitate si derivabilitate astfel ncat, asa cum se si numesc1 , curba care trece prin punctele de definitie este o
curba neteda (are o variatie minima a pantei).
Functiile spline de ordin m sunt polinoame de grad m pe orice interval [ xi , xi+1 ] (si
sunt notate de obicei Si ( x )). Aceste functii spline sunt de clasa C m1 si derivata de ordin
m este discontinua n nodurile xi . Daca Si ( x ) sunt polinoame de gradul trei atunci functia
definita de:
Si ( x ) = Ai x3 + Bi x2 + Ci x + Di , x [ xi , xi+1 ], i = 1, n 1
(4.7)
se numeste functie spline cubica. Coeficientii Ai , Bi , Ci , Di se pot determina din conditiile

de continuitate si de interpolare n punctele diviziunii:
S( xi ) = yi , i = 1, n
(4.8)
Impunand si conditiile de continuitate pentru derivatele functiilor spline cubice se determina:
Ai
B
i
Ci
Di
=
=
=
=
i +1 D
i
D
6hi
i x i +1 D
i +1 x i
D
2hi
i +1 x 2 D
i x2
D
i
i +1
2hi
i x3 D
i +1 x 3
D
i +1
i
6hi
+
+
y i +1 y i
Ai h2i
hi
B h2
y i x i +1 y i +1 x i
i3 i
hi
(4.9)
i derivata de ordin doi calculata n punctul xi .

unde hi = xi+1 xi , i = 1, n 1 si D
Derivatele de ordin 2 se calculeaza prin impunerea conditiei de continuitate a primei
derivate pentru Si ( x ) n capetele intervalului:
Si01 ( xi ) = Si0 ( xi )
1 Termenul
(4.10)
spline provine din engleza si desemneaza un set de instrumente care permit trasarea unei
curbe netede printr-o serie de puncte date.
spline cubic
20
4. APROXIMAREA FUNCT
IILOR
i:
si se obtine un sistem de ecuatii liniare n D
b D
+
1 1
i 1 +
ai D
2
c1 D
= d1
i
bi D
+ ci D i+1 = di , i = 2, n 1
+ bn D n = dn
n 1
an D
unde coeficientii ai , bi , ci , di sunt dati de relatiile:

y2 y1
0
y
a
=
0
b
=
2h
c
=
h
d
=
6
1
1
1
1
1
1
1
h1

y i +1 y i
y i y i 1
a i = h i 1 bi = 2 ( h i 1 + h i ) c i = h i d i = 6
h i 1
hi

y n y n 1
a =h
0
c n = 0 d n = 6 y n h n 1
n
n1 bn = 2hn1
(4.11)
(4.12)
Se observa ca pentru calculul coeficientilor d1 si dn trebuie sa se cunoasca derivatele y10 si

y0n n extremitatile intervalului de tabelare. De cele mai multe ori nu exista informatii cu
privire la aceste derivate si se foloseste interpolarea Lagrange de unde:
y10 =
y0n =
y2 y1
y3 y2
y3 y1
+
+
x2 x1
x3 x2
x3 x1
y n 1 y n 2
y n y n 1
y n y n 2
+
+
x n 1 x n 2
x n x n 1
x n x n 2
(4.13)
(4.14)
algoritmul de interpolare cu functii spline trebuie sa se afle valorile derivatelor de

In
ordin 2 din sistemul de ecuatii (4.11) pe baza coeficientilor din relatiile (4.12) si mai apoi
coeficientii interpolantului spline conform (4.9).
Bibliografie
[1]
Titus Adrian BEU. Calcul numeric n C. Microinformatica, Cluj, 2000.
[2]
Adrian BRADU. ANALIZA NUMERICA Exercitii si Probleme. Editura Universitatii

Al. I. Cuza, Iasi, 2001.
[3]
S. D. CONTE and Carl de BOOR. ELEMENTARY NUMERICAL ANALYSIS An Algorithmic Approach. International Series in Pure and Applied Mathematics. McGrawHill Book Company, New York, third edition, 1980.
[4]
Nicholas J. HIGHAM. Accuracy and Stability of Numerical Algorithms. SIAM, Philadelphia, 1996.
[5]
Alexandru LUPAS. METODE NUMERICE. Editura Constant, Sibiu, 2001.
[6]
John H. MATHEWS and Kurtis D. FINK. Numerical Methods Using MATLAB. Prentice Hall Inc., London, third edition, 1999.
[7]
J.C. NASH. COMPACT NUMERICAL METHODS FOR COMPUTERS linear algebra

and function minimisation. Adam Hilger, New York, second edition, 1990.
[8]
John C. NASH and Mary M. NASH. Scientific Computing with PCs. Nash Information
Services Inc., Ottawa, CANADA, 1993.
[9]
William H. PRESS, Saul A. TEUKOLSKY, William T. VETTERLING, and Brian P.

FLANNERY. Numerical Recipes in C The Art of Scientific Computing. CAMBRIDGE
UNIVERSITY PRESS, Cambridge, New York, second edition, 1997.
21
22
BIBLIOGRAFIE
[10] L. F. SHAMPINE, Jr. R. C. ALLEN, and S. PRUESS. FUNDAMENTALS OF NUMERICAL COMPUTING. JOHN WILEY & SONS, INC., New York, 1997.
[11] William J. THOMPSON. COMPUTING FOR SCIENTISTS AND ENGINEERS A Workbook of Analysis, Numerics, and Applications. JOHN WILEY & SONS, INC., New
York, 1992.

Tehnici de Programare Master

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Tehnici de Programare Master

Încărcat de

Drepturi de autor:

Formate disponibile

3

3.2 Structura programului. Functii

Exemplu factorialul unui numar natural

Variabilele globale f si n pot fi modificate de orice functie a programului pot rezulta

Implementare folosind recursivitatea:

3.4 Pointeri si liste de argumente

FIGURA 3.1. Pointerii contin adresele variabilelor catre care pointeaza.

atribuie pointerului p adresa variabilei x p pointeaza catre x.

pointerul p pointeaza catre variabile de tip int.

Returnarea variabilelor din functii prin lista de argumente

La intrare n Swap ax si by se interschimba nsa doar copii ale lui a si b.

n Swap se opereaza asupra valorilor variabilelor a si b din programul principal prin

3.5 Alocarea dinamica a tablourilor

Conform aritmeticii pointerilor:

sizeof(tip ) returneaza lungimea n octeti a reprezentarii interne a tipului tip .

Alocarea dinamica n heap a unui bloc de n locatii reale:

Context tipic de utilizare:

/* numele matricii este declarat ca pointer */

for (i=0; i<=n-1; i++) a[i] = . . . ;

/* a este folosit ca tablou */

Context tipic de utilizare (nu trebuie folosite componentele a[0],..., a[imin-1]):

Declaratia tabloului: float **a.

Functia Matrix aloca un tablou bidimensional cu elemente reale:

Functia pereche care elibereaza blocul de memorie alocat:

Context tipic de utilizare:

3.6 Operatii simple cu matrici

/*--------------------------------------------------------------------------Calculeaza produsul dintre matricea a[][] cu l linii si m coloane si matricea

/* (A B)_trans - B_trans A_trans */

5.1 Dispozitive grafice

5.2 Functii grafice ale mediului Borland C++

FIGURA 5.1. Sistemul coordonatelor ecran al interfetei grafice BGI.

5.3 Reprezentarea functiilor de o variabila

FIGURA 5.2. Corespondenta dintre coordonatele utilizator (xi , yi ) si coordonatele ecran (

Nu pot fi utilizate direct coordonate utilizator, (xi , yi ), ca argumente pt. functiile

Asimetrie n tratarea axelor x si y coordonatele yi nu sunt ordonate.

/*------------------------------- graphlib.h ------------------------------*/

ymin = y[1]; ymax = y[1];

Functiei Plot0 i se transmit coordonatele relative ale colturilor ferestrei de desenare.

FIGURA 5.3. Reprezentarea grafica a functiei x3 ex cu ajutorul functiei Plot0 (xmin=-0.8,

Functie mai elaborata n fisierul GRAPHLIB.H:

FIGURA 5.4. Reprezentarea grafica a functiei x3 ex cu ajutorul functiei Plot.

7.1 Separarea radacinilor

FIGURA 7.2. Exemple de radacini neseparate.

7.2 Metoda bisectiei (metoda njumatatirii)

FIGURA 7.3. Procesul de njumatatire a intervalului de cautare n cazul metodei bisectiei.

Dupa i pasi rezulta [ai , bi ] astfel nct

njumatatind [ai , bi ] prin

Procesul se ncheie, considernd ca radacina aproximativa 0 = xi , cnd

/*---------------------------- Metoda bisectiei ---------------------------*/

n main este partitionat intervalul de cautare [xmin , xmax ] n subintervale de lungime h

7.3 Metoda pozitiei false (metoda corzii)

Se nlocuieste functia cu coarda punctul de intersectie xi cu axa absciselor:

Dupa un anumit numar de pasi:

Dupa fiecare partitionare a intervalului se reactualizeaza nu numai capetele intervalului,

7.4 Metoda aproximatiilor succesive

Daca sirul este convergent = lim xi .

Radacina reala pt. x = (x) abscisa punctului de intersectie dintre y = (x) si y = x.

Teorema 7.2 Fie ecuatia

/*-------------------- Metoda aproximatiilor succesive --------------------*/

7.5 Metoda lui Newton

FIGURA 7.6. Determinarea aproximatiilor succesive n metoda Newton-Raphson. n cazul (b)

Aproximatie initiala x0 pt. .

Metoda lui Newton converge

catre radacina x = 0.567143

/------------------------------- graphlib.h ------------------------------/

/---------------------------- Metoda bisectiei ---------------------------/

/-------------------- Metoda aproximatiilor succesive --------------------/