Daniele Finocchiaro
	via P. Scuderi 1
	95015 Linguaglossa (Ct)
	e-mail: df133590@ipifidpt.difi.unipi.it

 ************************************************************************
  L'uso e l'eventuale modifica di questo testo è riservato all'autore
  del software. Tutti gli altri sono caldamente invitati a rinunciarvi.
 ************************************************************************

Questo file documenta le funzioni offerte dal modulo `simple.c' aggiornato
alla versione 1.0 del 24.10.1994

------------------------------------------------------------------------------


Questa parte della libreria serve ad integrare funzioni che sono già note
su un insieme assegnato di punti. Ciò vuol dire, ad esempio, che i valori
di x ed i corrispodenti f(x) sono stati ottenuti attraverso misurazioni
effettuate in precedenza, e si deve adesso calcolare una stima
dell'integrale di f(x). Questa eventualità si presenta di frequente nelle
applicazioni pratiche.

La librerie offre fondamentalmente due funzioni, una per il caso di punti x
equidistanti, una per il caso generico in cui gli x sono qualsiasi. Ci sono
inoltre due funzioni che restituiscono anche gli integrali `intermedi',
cioè dal primo dei punti a ciascun punto x fornito in input. L'uso di
queste ultime funzioni è sconsigliato in quanto implementano algoritmi
molto meno precisi delle altre (formula dei trapezi), pur risultando,
ovviamente, più veloci.


	double Int_points(int n, double x[n], double fx[n])

n	: numero di punti (>=2)
x[]	: vettore contenente i punti in cui si conosce la funzione
fx[]	: vettore con i valori della funzione nel rispettivo x[i]

Output	: il valore dell'integrale.

Nella versione attuale è implementata una formula interpolatoria 
generalizzata su 5 punti. Intuitivamente, ciò significa che per ogni 5
punti noti si fa passare un polinomio interpolante di grado 5, e si calcola
l'integrale di quest'ultimo.


	double Int_eq_points(int n, double h, double fx[n])

n	: numero di punti (>=2)
h	: scarto tra gli x
fx[]	: vettore con i valori della funzione

Output	: il valore dell'integrale.

Si assume che i punti x[i] siano distanziati di `h' ciascuno dal
precedente. Quindi in generale 
	x[i] = x[0] + i*h
In questo modo viene implementata una versione più efficiente della
funzione precedente, in quanto i pesi della formula di integrazione sono
stati precalcolati. 
Questo algoritmo può anche essere pensato come una estensione a 5 punti del
noto procedimento di Cavalieri-Simpson (che invece lavora su 3 punti).


	double Int_points_p(int n, double x[n], double fx[n], double partial[n-1])

n	: numero di punti (>=2)
x[]	: vettore contenente i punti in cui si conosce la funzione
fx[]	: vettore con i valori della funzione nel rispettivo x[i]
partial[]: vettore che verrà riempito con gli integrali parziali

Output	: il valore dell'integrale.

Questa funzione è concettualmente analoga a Int_points, ma restituisce nel
vettore partial[] tutti gli integrali parziali, ovvero:
	partial[i] = integrale di f(x) tra x[0] e x[i+1]
In particolare partial[n-2] coincide con il valore restituito dalla
funzione.
Si consiglia di utilizzare questa funzione solo quando necessario in quanto
essa implementa la formula dei trapezi, molto meno precisa, seppur più
veloce, di quella implementata dalle funzioni precedenti.
Nota: se partial==NULL viene automaticamente chiamata la funzione
Int_points().


	double Int_eq_points_p(int n, double h, double fx[n], double partial[n-1])

n	: numero di punti (>=2)
h	: scarto tra gli x
fx[]	: vettore con i valori della funzione nel rispettivo x[i]
partial[]: vettore che verrà riempito con gli integrali parziali

Output	: il valore dell'integrale.

Analoga alla funzione precedente per il caso di x equidistanziati.
Se partial==NULL viene automaticamente chiamata Int_eq_points().