@GuuJiang #3
我大概懂了，现在做一点总结。
假设全都是二元运算符（包括一元运算符的情况类似）。
定义辅助符号<==>，读作“在该算法意义下等价”。如 s1 <==> s2 表示对于表达式 s1 和 s2 应用上述算法得到的结果相等。
第一步：证 X exp Y <==> X eval(exp) Y ，exp 表示形如 (v1 op v2) 的由 v1 、op 、v2 组成的子表达式（ v1 、v2 、op 分别表示两个字面值和一个操作符），X 、Y 分别表示算数表达式除 exp 后的前面部分和后面部分，且 X 中不包含右括号，eval(exp) 表示算法对子表达式 exp 求值后的结果。
在算法遇到 exp 中的右括号时，算法将 exp 中的 v1 、v2 弹出进行计算得到 eval(exp) 并将其入栈，因为 X 中不包含右括号，所以，算法解析 X eval(exp) Y 至 eval(exp) 入栈时，其结果与算法解析 X exp Y 至将 exp 求值后完全相同，所以 X exp Y <==> X eval(exp) Y 。
第二步：记 p(n) 为含有 n 对括号的合法表达式、p(n-1) 为算法对 p(n) 求值时遇到第一个右括号后出栈求解再入栈得到的新表达式（注意到此时括号会减少一对），由第一步的证明有 p(n) <==> p(n-1) <==> p(n-2) ... <==> p(1) <==> p(0)，不难知道算法能够正确处理不包括括号（只包含一个字面值）的 p(0)，所以算法能够正确处理 p(n)。
再次感谢。

@GuuJiang #1 感谢回复。为了防止误解，我觉得我还是先问清楚几个问题比较好。

1. 这里的“规约规则”是不是指“归纳奠基”？
2. X...<exp>...Y <==> X...eval(exp)...Y 是什么意思？
3. eval(p(n)) 是指？

@ynyounuo #1 感谢回复。的确应该是这样。所以 DoublingStackOfStrings 中的 Doubling 是“倍增”的意思，对应于 ResizingArrayStack 类中的 resize(2*a.length)。DoublingStackOfStrings 指的就是前文中的 ResizingArrayStack 。

@OysterQAQ #8 嗯，的确不处理问题也不大。

@Buges #2
感谢回复。我会试试看，虽然似乎并不那么好找，因为我看见有些库里面也并没有处理这里的情况。

@OysterQAQ #4
我没把注释说清楚，这里的意思实际上是指，比如传入一个在 float 中为 NaN 的整数 0b01111111100000000000000000000001 ，虽然返回的浮点值为 NaN ，但它并不能**保证**这个 NaN 的位模式为 01111111100000000000000000000001 （除非自己亲自验证一下）。

@OysterQAQ #1
感谢回复。意思是判断指数位是否为全 1 ，全为 1 则给出提示？这似乎并没有真正在用二进制“初始化”浮点数。

@Higurashi #3
另外，可以使用 Float.floatToRawIntBits(float) 将单精度浮点数转换为对应的整数位模式，与 Float.intBitsToFloat(float) 不同，它将会保留 NaN 的原信息。

@agagega #4
感谢回复。https://stackoverflow.com/questions/25050133/are-the-bit-patterns-of-nans-really-hardware-dependent 中有与此相关的更多信息。

@icyalala #5
谢谢！👍

@imKiva #1
@icyalala #2
感谢回复。不知道是否有方法能够打印一个值为 NaN 的变量的二进制形式？

@shintendo #13
暂时只是十进制转二进制过程中的精度问题。

@shintendo #12
嗯，“不只是写在源代码里的，也包括计算产生的数”是不是指这样一种情况：
int a = 16777215;
int b = a * 10 + 1;
System.out.println((float)a);
System.out.println((float)b);
-----
1.6777215E7
1.67772144E8
在这里 167772151 为“计算产生的数”，其超过了单精度的精确范围，所以转换为单精度时不能够被准确表示。

@shintendo #9
意思是 23 bit 所保存着的小数转化（数学上的转化，不进行舍入）为十进制数后最多包含 8 位有效数字，且并不是所有拥有 8 位有效位的十进制小数都能够被准确保存？

@shintendo #6
抱歉我没有仔细理解。我想我懂得了你的意思，现在总结一下。
通常所说的精确到多少位（比如 7 ），指的是当我们在源代码中添加一个浮点数字面量时，浮点数超过第 7 位的有效位可能不能够准确表示。

@shintendo #6
的确，不同的场景有不同的所谓“精度”。我在 https://www.exploringbinary.com/decimal-precision-of-binary-floating-point-numbers/ 中看到了一种定义：
“For most of our purposes when we say that a format has n-digit precision we mean that over some range, typically [10^k, 10^(k+1)), where k is an integer, all n-digit numbers can be uniquely identified.”
我觉得暂时只讨论清楚这样一种“精度”比较好，所以现在我的疑惑是，[10^k, 10^(k+1)) 范围内的数字，它能够精确到多少位？是如何得到的？比如，我在源代码中写下一个浮点数，我如何知道从第几位开始程序就不再能够准确地将其表示？
链接指向的文章对此进行了解释，但说实话，我还看不太懂。

@shintendo #2 @oldshensheep #4 感谢回复。我稍微懂得了一些。24 位二进制最大为 (1111 1111 1111 1111 1111 1111)2 = (2^24-1)10 ，观察到 100(10^2)<=y<1000(10^3)，此时 y 有 [log10y] + 1 = 3 个有效位，类似可以知道 2^24-1 有 [log10(2^24-1)] + 1 个有效位。
但是小于 2^24-1 的 24 位二进制数转换为 10 进制也还是 [log10(2^24-1)] + 1 个有效位吗？比如 (0000 0000 0000 0000 0000 001)2 在十进制中有多少个有效位？

@GTim #1 感谢回复。是的，的确是这样，但我不明白的是，为什么计算得到的 n 就是十进制下的精确位数？[10506083.html#a4]( https://www.cnblogs.com/HDK2016/p/10506083.html#a4) 中也作了类似说明：

```
在单精度浮点数中的二进制小数位有 23 个，所能表示 2^23 个数，那么只需要换算成在 10 进制下能够表示相同个数的位数，就可以得到精度了。
10^n = 223
10^n = 8388608
10^6 < 8388608 < 107
所以但精度浮点数的精度为 6 位，同理也可以得到双精度浮点数的精度为 15 位。
```

我疑惑的其实是这背后的理由是什么。

《堂吉诃德》