11

INTEGRAREA FUNCŢIILOR

11.1 Introducere
Dacă pt. f (x) continuă pe [a, b] este cunoscută primitiva F (x) – formula Newton-Leibnitz:
Z b
I= f (x)dx = F (b) − F (a).
a

Calculul numeric al integralelor simple – cuadratură.

Aproximarea integralei printr-o sumă ponderată de valori f (xi ) pt. anumite argumente xi
din domeniul de integrare:
Z b X
n
f (x)dx ≈ wi f (xi ).
a i=1

Calculul numeric al integralelor duble – cubatură.

11.2 Formulele de cuadratură Newton-Cotes
Se cere: Z b
I= f (x)dx.
a
Fie nodurile echidistante xi ∈ [a, b]:
xi = a + (i − 1)h, i = 1, 2, . . . , n
h = (b − a)/(n − 1).

Aproximăm funcţia f (x) prin polinomul de interpolare Lagrange (fi ≡ f (xi )):
Xn Qn
(x − xj )
Pn−1 (x) = Qnj6=i fi .
i=1 j6=i (xi − xj )

Definim variabila adimensională:

q = (x − a)/h, q ∈ [0, n − 1].
Variabila iniţială se scrie x = a + qh.
Produsele din expresia polinomului de interpolare Lagrange:
Yn Yn
(x − xj ) = hn−1 [q − (j − 1)]
j6=i j6=i

Y
n Y
n Y
i−1 Y
n
n−1 n−i n−1
(xi − xj ) = h (i − j) = (−1) h (i − j) (j − i) = (−1)n−i hn−1 (i − 1)!(n − i)!
j6=i j6=i j=1 j=i+1

Polinomul Lagrange:
Qn
X
n
j6=i [q − (j − 1)]
Pn−1 (x) = fi
i=1
(−1)n−i (i − 1)!(n − i)!

Aproximaţie a integralei:
Z b Z b X
n
f (x)dx ≈ Pn−1 (x)dx = Ai fi ,
a a i=1
Z Qn R n−1 Qn
b
j6=i [q − (j − 1)]dx h 0 j6=i [q − (j − 1)]dq
Ai = = .
a (−1)n−i (i − 1)!(n − i)! (−1)n−i (i − 1)!(n − i)!
Punem Ai = (b − a)Hi → formula de cuadratură Newton-Cotes:
Z b X
n
f (x)dx ≈ (b − a) Hi fi ,
a i=1
Coeficienţii Cotes:
R n−1 Qn
0
− (j − 1)]dq
j6=i [q
Hi = , i = 1, 2, . . . , n.
(−1)n−i (i − 1)!(n − i)!(n − 1)
Proprietăţi:
X
n
Hi = 1, Hi = Hn−i+1 .
i=1

2
11.3 Formula trapezelor
Coeficienţii Cotes pt. n = 2:
Z 1 Z 1
1 1
H1 = − (q − 1)dq = , H2 = qdq = .
0 2 0 2
Formula trapezului: Z x2
h
f (x)dx ≈ (f1 + f2 ).
x1 2

y = f(x)

y = P1(x)
f2
f1
h
x1 x2 x

FIGURA 11.1. Formula trapezului aproximează funcţia prin dreapta care trece prin punctele
(x1 , f1 ) şi (x2 , f2 ).

Restul formulei trapezului – presupunând f (x) ∈ C (2) [a, b]:

Z x1 +h
h
R(h) = f (x)dx − [f (x1 ) + f (x1 + h)].
x1 2
Derivăm de două ori în raport cu h:
1 h
R0 (h) = [f (x1 + h) − f (x1 )] − f 0 (x1 + h)
2 2
h
R00 (h) = − f 00 (x1 + h).
2
Integrăm de două ori în raport cu h (R(0) = R0 (0) = 0) şi utilizăm teorema mediei:
Z h Z h
0 0 00 1 00 h2
R (h) = R (0) + R (t)dt = − f (ξ 1 ) tdt = − f 00 (ξ 1 ), ξ 1 ∈ (x1 , x1 + h)
0 2 0 4
Z h Z h
1 h3
R(h) = R(0) + R0 (t)dt = − f 00 (ξ) t2 dt = − f 00 (ξ), ξ ∈ (x1 , x1 + h)
0 4 0 12
Restul:
h3 00
R=− f (ξ), ξ ∈ (x1 , x2 ).
12

3
Generalizare – formulă de interes practic.
Utilizăm aditivitatea integralei faţă de intervalul de integrare.

fi
fn
f1
h h h
x1 x2 x3 xi xn x

FIGURA 11.2. Formula trapezelor aproximează integrandul cu linia poligonală definită de ab-
scisele echidistante şi valorile corespunzătoare ale funcţiei.

Divizăm [a, b] prin punctele echidistante:

xi = a + (i − 1)h, i = 1, 2, . . . , n.

h = (b − a)/(n − 1)
Aplicăm formula trapezului fiecărui subinterval [x1 , x2 ],..., [xn−1 , xn ]:
Z b
h h h
f (x)dx ≈ (f1 + f2 ) + (f2 + f3 ) + . . . + (fn−1 + fn ).
a 2 2 2

Formula trapezelor:
Z " #
f1 X
b n−1
fn
f (x)dx ≈ h + fi + .
a 2 i=2
2

Restul:
(n − 1)h3 00 (b − a)h2 00
R=− f (ξ) = − f (ξ), ξ ∈ [a, b].
12 12

/*=========================================================================*/
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;

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

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

• Înjumătăţirea lui h până când eroarea relativă a integralei scade sub un ε.

a h0 b
n0 =1

h1
n1 =2

h2
n2 =4

h3
n3 =8

FIGURA 11.3. Schema de înjumătăţire a intervalelor în metoda trapezelor cu control automat

al pasului. Prin cerculeţe sunt figurate valorile care trebuie calculate în fiecare etapă.

Primele aproximaţii ale formulei trapezelor:

· ¸
f (a) f (b)
T0 = h0 + , h0 = b − a
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 ) + , h2 = h1 /2
2 2
························

