Wolfram Language prend en charge trois types d’arithmétique des ordinateurs :

• Arithmétique en virgule flottante
• Arithmétique multi-précision
• Arithmétique de précision infinie

Chacun a ses avantages et faiblesses respectifs, il est important de savoir quand les utiliser pour obtenir les résultats les plus rapides et les plus précis. Cet article a pour but de fournir une vue d’ensemble de chaque type sans plonger dans toutes les spécificités techniques. Vous trouverez plus de détails dans la documentation de Wolfram Language, dont les liens sont indiqués tout au long de l’article.

Arithmétique en virgule flottante

L’arithmétique en virgule flottante est utilisée lorsqu’un nombre est entré avec une virgule (par exemple 4,2 ou 1,) ou lorsque la fonction N à argument unique est utilisée (par exemple N[1/2]). Sur la plupart des ordinateurs modernes, l’arithmétique en virgule flottante donne environ 16 chiffres de la mantisse (chiffres après la virgule).

La rapidité est le principal avantage de l’arithmétique en virgule flottante. Les calculs numériques multi-précision sont généralement beaucoup plus lents que les calculs en virgule flottante.

Bien que le calcul en virgule flottante soit rapide, il faut l’éviter lorsqu’on travaille avec des nombres très grands ou très petits dont la précision est essentielle (utiliser plutôt la multi-précision) ou lorsqu’un résultat symbolique est nécessaire (utiliser plutôt la précision infinie).

Il convient également de noter que lorsqu’on utilise la virgule flottante, les erreurs d’arrondi ne sont pas suivies. Cette méthode est utilisée pour des raisons de rapidité, mais elle peut entraîner des résultats erronés. Par exemple Out[1] est incorrect dans ce qui suit :

In[1]:= N[Sin[10^50]]
Out[1]= -0.4805

In[2]:= N[Sin[10^50], 20]
Out[2]= -0.78967249342931008271

La plupart des fonctions mathématiques intégrées au Wolfram Language fournissent un résultat qui correspond au mieux à la précision de l’entrée donnée. Si vous donnez à ces fonctions une entrée en virgule flottante, elles donneront une sortie en virgule flottante. Par exemple :

In[3]:= Sin[4.2]
Out[3]= -0.871576

In[4]:= Precision[%]
Out[4]= MachinePrecision

De même, si vous combinez des entrées en virgule flottante avec des entrées multi-précision ou de précision infinie dans un seul calcul, le résultat sera donné en virgule flottante :

In[5]:= 3 + 4.5
Out[5]= 7.5

In[6]:= Precision@%
Out[6]= MachinePrecision

Les opérateurs numériques (NIntegrate, NSum, NDSolve, etc.) renvoient la virgule flottante par défaut.

Arithmétique multi-précision

Lorsque vous effectuez des calculs avec des nombres arithmétiques multi-précision, Wolfram Language garde une trace de la précision en tout point. En général, Wolfram Language essaie de vous donner des résultats qui ont la plus grande précision possible, compte tenu de la précision de l’entrée que vous avez fournie.

Les nombres multi-précision sont le plus souvent créés en utilisant la fonction N avec son second argument. Par exemple N[Pi, 20] donne le résultat numérique de Pi à 20 chiffres de précision (3,1415926535897932385).

La multi-précision est utile pour les calculs qui exigent un haut degré de précision, y compris le travail avec des nombres très grands ou très petits. Cependant, les calculs multi-précision sont plus lents que les calculs en virgule flottante, de sorte que les nombres multi-précision ne sont généralement pas utilisés lorsqu’une précision élevée n’est pas nécessaire.

Comme pour les nombres en virgule flottante, si vous alimentez les fonctions mathématiques intégrées avec une entrée multi-précision, elles produiront une sortie multi-précision. Par exemple :

In[1]:= N[7, 30]^2
Out[1]= 49.0000000000000000000000000000

In[2]:= Precision[%]
Out[2]= 29.699

La combinaison d’une entrée en virgule flottante et d’une entrée multi-précision donnera une sortie en virgule flottante. Par conséquent, les erreurs ne seront pas suivies.

Un moyen efficace d’évaluer une expression en multi-précision est d’utiliser SetPrecision :

In[3]:= SetPrecision[1.9658*(1.23423423/500 + 600/3.9879), 20]
Out[3]= 295.76954069704845551

Vous pouvez forcer les opérateurs numériques (NIntegrate, NSum, NDSolve, etc.) à utiliser une multi-précision en définissant leur option WorkingPrecision.

Arithmétique de précision infinie

L’arithmétique de précision infinie est utilisée lorsque des entrées exactes sont connues et que des sorties exactes sont souhaitées, ou lors de la manipulation d’expressions de manière algébrique.

Rationalize est une fonction utile pour convertir des nombres à virgule flottante en un nombre exact.

Si vous alimentez des fonctions mathématiques intégrées avec une entrée de précision infinie, elles donneront une sortie de précision infinie. Par exemple :

In[1]:= Cos[Pi]
Out[1]= -1

In[2]:= Precision[%]
Out[2]= \[Infinity]

La combinaison d’une entrée de précision infinie et d’une entrée en virgule flottante donnera une sortie en virgule flottante.

[English]