【问题标题】:Number of consecutive zeros in the decimal representation of a doubledouble 十进制表示中连续零的数量
【发布时间】:2013-12-14 22:46:21
【问题描述】:

在 IEEE 754 双精度数的精确十进制表示中,连续的非前导非尾随零(分别为九)的最大数量是多少?

上下文

考虑将double 转换为十进制,向上(或向下)四舍五入的问题,当您能够使用的唯一原语是转换为最接近的现有函数时(正确四舍五入为任何所需的位数)。

您可以获取一些额外的数字并自行删除它们。例如,要将1.875 向下舍入到点后一位数,您可以将其转换为点后两位或三位数字的最接近十进制表示(1.87 或 1.875),然后自己按顺序擦除数字获得预期的答案,1.8。

对于某些数字和要打印的附加位数的选择,此方法会产生错误的结果。例如,对于最接近0.799999996 的double,在点产生0.80、0.800 和0.8000 之后,转换为十进制、四舍五入到最接近的2、3 或4 位数字。转换后擦除额外的数字会产生结果0.8,而所需的结果是0.7。

double 的数量是有限的,还有一些额外的数字足以在初始转换中打印,以便在截断获得的十进制表示后始终计算正确的结果。此数字与double 的精确十进制表示中可能出现的最大九或零有关。

相关

此问题与this question about rounding down in the conversion of a double to decimal 相关,是this question about the correctly rounded conversion of decimal representations to doubles 的对偶。

【问题讨论】:

  • 您是如何不断提出有关浮点运算的这些难题的? :)
  • @tmyklebu 作为一名数学家,我自己还不足以回答关于浮点的大多数有趣问题,但我被这个主题所吸引,因为它连接了位旋转和算术。一些有趣的浮点结果(由于复杂的原因而成立)具有简单易记的表达式,就像收集交易卡一样有趣。
  • @HotLicks double 数字的精确十进制表示可以有超过 750 位数字。您只能“选择”前 16 个左右,但其他的都在那里,并且在使用正确舍入的转换函数转换为十进制时会显示出来。有这么多double 数字,其中一些数字的十进制数字如此之多,以至于人们无法立即排除长序列 0 或 9 出现在其中一些数字的十进制表示中的可能性。
  • +1 表示书呆子狙击;我刚刚浪费了我星期六早上的一半时间!对于零,我相信答案是 20:正好有 10 个正 IEEE 754 binary64 浮点数,其十进制扩展包括 20 个连续的非前导非尾随零,其中最小的是 0x1.9527560bfbed8p-1000。没有十进制扩展具有 21 个连续内部零的 binary64 数字的示例。我正在整理一个正确的答案,并将在今天下午晚些时候(UTC)发布。
  • 我不得不看到,对于自己 - 的0x1.9527560bfbed8p-1000的第一331位为 “1.477012373908101575832232661339769380031937878886222568639663847578915738904402685093081763578918086880369974166811882659004450391286591500093106533326541096734395895637095523633076069664624790127807433173880682800315681861858968243277845522401259472373130330434329222431733172090251166174832460421937841944270000000000000000000074 ... E-301”。有你的 20 个零! (我迫不及待地想看到你的答案。)

标签: floating-point ieee-754


【解决方案1】:

[简短版:答案是 20。根据寻找 2^e / 10^d 形式的数的良好有理逼近来重新解决问题;然后使用连分数为每个合适的d 和e 找到最佳近似值。]

答案似乎是 20:也就是说,有一些 IEEE 754 binary64 浮点数的示例,其十进制扩展具有 20 连续零,但没有在其十进制扩展中具有 21 连续零(不包括前导和尾随零)。对于 9 字符串也是如此。

对于第一部分,我需要做的就是展示这样一个浮动。 0x1.9527560bfbed8p-1000 的值完全可以表示为二进制 64 浮点数,其十进制扩展包含 20 个零的字符串:

1.4770123739081015758322326613397693800319378788862225686396638475789157389044026850930817635789180868803699741668118826590044503912865915000931065333265410967343958956370955236330760696646247901278074331738806828003156818618589682432778455224012594723731303304343292224317331720902511661748324604219378419442700000000000000000000740694966568985212687104794747958616712153948337746429554804241586090095019654323133732729258896166004754316995632195371041441104566613036026346868128222593894931067078171989365490315525401375255259854894072456336393577718955037826961967325532389800834191597056333066925969522850884268136311674777047673845172073566950098844307658716553833345849153012040436628485227928616281881622762650607683099224232137203216552734375E-301 P>

