java - 什么会导致 float 在没有算术变化的情况下突然偏离 1 位

Question

在进行较大的重构更改时，未修改任何类型的算法，我设法以某种方式更改了我的程序(基于代理的模拟系统)的输出。输出中的各种数字现在相差极小。检查表明，这些数字的最低有效位相差 1 位。

例如，24.198110084326416 将变为 24.19811008432642。每个数字的浮点表示为:

24.198110084326416 = 0 10000000011 1000001100101011011101010111101011010011000010010100
24.19811008432642  = 0 10000000011 1000001100101011011101010111101011010011000010010101

我们注意到最低有效位不同。

我的问题是，当我没有修改任何类型的算术时，我怎么会引入这种变化？更改涉及通过删除继承来简化对象(它的父类(super class)因不适用于此类的方法而变得臃肿)。

我注意到输出(在模拟的每个刻度显示某些变量的值)有时会关闭，然后对于另一个刻度，数字符合预期，只是在下一个刻度再次关闭(例如，在一个智能体上，它的值在第 57 - 83 个节拍上表现出这个问题，但在第 84 个和第 85 个节拍上符合预期，只是在第 86 个节拍上再次关闭)。

我知道我们不应该直接比较 float 。当仅将输出文件与预期输出进行比较的集成测试失败时，就会注意到这些错误。我可以(也许应该)修复测试以解析文件并将解析的 double 值与一些 epsilon 进行比较，但我仍然很好奇为什么会引入此问题。

编辑:

引入问题的最小变化差异:

diff --git a/src/main/java/modelClasses/GridSquare.java b/src/main/java/modelClasses/GridSquare.java
index 4c10760..80276bd 100644
--- a/src/main/java/modelClasses/GridSquare.java
+++ b/src/main/java/modelClasses/GridSquare.java
@@ -63,7 +63,7 @@ public class GridSquare extends VariableLevel
    public void addHousehold(Household hh)
    {
        assert household == null;
-       subAgents.add(hh);
+       neighborhood.getHouseholdList().add(hh);
        household = hh;
    }

@@ -73,7 +73,7 @@ public class GridSquare extends VariableLevel
    public void removeHousehold()
    {
        assert household != null;
-       subAgents.remove(household);
+       neighborhood.getHouseholdList().remove(household);
        household = null;
    }

diff --git a/src/main/java/modelClasses/Neighborhood.java b/src/main/java/modelClasses/Neighborhood.java
index 834a321..8470035 100644
--- a/src/main/java/modelClasses/Neighborhood.java
+++ b/src/main/java/modelClasses/Neighborhood.java
@@ -166,9 +166,14 @@ public class Neighborhood extends VariableLevel
    World world;

    /**
+    * List of all grid squares within the neighborhood.
+    */
+   ArrayList<VariableLevel> gridSquareList = new ArrayList<>();
+
+   /**
     * A list of empty grid squares within the neighborhood
     */
-   ArrayList<GridSquare> emptyGridSquareList;
+   ArrayList<GridSquare> emptyGridSquareList = new ArrayList<>();

    /**
     * The neighborhood's grid square bounds
@@ -836,7 +841,7 @@ public class Neighborhood extends VariableLevel
     */
    public GridSquare getGridSquare(int i)
    {
-       return (GridSquare) (subAgents.get(i));
+       return (GridSquare) gridSquareList.get(i);
    }

    /**
@@ -865,7 +870,7 @@ public class Neighborhood extends VariableLevel
    @Override
    public ArrayList<VariableLevel> getGridSquareList()
    {
-       return subAgents;
+       return gridSquareList;
    }

    /**
@@ -874,12 +879,7 @@ public class Neighborhood extends VariableLevel
    @Override
    public ArrayList<VariableLevel> getHouseholdList()
    {
-       ArrayList<VariableLevel> list = new ArrayList<VariableLevel>();
-       for (int i = 0; i < subAgents.size(); i++)
-       {
-           list.addAll(subAgents.get(i).getHouseholdList());
-       }
-       return list;
+       return subAgents;
    }

不幸的是，我无法创建一个小的、可编译的示例，因为我无法在程序外部复制此行为，也无法将这个非常大且复杂的程序缩小到一定大小。

至于在做什么样的浮点运算，没有什么特别刺激的。大量的加法、乘法、自然对数和幂(几乎总是以 e 为底)。后两者是用标准库完成的。整个程序都使用随机数，并用 Random class 生成。包含在正在使用的框架中 (Repast)。

大多数数字都在 1e-3 到 1e5 的范围内。几乎没有非常大或非常小的数字。 Infinity 和 NaN 被用在很多地方。

作为基于代理的模拟系统，许多公式被重复应用于模拟出现。评估的顺序非常重要(因为许多变量取决于首先评估的其他变量——例如，要计算 BMI，我们需要首先计算饮食和心脏状况)。变量的先前值在许多计算中也非常重要(因此这个问题可以在程序的早期某处引入，并贯穿整个程序的其余部分)。

Answer 1

以下是浮点表达式求值可能不同的几种方式:

(1) 浮点处理器具有“当前舍入模式”，这可能导致结果在最低有效位上有所不同。您可以进行调用，获取或设置当前值:向零舍入、向 -∞ 或向 +∞ 舍入。

(2) 听起来strictfp 与C 中的FLT_EVAL_METHOD 相关，它指定了中间计算中使用的精度。有时新版本的编译器会使用与旧版本不同的方法(我被那个版本咬了)。 {0,1,2} 分别对应于 {single,double,extended} 精度，除非被更高精度的操作数覆盖。

(3) 就像不同的编译器可以有不同的默认浮点计算方法一样，不同的机器可以使用不同的浮点计算方法。

(4) 单精度 IEEE 浮点运算是定义明确、可重复且与机器无关的。 double 也是如此。我已经(非常小心地)编写了跨平台浮点测试，它使用 SHA-1 哈希来检查计算的位准确性!但是，FLT_EVAL_METHOD=2时，中间计算使用扩展精度，使用64位、80位或128位浮点运算实现，因此很难获得跨平台和跨编译器的可重复性如果在中间计算中使用扩展精度。

(5) 浮点运算是非关联的，即

(A + B) + C ≠ A + (B + C)

因此不允许编译器对 float 的计算重新排序。

(6) 操作顺序很重要。以最大可能的精度计算大量数字之和的算法是按递增的数量级对它们求和。另一方面，如果两个数字的大小差异足够大

B < (A * epsilon)

然后将它们相加是一个空操作:

A + B = A