[C] funzione exp da perfezionare

[matteolandi]

ciao,

non è molto che programmo in c e vorrei qualche dritta per
migliorare questo sorgente per il calcolo di exp(x), con particolare riferimento ai tipi da usare e agli specificatori di formato. Comunque sono certo che
qualcosa si possa affinare anche negli algoritmi usati...

#include <stdio.h>
#define MAX_N 10

long fct(long); /* fattoriale*/
long double pow(long double, long); /*potenza*/
long double exp(long double); /* exp */

int main(){
   printf("%Lf\n\n", exp(1));
   return(0);
}

long fct(long x){
   int i;
   long f = 1;
   if(x == 0) return(1);
   for(i = 1; x > 0; --x){
      f = f * i;
      ++i;
   }
   return(f);
}

long double pow(long double x, long i){
   int j;
   long double p;
   if(i == 0) return(1);
   if(i == 1) return(x);
   p = x;
   for(j = 1; j < i; ++j) p = p*x;
   return(p);
}

long double exp(long double x){
   int i;
   long double sum, e;
   for(i = 1; i <= MAX_N; ++i) sum = sum + (pow(x, i)/fct(i));
   e = 1 + sum;
   return(e);
}

grazie tante
ciao

[AleX ZeTa]

non capisco cosa tu voglia migliorare... l'algoritmo è la classica approssimazione di e^x in serie con MacLaurin, e non vedo alternative particolarmente vantaggiose...

si può fare qualcosa coi metodi di integrazione numerica, ma non mi pare molto coveniente... lo sviluppo in serie è sicuramente più veloce.

E anche come codice non mi pare così brutto... io lascerei com'è.

L'unica cosa che si potrebbe modificare è il controllo di precisione: invece di dare un numero MAX_N di iterazioni forse sarebbe preferibile controllare l'errore commesso (lo si fa col Resto di Lagrange). In questo caso il codice risulterebbe una cosa del tipo:

#include <stdio.h>
#define prec 0.001 //ad esempio...

double abs(double x) {
double a;
   if (x < 0) {
    a = -x;
   } else { a = x; }
   return(a);
}

long double exp(long double x){
   int i;
   long double e, er;
   i = 0;
   e = 0;
   er = 1;
   while (abs(e - er) > prec) {
   e = e + (pow(x, i)/fct(i));
   i++;
   er = pow(x, i)/fct(i);
   } 
   return(e);
}

[matteolandi]

Grazie per il suggerimento, ho ritoccato qua e la i codice che hai postato che in effetti è più elegante oltre che + efficente

#include <stdio.h>
#define PRECISION 0.000001

long double absl(long double x){
	if(x < 0) return(-x);
	return(x);
}

long double exp(long double x){
	int i = 1;
	long double er = 1, sum = 0;
	while(absl(0 - er) > PRECISION){
		sum = sum + (pow(x, i)/fct(i));
		++i;
		er = pow(x, i)/fct(i);
	}
	return(sum + 1);
}

ciao

[AleX ZeTa]

ops avevo fatto un errore allucinante... in effetti quel (e - er) non aveva alcun senso... il resto di Lagrange è solo er -.-

quindi togli anche quel 'absl(0 - er)' e metti semplicemente 'er' (che tanto è sicuramente positivo... lo sviluppo in serie di Mac Laurin di e^x è monotono e convergente)