Section courante

A propos

Section administrative du site

Parmi les fonctions mathématiques fondamentales utilisées en informatique scientifique, la fonction exponentielle occupe une place particulièrement importante. Notée généralement exp(x) ou e^x, elle intervient dans un très grand nombre de domaines tels que les mathématiques, la physique, la chimie, l'économie, les statistiques et l'ingénierie. Elle est également l'inverse naturel de la fonction logarithme népérien, ce qui lui confère un rôle essentiel dans la résolution de nombreuses équations et dans la modélisation de phénomènes naturels. Malgré son importance considérable, il n'est pas toujours facile de trouver dans les ouvrages de programmation ou les manuels de mathématiques une explication détaillée de la manière dont cette fonction peut être calculée efficacement par un ordinateur. De nombreux livres présentent son utilisation sans nécessairement décrire les algorithmes employés pour obtenir une approximation numérique précise. Cette difficulté est particulièrement perceptible lorsque l'on souhaite développer soi-même une bibliothèque mathématique ou comprendre les mécanismes internes des fonctions proposées par les compilateurs.

Après avoir consulté diverses références spécialisées, notamment des ouvrages consacrés au langage Pascal, des dictionnaires mathématiques et plusieurs manuels scientifiques, il apparaît que peu de sources expliquent clairement comment reproduire le calcul de la fonction exponentielle avec un haut niveau de précision. Parmi les références les plus intéressantes figure néanmoins le projet GNU HaypoCALC, dont les algorithmes constituent une excellente source d'inspiration pour l'implémentation de fonctions mathématiques avancées. Le programme présenté ci-dessous s'appuie sur des principes similaires afin de construire une approximation très précise de la fonction exponentielle. Pour y parvenir, l'algorithme réduit d'abord la valeur à calculer en exploitant certaines propriétés mathématiques de l'exponentielle, puis applique un développement en série permettant d'obtenir progressivement une approximation de plus en plus exacte. Une série d'opérations de mise à l'échelle est ensuite utilisée pour retrouver la valeur finale recherchée.

Le code source en langage C compare directement les résultats obtenus par cette implémentation avec ceux retournés par la fonction exp() de la bibliothèque mathématique standard. Les différentes valeurs affichées montrent que les deux méthodes produisent des résultats pratiquement identiques, confirmant ainsi la précision de l'algorithme utilisé. Cet exemple constitue une excellente démonstration de calcul numérique et permet de mieux comprendre les techniques employées par les bibliothèques mathématiques modernes. Il illustre également comment des concepts tels que les développements en série, les logarithmes, les puissances et les transformations algébriques peuvent être combinés afin de reproduire efficacement une fonction mathématique aussi importante que l'exponentielle. Pour les programmeurs intéressés par les algorithmes numériques ou par la conception de bibliothèques scientifiques, ce type d'implémentation représente un excellent exercice permettant d'explorer les fondements mathématiques cachés derrière les fonctions les plus couramment utilisées.

Voici un code source C effectuant un calcul correct de cette formule en se basant sur les savants calculs de ce projet :

Essayer maintenant !
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4.  
  5. double Exponentiel(double x) {
  6.  int inverse = 0;
  7.  double n = 0, dl = 1;
  8.  int i = 1;
  9.  if(x<0) {
  10.   inverse = 1;
  11.   x = -x;
  12.  }
  13.  while(x >= 2) {
  14.      x /= 2;
  15.      n++;
  16.  }
  17.  x /= 16;
  18.  n += 4;
  19.  double q = x;
  20.  while (q > 1.0E-15) {
  21.     dl += q;
  22.     i++;
  23.     q = q*x/i;
  24.  }
  25.  for(i=1;i<= n; i++) dl=dl*dl;
  26.  if(inverse) dl = 1/dl;
  27.  return dl;
  28. }
  29.  
  30. int main()
  31. {
  32.     double I;
  33.     for(I=0;I<=2.0;I+=0.1) {
  34.           printf("Exp(%f)=%f %f\n",I,Exponentiel(I),exp(I));
  35.     }
  36.     return 0;
  37. }

on obtiendra le résultat suivant :

Exp(0.000000)=1.000000 1.000000
Exp(0.100000)=1.105171 1.105171
Exp(0.200000)=1.221403 1.221403
Exp(0.300000)=1.349859 1.349859
Exp(0.400000)=1.491825 1.491825
Exp(0.500000)=1.648721 1.648721
Exp(0.600000)=1.822119 1.822119
Exp(0.700000)=2.013753 2.013753
Exp(0.800000)=2.225541 2.225541
Exp(0.900000)=2.459603 2.459603
Exp(1.000000)=2.718282 2.718282
Exp(1.100000)=3.004166 3.004166
Exp(1.200000)=3.320117 3.320117
Exp(1.300000)=3.669297 3.669297
Exp(1.400000)=4.055200 4.055200
Exp(1.500000)=4.481689 4.481689
Exp(1.600000)=4.953032 4.953032
Exp(1.700000)=5.473947 5.473947
Exp(1.800000)=6.049647 6.049647
Exp(1.900000)=6.685894 6.685894

Voir également

Science - Mathématique

Dernière mise à jour : Samedi, le 22 août 2015