在对多个FP操作数进行算术运算时，是否可以忽略中间结果的舍入？

Question

是否有可能对多个浮点操作数进行算术操作，而不舍入中间结果，只对最终结果进行舍入，目前是否有任何体系结构这样做？因为据我所见，在一个加/减操作中使用了两个浮点操作数之后，结果在被用作另一个操作的操作数之前会被舍入，我还看到了这。

编辑：

下面是一些例子，考虑单精度格式来阐明这一概念，参与算术操作的中间27位人中最不重要的3位是保护位、圆位和粘性位；从示例中可以看出，使用IEEE754兼容的FP系统中使用的中间尾数位结构，可以避免中间值的舍入，这样可以获得更准确的结果：

1_Example 1

A-B = 101001000010001110110100 1 0 1×2^EXP

C   = 100011001011001010010100×2^(EXP-4) --> 
C   = 000010001100101100101001 0 1 0×2^EXP

1_1_If after是在A-B四舍五入后计算的：

Rounded A-B   = 101001000010001110110101×2^EXP
        A-B-C = 100110110101100010001011 1 1 0×2^EXP
Rounded A-B-C = 100110110101100010001100×2^EXP

1_2_If A是在不舍入的情况下计算的：

        A-B-C = 100110110101100010001011 0 1 1×2^EXP
Rounded A-B-C = 100110110101100010001011×2^EXP

2_Example 2

A-B = 100001001100101011100000 1 0 1×2^EXP
C   = 101001011010001110001000×2^(EXP-5) --> 
C   = 000001010010110100011100 0 1 0×2^EXP

2_1_If after是在A-B四舍五入后计算的：

Rounded A-B   = 100001001100101011100001×2^EXP
A-B-C         = 011111111001110111000100 1 1 0×2^EXP
A-B-C shifted 1 bit to left 
              = 111111110011101110001001 1 0 0×2^(EXP-1)
Rounded A-B-C = 11111111001110111000101×2^(EXP-1)

2_2_If A是在不舍入的情况下计算的：

A-B-C         = 011111111001110111000100 0 1 1×2^EXP
A-B-C shifted 1 bit to left 
              = 111111110011101110001000 1 1 0×2^(EXP-1)
Rounded A-B-C = 111111110011101110001001×2^(EXP-1)

3_Example 3

A-B = 10000001101000110101001 1 1 1×2^EXP

C   = 100010100101011010010000×2^(EXP-6) -->
C   = 000000100010100101011010 0 1 0×2^EXP

3_1_If after是在A-B四舍五入后计算的：

Rounded A-B = 10000001101000110101010×2^EXP
   A-B-C    = 01111101010100001001111 1 1 0×2^EXP
A-B-C shifted 1 bit to left 
            = 11111010101000010011111 1 0 0×2^(EXP-1)
Rounded A-B-C=11111010101000010100000×2^(EXP-1)

3_2_If A是在不舍入的情况下计算的：

A-B-C       = 01111101010100001001111 1 0 1×2^EXP
A-B-C shifted 1 bit to left
            = 11111010101000010011111 0 1 0×2^(EXP-1)
Rounded A-B-C=11111010101000010011111×2^(EXP-1)

4_Example 4

A-B = 101100101000111000110101 0 1 1×2^EXP

C = 100110010110011101100000×2^(EXP-7) --> 
C = 000000010011001011001110 1 1 0×2^EXP

4_1_If after是在A-B四舍五入后计算的：

Rounded A-B = 101100101000111000110110×2^EXP
A-B-C       = 101100010101101101100111 0 1 0×2^EXP
Rounded A-B-C=101100010101101101100111×2^EXP

4_2_If A是在不舍入的情况下计算的：

A-B-C         = 101100010101101101100111 1 0 1×2^EXP
Rounded A-B-C = 101100010101101101101000×2^EXP

5_Example 5

A-B = 100000111011001111001010 0 1 1×2^EXP

C = 110001011010010110010110×2^(EXP-3) --> 
C = 000110001011010010110010 1 1 0×2^EXP

5_1_If after是在A-B四舍五入后计算的：

Rounded A-B = 100000111011001111001010×2^EXP
A-B-C       = 011010101111111100010111 0 1 0×2^EXP
A-B-C shifted 1 bit to left
            = 110101011111111000101110 1 0 0×2^(EXP-1)
Rounded A-B-C=110101011111111000101110×2^(EXP-1)

5_2_If A是在不舍入的情况下计算的：

A-B-C       = 011010101111111100010111 1 0 1×2^EXP
A-B-C shifted 1 bit to left 
            = 110101011111111000101111 0 1 0×2^(EXP-1)
Rounded A-B-C=110101011111111000101111×2^(EXP-1)

6_Example 6

A-B = 100000000011000111001010 0 0 1×2^EXP
C = 110010001100110111000000×2^(EXP-8) -->
C = 000000001100100011001101 1 1 0×2^EXP

6_1_If after是在A-B四舍五入后计算的：

Rounded A-B = 100000000011000111001010×2^EXP
A-B-C       = 011111110110100011111100 0 1 0×2^EXP
A-B-C shifted 1 bit to left
            = 111111101101000111111000 1 0 0×2^(EXP-1)
Rounded A-B-C=111111101101000111111000×2^(EXP-1)

6_2_If A是在不舍入的情况下计算的：

A-B-C       = 011111110110100011111100 0 1 1×2^EXP
A-B-C shifted 1 bit to left
            = 111111101101000111111000 1 1 0×2^(EXP-1)
Rounded A-B-C=111111101101000111111001×2^(EXP-1)

Answer 1

根据问题中引用的论文，可以计算一对长度N向量的点乘积，最后只进行一次四舍五入运算，得到与点积最接近的表示结果。

在实践中，目前的计算机围绕中间结果，这往往导致的答案是最接近的代表性。充其量，舍入是一种扩展格式，这将倾向于减少而不是消除中间结果舍入错误。

对于一个融合的乘法-加法，四舍五入是N次，每乘加一次。如果没有融合的乘法-加法对每对做两次，一次在乘法之后，一次在加法之后。

论文的BibTex信息是：

@INPROCEEDINGS{ yao:correctly,
AUTHOR = "Tao Yao and Deyuan Gao and Xiaoya Fan and Jari Nurmi",
TITLE = "Correctly rounded architectures for Floating-Point multi-operand addition and dot-product computation",
BOOKTITLE = "ASAP'13",
PAGES = {346-355},
YEAR = {2013}, 
}

Answer 2

一些体系结构将使用80位“扩展精度”浮点类型来评估表达式的中间结果，即使这些结果随后将被存储到64位或32位类型中。不幸的是，今天的编程语言除了允许选择“允许”还是“禁止”之外，通常无法控制这种行为，它们无法在有帮助的地方请求这种行为。一般来说，对于语言来说，除了80位的扩展精度类型之外，尝试执行浮点运算的代价太高了。

Answer 3

另一种方法是利用区间算法对计算机算法引入的可能误差进行控制和约束。计算之后，您将得到一个保证包含“真正结果”的间隔。有一些实现可用于此。在用于区间算法的维基百科页面上，有一个关于实现的部分，其中列出了一些库。在20世纪80年代末，我在卡尔斯鲁厄大学担任编程导师时提到了Pacal-SC：)