Regola del trapezio

Regola del trapezio.

In analisi numerica, la regola del trapezio fornisce un procedimento per il calcolo approssimato di un integrale definito della forma

$\int _{a}^{b}f(x)\,dx$.

Nella sua formulazione elementare, la regola del trapezio o di Stevino propone di approssimare l'integrale (cioè, se la funzione è non negativa, l'area della regione piana compresa fra il grafico della funzione $f(x)$ e l'asse delle ascisse) con l'area del trapezio di vertici $(a,f(a)),(b,f(b)),(b,0)$ e $(a,0).$ Di conseguenza

$\int _{a}^{b}f(x)\,dx\,\approx \,(b-a){\frac {f(a)+f(b)}{2}}.$

Come è visivamente intuibile, questa approssimazione è accettabile se nell'intervallo di integrazione la funzione ha un andamento che si scosta poco dal lineare. Se questo non accade si può suddividere l'intervallo complessivo $\,[a,b]$ in un numero n opportuno di sottointervalli $a=z_{0}<z_{1}<\ldots <z_{n}=b,$ in ciascuno dei quali in genere accade che la funzione ha andamento poco lontano dal lineare; quindi la regola del trapezio nella forma composta dice di applicare l'approssimazione precedente a tutti i sottointervalli. Si ottiene quindi la formula

$\int _{a}^{b}f(x)\,dx\,\approx {\frac {b-a}{n}}\sum _{k=0}^{n-1}{f(z_{k})+f(z_{k+1}) \over 2}=\,{\frac {b-a}{n}}\left({f(a)+f(b) \over 2}+\sum _{k=1}^{n-1}f\left(a+k{\frac {b-a}{n}}\right)\right).$

La regola del trapezio fa parte della famiglia di formule per l'integrazione numerica chiamate formule di Newton-Cotes. Di questa famiglia fa parte anche la regola di Cavalieri-Simpson che dà spesso risultati più accurati. La regola di Cavalieri-Simpson e altri metodi simili migliorano la regola dei trapezi per gran parte delle funzioni dotate di due derivate continue. Accade però per certe funzioni dal comportamento irregolare che la più semplice regola del trapezio risulti preferibile. Inoltre la regola del trapezio tende a diventare molto accurata per gli integrali di funzioni periodiche nei rispettivi intervalli di periodicità; questo comportamento viene chiarito in relazione alla formula di Eulero-Maclaurin.

La regola del trapezio è alla base del procedimento di discretizzazione noto come discretizzazione di Tustin.

Implementazione sul calcolatore

In Python

def Integrale_Trapezio(f, a, b, n):
	"""
	Funzione in Python per il calcolo di un
	integrale definito, mediante la regola di Stevino.
	Argomenti della funzione:
	f      => funzione in Python dell'equazione da risolvere. *
	(a, b) => intervallo dell'integrale.
	n      => numero di suddivisioni da applicare all'integrale.
	"""
	
	s = [(b-a)/n*i+a for i in range(n+1)]	# Determino lo spazio lineare | Equivalente di numpy.linspace(a, b, n+1)
	S=[]
    for i in range(n):
        S=S+[(s[1]-s[0])*0.5*(f(s[i])+f(s[i+1]))]
    return sum(S)	# Restituisco il valore dell'area.

	# * Un esempio:
	#
	#   def f(x):
	#     return x*x
	#
	#   a = Integrale_Trapezio(f, 1, 2, 5) = 2.3399999999999994
	#
	#   Oppure:
 	#
	#   a = Integrale_Trapezio(lambda x: x*x, 1, 2, 5) = 2.3399999999999994

In MATLAB

function [int]=integrale_trap(f,a,b,n)
%Questa funzione calcola l'integrale definito in [a,b] della
% funzione f mediante il metodo dei Trapezi composto
% f è una funzione definita come function handle
% n è il numero di sottointervalli in cui si vuole dividere l'intervallo d'integrazione.

H = (b-a)/n; %Ampiezza di ogni sottointervallo
x=linspace(a,b,n+1); %Creo un intervallo di punti equispaziati di ampiezza H
int = 0;

for i=1:(length(x)-1)

int = int + 0.5*H*(f(x(i)) +  f(x(i+1)));

end

end
% Esempio numerico: Calcolo dell'integrale definito di x^2 tra [0,2]
% f = @(x) x.^2;
% I = integrale_trap(f,0,2,100)

In Java

 public class fuctionIntegral
{
	    public double power(double number,int elevation){
			double ret=1;
			for(int i=elevation;i>0;i--){
				ret *= number;
				}
				return ret;
			}
        public double f(double x)
        {      double y=0;
                y=power(x,2);
                return y;
        }
         public double trapArea(double b1, double b2, double h)
        {
                return (b1+b2)*h/2;
        }

        public double trapRule(double x0, double x1, int div)
        {
                double area = 0;
                double h = (x1 - x0) / div;
                for (int i=0; i<div-1; i++)
                {
                        area += trapArea(f(x0), f(x0+h), h);
                        x0 += h;
                }
                area += trapArea(f(x0), f(x1), x1-x0);
                return area;

        }
        public static void main(String args[])
        {

                fuctionIntegral integral = new fuctionIntegral();
               double number = integral.trapRule(1,2,5);
                System.out.println(number);
        }
}

In C

#include <stdio.h>

double power(double numero,double elevazione);
double funzione(double varF);
double areaTrapezio(double lato1,double lato2,double altezza);
double trapezioIntegral(double a,double b,int colonne);

int main(int argc,char**argv){
	printf("[{  %If  }]",trapezioIntegral(1,2,5000));
	}
	
double power(double numero,double elevazione){
	double ret = 1;
	for(int i=elevazione;i>0;i--){
				ret *= numero;
				}
				return ret;
	}
double funzione(double varF){
	double y = power(varF,2);
	return y;
	}

double areaTrapezio(double lato1,double lato2,double altezza){
	return (lato1+lato2)*altezza/2;
	}

double trapezioIntegral(double a,double b,int colonne){
	double area = 0;
	double nPartiUguali = (b-a)/colonne;
	for(int i=0;i<colonne-1;i++){
		area += areaTrapezio(funzione(a),funzione(a+nPartiUguali),nPartiUguali);
		a += nPartiUguali;
		}
		area += areaTrapezio(funzione(a),funzione(b),b-a);
		return area;
	}

Bibliografia

• Richard L. Burden, J. Douglas Faires (2000): Numerical Analysis, (7th Ed.), Brooks/Cole. ISBN 0534382169

Voci correlate

• Regola di Cavalieri-Simpson
• Regola del rettangolo

Altri progetti

Altri progetti

• Wikimedia Commons

• Wikimedia Commons contiene immagini o altri file su Regola del trapezio