Comment vérifier si un double a au plus n décimales?

Actuellement, j'ai cette méthode:

static boolean checkDecimalPlaces(double d, int decimalPlaces){
    if (d==0) return true;

    double multiplier = Math.pow(10, decimalPlaces); 
    double check  =  d * multiplier;
    check = Math.round(check);      
    check = check/multiplier; 
    return (d==check);      
}

Mais cette méthode n'est pas pour checkDecmialPlaces(649632196443.4279, 4) probablement parce que je fais de la base de 10 les mathématiques sur une base de 2 numéro.

Alors, comment cela peut-il vérifier être fait correctement?

J'ai pensé à l'obtention d'une représentation de chaîne de la valeur double, puis vérifier avec une regexp - mais que me sentais bizarre.

EDIT:
Merci pour toutes les réponses. Il y a des cas où j'ai vraiment obtenir un double et pour les cas j'ai mis en place les éléments suivants:

private static boolean checkDecimalPlaces(double d, int decimalPlaces) {
    if (d == 0) return true;

    final double epsilon = Math.pow(10.0, ((decimalPlaces + 1) * -1));

    double multiplier = Math.pow(10, decimalPlaces);
    double check = d * multiplier;
    long checkLong = (long) Math.abs(check);
    check = checkLong / multiplier;

    double e = Math.abs(d - check);
    return e < epsilon;
}

J'ai changé le round à une troncature. Semble que le calcul fait dans round augmente l'imprécision de trop. Au moins dans le défaut testcase.

Comme certains de vous l'ont souligné, si je pouvais obtenir la 'vraie' entrée de chaîne que je devrais utiliser BigDecimal de vérifier et j'ai donc fait:

BigDecimal decimal = new BigDecimal(value);
BigDecimal checkDecimal = decimal.movePointRight(decimalPlaces);
return checkDecimal.scale() == 0;

La double valeur que je reçois vient de Apache POI API qui lit les fichiers excel. J'ai fait quelques tests et constaté que, bien que l'API retourne double valeurs numériques des cellules que je peux obtenir une représentation exacte quand j'ai immédiatement format double avec le DecimalFormat:

DecimalFormat decimalFormat = new DecimalFormat();
decimalFormat.setMaximumIntegerDigits(Integer.MAX_VALUE);
//don't use grouping for numeric-type cells
decimalFormat.setGroupingUsed(false);
decimalFormat.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US));
value = decimalFormat.format(numericValue);

Cela fonctionne aussi pour les valeurs qui ne peuvent pas être représentés exactement dans le format binaire.

"correctement" ne veut pas dire grand-chose ici. Vos aléatoire des nombres décimaux n'ont pas exact des représentations binaires. Vous êtes à la recherche pour un nombre décimal qui est "assez proche" de sorte que des gens comme les décimales version de la valeur binaire. Comment fermer est assez proche?

OriginalL'auteur Turismo | 2008-11-05

6

Le test échoue, parce que vous avez atteint la précision de la binaire à virgule flottante représentation, qui est d'environ 16 chiffres avec IEEE754 double précision. En multipliant par 649632196443.4279 par 10000 va tronquer la représentation binaire, conduisant à des erreurs lors de l'arrondissement et en divisant par la suite, ce qui permet d'invalider le résultat de votre fonction complètement.

Pour plus de détails, voir http://en.wikipedia.org/wiki/Floating_point#Accuracy_problems

Une meilleure façon serait de vérifier si le n+1 décimales sont en dessous d'un certain seuil. Si d - round(d) est à moins de epsilon (voir limite), la représentation décimale de d n'a pas de décimales significatives. De même, si (d - round(d)) * 10^n est à moins de epsilon, d peut avoir au plus n endroits importants.

Utilisation Jon Skeet's DoubleConverter à vérifier pour le cas où d n'est pas assez précis pour contenir le nombre de décimales que vous recherchez.

J'ai également regardé la DoubleConverter Jon posté dans sa réponse et il semble faire à peu près la même que BigDecimal. Je me demande pourquoi il a enlevé sa réponse.

OriginalL'auteur David Schmitt
5

Si votre objectif est de représenter un nombre avec exactement n chiffres significatifs à droite de la virgule, BigDecimal est la classe à utiliser.

Immuable, en précision arbitraire signé
les nombres décimaux. Un BigDecimal se compose
d'une précision arbitraire entier
non mis à l'échelle de la valeur et un entier de 32 bits
l'échelle. Si le zéro ou positif, l'échelle
est le nombre de chiffres à droite
du point décimal. Si le résultat est négatif, le
non mis à l'échelle de la valeur du nombre est
multiplié par dix à la puissance de l'
la négation de l'échelle. La valeur de
le nombre représenté par la
BigDecimal est donc (unscaledValue
× 10-échelle).

scale peut être réglée via setScale(int)

OriginalL'auteur Ken Gentle
3

