À chaque endroit où j'ai regardé, il est dit que doublec'est supérieur à floatpresque à tous les égards. floata été rendu obsolète par doubleJava, pourquoi est-il toujours utilisé?

Je programme beaucoup avec Libgdx, et ils vous obligent à utiliser float(deltaTime, etc.), mais il me semble que doublec'est simplement plus facile de travailler en termes de stockage et de mémoire.

Je lis aussi Quand utilisez-vous float et quand utilisez-vous double , mais si ce floatn'est vraiment bon que pour les nombres avec beaucoup de chiffres après la virgule, alors pourquoi ne pourrions-nous pas simplement utiliser l'une des nombreuses variations de double?

Y a-t-il une raison pour laquelle les gens insistent pour utiliser des flotteurs même s'ils ne présentent plus aucun avantage? Est-ce trop de travail pour tout changer?

LibGDX est un framework principalement utilisé pour le développement de jeux.

En développement de jeu, vous devez généralement effectuer un nombre considérable de calculs en temps réel, ainsi que toutes les performances que vous pouvez obtenir. C'est pourquoi les développeurs de jeux utilisent généralement float chaque fois que sa précision est suffisante.

La taille des registres FPU dans la CPU n'est pas la seule chose à prendre en compte dans ce cas. En fait, la plupart des problèmes de calcul dans le développement de jeux sont effectués par le GPU, et les GPU sont généralement optimisés pour les floats, pas pour les doublons .

Et puis il y a aussi:

• Bande passante du bus mémoire (à quelle vitesse vous pouvez pelleter des données entre RAM, CPU et GPU)
• Cache de la CPU (ce qui rend la précédente moins nécessaire)
• RAM
• VRAM

qui sont toutes des ressources précieuses dont vous obtenez deux fois plus lorsque vous utilisez float 32 bits au lieu de 64 bits double.

Les flotteurs utilisent deux fois moins de mémoire que les doubles.

Ils ont peut-être moins de précision que les doubles, mais de nombreuses applications n'exigent pas de précision. Ils ont une gamme plus large que tout format de point fixe de taille similaire. Par conséquent, ils occupent un créneau qui nécessite de grands nombres de chiffres mais qui n’a pas besoin d’une précision élevée et où l’utilisation de la mémoire est importante. Je les utilisais par exemple dans le cadre de grands réseaux de neurones.

En dehors de Java, ils sont également largement utilisés dans les graphiques 3D, car de nombreux GPU les utilisent comme format principal. En dehors des périphériques très coûteux de NVIDIA Tesla / AMD FirePro, la virgule flottante double précision est très lente sur les GPU.

Rétrocompatibilité

C'est la raison numéro un pour conserver le comportement dans une langue / bibliothèque / ISA / etc. déjà existante .

Pensez à ce qui se produirait s’ils retiraient les flotteurs de Java. Libgdx (et des milliers d'autres bibliothèques et programmes) ne fonctionnerait pas. Il faudra beaucoup d'efforts pour mettre le tout à jour, probablement des années pour de nombreux projets (il suffit de regarder la transition en amont de la compatibilité entre Python 2 et Python 3). Et tout ne sera pas mis à jour, certaines choses seront brisées pour toujours parce que les mainteneurs les ont abandonnées, peut-être plus tôt qu’elles ne l’auraient été parce qu’il faudrait plus d’efforts qu’elles ne veulent mettre à jour, ou parce qu’il n’est plus possible d’accomplir ce que leur logiciel était supposé faire.

Performance

Les doubles 64 bits occupent deux fois plus de mémoire et sont presque toujours plus lents à traiter que les bits flottants 32 bits (les très rares exceptions étant celles où la capacité 32 bits flottants est censée être utilisée si rarement, voire pas du tout, qu'aucun effort n'a été fait pour les optimiser. Sauf si vous développez pour du matériel spécialisé, cela ne se produira pas dans un avenir proche.)

Pour vous, Libgdx est une bibliothèque de jeux. Les jeux ont tendance à être plus sensibles aux performances que la plupart des logiciels. Et les cartes graphiques de jeu (AMD Radeon et NVIDIA Geforce, et non FirePro ou Quadro) ont tendance à avoir de très faibles performances en virgule flottante 64 bits. Grâce à Anandtech, voici comment comparer les performances en double précision à celles en simple précision de certaines des meilleures cartes de jeu disponibles d' AMD et de NVIDIA (à partir de début 2016).

AMD
Card    R9 Fury X      R9 Fury       R9 290X    R9 290
FP64    1/16           1/16          1/8        1/8

NVIDIA
Card    GTX Titan X    GTX 980 Ti    GTX 980    GTX 780 Ti
FP64    1/32           1/32          1/32       1/24

Notez que les séries R9 Fury et GTX 900 sont plus récentes que les séries R9 200 et GTX 700, de sorte que les performances relatives pour la virgule flottante 64 bits sont en baisse. Retournez assez loin et vous trouverez la GTX 580, qui avait un rapport de 1/8 comme la série R9 200.

1/32 de la performance est une pénalité assez lourde à payer si vous avez une contrainte de temps serrée et que vous ne gagnez pas beaucoup en utilisant le double plus grand.

Opérations atomiques

Outre ce que d'autres ont déjà dit, un inconvénient spécifique à Java de double(et long) est que les assignations à des types primitifs 64 bits ne sont pas forcément atomiques . Extrait de la spécification du langage Java, édition Java SE 8 , page 660 (non souligné dans l'original):