关于九的部分,0x1.c23142c9da581p-405的十进制扩展包含一个20个九的字符串:

2.12818792307269553358078502102171540639252016258831784842556110831434197718043638405555406495645619729155240037555858106390933161420388023706431461384056688295540725831155392678607931808851292893574214797681879999999999999999999941026584542575391157788777223962620780080784703190447744595561259568772261019375946489162743091583251953125E-122 P>

为了解释我是如何找到上面的数字的,并且为了证明没有连续 21 个零的例子,我们需要更加努力。一个实数在其十进制扩展中具有长字符串 9 或 0,对于某些整数 a 和 d 和实数 eps 的形式为 (a + eps)*10^d,其中 a 非零(我们不妨假设 @ 987654335@ 正)和eps 非零和小。例如,如果0 < abs(eps) < 10^-10 则a + eps 小数点后至少有10 个零(如果eps 为正数),或小数点后有10 个九(如果eps 为负数);乘以10^d 可以移动零或九字符串的位置。

但我们对上述形式的数字感兴趣,它们可以同时表示为 IEEE 754 binary64 浮点数;换句话说,对于整数 b 和 e 满足 2^52 <= b <= 2^53 的整数也是 b*2^e 形式的数字,e 的范围有限(并且一旦我们进入低于正常范围,但我们可以稍后再担心)。

因此,结合这一点,我们正在寻找整数 a、b、d 和 e 的 (a + eps) * 10^d = b * 2^e 的解决方案,使得 eps 很小,a 是正数,@987654355 @(我们稍后会担心 d 和 e 的范围)。重新排列,我们得到eps / b = 2^e / 10^d - a / b。换句话说,我们正在寻找对2^e / 10^d 具有有限分母的良好有理近似值。这是连分数的经典应用:给定d 和e,可以有效地找到分母以2^53 为界的最佳有理逼近。

所以一般的解决策略是:

for each appropriate d and e:
    find the best rational approximation a / b to 2^e / 10^d with denominator <= 2^53
    if (the error in this rational approximation is small enough):
        # we've got a candidate
        examine the decimal expansion of b*2^e

我们只有大约 2000 个值要检查 e,最坏的情况是每个这样的 e 有几百个 d,所以整个事情在计算上是非常可行的。

现在详细说明:“足够小”是什么意思?哪个d 和e 是“合适的”?

