我一直在疯狂地尝试读取使用 Java 程序编写的二进制文件(我正在将 Java 库移植到 C# 并希望保持与 Java 版本的兼容性)。

Java 库

组件的作者选择使用 float 和乘法来确定一段数据的开始/结束偏移量。不幸的是，它在 .NET 中的工作方式与在 Java 中的工作方式有所不同。在 Java 中，该库使用 Float.intBitsToFloat(someInt)，其中 someInt 的值为 1080001175。

int someInt = 1080001175;
float result = Float.intBitsToFloat(someInt);
// result (as viewed in Eclipse): 3.4923456

稍后，这个数字乘以一个值来确定开始和结束位置。在这种情况下，当索引值为 2025 时就会出现问题。

int idx = 2025;
long result2 = (long)(idx * result);
// result2: 7072

根据我的计算器，这个计算的结果应该是 7071.99984 。但在 Java 中，它完全是 7072 在它被转换为 long 之前，在这种情况下它仍然是 7072 。为了使因子完全 7072 ， float 的值必须是 3.492345679012346 。

假设 float 的值实际上是 3.492345679012346 而不是 3.4923456(Eclipse 中显示的值)是否安全？

.NET 等效

现在，我正在寻找一种在 .NET 中获得完全相同结果的方法。但到目前为止，我只能使用 hack 读取这个文件，而且我不完全确定该 hack 是否适用于 Java 库生成的任何文件。

根据 intBitsToFloat method in Java VS C#? ，等效功能正在使用:

int someInt = 1080001175;
int result = BitConverter.ToSingle(BitConverter.GetBytes(someInt), 0);
// result: 3.49234557

这样计算:

int idx = 2025;
long result2 = (long)(idx * result);
// result2: 7071

转换为 long 之前的结果是 7071.99977925 ，这低于 Java 产生的 7072 值。

我尝试了什么

从那里开始，我假设 Float.intBitsToFloat(someInt) 和 BitConverter.ToSingle(BitConverter.GetBytes(value), 0) 之间的数学运算一定存在差异，才会收到如此不同的结果。因此，我查阅了 javadocs for intBitsToFloat(int) 以查看是否可以在 .NET 中重现 Java 结果。我最终得到了:

public static float Int32BitsToSingle(int value)
{
    if (value == 0x7f800000)
    {
        return float.PositiveInfinity;
    }
    else if ((uint)value == 0xff800000)
    {
        return float.NegativeInfinity;
    }
    else if ((value >= 0x7f800001 && value <= 0x7fffffff) || ((uint)value >= 0xff800001 && (uint)value <= 0xffffffff))
    {
        return float.NaN;
    }

    int bits = value;
    int s = ((bits >> 31) == 0) ? 1 : -1;
    int e = ((bits >> 23) & 0xff);
    int m = (e == 0) ? (bits & 0x7fffff) >> 1 : (bits & 0x7fffff) | 0x800000;
    
    //double r = (s * m * Math.Pow(2, e - 150));
    // value of r: 3.4923455715179443
    
    float result = (float)(s * m * Math.Pow(2, e - 150));
    // value of result: 3.49234557
    
    return result;
}

如您所见，结果完全与使用 BitConverter 时相同，并且在转换为 float 之前，该数字 ( 3.4923455715179443 ) 比 ( 3.492345679012346 ) 的假定 Java 值低很多) 所需的结果恰好是 7072 。

我尝试了 this solution ，但结果值完全相同， 3.49234557 。

我也试过四舍五入和截断，但当然这会使所有其他不是很接近整数的值都是错误的。

当浮点值在整数的特定范围内时，我能够通过更改计算来解决这个问题，但由于可能存在计算非常接近整数的其他地方，这个解决方案可能会获胜'普遍适用。

float avg = (idx * averages[block]);
avgValue = (long)avg; // yields 7071
if ((avgValue + 1) - avg < 0.0001)
{
    avgValue = Convert.ToInt64(avg); // yields 7072
}

请注意，Convert.ToInt64 函数在大多数情况下也不起作用，但在这种特殊情况下它具有舍入效果。

问题

如何在 .NET 中创建一个返回与 Java 中的 Float.intBitsToFloat(int) 完全相同结果的函数？或者，在给定值 7072 和 7071 的情况下，我怎样才能规范化浮点计算的差异，以便此结果是 1080001175(不是 2025)？

Note: It should work the same as Java for all other possible integer values as well. The above case is just one of potentially many places where the calculation is different in .NET.

I am using .NET Framework 4.5.1 and .NET Standard 1.5 and it should produce the same results in both x86 and x64 environments.

最佳答案

C# 和 Java(以及任何其他合适的编程平台)中 4 字节 float 的定义基于 IEEE standards , 所以二进制格式是一样的。

所以，它应该可以工作。事实上它确实有效，但仅适用于 X64 目标(我之前关于 .NET 2 和 4 的评论可能是错误的或正确的，我无法真正测试旧的平台二进制文件)。

如果你想让它适用于所有目标，你必须像这样定义它:

long result2 = (long)(float)(idx * result);

如果您查看生成的 IL，它会添加一个补充 conv.r4乘法后的操作码。我想这会强制在编译的 x86 代码中实现 float 。我想这是一个 jit 优化问题。

我对 jit 优化了解不够，无法确定它是否是错误。有趣的是，Visual Studio 2017 IDE 甚至将转换为“冗余”或“不必要”的 (float) 文本和报告变灰，因此闻起来不太好。

关于c# - 如何在 C# 中模仿 Number.intBitsToFloat()？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43993601/