Comme avec tous arithmétique à virgule flottante, vous ne devez pas vérifier pour l'égalité, mais plutôt que l'erreur (epsilon) est suffisamment petit.

Si vous remplacez:
```
return (d==check);
```
avec quelque chose comme
```
return (Math.abs(d-check) <= 0.0000001);
```
il devrait fonctionner. De toute évidence, l'epsilon doit être sélectionné pour être assez petit comparé avec le nombre de décimales que vous êtes arrivée.

Le plus gros problème est le débordement lorsque vous n': case = d * multiplicateur, ce n'est pas travailler pour un grand nombre;
IEE 754 64 bits double seulement environ 18 chiffres de précision de toute façon donc, si vous vous levez dans les numéros de la multipliant par 1000 va entraîner un dépassement de capacité (environ 10^304), vous pouvez être certain qu'il y a zéro décimales dans la représentation.

OriginalL'auteur paxdiablo
1

La double est de type binaire, nombre à virgule flottante. Il y a toujours apparentes inexactitudes de traiter avec eux comme s'ils étaient décimale des nombres à virgule flottante. Je ne sais pas que vous aurez jamais être en mesure d'écrire fonctionner, de sorte qu'il fonctionne comme vous le souhaitez.

Vous aurez probablement à revenir à la source du numéro (une chaîne de caractères d'entrée peut-être), et de garder la représentation décimale si il est important pour vous.

OriginalL'auteur Ned Batchelder
1

Si vous pouvez passer à BigDecimal, alors que Ken G explique, c'est ce que vous devriez être en utilisant.

Si non, alors vous avez à traiter avec une foule de questions, comme mentionné dans les autres réponses. Pour moi, vous êtes face à un nombre binaire (double) et poser une question à propos d'une représentation décimale de ce nombre; c'est à dire, que vous posez sur une Chaîne. Je pense que votre intuition est correcte.

OriginalL'auteur Glenn
0

Je ne suis pas sûr que ce soit vraiment faisable en général. Par exemple, combien de décimales ne 1.0e-13? Que faire si il y a certaines erreurs d'arrondi tout en faisant de l'arithmétique et est vraiment juste 0 dans le déguisement? Si, d'autre part, vous vous demandez s'il y a des non-zéro chiffres dans la première n décimales, vous pouvez faire quelque chose comme:
```
   static boolean checkDecimalPlaces(double d, unsigned int decimalPlaces){
      //take advantage of truncation, may need to use BigInt here
      //depending on your range
      double d_abs = Math.abs(d);
      unsigned long d_i = d_abs; 
      unsigned long e = (d_abs - d_i) * Math.pow(10, decimalPlaces);
      return e > 0;
   }
```
en fait, votre réponse m'a aidé, mais comme il est maintenant il est imparfait, comme vous l'avez multiplier d avant de le tronquer pour ne pas perdre de chiffres significatifs - voir mon edit de la question

OriginalL'auteur tvanfosson

Je pense que c'est mieux
Convertir en string et d'interroger la valeur de l'exposant

 public int calcBase10Exponet (Number increment)
 {
  //toSting of 0.0=0.0
  //toSting of 1.0=1.0
  //toSting of 10.0=10.0
  //toSting of 100.0=100.0
  //toSting of 1000.0=1000.0
  //toSting of 10000.0=10000.0
  //toSting of 100000.0=100000.0
  //toSting of 1000000.0=1000000.0
  //toSting of 1.0E7=1.0E7
  //toSting of 1.0E8=1.0E8
  //toSting of 1.0E9=1.0E9
  //toSting of 1.0E10=1.0E10
  //toSting of 1.0E11=1.0E11
  //toSting of 0.1=0.1
  //toSting of 0.01=0.01
  //toSting of 0.0010=0.0010  <== need to trim off this extra zero
  //toSting of 1.0E-4=1.0E-4
  //toSting of 1.0E-5=1.0E-5
  //toSting of 1.0E-6=1.0E-6
  //toSting of 1.0E-7=1.0E-7
  //toSting of 1.0E-8=1.0E-8
  //toSting of 1.0E-9=1.0E-9
  //toSting of 1.0E-10=1.0E-10
  //toSting of 1.0E-11=1.0E-11
  double dbl = increment.doubleValue ();
  String str = Double.toString (dbl);
// System.out.println ("NumberBoxDefaultPatternCalculator: toSting of " + dbl + "=" + str);
  if (str.contains ("E"))
  {
   return Integer.parseInt (str.substring (str.indexOf ("E") + 1));
  }
  if (str.endsWith (".0"))
  {
   return str.length () - 3;
  }
  while (str.endsWith ("0"))
  {
   str = str.substring (0, str.length () - 1);
  }
  return - (str.length () - str.indexOf (".") - 1);
 }

OriginalL'auteur Norm Wright

Vous devez vous connecter pour publier un commentaire.