Proces recurent:
h0
T0 = [f (a) + f (b)], h0 = b − a, n0 = 1
2" #
nk−1
1 X
Tk = Tk−1 + hk−1 f (a + (i − 1/2)hk−1 ) ,
2 i=1
hk = hk−1 /2, nk = 2nk−1 , k = 1, 2, . . .

hk = (b − a)/nk – lungimea subintervalelor după etapa k

nk = 2k – numărul de subintervale după etapa k (numărul noilor puncte de integrare).

Criteriu de convergenţă:
|Tk − Tk−1 | ≤ ε |Tk | .

6
/*=========================================================================*/
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
---------------------------------------------------------------------------*/
{
const float eps = 1e-6; /* 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); /* noua aproximatie */
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;
}

7
11.4 Formula lui Simpson
Coeficienţii Cotes pentru n = 3:
Z 2
1 1
H1 = (q − 1)(q − 2)dq = ,
4 0 6
Z 2
1 2
H2 = − q(q − 2)dq = ,
2 3
Z 20
1 1
H3 = q(q − 1)dq = .
4 0 6
Formula lui Simpson (x3 − x1 = 2h):
Z x3
h
f (x)dx ≈ (f1 + 4f2 + f3 ).
x1 3

Înlocuirea curbei y = f (x) cu parabola y = P2 (x) definită de (x1 , f1 ), (x2 , f2 ) şi (x3 , f3 ).

Restul:
h5 (4)
R=− f (ξ), ξ ∈ [a, b]
90

Generalizare – formulă de interes practic.

Utilizăm aditivitatea integralei faţă de intervalul de integrare.
Divizăm [a, b] printr-un număr impar, n = 2m + 1, de puncte echidistante:

xi = a + (i − 1)h, i = 1, 2, . . . , n,
b−a b−a
h= = ,
n−1 2m
Aplicăm formula trapezului fiecărui subinterval [x1 , x2 ],..., [xn−1 , xn ]:
Z b
h h h
f (x)dx ≈ (f1 + 4f2 + f3 ) + (f3 + 4f4 + f5 ) + . . . + (fn−2 + 4fn−1 + fn ).
a 3 3 3

Formula lui Simpson generalizată,

Z b
h
f (x)dx ≈ (f1 + 4σ 2 + 2σ 1 + fn ) ,
a 3
(n−3)/2 (n−1)/2
X X
σ1 = f2i+1 , σ2 = f2i .
i=1 i=1

Restul – admiţând că f (x) ∈ C (4) [a, b]:

mh5 (4) (b − a)h4 (4)

R=− f (ξ) = − f (ξ), ξ ∈ [a, b].
90 180

8
/*=========================================================================*/
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 eficientă:

(n−3)/2
X
σ1 = f (x2i+1 ), x2i+1 = a + i(2h)
i=1
(n−3)/2
X
σ 2 = f (x2 ) + f (x2(i+1) ), x2(i+1) = x2i+1 + h,
i=1

/*=========================================================================*/
float Simpson(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, 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));
}

