Après avoir consulté de nombreux ouvrages spécialisés, notamment Scientific Pascal, le Dictionnaire mathématique ainsi que plusieurs livres consacrés aux méthodes numériques, je n'ai trouvé que très peu d'explications détaillant l'algorithme complet permettant de calculer le logarithme népérien (Ln) avec une excellente précision. La plupart des auteurs se contentent de présenter la définition mathématique de cette fonction ou d'utiliser directement les bibliothèques fournies par le langage, sans expliquer la méthode de calcul employée. Parmi les rares exceptions figure le projet GNU HaypoCALC, dont les algorithmes constituent une excellente source d'inspiration pour comprendre les mécanismes internes de cette fonction fondamentale.
Le langage C++ offre déjà plusieurs fonctions logarithmiques dans l'entête math.h, telles que log, log10 ou encore log2, lesquelles sont généralement optimisées et adaptées aux différents processeurs modernes. Toutefois, il demeure particulièrement intéressant, tant sur le plan pédagogique que scientifique, de développer sa propre implémentation. Cette démarche permet de mieux comprendre les séries numériques, les méthodes d'approximation successives, les techniques de normalisation des valeurs ainsi que les différents compromis entre la rapidité d'exécution et la précision des résultats.
Le programme présenté ci-dessous illustre justement une telle approche. Après avoir réduit progressivement la valeur d'entrée dans un intervalle favorable au calcul, il exploite une fonction de racine carrée et un développement en série afin d'obtenir une approximation très précise du logarithme naturel. Cette méthode reproduit fidèlement les résultats attendus tout en démontrant qu'il est parfaitement possible d'implémenter soi-même une fonction logarithmique performante en C++, sans dépendre directement des fonctions prédéfinies de la bibliothèque standard. Les exemples qui suivent permettent de comparer les valeurs calculées pour différentes entrées et de constater la qualité ainsi que la précision de cette implémentation :
- #include <iostream>
-
- double SquareRoot(double X) {
- double A,B,M,XN;
- if(X==0.0) {
- return 0.0;
- } else {
- M=1.0;
- XN=X;
- while(XN>=2.0) {
- XN=0.25*XN;
- M=2.0*M;
- }
- while(XN<0.5) {
- XN=4.0*XN;
- M=0.5*M;
- }
- A=XN;
- B=1.0-XN;
- do {
- A=A*(1.0+0.5*B);
- B=0.25*(3.0+B)*B*B;
- } while(B>=1.0E-15);
- return A*M;
- }
- }
-
- double Ln(double x) {
- int negatif = false;
- double fois = 1;
- double ajout = 0;
- if(x<=0.0) return 0;
- if(x<1.0) {
- negatif = true;
- x = 1.0/x;
- }
- while(x >= 10.0) {
- x /= 10.0;
- ajout += 2.302585092994046;
- };
-
- while(x>=1.1) {
- x = SquareRoot(x);
- fois *= 2;
- };
- x--;
- double savx = x;
- double i = 2;
- double xp = x*x;
- double quotient = (xp/i);
- double dl = x-quotient;
- while (1.0E-15<quotient) {
- i++;
- xp *= x;
- dl += (xp/i);
- i++;
- xp *= x;
- quotient = (xp/i);
- dl -= quotient;
- }
-
- dl *= fois;
- dl += ajout;
- if(negatif) dl = -dl;
- return dl;
- }
-
- int main()
- {
- for(double I=0;I<=2.0;I+=0.1) std::cout << "Ln(" << I << ")=" << Ln(I) << std::endl;
- return 0;
- }
on obtiendra le résultat suivant :
Ln(0.0)=0.0Ln(0.1)=-2.302585092994046
Ln(0.2)=-1.6094379124341056
Ln(0.3)=-1.2039728043259357
Ln(0.4)=-0.916290731874156
Ln(0.5)=-0.6931471805599471
Ln(0.6)=-0.5108256237659916
Ln(0.7)=-0.3566749439387316
Ln(0.8)=-0.22314355131420963
Ln(0.9)=-0.10536051565782642
Ln(1.0)=0.09531017980432469
Ln(1.2)=0.18232155679395437
Ln(1.3)=0.2623642644674894
Ln(1.4)=0.3364722366212136
Ln(1.5)=0.40546510810816594
Ln(1.6)=0.47000362924573785
Ln(1.7)=0.5306282510621684
Ln(1.8)=0.5877866649021186
Ln(1.9)=0.6418538861723971