s
19 708 Pages

Réglez le trapézoïde
Règle du trapèze.

en analyse numérique, la règle trapézoïdale Il fournit un processus pour le calcul approximatif d'un intégrale définie forme

.

La règle trapézoïdale ou Stevino, dans sa formulation élémentaire, se propose de rapprocher l'intégrale, à savoir la zone de la zone plane entre le graphique de la fonction et l'axe des abscisses, avec la zone de la trapèze des sommets (a, f (a)), (b, f (b)), (b, 0) et (A, 0). En conséquence

.

Comme cela est visuellement compréhensible, cette approximation est acceptable si la plage d'intégration de la fonction a un motif qui diffère peu du linéaire. Si cela ne vous arrive pas diviser la gamme globale dans un certain nombre n appropriés sous-intervalles , dans chacune desquelles est généralement le cas que la fonction a peu de distance de la tendance linéaire; alors la règle trapézoïdal dit la forme du composé à appliquer l'approximation précédente à tous les sous-intervalles. Il obtient alors la formule

La règle trapézoïdal fait partie de la formule pour la famille 'intégration numérique appel formules de Newton-Cotes. De cette famille, il fait également partie de la règle Cavalieri-Simpson ce qui donne souvent des résultats plus précis. La règle Cavalieri-Simpson et d'autres méthodes similaires améliorer la règle du trapèze pour la plupart des fonctions prévues avec deux dérivées continues. Il arrive, cependant, pour certaines fonctions par le comportement erratique que la règle de la trapézoïdal se révèle plus facile préférable. En outre, la règle trapézoïdal a tendance à être très précis pour Intégrales fonctions périodiques dans les plages de fréquences respectives; ce comportement est expliqué par rapport à formule d'Euler-Maclaurin.

La règle trapézoïdal est la base de la procédure de discrétisation connu sous le nom de discrétisation Tustin.

La mise en œuvre sur l'ordinateur

en Python

def Integrale_Trapezio(fa, à, b, n):
« » "
	Fonction en python pour le calcul d'un
	intégrale définie, au moyen de la règle Stevino.
	Sujets de la fonction:
	f => fonction dans l'équation à résoudre python. *
	(A, b) => intervalle intégral.
	n => nombre de subdivisions à appliquer à l'intégrale.
	« » "
s = [(b-à)/(1.*n)*la+à pour la en gamme(n+1)]	# Déterminer l'espace linéaire | numpy.linspace équivalent (a, b, n)
retour (s[1]-s[0])*(somme([fa(la) pour la en s[1:n]])+(fa(s[0])+fa(s[n]))/2.)	# Redonner la valeur de la zone.
# * Par exemple:
#
Def # f (x):
# Retour x * x
#
# A = Integrale_Trapezio (f, 1, 2, 5) = 2,3399999999999994
#
# Ou:
#
# A = Integrale_Trapezio (lambda x: x * x, 1, 2, 5) = 2,3399999999999994

en Matlab

fonction [Int]=integrale_trap(f, a, b, n)
% Cette fonction calcule l'intégrale définie dans [a, b] de la
% La fonction f en utilisant le procédé du composé Trapezi
% F est une fonction définie comme une poignée de fonction
% N est le nombre de sous-intervalles dans lesquels vous voulez diviser l'intervalle d'intégration.
H = (b-à)/n; % Largeur de chaque sous-intervalle
int=linspace(à,b,n+1); % Creo équidistants une gamme de points d'amplitude H
int = 0;
pour la=1:(longueur(int)-1)
int = int + 0,5*H*(fa(int(la)) +  fa(int(la+1)));
fin
fin
% Exemple numérique: calcul de l'intégrale définie par x ^ 2 entre [0,2]
% F = @ (x) x ^ 2.
% I = integrale_trap (f, 0,2,100)

en Java

public classe fuctionIntegral
{
public double puissance(double nombre,int élévation) {
double ret=1;
pour(int la=élévation;la>0;la--) {
ret * = nombre;
}
retour ret;
}
public double fa(double x)
{      double y=0;
y=puissance(x,2);
retour y;
}
public double trapArea(double b1, double b2, double h)
{
retour (b1+b2) *h/2;
}
public double trapRule(double x0, double x1, int div)
{
double zone = 0;
double h = (x1 - x0) / div;
pour (int la=0; la<div-1; la++)
{
zone += trapArea(fa(x0) fa(x0+h) h);
x0 += h;
}
zone += trapArea(fa(x0) fa(x1) x1-x0);
retour zone;
}
public statique vide principal(chaîne args[])
{
fuctionIntegral intégral = nouveau fuctionIntegral();
double nombre = intégral.trapRule(1,2,5);
système.dehors.println(nombre);
}
}

En C ++

#include 
double puissance(double nombre,double élévation);
double fonction(double varF);
double areaTrapezio(double côté 1,double lato2,double hauteur);
double trapezioIntegral(double à,double b,int colonnes);
int principal(int argc,carboniser**argv) {
printf("[% {Si}]",trapezioIntegral(1,2,5000));
}
double puissance(double nombre,double élévation) {
double ret = 1;
pour(int la=élévation;la>0;la--) {
ret * = nombre;
}
retour ret;
}
double fonction(double varF) {
double y = puissance(varF,2);
retour y;
}
double areaTrapezio(double côté 1,double lato2,double hauteur) {
retour (côté 1+lato2)*hauteur/2;
}
double trapezioIntegral(double à,double b,int colonnes) {
double zone = 0;
double nPartiUguali = (b-à)/colonnes;
pour(int la=0;la<colonnes-1;la++) {
zone += areaTrapezio(fonction(à)fonction(à+nPartiUguali)nPartiUguali);
à += nPartiUguali;
}
zone += areaTrapezio(fonction(à)fonction(b)b-à);
retour zone;
}

bibliographie

  • Richard L. Burden, J. Douglas Faires (2000): Analyse numérique, (7e éd.), Brooks / Cole. ISBN 0534382169

Articles connexes

  • La règle de Simpson
  • Règle du rectangle

D'autres projets