Section courante

A propos

Section administrative du site

Après avoir effectué des recherches dans de nombreux ouvrages spécialisés, notamment des références reconnues comme Scientific Pascal, différents dictionnaires mathématiques et plusieurs manuels de programmation scientifique, je n'ai pratiquement jamais trouvé d'explication détaillée ou de méthode complète permettant de recalculer correctement le logarithme népérien à partir de ses principes fondamentaux. La plupart des livres se contentent de présenter la fonction comme un outil déjà disponible dans les bibliothèques mathématiques des langages de programmation, sans expliquer les algorithmes qui se cachent derrière son fonctionnement. Une des rares exceptions rencontrées au cours de mes recherches fut le projet GNU HaypoCALC, dont les méthodes de calcul constituent une source d'inspiration particulièrement intéressante.

Pourtant, le logarithme est l'une des fonctions les plus importantes des mathématiques modernes. Il intervient dans de nombreux domaines tels que la physique, les statistiques, la finance, la chimie, l'informatique ou encore l'ingénierie. Son rôle est fondamental puisqu'il représente l'opération inverse de l'exponentielle et permet de manipuler plus facilement des grandeurs extrêmement grandes ou extrêmement petites. Malgré la présence de fonctions telles que Ln ou LogN dans les bibliothèques standards du langage Delphi, il demeure très instructif de comprendre comment ces résultats peuvent être obtenus à l'aide d'algorithmes numériques élaborés.

D'un point de vue pédagogique, programmer soi-même une fonction logarithmique permet de mieux comprendre les séries mathématiques, les méthodes d'approximation et les techniques de convergence utilisées dans les logiciels scientifiques. Cette démarche offre également l'occasion d'explorer des concepts tels que la racine carrée, les développements en série et les transformations successives permettant de rapprocher une valeur de la zone où le calcul devient plus précis et plus rapide.

Le programme Delphi présenté ci-dessous illustre justement une approche complète permettant de calculer le logarithme népérien sans recourir directement aux fonctions mathématiques intégrées du compilateur. En combinant une routine de calcul de racine carrée avec une série de développements numériques soigneusement choisis, il devient possible d'obtenir des résultats très proches de ceux fournis par les bibliothèques professionnelles. À l'aide de ce code source, vous pourrez ainsi découvrir les mécanismes internes du calcul du logarithme et vérifier la précision des résultats obtenus pour différentes valeurs numériques :

  1. Program LogSamples;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. Uses SysUtils;
  6.      
  7. Function SquareRoot(X:Real):Real;
  8. Var
  9.  A,B,M,XN:Real;
  10. Begin
  11.  If X=0.0Then Begin
  12.   SquareRoot:=0.0;
  13.  End
  14.   Else
  15.  Begin
  16.   M:=1.0;
  17.   XN:=X;
  18.   While XN>=2.0 do Begin
  19.    XN:=0.25*XN;
  20.    M:=2.0*M;
  21.   End;
  22.   While XN<0.5 do Begin
  23.    XN:=4.0*XN;
  24.    M:=0.5*M;
  25.   End;
  26.   A:=XN;
  27.   B:=1.0-XN;
  28.   Repeat
  29.    A:=A*(1.0+0.5*B);
  30.    B:=0.25*(3.0+B)*B*B;
  31.   Until B<1.0E-15;
  32.   SquareRoot:=A*M;
  33.  End;
  34. End;
  35.      
  36. Function LogNip(x:Real):Real;
  37. Var
  38.  negatif:Boolean;
  39.  fois,i:Integer;
  40.  ajout,savx,xp,quotient,dl:Real;
  41. Begin
  42.  negatif := False;
  43.  fois := 1;
  44.  ajout := 0;
  45.  If x <= 0.0 Then Begin
  46.   LogNip:=0;
  47.   Exit;
  48.  End;
  49.  If x < 1.0 Then Begin
  50.   negatif := True;
  51.   x := 1.0 / x;
  52.  End;
  53.  While x >= 10.0 do Begin
  54.   x := x / 10.0;
  55.   ajout := ajout + 2.302585092994046;
  56.  End;
  57.  While x >= 1.1 do Begin
  58.   x := SquareRoot(x);
  59.   fois := fois * 2;
  60.  End;
  61.  x := x - 1;
  62.  savx := x;
  63.  i := 2;
  64.  xp := x * x;
  65.  quotient := (xp / i);
  66.  dl := x - quotient;
  67.  While 1.0E-15 < quotient do Begin
  68.   i := i + 1;
  69.   xp := xp * x;
  70.   dl := dl + (xp / i);
  71.   i := i + 1;
  72.   xp := xp * x;
  73.   quotient := (xp / i);
  74.   dl := dl - quotient;
  75.  End;
  76.  dl := dl * fois;
  77.  dl := dl + ajout;
  78.  If(negatif)Then dl := - dl;
  79.  LogNip:=dl;
  80. End;
  81.      
  82. Var
  83.  I:Real;
  84.      
  85. BEGIN
  86.  I:=0;
  87.  While I <= 2.0 do Begin
  88.   WriteLn('Ln(',I:1:1,')=',LogNip(I):1:10);
  89.   I := I + 0.1;
  90.  End;
  91. END.

on obtiendra le résultat suivant :

Ln(0.0)=0.0000000000
Ln(0.1)=-2.3025850930
Ln(0.2)=-1.6094379125
Ln(0.3)=-1.2039728043
Ln(0.4)=-0.9162907318
Ln(0.5)=-0.6931471806
Ln(0.6)=-0.5108256238
Ln(0.7)=-0.3566749440
Ln(0.8)=-0.2231435513
Ln(0.9)=-0.1053605157
Ln(1.0)=0.0000000000
Ln(1.1)=0.0953101798
Ln(1.2)=0.1823215568
Ln(1.3)=0.2623642645
Ln(1.4)=0.3364722366
Ln(1.5)=0.4054651081
Ln(1.6)=0.4700036292
Ln(1.7)=0.5306282511
Ln(1.8)=0.5877866649
Ln(1.9)=0.6418538862

Voir également

Science - Mathématique

Dernière mise à jour : Dimanche, le 17 août 2014