我在 .NET Source Code 中找到了这个:它声称比 System.Double.IsNaN 快 100 倍。是否有理由不使用此函数而不是 System.Double.IsNaN？

[StructLayout(LayoutKind.Explicit)]
private struct NanUnion
{
    [FieldOffset(0)] internal double DoubleValue;
    [FieldOffset(0)] internal UInt64 UintValue;
}

// The standard CLR double.IsNaN() function is approximately 100 times slower than our own wrapper,
// so please make sure to use DoubleUtil.IsNaN() in performance sensitive code.
// PS item that tracks the CLR improvement is DevDiv Schedule : 26916.
// IEEE 754 : If the argument is any value in the range 0x7ff0000000000001L through 0x7fffffffffffffffL 
// or in the range 0xfff0000000000001L through 0xffffffffffffffffL, the result will be NaN.         
public static bool IsNaN(double value)
{
    NanUnion t = new NanUnion();
    t.DoubleValue = value;

    UInt64 exp = t.UintValue & 0xfff0000000000000;
    UInt64 man = t.UintValue & 0x000fffffffffffff;

    return (exp == 0x7ff0000000000000 || exp == 0xfff0000000000000) && (man != 0);
}

编辑:仍然according to the .NET Source Code ，System.Double.IsNaN 的代码如下:

public unsafe static bool IsNaN(double d)
{
    return (*(UInt64*)(&d) & 0x7FFFFFFFFFFFFFFFL) > 0x7FF0000000000000L;
}

最佳答案

It claims to be 100 times faster than System.Double.IsNaN

是的，曾经是真的。您错过了知道何时做出此决定的时间机器。 Double.IsNaN() 以前不像那样。来自 SSCLI10 源代码:

   public static bool IsNaN(double d)
   {
       // Comparisions of a NaN with another number is always false and hence both conditions will be false.
       if (d < 0d || d >= 0d) {
          return false;
       }
       return true;
   }

如果 d 为 NaN，则在 32 位代码的 FPU 上执行非常很差。只是芯片设计的一个方面，它在微代码中被视为异常(exception)。英特尔处理器手册对此只字未提，只是记录了一个跟踪“浮点辅助”数量的处理器性能计数器，并指出微代码定序器对非规范化和 NaN 起作用，“可能会花费 数百个周期”。这在 64 位代码中不是问题，它使用没有此性能命中的 SSE2 指令。

一些代码供您自己查看:

using System;
using System.Diagnostics;

class Program {
    static void Main(string[] args) {
        double d = double.NaN;
        for (int test = 0; test < 10; ++test) {
            var sw1 = Stopwatch.StartNew();
            bool result1 = false;
            for (int ix = 0; ix < 1000 * 1000; ++ix) {
                result1 |= double.IsNaN(d);
            }
            sw1.Stop();
            var sw2 = Stopwatch.StartNew();
            bool result2 = false;
            for (int ix = 0; ix < 1000 * 1000; ++ix) {
                result2 |= IsNaN(d);
            }
            sw2.Stop();
            Console.WriteLine("{0} - {1} x {2}%", sw1.Elapsed, sw2.Elapsed, 100 * sw2.ElapsedTicks / sw1.ElapsedTicks, result1, result2);

        }
        Console.ReadLine();
    }
    public static bool IsNaN(double d) {
        // Comparisions of a NaN with another number is always false and hence both conditions will be false.
        if (d < 0d || d >= 0d) {
            return false;
        }
        return true;
    }
}

它使用经过微优化的 Double.IsNaN() 版本。顺便说一句，这种微优化在框架中并不是坏事，Microsoft .NET 程序员的巨大负担是他们很少能猜到他们的代码何时位于应用程序的关键路径中。

针对 32 位代码(Haswell 移动核心)在我的机器上的结果:

00:00:00.0027095 - 00:00:00.2427242 x 8957%
00:00:00.0025248 - 00:00:00.2191291 x 8678%
00:00:00.0024344 - 00:00:00.2209950 x 9077%
00:00:00.0024144 - 00:00:00.2321169 x 9613%
00:00:00.0024126 - 00:00:00.2173313 x 9008%
00:00:00.0025488 - 00:00:00.2237517 x 8778%
00:00:00.0026940 - 00:00:00.2231146 x 8281%
00:00:00.0025052 - 00:00:00.2145660 x 8564%
00:00:00.0025533 - 00:00:00.2200943 x 8619%
00:00:00.0024406 - 00:00:00.2135839 x 8751%

关于c# - Double.IsNaN 测试快 100 倍吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24331540/