C# 中的双精度数、整数、Math.Round

Question

我必须将双精度值 x 转换为以下指定的两个整数...

“x 字段由两个带符号的 32 位整数组成：x_i 表示整数部分，x_f 表示小数部分乘以 10^8。例如: x of 80.99 的 x_i 为 80，x_f 为 99,000,000"

首先我尝试了以下方法，但有时似乎会失败，给出 xF 值1999999 当它应该是 2000000

// Doesn't work, sometimes we get 1999999 in the xF
int xI = (int)x;
int xF = (int)(((x - (double)xI) * 100000000));

以下似乎适用于我测试过的所有情况。但我想知道是否有更好的方法可以在不进行循环调用的情况下做到这一点。而且，是否存在仍然会失败的情况？

// Works, we get 2000000 but there's the round call
int xI = (int)x;
double temp = Math.Round(x - (double)xI, 6);
int xF = (int)(temp * 100000000);

Answer 1

问题是 (1) 二进制浮点以精度换取范围，以及 (2) 某些值（例如 3.1）无法以标准二进制浮点格式（例如 IEEE 754-2008）精确表示。

首先阅读 David Goldberg 的 “What Every”计算机科学家应该了解浮点算术”，发表于 ACM 计算调查，第 23 卷，第 1 期，3 月1991。

然后请参阅这些页面，了解有关使用浮点数存储精确值的危险、陷阱和陷阱的更多信息：

http://steve.hollasch.net/cgindex/coding/ieeefloat.html
http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm

当 System.Decimal 为您提供精确的十进制浮点数时，为什么要自己动手呢？

但是，如果你打算这样做，像这样的事情应该可以满足你的要求：

struct WonkyNumber
{
    private const double SCALE_FACTOR    = 1.0E+8          ;
    private int          _intValue        ;
    private int          _fractionalValue ;
    private double       _doubleValue     ;

    public int    IntegralValue
    {
        get
        {
            return _intValue ;
        }
        set
        {
            _intValue = value ;
            _doubleValue = ComputeDouble() ;
        }
    }
    public int    FractionalValue
    {
        get
        {
            return _fractionalValue ;
        }
        set
        {
            _fractionalValue = value ;
            _doubleValue     = ComputeDouble() ;
        }
    }
    public double DoubleValue
    {
        get
        {
            return _doubleValue ;
        }
        set
        {
            this.DoubleValue = value ;
            ParseDouble( out _intValue , out _fractionalValue ) ;
        }
    }

    public WonkyNumber( double value ) : this()
    {
        _doubleValue = value ;
        ParseDouble( out _intValue , out _fractionalValue ) ;
    }

    public WonkyNumber( int x , int y ) : this()
    {

        _intValue        = x ;
        _fractionalValue = y ;
        _doubleValue     = ComputeDouble() ;

        return ;
    }

    private void ParseDouble( out int x , out int y )
    {
        double remainder = _doubleValue % 1.0 ;
        double quotient  = _doubleValue - remainder ;

        x = (int)   quotient                   ;
        y = (int) Math.Round( remainder * SCALE_FACTOR ) ;

        return ;
    }

    private double ComputeDouble()
    {
        double value =     (double) this.IntegralValue
                     + ( ( (double) this.FractionalValue ) / SCALE_FACTOR )
                     ;
        return value ;
    }

    public static implicit operator WonkyNumber( double value )
    {
        WonkyNumber instance = new WonkyNumber( value ) ;
        return instance ;
    }

    public static implicit operator double( WonkyNumber value )
    {
        double instance = value.DoubleValue ;
        return instance ;
    }

}

Answer 2

我认为使用小数可以解决问题，因为在内部它们实际上使用数字的十进制表示形式。使用 double 将数字的二进制表示形式转换为十进制时会出现舍入错误。试试这个：

double x = 1234567.2;
decimal d = (decimal)x;
int xI = (int)d;
int xF = (int)(((d - xI) * 100000000)); 

编辑：与 RuneFS 的无休止的讨论表明事情并不那么容易。因此，我做了一个非常简单的测试，迭代次数为一百万次：

public static void TestDecimals()
{
    int doubleFailures = 0;
    int decimalFailures = 0;
    for (int i = 0; i < 1000000; i++) {
            double x = 1234567.7 + (13*i);
            int frac = FracUsingDouble(x);
            if (frac != 70000000) {
                    doubleFailures++;
            }
            frac = FracUsingDecimal(x);
            if (frac != 70000000) {
                    decimalFailures++;
            }
    }
    Console.WriteLine("Failures with double:  {0}", doubleFailures);  // => 516042
    Console.WriteLine("Failures with decimal: {0}", decimalFailures); // => 0
    Console.ReadKey();
}

private static int FracUsingDouble(double x)
{
    int xI = (int)x;
    int xF = (int)(((x - xI) * 100000000));
    return xF;
}

private static int FracUsingDecimal(double x)
{
    decimal d = (decimal)x;
    int xI = (int)d;
    int xF = (int)(((d - xI) * 100000000));
    return xF;
}

在这个测试中，51.6% 的仅双精度转换失败，而当数字首先转换为十进制时，没有转换失败。

Answer 3

有两个问题：

1. 您的输入值很少会等于小数点后 8 位的十进制表示形式。因此某种舍入是不可避免的。换句话说：您的数字 i.20000000 实际上会略小于或略大于 i.2。

2. 转换为int 总是向零舍入。这就是为什么，如果 i.20000000 小于 i.2，您将得到小数部分的 19999999。使用 Convert.ToInt32 四舍五入到最接近的值，这正是您想要的。在所有情况下，它都会为您提供 20000000。

因此，只要您的所有数字都在 0-99999999.99999999 范围内，以下内容将始终为您提供最接近的解决方案：

int xI = (int)x; 
int xF = Convert.ToInt32((x - (double)xI) * 100000000); 

当然，正如其他人所建议的那样，转换为 十进制并使用它进行计算是一个很好的选择。