标签: ieee-754

我正在尝试将基于 IEEE 的浮点数转换为 MIL-STD 1750A 浮点数。

我已附上两者的规格：

我了解如何按照维基百科上的示例分解 IEEE 格式的浮点 12.375 。

但是，我不确定我对 MIL-STD 的解释是否正确。

12.375 = (12)b10 + (0.375)b10 = (1100)b2 + (0.011)b2 = (1100.011)b2 (1100.011)b2 = 0.1100011 x 2^4 => 指数，E = 4。

4 标准化 2 的补码 = (100)b2 = 指数

因此，MIL-STD 1750A 32 位浮点数为：

S=0, F=11000110000000000000000, E=00000100

我的上述解释正确吗？

对于-12.375，只是交换符号位吗？IE：

S=1, F=11000110000000000000000, E=00000100

或者小数部分会发生什么奇怪的事情吗？

我正在尝试从以下来源了解 IEEE 舍入的功能On fast IEEE Rounding

谁能解释一下舍入的方程式吗？round up with fix up 是什么意思？什么是地板和天花板功能？我尝试了 IEEE 754 ，但它没有提到这些

我可以假设(int)(float)n == n任何int n？至少我需要这个非负31位值.

附录.怎么样(int)(double)n ==n？

假设处理器只有符合 IEEE-754 的“fadd”和“fmul”操作（没有“dot”或“fma”指令）。通过点积运算的简单实现将达到的最坏情况精度是多少。例如，对于长度为 3 的向量：

dot(vec_a, vec_b) = vec_a.x*vec_b.x + vec_a.y*vec_b.y + vec_a.z*vec_b.z

这是我的分析，但我不确定它是否正确：对于长度为 N 的向量，有 N 次乘法和 N-1 次加法，导致 2N-1 次浮点运算。在最坏的情况下，对于这些操作中的每一个，表示对于准确结果来说都太小了，因此中间结果将被四舍五入。每次舍入增加 0.5 ULP 误差。那么最大误差将是 (2N-1)*0.5 = N-1/2 ULP？

我正在尝试了解 After Effect CS6 和 CC 的 aepx 文件的数字格式

坐标以 cdat 十六进制数据编码。坐标是两个数字。我制作了一个带有编码的十六进制值的数字列表，以帮助理解格式：

-100;-100   -> <cdat bdata="bfaaaaaaaaaaaaabbfb7b425ed097b420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

100;100     -> <cdat bdata="3faaaaaaaaaaaaab3fb7b425ed097b420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

100;200     -> <cdat bdata="3faaaaaaaaaaaaab3fc7b425ed097b420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

200;100     -> <cdat bdata="3fbaaaaaaaaaaaab3fb7b425ed097b420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

200;200     -> <cdat bdata="3fbaaaaaaaaaaaab3fc7b425ed097b420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

300;300     -> <cdat bdata="3fc40000000000003fd1c71c71c71c720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

800;200     -> <cdat bdata="3fdaaaaaaaaaaaab3fc7b425ed097b420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

800;400     -> <cdat bdata="3fdaaaaaaaaaaaab3fd7b425ed097b420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

800,5;400   -> <cdat bdata="3fdaaeeeeeeeeeef3fd7b425ed097b420000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

800,5;400,5 -> <cdat bdata="3fdaaeeeeeeeeeef3fd7bbbbbbbbbbbc0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

0;400,5     -> <cdat bdata="00000000000000003fd7bbbbbbbbbbbc0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

800,5;0     -> <cdat bdata="3fdaaeeeeeeeeeef00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

400,5;800,5 -> <cdat bdata="3fcab333333333333fe7b7f0d4629b7f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"/>

有人知道这种数字格式吗？

如果我使用像http://www.h-schmidt.net/FloatConverter/IEEE754.html这样的网站将十六进制字符串'424E4B31'转换为 float32，我得到 51.57343。

我需要使用 Python 来转换字符串，但是，使用 StackExchange 上的解决方案，例如：

import struct, binascii
hexbytes = b"\x42\x4E\x4B\x31"
struct.unpack('<f',hexbytes)

或者

struct.unpack('f', binascii.unhexlify('424E4B31'))

我得到 2.9584e-09... 为什么不同？

我从蓝牙控制器中获得了蓝牙特性，并将颤动蓝色作为列表。此特性包含蓝牙秤的重量测量。是否有将这个整数列表转换为双精度的函数？

我试图通过阅读 IEEE 754 标准来寻找有关浮点表示的一些背景知识。有 dart 库 typed_data 但我是 dart 的新手并且没有使用这个库的经验。

例子：

我有这个 List: [191, 100, 29, 173] 它来自蓝牙控制器，作为浮点值的 IEEE754 表示。现在我相信我必须将每个 int 转换为十六进制并连接这些值：bf 64 1d ad

接下来需要做的是将其转换为双精度，但我找不到将十六进制转换为双精度的函数。只有int.parse("0xbf641dad")。

IEEE 754 规范在 §5.10 中定义了一个总顺序，我想在汇编中实现它。

从维基百科的描述来看，这听起来很像可以实现无分支，或者几乎无分支，但我一直没能想出一个像样的方法；我在主要编程语言中找不到任何现有的符合规范的实现

比较两个浮点数时，它充当 ? 操作，除了 totalOrder(?0, +0) ? ¬ totalOrder(+0, ?0) 和同一个浮点数的不同表示按它们的指数乘以符号位排序。然后通过排序 ?qNaN < ?sNaN < numbers < +sNaN < +qNaN 将排序扩展到 NaN，同一类中的两个 NaN 之间的排序基于整数有效负载乘以这些数据的符号位。

首先检查 NaN 然后跳转到浮点比较或处理 NaN 情况是否有意义，或者将浮点值移动到整数寄存器并在那里执行所有操作是否更有意义？

（至少从阅读描述来看，感觉规范作者努力允许使用整数指令进行直接实现。）

在 x86-64 处理器上实现浮点总顺序的“最佳”方法是什么？

根据几个浮点计算器以及我下面的代码，以下 32 位00111111010000000100000110001001的实际浮点值为 (0.750999987125396728515625)。由于它是实际的 Float 值，我应该认为将它存储在 Double 或 Float 中将保留精度和精确值，只要 (1) 不执行算术 (2) 使用实际值和 (3) 值是没有被贬低。那么为什么实际值与 (0.7509999871253967) 的强制转换（示例 1）和文字（示例 2）值不同？

我以这个计算器为例：https : //www.h-schmidt.net/FloatConverter/IEEE754.html

import java.math.BigInteger;
import java.math.BigDecimal;

public class MyClass {
    public static void main(String args[]) {
      int myInteger = new BigInteger("00111111010000000100000110001001", 2).intValue();
      Double myDouble = (double) Float.intBitsToFloat(myInteger);
      String myBidDecimal = new BigDecimal(myDouble).toPlainString();

      System.out.println("      bits converted to integer: 00111111010000000100000110001001 = " + myInteger);
      System.out.println("    integer converted to double: " + myDouble);
      System.out.println(" double converted to BigDecimal: " …

标准（IEEE 754 / C）是否保证以下代码断言永远不会失败？

int main()
{
    for ( /* all possible float / double values */ )
    {
        v_neg1 = v * -1;
        v_neg2 = -v;
        assert( v_neg1 == v_neg2 );
    }
    return 0;
}

更新。

1. 当问我的意思是all possible float / double values 排除 NaNs。
2. 请参阅类似问题：.NET decimal.Negate 与乘以 -1