17.7 Traitement non atomique du doubleetlong

Pour les besoins du modèle de mémoire en langage de programmation Java, une seule écriture dans une valeur longou une doublevaleur non volatile est traitée comme deux écritures distinctes: une dans chaque moitié de 32 bits. Cela peut entraîner une situation dans laquelle un thread voit les 32 premiers bits d'une valeur de 64 bits d'une écriture et les 32 derniers bits d'une autre écriture.

Beurk.

Pour éviter cela, vous devez déclarer la variable 64 bits avec levolatile mot clé ou utiliser une autre forme de synchronisation autour des assignations.

Il semble que d’autres réponses aient manqué un point important: les architectures SIMD peuvent traiter moins / plus de données selon qu’elles fonctionnent sur doubleou des floatstructures (par exemple, huit valeurs flottantes à la fois ou quatre valeurs doubles à la fois).

Résumé des considérations de performance

• float peut être plus rapide sur certains processeurs (par exemple, certains appareils mobiles).
• float utilise moins de mémoire, ce qui peut réduire considérablement la mémoire totale requise (disque dur / RAM) et la bande passante consommée dans les grands ensembles de données.
• float peut faire en sorte que le processeur consomme moins d’énergie (je ne trouve pas de référence, mais si ce n’est pas possible, cela semble au moins plausible) pour les calculs à simple précision par rapport aux calculs à double précision.
• float consomme moins de bande passante, et dans certaines applications, cela compte.
• Les architectures SIMD peuvent traiter jusqu'à deux fois la même quantité de données car d'habitude.
• float utilise autant que la moitié de la mémoire cache par rapport au double.

Résumé des considérations de précision

• Dans de nombreuses applications floatsuffit
• double a beaucoup plus de précision quand même

Considérations de compatibilité

• Si vos données doivent être soumises à un GPU (par exemple, pour un jeu vidéo utilisant OpenGL ou toute autre API de rendu), le format de virgule flottante est considérablement plus rapide que double(c'est parce que les fabricants de GPU tentent d'augmenter le nombre de cœurs graphiques et ainsi, ils essaient de sauvegarder autant de circuits que possible dans chaque cœur, donc l’optimisation floatpermet de créer des GPU avec plus de cœurs à l’intérieur)
• Les anciens GPU et certains appareils mobiles ne peuvent tout simplement pas être acceptés doublecomme format interne (pour les opérations de rendu 3D)

Conseils généraux

• Sur les processeurs de bureau modernes (et probablement sur un grand nombre de processeurs mobiles), vous pouvez en principe supposer que l’utilisation de doublevariables temporaires sur la pile donne une précision supplémentaire gratuite (précision supplémentaire sans perte de performances).
• N'utilisez jamais plus de précision que nécessaire (vous pouvez ne pas savoir quelle précision vous avez réellement besoin).
• Parfois, vous êtes forcé par la plage de valeurs (certaines valeurs seraient infinies si vous utilisez float, mais peuvent être limitées si vous utilisez double)
• Utiliser seulement floatou seulement doublebeaucoup aide le compilateur à simplifier les instructions.

Voir les commentaires ci-dessous de PeterCordes pour plus d'informations.

Outre les autres raisons évoquées:

Si vous avez des données de mesure, qu'il s'agisse de pressions, de débits, de courants, de tensions ou autres, cela se fait souvent avec du matériel doté d'un CAN.

Un ADC a typiquement 10 ou 12 bits, les 14 ou 16 bits étant plus rares. Mais restons sur le 16 bits - si vous mesurez à la pleine échelle, vous avez une précision de 1/65535. Cela signifie qu'un changement de 65534/65535 en 65535/65535 correspond à cette étape - 1/65535. C'est à peu près 1.5E-05. La précision d'un flotteur est d'environ 1E-07, donc bien meilleure. Cela signifie que vous ne perdez rien en utilisant floatpour stocker ces données.

Si vous effectuez des calculs excessifs avec des flotteurs, vos performances sont légèrement moins bonnes qu'en doublestermes de précision, mais souvent vous n’avez pas besoin de cette précision, car vous ne vous souciez pas souvent de mesurer une tension de 2 V ou de 2 000 000 V. De même. , si vous convertissez cette tension en pression, vous n’aurez rien à faire si vous avez 3 bars ou 3.00003 bars.