Convertir float double sans perdre de précision

J'ai une primitive de flotteur et j'ai besoin aussi d'une primitive double. Tout simplement couler le flotteur à double me donne bizarre une précision supplémentaire. Par exemple:

float temp = 14009.35F;
System.out.println(Float.toString(temp)); //Prints 14009.35
System.out.println(Double.toString((double)temp)); //Prints 14009.349609375

Toutefois, si, au lieu de casting, j'ai sortie le flotteur comme une chaîne de caractères, et d'analyser la chaîne comme un double, j'obtiens ce que je veux:

System.out.println(Double.toString(Double.parseDouble(Float.toString(temp))));
//Prints 14009.35

Est-il un meilleur moyen que d'aller à la Chaîne et à l'arrière?

InformationsquelleAutor Steve Armstrong | 2009-05-27

114

Ce n'est pas que vous êtes fait plus de précision, c'est que le flotteur ne pas représenter avec précision le nombre vous visaient à l'origine. Le double est représentant l'original flotteur avec précision; toString est de montrer les "extra" des données qui étaient déjà présents.

Par exemple (et ces chiffres ne sont pas de droite, je suis juste rendre les choses jusqu') supposons que vous avez eu:
```
float f = 0.1F;
double d = f;
```
Alors la valeur de f pourrait être exactement 0.100000234523. d aura exactement la même valeur, mais quand vous convertir en une chaîne de "confiance" que c'est exact pour une plus grande précision, afin de ne pas arrondir comme au début, et vous verrez les "chiffres supplémentaires", qui étaient déjà là, mais caché.

Lors de la conversion en chaîne de caractères et à l'arrière, vous êtes de se retrouver avec une double valeur qui est plus proche de la chaîne de valeur que l'original float - mais, c'est seulement une bonne si croyez-vous vraiment que la chaîne de la valeur est ce que vous avez vraiment voulu.

Êtes-vous sûr que float/double sont les types appropriés à utiliser, ici au lieu de BigDecimal? Si vous essayez d'utiliser les nombres qui ont précise des valeurs décimales (par exemple de l'argent), puis BigDecimal est plus approprié de type OMI.
- Je pense que votre réponse décrit le mieux la raison de mon problème. Ma solution peut "travailler", mais je me rends compte maintenant que je suis une sorte de poser la mauvaise question. Merci.
- J'ai eu le même problème dans .NET et ceci explique cela très bien, merci.
InformationsquelleAutor Jon Skeet

Je trouve la conversion de la représentation binaire plus facile à appréhender ce problème.

float f = 0.27f;
double d2 = (double) f;
double d3 = 0.27d;

System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(f)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d2)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d3)));

Vous pouvez voir le flotteur est élargi pour le double par l'ajout de 0s à la fin, mais que la double représentation de 0,27 est "plus précis", donc le problème.

   111110100010100011110101110001
11111111010001010001111010111000100000000000000000000000000000
11111111010001010001111010111000010100011110101110000101001000

InformationsquelleAutor Brecht Yperman

24

C'est en raison du contrat de Float.toString(float), qui dit en partie:

Du nombre de chiffres doit être imprimé pour
la partie fractionnaire [...]? Il y
doit être d'au moins un chiffre
représenter la partie fractionnaire, et
au-delà de que le plus grand nombre, mais seulement autant,
plus de chiffres sont nécessaires pour unique
distinguer la valeur de l'argument de
adjacent valeurs de type float. Que
supposons par exemple que x est l'exact
valeur mathématique représentée par le
représentation décimale produit par
cette méthode pour un fini différent de zéro
l'argument de f. Alors f doit être le flotteur
la valeur la plus proche de x; ou, si les deux flotteur
les valeurs sont également proches de x, alors f
doit être l'un d'entre eux et le moins que l'
bit significatif de la significande de
f doit être 0.
- +1 Grande réponse avec citation de la documentation.
InformationsquelleAutor erickson
13

J'ai rencontré ce problème aujourd'hui et ne pouvait pas utiliser refactoriser à BigDecimal, parce que le projet est vraiment énorme. Cependant, j'ai trouvé la solution à l'aide de
```
Float result = new Float(5623.23)
Double doubleResult = new FloatingDecimal(result.floatValue()).doubleValue()
```
Et cela fonctionne.

Noter que l'appel de résultat.doubleValue() renvoie 5623.22998046875

Mais en l'appelant doubleResult.doubleValue() renvoie correctement 5623.23

