Tronquer une valeur décimale en C++

Quelle est la meilleure façon de tronquer une C++ float variable qui a une valeur de 0.6000002 à une valeur de 0,6000 et de les stocker dans la variable?

OriginalL'auteur BeachRunnerFred | 2008-11-20

  1. 7

    Abord, il est important de savoir que les nombres à virgule flottante sont approximatives. Voir le lien donné par @Greg Hewgill à comprendre pourquoi ce problème n'est pas complètement résoluble.

    Mais ici, êtes un couple de solutions pour le problème qui va probablement répondre à votre besoin:

    Probablement la meilleure méthode, mais de moins en moins efficace:

    char sz[64];
double lf = 0.600000002;
sprintf(sz, "%.4lf\n", lf); //sz contains 0.6000

double lf2 = atof(sz);

//lf == 0.600000002;
//lf2 == 0.6000

printf("%.4lf", lf2); //print 0.6000

    La façon la plus efficace, mais probablement moins précis:

    double lf = 0.600000002;
int iSigned = lf > 0? 1: -1;
unsigned int uiTemp = (lf*pow(10, 4)) * iSigned; //Note I'm using unsigned int so that I can increase the precision of the truncate
lf = (((double)uiTemp)/pow(10,4) * iSigned);

    OriginalL'auteur Brian R. Bondy

  2. 12

    Une bonne référence pour pourquoi ce qui se passe peut être trouvé dans Ce Que Tout Informaticien Devriez Savoir Sur L'Arithmétique À Virgule Flottante par David Goldberg.

    Merci de poster le lien Greg, je pensais exactement la même document, lorsque j'ai écrit ma réponse mais je ne pouvais pas pour la vie de me rappeler le titre.

    OriginalL'auteur Greg Hewgill

  3. 6

    De façon réaliste, ce n'est pas possible. Ce n'est pas une C++ limitation, mais juste la façon dont virgule flottante œuvres. Pour de nombreuses valeurs il n'y a pas représenter de façon précise, de sorte que vous ne pouvez pas simplement couper un certain nombre de chiffres.

    Vous pourriez tronquée lors de l'impression à l'aide de printf chaînes de format.

    Si vous avez vraiment besoin pour être en mesure de stocker qu'un nombre limité de chiffres, je vous suggère d'utiliser un fixe de précision type de données à la place.

    OriginalL'auteur Kamil Kisiel

  4. 3

    je pense que la question qui doit être posée ici est:
    Pourquoi avez-vous besoin tronquée?

    Si ses pour la comparaison entre les valeurs, peut-être vous devriez envisager d'utiliser l'epsilon de test. (avec un supplément de valeur tolérance, dans votre cas, puisqu'il semble être beaucoup plus important que celui généralement admis epsilon).

    Si vous avez juste envie de l'imprimer comme de 0,6000 , utiliser les méthodes d'autres ont suggéré.

    OriginalL'auteur Alex Lim

  5. 1
    roundf(myfloat * powf(10, numDigits)) / powf(10, numDigits);

    Par exemple, dans votre cas, vous êtes en tronquant les trois chiffres (numDigits). Vous pouvez utiliser:

    roundf(0.6000002 * 1000) / 1000
//And thus:
roundf(600.0002) / 1000
600 / 1000
0.6

    (Vous auriez probablement stocker le résultat de powf quelque part, puisque vous êtes à l'aide de deux fois.)

    En raison de la façon dont les flotteurs sont normalement stockées sur les ordinateurs, il n'y aurait probablement des inexactitudes. C'est ce que vous obtenez pour l'utilisation de flotteurs.

    OriginalL'auteur strager

  6. 1

    Utiliser ceci: 

    floor(0.6000002*10000)/10000

    OriginalL'auteur JBOI

  7. 1

    Pour le C++11, vous pouvez utiliser std::round défini dans l'en-tête <cmath>:

    auto trunc_value = std::round(value_to_trunc * 10000) / 10000;

    OriginalL'auteur chema989

  8. 0

    Ici est une fonction en utilisant les conseils dans d'autres réponses et un exemple de son utilisation:

    #include <iostream>
#include <cmath>

static void Truncate(double& d, unsigned int numberOfDecimalsToKeep);

int main(int, char*[])
{

  double a = 1.23456789;
  unsigned int numDigits = 3;

  std::cout << a << std::endl;

  Truncate(a,3);

  std::cout << a << std::endl;

  return 0;
}

void Truncate(double& d, unsigned int numberOfDecimalsToKeep)
{
    d = roundf(d * powf(10, numberOfDecimalsToKeep)) / powf(10, numberOfDecimalsToKeep);
}

    OriginalL'auteur David Doria

  9. 0

    Similaire à d'autres réponses, MAIS vous ne devez pas oublier que ronde, le plancher et le tronc sont différents de par leur définition. Voir la définition et exemple de sortie de la suivante:

    http://www.cplusplus.com/reference/cmath/trunc/

    Dans ce cas, nous avons besoin de trucate avec une précision de 4 décimales et de se débarrasser de non-significative décimales:

    trunc(valueToTrunc*10000)/10000

    ou

    value = (double)((int)(valueToTrunc*10000))/(double)10000

    OriginalL'auteur Rubarb