Pourquoi l'arithmétique à virgule flottante en C entraîne-t-elle des erreurs de précision ?

Précision à virgule flottante en C

En C , les nombres à virgule flottante sont précis jusqu'à un certain nombre de décimales. Cependant, cette précision présente des limites, qui peuvent conduire à des résultats inattendus.

Énoncé du problème

Considérez l'extrait de code suivant :

<code class="cpp">double a = 0.3;
std::cout.precision(20);
std::cout << a << std::endl;

// Print 0.2999999999999999889

double a, b;
a = 0.3;
b = 0;
for (char i = 1; i <= 50; i++) {
  b = b + a;
};
std::cout.precision(20);
std::cout << b << std::endl;

// Print 15.000000000000014211

Comme illustré, a est légèrement inférieur à 0,3, mais multiplié par 50, b devient légèrement supérieur à 15,0. Cet écart par rapport au résultat attendu peut être attribué aux limites de la précision en virgule flottante.

Solution

Pour obtenir des résultats corrects, il est crucial d'éviter de définir la précision supérieure à la précision disponible pour le type numérique. L'extrait de code révisé suivant illustre cette approche :

<code class="cpp">#include <iostream>
#include <limits>
int main() {
  double a = 0.3;
  std::cout.precision(std::numeric_limits<double>::digits10);
  std::cout << a << std::endl;

  double b = 0;
  for (char i = 1; i <= 50; i++) {
    b = b + a;
  };
  std::cout.precision(std::numeric_limits<double>::digits10);
  std::cout << b << std::endl;
}</code>

Cette approche garantit que la précision est définie au maximum disponible pour le type de données double. Il est important de noter que si la boucle devait s'exécuter sur un nombre d'itérations beaucoup plus important, par exemple 5 000 au lieu de 50, l'erreur accumulée finirait par devenir perceptible, quel que soit le paramètre de précision. Il s'agit d'une limitation inhérente à l'arithmétique à virgule flottante.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!