什么是第一个双倍偏离相应的长三角？-What'sthefirstdoublethatdeviatesfromitscorrespondinglongbydelta?

Doubles in IEE754 have a precision of 52 bits which means they can store numbers accurately up to (at least) 2⁵¹.

IEE754中的双精度具有52位的精度,这意味着它们可以准确地存储数字(至少)251。

If your longs are 32-bit, they will only have the (positive) range 0 to 2³¹ so there is no 32-bit long that cannot be represented exactly as a double. For a 64-bit long, it will be (roughly) 2⁵² so I'd be starting around there, not at zero.

如果你的long是32位,它们只有(正)范围0到231,所以没有32位长,不能完全表示为double。对于64位长,它将(大致)252,所以我将在那里开始,而不是零。

You can use the following program to detect where the failures start to occur. An earlier version I had relied on the fact that the last digit in a number that continuously doubles follows the sequence {2,4,8,6}. However, I opted eventually to use a known trusted tool (bc) for checking the whole number, not just the last digit.

您可以使用以下程序来检测故障开始的位置。我之前的版本依赖于这样一个事实:数字中的最后一个数字连续加倍,遵循序列{2,4,8,6}。但是,我最终选择使用已知的可信工具(bc)来检查整数,而不仅仅是最后一位数。

Keep in mind that this may be affected by the actions of sprintf() rather than the real accuracy of doubles (I don't think so personally since it had no troubles with certain numbers up to 2¹⁴³).

请记住,这可能会受到sprintf()的操作的影响,而不是双打的真实准确性(我不这么认为,因为它对2143年的某些数字没有任何麻烦)。

This is the program:

这是该计划:

#include 
#include 

int main() {
    FILE *fin;
    double d = 1.0; // 2^n-1 to avoid exact powers of 2.
    int i = 1;
    char ds[1000];
    char tst[1000];

    // Loop forever, rely on break to finish.
    while (1) {
        // Get C version of the double.
        sprintf (ds, "%.0f", d);

        // Get bc version of the double.
        sprintf (tst, "echo '2^%d - 1' | bc >tmpfile", i);
        system(tst);
        fin = fopen ("tmpfile", "r");
        fgets (tst, sizeof (tst), fin);
        fclose (fin);
        tst[strlen (tst) - 1] = '\0';

        // Check them.
        if (strcmp (ds, tst) != 0) {
            printf( "2^%d - 1 <-- bc failure\n", i);
            printf( "   got       [%s]\n", ds);
            printf( "   expected  [%s]\n", tst);
            break;
        }

        // Output for status then move to next.
        printf( "2^%d - 1 = %s\n", i, ds);
        d = (d + 1) * 2 - 1;  // Again, 2^n - 1.
        i++;
    }
}

This keeps going until:

这一直持续到:

2^51 - 1 = 2251799813685247
2^52 - 1 = 4503599627370495
2^53 - 1 = 9007199254740991
2^54 - 1 <-- bc failure
   got       [18014398509481984]
   expected  [18014398509481983]

which is about where I expected it to fail.

这是关于我预期失败的地方。

As an aside, I originally used numbers of the form 2ⁿ but that got me up to:

顺便说一句,我最初使用2n形式的数字,但这让我达到了:

2^136 = 87112285931760246646623899502532662132736
2^137 = 174224571863520493293247799005065324265472
2^138 = 348449143727040986586495598010130648530944
2^139 = 696898287454081973172991196020261297061888
2^140 = 1393796574908163946345982392040522594123776
2^141 = 2787593149816327892691964784081045188247552
2^142 = 5575186299632655785383929568162090376495104
2^143 <-- bc failure
   got       [11150372599265311570767859136324180752990210]
   expected  [11150372599265311570767859136324180752990208]

with the size of a double being 8 bytes (checked with sizeof). It turned out these numbers were of the binary form "1000..." which can be represented for far longer with doubles. That's when I switched to using 2ⁿ-1 to get a better bit pattern: all one bits.

double的大小是8个字节(用sizeof检查)。事实证明,这些数字是二进制形式“1000 ......”,可以用双倍表示更长的时间。那是当我切换到使用2n-1来获得更好的位模式时:所有的一位。

The first long to be 'wrong' when cast to a double will not be off by 1e-8, it will be off by 1. As long as the double can fit the long in its significand, it will represent it accurately.

当施放到双精灵时,第一个长度为'错误'将不会被1e-8关闭,它将被关闭1.只要双精度符合其有效位数的长度,它就能准确地表示它。

I forget exactly how many bits a double has for precision vs offset, but that would tell you the max size it could represent. The first long to be wrong should have the binary form 10000..., so you can find it much quicker by starting at 1 and left-shifting.

我确切地忘记了double对于精度与偏移有多少位,但这会告诉你它可以表示的最大大小。第一个长的错误应该是二进制形式10000 ...,所以你可以通过从1开始和左移来更快地找到它。

Wikipedia says 52 bits in the significand, not counting the implicit starting 1. That should mean the first long to be cast to a different value is 2^53.

维基百科在有效数字中表示52位,不包括隐式起始1.这应该意味着第一个长期被投射到不同的值是2 ^ 53。

Although I'm hesitant to mention Fortran 95 and successors in this discussion, I'll mention that Fortran since the 1990 standard has offered a SPACING intrinsic function which tells you what the difference between representable REALs are about a given REAL. You could do a binary search on this, stopping when SPACING(X) > DELTA. For compilers that use the same floating point model as the one you are interested in (likely to be the IEEE754 standard), you should get the same results.

虽然我在这次讨论中提到Fortran 95和后继者时犹豫不决,但我会提到自1990年标准以来Fortran提供了一个SPACING内在函数,该函数告诉你可表示REAL之间的差异是关于给定的REAL。您可以对此进行二进制搜索,在SPACING(X)> DELTA时停止。对于使用与您感兴趣的浮点模型相同的编译器(可能是IEEE754标准),您应该得到相同的结果。

Off hand, I thought that doubles could represent all integers (within their bounds) exactly.

在手边,我认为双打可以完全代表所有整数(在他们的范围内)。

If that is not the case, then you're going to want to cast both i and d to something with MORE precision than either of them. Perhaps a long double will work.

如果情况并非如此,那么你将要把i和d都投射到比其中任何一个更精确的东西。也许一个长的双重将起作用。