9
Controlul automat al preciziei de integrare.
Primele aproximaţii ale formulei lui Simpson:
h1 4T1 − T0
S1 = [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
························

Generalizând:
4Tk − Tk−1
Sk = .
3

Proces recurent:
h0
T0 = [f (a) + f (b)], h0 = b − a, n0 = 1
2" #
nk−1
1 X
Tk = Tk−1 + hk−1 f (a + (i − 1/2)hk−1 ) , k = 1, 2, . . .
2 i=1
4Tk − Tk−1
Sk = , hk = hk−1 /2, nk = 2nk−1 .
3

Criteriu de convergenţă:
|Sk − Sk−1 | ≤ ε |Sk | .

/*=========================================================================*/
float SimpsonControl(float Func(float), float a, float b)
/*---------------------------------------------------------------------------
Calculeaza integrala functiei Func pe intervalul [a,b] utilizand formula lui
Simpson cu controlul automat al pasului de integrare
---------------------------------------------------------------------------*/
{
const float eps = 1e-6; /* 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; /* noua aproximatie */
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
Complicaţii:

• creşterea rapidă a numărului de evaluări ale funcţiei – nd

n – nr. de evaluări pt. o schemă unidimensională, d – dimensiunea integralei

• dificultatea descrierii frontierei (d − 1)-dimensionale a domeniului de integrare.

Opţiuni pt. integranzi netezi:

• frontiere complicate, precizie redusă – metoda Monte Carlo

(lent convergentă în raport cu numărul de puncte de integrare).

• frontiere simple, precizie ridicată – descompunerea în integrale 1D repetate

aplicarea unui integrator 1D cu control automat al pasului pt. fiecare dimensiune.

Integrală bidimensională:
Z xmax Z ymax (x) Z xmax Z ymax (x)
f (x, y)dxdy = Fx (x)dx, Fx (x) = f (x, y)dy,
xmin ymin (x) xmin ymin (x)

integrală ”exterioară” în raport cu x, al cărei integrand este integrala în raport cu y pe o

anumită linie cu x fixat.

y
ymax(xi)

ymin(xi)

xmin xi xmax x

FIGURA 11.4. În metoda descompunerii în integrale unidimensionale, integrarea ”interioară”

după y are loc pe o reţea de puncte independentă pentru fiecare argument xi al integrării
”exterioare”.

Pt. fiecare xi se calculează

Z ymax (xi )
Fx (xi ) = f (xi , y)dy
ymin (xi )

pe o reţea determinată de particularităţile locale ale integrandului.

11
Exemplu:
Z p
1 Z √
1−x2
π
I= 1 − x2 − y 2 dy = ≈ 0.523599.
dx
0 0 6
Domeniul de integrare – primul cadran al cercului de rază 1.
Rezultatul – volumul primului octant al sferei de rază 1.

#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 SimpsonControl(float Func(float), float a, float b)
{
. . . . . . . . . .
}
/*=========================================================================*/
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 integrată în raport cu y, func este apelată prin funcţia ”interfaţă” Fy.
Parametrul global xconst îşi primeşte valoarea în funcţia Fx.
Integrală triplă:
Z xmax Z ymax (x) Z zmax (x,y) Z xmax
f (x, y, z)dxdydz = Fx (x)dx,
xmin ymin (x) zmin (x,y) xmin
Z ymax (x) Z zmax (x,y)
Fx (x) = Fy (x, y)dy, Fy (x, y) = f (x, y, z)dz.
ymin (x) zmin (x,y)

12
Exemplu:
Z 1 Z √
1−x2 Z √1−x2 −y2
π
I= dx dy dz = ≈ 0.523599,
0 0 0 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 SimpsonControl(float Func(float), float a, float b)
{
. . . . . . . . . .
}
/*=========================================================================*/
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 integrată în raport cu z, func este apelată prin funcţia ”interfaţă” Fz.
Parametrii globali xconst şi yconst îşi primesc valorile în funcţia Fx, respectiv Fy.

13
Bibliography

[1] M. Abramowitz şi I. Stegun, Handbook of Mathematical Functions (Dover Publica-

tions, New York, 1972).

[2] A.H. Stroud şi D. Secrest, Gaussian Cuadrature Formulas (Prentice-Hall, Englewood
Cliffs, 1966).

[3] A.H. Stroud, Approximate Calculation of Multiple Integrals (Prentice-Hall, Englewood

Cliffs, 1971).

[4] A. Ralston şi P. Rabinowitz, A First Course in Numerical Analysis (McGraw-Hill,

New York, 1978).

[5] B.P. Demidovich şi I.A. Maron, Computational Mathematics (MIR Publishers,
Moskow, 1981).

[6] R.L. Burden şi J.D. Faires, Numerical Analysis, Third Edition (Prindle, Weber &
Schmidt, Boston, 1985).

[7] W.H. Press, S.A. Teukolsky, W.T. Vetterling şi B.P. Flannery, Numerical Recipes in
C: The Art of Scientific Computing, Second Edition (Cambridge University Press,
Cambridge, 1992).