Regola del trapezio

Da Wikipedia, l'enciclopedia libera.
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.

La regola del trapezio o di Stevin, nella sua formulazione elementare, propone di approssimare l'integrale, cioè l'area della regione piana compresa fra il grafo 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 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} \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.

Implementazione sul calcolatore[modifica | modifica sorgente]

In Python[modifica | modifica sorgente]

def IntegraleTrap(f,a,b,m):
    """
Funzione che calcola l'integrale di una funzione nell'intervallo [a,b] con
il metodo dei trapezi.
    """  
    i=a
    ris=0
    k=float(b-a)/m
    while (i<=b):
        try:
            ris+=((f(i)+f(i-k))*k)/2.0
            i+=k
        except:
            i+=k
            continue
    return ris


In MATLAB[modifica | modifica sorgente]

/* Danilo Pipitone */
 
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 stringa di testo dove c'è scritta l'espressione della funzione
% n è il numero in cui si vuole dividere l'intervallo di osservazione.
 
x=linspace(a,b,n+1);
f=inline(f);
y=f(x);
 
h=x(2)-x(1); % è l'incremento infinitesimo
 
int=h*(sum(y(2:n))+(y(1)+y(n+1))/2);
end
 
%esempio numerico
% int=integrale_trap('x.^2',0,3,100);
% err=abs(9-int)

In Java[modifica | modifica sorgente]

/* Alex Voicu */
 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++[modifica | modifica sorgente]

/* Alex Voicu*/
#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[modifica | modifica sorgente]

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

Voci correlate[modifica | modifica sorgente]

Altri progetti[modifica | modifica sorgente]

matematica Portale Matematica: accedi alle voci di Wikipedia che trattano di matematica