Mais je ne suis pas entièrement sûr si ses une bonne solution.
- A travaillé pour moi. Est également très rapide. Je ne sais pas pourquoi ce n'est pas marqué comme réponse.
- C'est la méthode que j'utilise, et u n'a pas besoin d'une nouvelle Float partie... il suffit de créer le FloatingDecimal avec la primitive. Il sera automatiquement en boîte... Et travaille vite trop... Il est sur;y un inconvénient, FloatingDecimal est immuable, de sorte que u besoin d'en créer un pour chaque flotteur... imaginez un code de calcul de O(1e10)!!! Bien sûr BigDecimal a le même inconvénient...
- L'inconvénient de cette solution est que le soleil.misc.FloatingDecimal est la classe interne de la JVM et la signature de son constructeur a été changé en Java 1.8. Personne ne devrait utiliser les classes internes dans la vie réelle demande.
InformationsquelleAutor Andrew
7

Utiliser un BigDecimal au lieu de float/double. Il y a beaucoup de chiffres qui ne peuvent pas être représentés en virgule flottante binaire (par exemple, 0.1). Donc vous devez toujours arrondir le résultat à une précision ou l'utilisation BigDecimal.

Voir http://en.wikipedia.org/wiki/Floating_point pour plus d'informations.
- Disons que vous avez de 10m flotter les prix du commerce dans votre cache, avez-vous toujours envisager d'utiliser BigDecimal et instancier unique permet de dire ~6m objets ( à l'actualisation des poids mouche/immuables).. ou il y a de plus?
- Merci de ne pas utiliser les commentaires pour poser des questions complexes 🙂
- Merci pour la recherche!.. nous utilisons des flotteurs, maintenant, alors que qui a été décidé il y a dix ans --j'essayais de voir votre point de vue sur cette situation sur le suivi -- . merci!
- L'incompréhension. Je ne peux pas répondre à votre question en 512 caractères. Merci de poser la question et de m'envoyer un lien.
- Longtemps après que vous l'avez demandé, je pense que la solution est de stocker des prix en pence/cents comme un int pour rapide, des calculs précis. (Évidemment, si vous utilisez des nombres non-entiers de pence/cents, puis ajuster le degré de précision nécessaire.)
- C'est exactement ce que BigDecimal n'. C'est un BigInteger plus la position de la virgule décimale.
- Je pensais que le problème était avec les performances de la mémoire et du hit associées à la création (par exemple) de 6 millions de BigDecimals. Si vous savez à l'avance que le point décimal seulement ne va jamais à la position 2, vous pouvez (probablement) rendre les choses plus vite avec un int tableau [].
- Il n'existe pas de "one size fits all" quand il s'agit de la manipulation des nombres décimaux sur les ordinateurs. Mais puisque la plupart des gens ne comprennent pas, je leur BigDecimal depuis que va attraper la plupart des erreurs courantes. Si les choses sont trop lents, ils ont besoin de pour en savoir plus et trouver des moyens d'optimiser leurs problèmes. L'optimisation prématurée est la racine de tous les maux - D. E. Knuth.
InformationsquelleAutor Aaron Digulla

J'ai trouvé la solution suivante:

public static Double getFloatAsDouble(Float fValue) {
    return Double.valueOf(fValue.toString());
}

Si vous utilisez float et double au lieu de Float et Double utiliser les éléments suivants:

public static double getFloatAsDouble(float value) {
    return Double.valueOf(Float.valueOf(value).toString()).doubleValue();
}

InformationsquelleAutor GSD.Aaz

1

Flotteurs, par nature, sont imprécises et ont toujours soigné arrondissement "questions". Si la précision est importante, alors vous pourriez envisager de la refactorisation de votre application pour utiliser Décimal ou BigDecimal.

Oui, les chars de calcul plus rapide que les décimales en raison de la prise en charge des processeurs. Toutefois, voulez-vous rapide ou précis?
- L'arithmétique décimale est inexact trop. (par ex. 1 / 3 * 3 == 0.9999999999999999999999999999 C'est, bien sûr, le meilleur pour la représentation exacte décimal des quantités comme de l'argent, mais pour les mesures physiques, il n'a aucun avantage.
- Mais 1 == 0.9999999999999999999999999999 🙂
InformationsquelleAutor NotMe
0

Pour plus d'informations, ce qui vient en vertu de l'Article 48 - Éviter les float et double lorsque les valeurs exactes sont nécessaires, Efficaces Java 2nd edition de Joshua Bloch. Ce livre est bourré avec de bonnes choses, et certainement en valeur un regard.

InformationsquelleAutor mR_fr0g

Fait ce travail?

float flt = 145.664454;

Double dbl = 0.0;
dbl += flt;

InformationsquelleAutor AesmaDiv

Vous devez vous connecter pour publier un commentaire.