Je suis en train de recoder les fonctions mathématiques en C.

On a vu que:
Exp(x) = SOMME de i jusqu´à l´infinie de (x^i / i ! )

Donc en prenant la valeur de 100 pour l´infinie, j´ai le code suivant:

1. include<stdio.h>
2. include<stdlib.h>

int main()
{
float x, u=1, exp=0;
int i;

scanf("%l", &x);

for (i=1; i==100; i++)
{
exp += u;
u = u*(x/i);
}

printf("%l\n", exp);
system("PAUSE");
return 0;
}

Je code sous Windows via Dev-C++ (pas de commentaires ;) ) mais le printf n´affiche rien (juste un retour à la ligne). Pourriez-vous m´aider svp ?

Merci. :D

exp est de type float donc pour l´afficher il faut utiliser %f ou %le

Deja ton implementation de l´algo est faut. Tu divises par i au lieu de i! (factorielle i). Ensuite il faut utiliser %f et non pas %l, ou %lf pour de double. Ensuite fait gaffe aux overflow, meme si avec 100 l´algo que je te donne cela fonctionne encore a peu pret (mais style 20 donne de bons resultats). Pourquoi ne pas utiliser la fonction exp() de math.h ? :P
Le code:
http://rafb.net/paste/results/GbeSSl43.html

C´est bon

Merci beaucoup!

Il ne s´est pas trompé pour la division : u est le terme général de la série donc u(n)=u(n-1)*x/n
C´est bien ce qu´il fait.

Sinon il y a la possibilité de le faire en assembleur, ce qui (sous certaines conditions) peut-être plus rapide que le code généré par le compilo (en tout cas que gcc...)

un exemple :
http://wall.sectionpc.info/fct_exp.txt

oups

Une bonne méthode pour faire autre chose que
for (i=1; i==100; i++) {
exp += u;
u = u*(x/i);
}
qui est un peu gorissime quand meme est de continuer a faire converger la suite jusqu´a ce que la différence soit négligable, c´est a dire
expnmoins1 = -infini
for (i=1; exp-expnmois1 < epsilon; i++) {
expnmoins1 = exp;
exp += u;
u = u*(x/i);
}

ce qui permet d´approcher ta valeur aussi pres que tu le veux.

PS: ce que tu as donner ce n´est pas un DL en 0 ?

godrik, ta question s´adresse à qui ?

Si c´est pour le code de Darigaaz, alors la réponse est oui, c´est plus ou moins un DL à l´ordre 100, mais bon au final c´est le même calcul que la série entière.

Pour ma version en asm, ce n´est pas un DL, mais un calcul "directe" avec les fonction "bizarre" du FPU x86 (F2XM1 n´est peut-être pas l´opérande le plus intuitif que l´on trouve).