关于“足够小”:假设我们正在寻找至少有 19 个零或九的字符串,所以我们正在寻找0 &lt; abs(eps) &lt;= 10^-19 的解决方案。因此,对于每个d 和e,找到所有a 和b 这样abs(2^e / 10^d - a / b) &lt;= 10^-19 * 2^-52 就足够了。请注意,由于b 的限制,a / b 只能有一个这样的分数;如果还有另一个这样的a' / b',那么我们就有1 / 2^106 &lt;= 1 / (b *b') &lt;= abs(a / b - a' / b') &lt;= 2 * 10^-19 * 2^-52,这是一个矛盾。因此,如果存在这样的分数,它必然是给定分母界的最佳有理近似值。

对于d 和e:为了覆盖包括次正规的二进制64 范围,我们希望e 的范围从-1126 到971 包括在内。如果d 太大,那么2^e / 10^d 会比2^-53 小很多,没有解决的希望; d &lt;= 16 + floor(e*log10(2)) 是一个实际的界限。如果d 太小(或太负),那么2^e / 10^d 将是一个整数并且没有解决方案;为了避免这种情况,我们需要d &gt; min(e, 0)。

介绍完所有内容后,让我们编写一些代码。 Python 解决方案非常简单,部分归功于 Fraction.limit_deminator 方法的存在,该方法完全可以在限制内找到最佳有理近似值。

from fractions import Fraction
from itertools import groupby
from math import floor, log10

def longest_run(s, c):
    """Length of the longest run of a given character c in the string s."""
    runs = [list(g) for v, g in groupby(s, lambda k: k == c) if v]
    return max(len(run) for run in runs) if runs else 0

def closest_fraction(d, e):
    """Closest rational to 2**e/10**d with denominator at most 2**53."""
    f = Fraction(2**max(e-d, 0) * 5**max(-d, 0), 2**max(0, d-e) * 5**max(0, d))
    approx = f.limit_denominator(2**53)
    return approx.numerator, approx.denominator

seen = set()
emin = -1126
emax = 971
for e in range(emin, emax+1):
    dmin = min(e, 0) + 1
    dmax = int(floor(e*log10(2))) + 16
    for d in range(dmin, dmax+1):
        num, den = closest_fraction(d, e)
        x = float.fromhex('0x{:x}p{}'.format(den, e))
        # Avoid duplicates.
        if x in seen:
            continue
        seen.add(x)
        digits = '{:.1000e}'.format(x).split('e')[0].replace('.','').strip('0')
        zero_run = longest_run(digits, '0')
        if zero_run >= 20:
            print "{} has {} zeros in its expansion".format(x.hex(), zero_run)
        nine_run = longest_run(digits, '9')
        if nine_run >= 20:
            print "{} has {} nines in its expansion".format(x.hex(), nine_run)

那里有很大的性能改进空间(不使用 Python 的 fractions 模块将是一个好的开始:-);就目前而言,运行完成需要几分钟。结果如下:

0x1.9527560bfbed8p-1000 has 20 zeros in its expansion
0x1.fa712b8efae8ep-997 has 20 zeros in its expansion
0x1.515476ae79b24p-931 has 20 nines in its expansion
0x1.a5a9945a181edp-928 has 20 nines in its expansion
0x1.86049d3311305p-909 has 20 zeros in its expansion
0x1.69c08f3dd8742p-883 has 20 zeros in its expansion
0x1.1b41d80091820p-861 has 20 zeros in its expansion
0x1.62124e00b5e28p-858 has 20 zeros in its expansion
0x1.ba96e180e35b2p-855 has 20 zeros in its expansion
0x1.31c5be6377c48p-786 has 20 zeros in its expansion
0x1.7e372dfc55b5ap-783 has 20 zeros in its expansion
0x1.7e89dc1c3860ap-555 has 20 nines in its expansion
0x1.7e89dc1c3860ap-554 has 20 nines in its expansion
0x1.7e89dc1c3860ap-553 has 20 nines in its expansion
0x1.7e89dc1c3860ap-552 has 20 nines in its expansion
0x1.30bd91ea994cbp-548 has 20 zeros in its expansion
0x1.4a5f9de9ee064p-468 has 20 nines in its expansion
0x1.9cf785646987dp-465 has 20 nines in its expansion
0x1.c23142c9da581p-408 has 20 nines in its expansion
0x1.c23142c9da581p-407 has 20 nines in its expansion
0x1.c23142c9da581p-406 has 20 nines in its expansion
0x1.c23142c9da581p-405 has 20 nines in its expansion
0x1.ba431f4e34be9p+738 has 20 nines in its expansion

【讨论】:

    【解决方案2】:

    显然,它至少为 15,如以下 Smalltalk/Squeak 代码所示:

    1.0 successor asTrueFraction printShowingMaxDecimalPlaces: 100.
    -> '1.0000000000000002220446049250313080847263336181640625'
    
    1.0 predecessor asTrueFraction printShowingMaxDecimalPlaces: 100.
    -> '0.99999999999999988897769753748434595763683319091796875'
    

    现在,要证明不能超过 15 个连续的零,就有点复杂了。你在哪里搜索一个浮点数f=(A*10^n+B)*10^p

    • n > 15
    • A 是整数
    • 0

    但浮点数也必须表示为整数有效数和有偏指数f=s*2^e where

    • s 是整数
    • 0

    因此我们有:s=(A*2^n*5^n+B)*2^(p-e)*5^p 和 s &lt; 2^53。

    我的第一个答案是假的,这是要完蛋了……

    总的来说,s 可以写成,s=2^a*5^b+c,c 不能被 2 或 5 整除。

    A*2^(n+p-e)*5^(n+p)+B*2^(p-e)*5^p = 2^a*5^b+c

    我们可以搜索 A=1, B=c*2^(e-p)/5^p

    B=c*2^(n-a)/5^(b-n)

    我尝试了所有对 a,b,使得 2^52 15...尝试使用 A > 1 将只会让事情变得更糟(它涉及减少 a 和 b)。

    因此我不认为有 16 个连续 0 的双精度数,但这不是一个漂亮的演示......

    【讨论】:

    • 我完全不明白你的论点。为什么是s = (A*10^n+B)*10^(p-e)? e 是二进制指数,将其转换为十进制指数似乎会让您处于需要争论 log_10(2) 的位置。
    • 您可能需要使用一些关于存在有限多个double exponents 的信息。对于任何k,我可能会找到在其十进制扩展中包含k 连续零的2 的幂。
    • 不,我想从有效数 s 的限制中提取不等式,甚至不调用指数 e 的限制
    【解决方案3】:

    我对此没有解决方案,但我可能会遵循以下方法:

    • 跟踪迄今为止发现的最长的零字符串。拨打长度L。感谢 aka.nice 的回答,它至少有 15 长。
    • 对于每个可能的指数和每个可能出现L+1 连续零的位置10^k,您会遇到一个混乱的小背包问题。
    • 计算两个模 10^{k+L}, 的相关 53 次幂并将它们四舍五入,使它们具有大约 L+1 有效数字。
    • 使用原生整数数学计算两个模 10^{k+L} 的前 26 次幂的所有组合。
    • 类似地找出两个模 10^{k+L} 的最后 26 次幂的所有组合。
    • 对两半进行排序,并使用线性扫描寻找能够提供非常接近隐含位负数的对。这样做你可能只会得到几场比赛。
    • 使用sprintf 或其他方式检查每个匹配项。

    看起来你必须运行这个循环几百万次,但它应该可以在几十小时内在几十台现代计算机上运行。

    我还要补充一点,有一个整数可以用浮点数精确表示,它有很多尾随零:87960930222080000000000000000000000 有 22 个尾随零,并且是十六进制的 10F0CF064DD5920000000000000000。 (事实上​​,10^22 完全可以表示为一个双精度数,并且它显然有 22 个尾随零。你不能做得更好,因为 5^23 需要除以这样的有效数字,这是不可能的。哦,好吧。)

    【讨论】:

    • 也许一种基于过滤可能有效数字的方法也可以使用一些奇特的数论。我还没有解决这个问题,但可能值得这样做。
    • 有趣。取 87960930222080000000000000000000000 并继续乘以 3。看起来你会得到更长的序列,例如 3407786659953310000000000000000000000000000000,尽管我无法验证它们是否准确。
    • @HotLicks:他们不是;你乘以 3。(扩展:乘以 3 使低位保持不变,将高位向左移动;这样做几次后,低位和高位相距太远。)
    • 问题是 ((5 raiseTo: 22)*(2 raiseTo: 22)) asFloat ulp -> 2.097152e6,所以你不能轻易添加尾随非零数字而不浪费 7 个零...
    • @aka.nice:是的。主要是为了表明合理性——尽管马克·迪金森的回答已经做到了这一点,而且做得更多。
    【解决方案4】:

    此代码将删除小数点后的 0。

     private void button1_Click(object sender, EventArgs e)
            {
                String Str = textBox1.Text;
                String lstVal = GetDecimalString(Str);
               textBox2.Text = lstVal;
            }
    
        private static string GetDecimalString(String Str)
        {
            String lstVal = "";
            if (Str.IndexOf(".") > -1)
            {
                String[] Last = Str.Split('.');
                if (Last.Length == 1)
                {
                    lstVal = Last[0];
                }
                else
                {
                    lstVal = Last[1];
                }
                String TrimedData = lstVal;
                for (int i = lstVal.Length - 1; i >= 0; i--)
                {
                    if (TrimedData.EndsWith("0") && TrimedData.Length > 3)
                    {
                        TrimedData = TrimedData.Substring(0, i - 1);
                    }
                }
                lstVal = TrimedData;
    
                if (lstVal.Length < 3)
                    lstVal = lstVal.PadRight(3, '0');
    
                lstVal = String.Join(".", Last[0], lstVal);
            }
            else
            {
                lstVal = Str;
            }
            return lstVal;
        }
    

    【讨论】:

    • 问题不在于如何从十进制表示中删除尾随零。问题是关于 IEEE 754 双精度数的精确表示中连续非前导非尾随零的最大数量。
    • ……答案已提供:20。在回答老问题之前,您应该始终阅读提供的答案:如果您错过了问题,他们可能会澄清问题的含义。
    【解决方案5】:

    务实的解决办法是:

    • 调用您现有的函数以返回仅包含您需要的小数位数的字符串;
    • 将结果转换回双精度值;
    • 如果此值大于原始值,则减少最后一位。

    【讨论】:

    • 这将是我链接到的问题 stackoverflow.com/questions/20264681/… 的答案,但它不起作用:从获得的十进制表示转换回 double 时再次发生舍入,并且此舍入可以方向相反,无法得出结论。
    • 请注意,实用的解决方案是,如果您只有一个只四舍五入的黑盒 double->decimal 转换函数,那就是实现您自己的 double->decimal 转换函数。如果一个人不关心性能,这是非常容易的,并且将其向下或向上取整是微不足道的。
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2017-12-16
    • 1970-01-01
    • 2010-10-04
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2023-03-27
    相关资源
    最近更新 更多