grootste geheel getal dat kan worden opgeslagen in een dubbele

Wat is het grootste “niet-zwevende” gehele getal dat kan worden opgeslagen in een IEEE 754 dubbel type zonder precisie te verliezen?

Antwoord 1, autoriteit 100%

Het grootste/grootste gehele getal dat in een double kan worden opgeslagen zonder de precisie te verliezen, is hetzelfde als de grootst mogelijke waarde van een double. Dat wil zeggen, DBL_MAXof ongeveer 1,8 × 10³⁰⁸(als uw double een IEEE 754 64-bit double is). Het is een geheel getal. Het is precies weergegeven. Wat wil je nog meer?

Ga door, vraag me wat het grootste gehele getal is, zodat het en alle kleinere gehele getallenkunnen worden opgeslagen in IEEE 64-bit doubles zonder aan precisie in te boeten. Een IEEE 64-bit double heeft 52 bits mantisse, dus ik denk dat het 2⁵³is:

• 2⁵³+ 1 kan niet worden opgeslagen, omdat de 1 aan het begin en de 1 aan het einde te veel nullen ertussen hebben.
• Alles minder dan 2⁵³kan worden opgeslagen, met 52 bits expliciet opgeslagen in de mantisse, en dan geeft de exponent je een andere.
• 2⁵³kan uiteraard worden opgeslagen, aangezien het een kleine macht van 2 is.

Of een andere manier om ernaar te kijken: als de bias eenmaal van de exponent is gehaald en het tekenbit als irrelevant voor de vraag wordt genegeerd, is de waarde die wordt opgeslagen door een double een macht van 2 plus een 52-bits geheel getal vermenigvuldigd met 2^{exponent − 52}. Dus met exponent 52 kun je alle waarden van 2⁵²tot en met 2⁵³ − 1 opslaan. Dan is met exponent 53 het volgende getal dat je kunt opslaan na 2⁵³2⁵³+ 1 × 2^{53 − 52}. Dus verlies van precisie treedt eerst op met 2⁵³+ 1.

Antwoord 2, autoriteit 15%

9007199254740992(dat is 9.007.199.254.740.992 of 2^53) zonder garanties 🙂

Programma

#include <math.h>
#include <stdio.h>
int main(void) {
  double dbl = 0; /* I started with 9007199254000000, a little less than 2^53 */
  while (dbl + 1 != dbl) dbl++;
  printf("%.0f\n", dbl - 1);
  printf("%.0f\n", dbl);
  printf("%.0f\n", dbl + 1);
  return 0;
}

Resultaat

9007199254740991
9007199254740992
9007199254740992

Antwoord 3, Autoriteit 5%

Wikipedia heeft dit te zeggen in dezelfde context met een link naar IEEE 754 :

Op een typisch computersysteem heeft een ‘dubbele precisie’ (64-bits) binair drijvende-puntnummer een coëfficiënt van 53 bits (waarvan er één geïmpliceerd), een exponent van 11 bits en één tekenbit.

2 ^ 53 is iets meer dan 9 * 10 ^ 15.

Antwoord 4, Autoriteit 4%

Het grootste gehele getal dat kan worden weergegeven in IEEE 754 Double (64-bit) is hetzelfde als de grootste waarde die het type kan vertegenwoordigen, omdat die waarde zelf een geheel getal is.

Dit is weergegeven als 0x7FEFFFFFFFFFFFFF, die bestaat uit:

• het tekenbit 0 (positief) in plaats van 1 (negatief)
• De maximale exponent 0x7FE(2046 die 1023 vertegenwoordigt nadat de bias wordt afgetrokken) in plaats van 0x7FF(2047 die een NaNof oneindigheid aangeeft ).
• De MAXIMALE MANTISSA 0xFFFFFFFFFFFFFDIE 52 BITS ALLES IS 1.

In binary is de waarde de impliciete 1 gevolgd door nog eens 52 exemplaren van de Mantissa, dan 971 nullen (1023 – 52 = 971) van de exponent.

De exacte decimale waarde is:

179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368

Dit is ongeveer 1,8 x 10³⁰⁸.

Antwoord 5

Je moet kijken naar de grootte van de mantisse. Een IEEE 754 64-bits drijvende-kommagetal (dat 52 bits heeft, plus 1 impliciet) kan exact gehele getallen vertegenwoordigen met een absolute waarde van minder dan of gelijk aan 2^53.

Antwoord 6

1.79769931348623157 × 10^308

http://en.wikipedia.org/wiki/Double_precision_floating-point_format

Antwoord 7

Het is waar dat voor 64-bits IEEE754 double alle gehele getallen tot 9007199254740992 == 2^53 exact kunnen worden weergegeven.

Het is echter ook de moeite waard om te vermelden dat alle representeerbare getallen voorbij 4503599627370496 == 2^52 gehele getallen zijn.
Voorbij 2^52 wordt het zinloos om te testen of het gehele getallen zijn, omdat ze allemaal impliciet worden afgerond op een nabijgelegen representeerbare waarde.

In het bereik van 2^51 tot 2^52 zijn de enige niet-gehele waarden de middelpunten die eindigen op “.5”, wat betekent dat van elke toets met een geheel getal na een berekening moet worden verwacht dat deze ten minste 50% foutieve antwoorden oplevert.

Onder 2^51 hebben we ook “.25” en “.75”, dus het is logisch om een getal te vergelijken met zijn afgeronde tegenhanger om te bepalen of het een geheel getal is of niet.

TLDR: als je wilt testen of een berekend resultaat een geheel getal mag zijn, vermijd dan getallen groter dan 2251799813685248 == 2^51

Antwoord 8

Zoals anderen al hebben opgemerkt, ga ik ervan uit dat het OP om de grootste drijvende-kommawaarde heeft gevraagd, zodat alle gehele getallen die kleiner zijn dan zichzelf nauwkeurig kunnen worden weergegeven.

U kunt FLT_MANT_DIGen DBL_MANT_DIGgebruiken die zijn gedefinieerd in float.hom niet te vertrouwen op de expliciete waarden (bijv. 53):

#include <stdio.h>
#include <float.h>
int main(void)
{
    printf("%d, %.1f\n", FLT_MANT_DIG, (float)(1L << FLT_MANT_DIG));
    printf("%d, %.1lf\n", DBL_MANT_DIG, (double)(1L << DBL_MANT_DIG));
}

uitgangen:

24, 16777216.0
53, 9007199254740992.0