Regula trapezului

De la Wikipedia, enciclopedia liberă.
Salt la navigare Salt la căutare
Regula trapezului.

În analiza numerică , regula trapezoidală oferă o procedură pentru calculul aproximativ al unei integrale definite a formei

.

Regula trapezului sau Stevino, în formularea sa elementară, propune aproximarea integralei, adică, dacă funcția nu este negativă, aria regiunii plane cuprinse între graficul funcției și axa absciselor, cu aria trapezului vârfurilor Și În consecință

După cum se poate înțelege vizual, această aproximare este acceptabilă dacă în intervalul de integrare funcția are o tendință care se abate puțin de la liniar. Dacă acest lucru nu se întâmplă, intervalul general poate fi împărțit într-un număr adecvat n de sub-intervale în fiecare dintre care se întâmplă de obicei ca funcția să aibă o tendință nu departe de liniară; prin urmare regula trapezului în forma compusă spune să se aplice aproximarea anterioară tuturor subintervalelor. Apoi se obține formula

Regula trapezoidului face parte din familia formulelor de integrare numerică numite formule Newton-Cotes . De asemenea, o parte a acestei familii este regula Knights-Simpson, care oferă adesea rezultate mai precise. Regula Knights-Simpson și alte metode similare îmbunătățesc regula trapezoidală pentru majoritatea funcțiilor cu două derivate continue. Totuși, pentru anumite funcții cu comportament neregulat, este preferabilă cea mai simplă regulă a trapezului. Mai mult, regula trapezului tinde să devină foarte precisă pentru integralele funcțiilor periodice în intervalele respective de periodicitate; acest comportament este clarificat în raport cu formula Euler-Maclaurin .

Regula trapezului este baza procesului de discretizare cunoscut sub numele de discretizare Tustin .

Implementare pe computer

În Python

 def integral_trapezium ( f , a , b , n ):
"" "
Funcția Python pentru calcularea a
integrală definită, prin intermediul regulii lui Stevino.
Argumente funcționale:
f => Funcția Python a ecuației de rezolvat. *
(a, b) => interval al integralului.
n => numărul de subdiviziuni care se aplică integralei.
"" "
	
s = [( b - a ) / n * i + a pentru i în intervalul ( n + 1 )] # Determinați spațiul liniar | Echivalent cu numpy.linspace (a, b, n)
S = []
pentru i în intervalul ( n ):
S = S + [( s [ 1 ] - s [ 0 ]) * 0,5 * ( f ( s [ i ]) + f ( s [ i + 1 ]))]
returnează suma ( S ) # Returnează valoarea zonei.

# * Un exemplu:
#
# def f (x):
# returnează x * x
#
# a = Trapezium_Integral (f, 1, 2, 5) = 2.3399999999999994
#
# Sau:
#
# a = Trapezium_Integral (lambda x: x * x, 1, 2, 5) = 2.339999999999999994

În MATLAB

 funcţie [int] = capcana_integrală ( f, a, b, n )
% Această funcție calculează integralul definit în [a, b] din
% funcție f prin metoda Trapezius compus
% f este o funcție definită ca un handle de funcție
% n este numărul de sub-intervale în care doriți să împărțiți intervalul de integrare.

H. = ( b - a ) / n ; % Amplitudinea fiecărei sub-game
x = linspace ( a , b , n + 1 ); % Creez un interval de puncte la distanțe egale de amplitudine H
int = 0 ; 

pentru i = 1 :( lungimea ( x ) - 1 )

int = int + 0,5 * H * ( f ( x ( i )) +  f ( x ( i + 1 )));

Sfârșit

Sfârșit
% Exemplu numeric: Calculul integralei definite a lui x ^ 2 între [0,2]
% f = @ (x) x. ^ 2;
% I = integral_trap (f, 0,2,100)

În Java

 public class fuctionIntegral 
{
putere dublă publică ( număr dublu , altitudine int ) {
dublă ret = 1 ;
for ( int i = cota ; i > 0 ; i - ) {
ret * = număr ;
}
retur ret ;
}
public double f ( double x )                                       
{ dublu y = 0 ;
y = putere ( x , 2 );
returnează y ;
}
public double trapArea ( double b1 , double b2 , double h )         
{
returnare ( b1 + b2 ) * h / 2 ;
}
 
public double trapRule ( double x0 , double x1 , int div )          
{
zona dubla = 0 ;
dublu h = ( x1 - x0 ) / div ;                                                              
for ( int i = 0 ; i < div - 1 ; i ++ )                            
{                                                    
aria + = trapArea ( f ( x0 ), f ( x0 + h ), h );            
x0 + = h ;
}
area + = trapArea ( f ( x0 ), f ( x1 ), x1 - x0 );
zona de întoarcere ;
 
}
public static void main (String args [])
{
               
fuctionIntegral integral = nou fuctionIntegral ();
număr dublu = integral . trapRule ( 1 , 2 , 5 );
Sistem . afară . println ( număr );
}
}

În C

 #include <stdio.h>

putere dublă (număr dublu, dublu elevație);
funcție dublă ( varF dublu );
areaTrapezio double (dublă latură 1, lato2 dublă, dublă înălțime);
double trapezioIntegral (double a, dublu b, coloane int);

int main ( int argc , char ** argv ) {
printf ( "[{% Dacă}]" , trapez integral ( 1 , 2 , 5000 ));
} 
	
putere dublă (număr dublu, dublu elevație) {
dublă ret = 1 ;
for ( int i = cota ; i > 0 ; i - ) {
ret * = număr ;
}
retur ret ;
}
funcție dublă ( varF dublu ) {
y dublu = putere ( varF , 2 );
returnează y ;
}

areaTrapezio double (latura 1 dublă, dublă lato2, dublă înălțime) {
retur (latura 1 + lato2) * înălțime / 2;
}

double trapezioIntegral ( double a , double b , int coloane ) {
zona dubla = 0 ;
dublu nPartiUguali = ( b - a ) / coloane ;
for ( int i = 0 ; i < coloane -1 ; i ++ ) {
area + = areaTrapezium ( function ( a ), function ( a + nPartiUguali ), nPartiUguali );
a + = nPartiEguali ;
}
aria + = aria Trapez ( funcția ( a ), funcția ( b ), b - a );
zona de întoarcere ;
}

Bibliografie

  • Richard L. Burden, J. Douglas Faires (2000): Analiză numerică , (Ediția a VII-a), Brooks / Cole. ISBN 0534382169

Elemente conexe

Alte proiecte

Matematica Portalul de matematică : accesați intrările Wikipedia care se ocupă de matematică