相关疑难解决方法(0)

对不起,这可能是一个简单的愚蠢问题,但我需要知道确定.

我有这个if表达,

void Foo()
{
    System.Double something = GetSomething();
    if (something == 0) //Comparison of floating point numbers with equality 
                     // operator. Possible loss of precision while rounding value
        {}
}

这个表达是否与...相等

void Foo()
{
    System.Double something = GetSomething();
    if (something < 1)
        {}
}

？因为那时我可能会遇到问题,输入if例如0.9的值.

http://msdn.microsoft.com/en-us/library/system.double.epsilon.aspx

如果创建一个自定义算法来确定是否可以将两个浮点数视为相等,则必须使用大于Epsilon常量的值来确定两个值相等的可接受的绝对差值.(通常,差异幅度比Epsilon大很多倍.)

那么这不是真正可以用于比较的ε吗？我真的不明白MSDN的措辞.

它可以在这里的示例中用作epsilon吗？- 浮动和双重比较最有效的方法是什么？

最后这看起来非常重要,所以我想确保我有一个可靠的实现平等,大于,小于,小于或等于,大于或等于.

可能重复:
比较C#中的double值时出现问题

我在其他地方读过它,但是真的忘记了答案,所以我再次问这里.无论你用任何语言编写它,我都不会结束这个循环(我用C#,C++,Java测试它):

double d = 2.0;
while(d != 0.0){
   d = d - 0.2;
}

为什么以下程序会打印出打印的内容？

class Program
{
    static void Main(string[] args)
    {
        float f1 = 0.09f*100f;
        float f2 = 0.09f*99.999999f;

        Console.WriteLine(f1 > f2);
    }
}

输出是

false

可以这样做吗？

double doubleVariable=0.0;
if (doubleVariable==0) {
   ...
}

或者这段代码会遇到潜在的舍入问题？

我有一个List<CustomPoint> points;包含近百万个对象的东西.从这个列表中我想得到恰好发生两次的对象列表.最快的方法是什么？我也会对非Linq选项感兴趣,因为我可能也必须在C++中这样做.

public class CustomPoint
{
    public double X { get; set; }
    public double Y { get; set; }

    public CustomPoint(double x, double y)
    {
        this.X = x;
        this.Y = y;
    }
}

public class PointComparer : IEqualityComparer<CustomPoint>
{
    public bool Equals(CustomPoint x, CustomPoint y)
    {
        return ((x.X == y.X) && (y.Y == x.Y));
    }

    public int GetHashCode(CustomPoint obj)
    {
        int hash = 0;
        hash ^= obj.X.GetHashCode();
        hash ^= obj.Y.GetHashCode();
        return hash;
    }
}

基于这个答案,我试过, …

我尝试以下代码使用==和Equals数字比较：

Console.WriteLine( (int)2 == (double)2.0 );     
Console.WriteLine( ( (int)2 ).Equals( (double)2.0) );

Console.WriteLine((float)2.0 == (double)2.0);
Console.WriteLine( ( (float)2.0 ).Equals( (double)2.0 )   );

结果：

true 
false
true 
false

int, double, float都是ValueType，在阅读了帖子Here1和Here2后，我仍然无法理解为什么==结果Equals不同，

这4个案例==背后的工作细节是什么？Equals

（如果这个问题重复，请告诉我）

编辑： 4个更有趣的案例：

双精度型、浮点型 <-> 整数型

Console.WriteLine((double)2.0 == (int)2);              //True
Console.WriteLine(((double)2.0).Equals((int)2));       //True

Console.WriteLine((float)2.0 == (int)2.0);             //True
Console.WriteLine(((float)2.0).Equals((int)2.0));      //True

双精度型、整型 <-> 浮点型

Console.WriteLine((double)2.0 == (float)2.0);          //True
Console.WriteLine(((double)2.0).Equals((float)2.0));   //True

Console.WriteLine((int)2 == (float)2.0);               //True …

谁能告诉我为什么下面的语句评估为false？

bool myBoolean = .6 + .3 + .1 == .1 + .3 + .6; // false

它在Javascript和C++中做同样的事情.

我使用ReShaper,当我用==比较两个double值时,它表明我应该使用Math.具有公差的ABS方法.请参阅:https://www.jetbrains.com/help/resharper/2016.2/CompareOfFloatsByEqualityOperator.html

这个例子

double d = 0.0;
double d2 = 0.0;
if (d == d2)
{
    /* some code */
}

然后转换为

double d = 0.0;
double d2 = 0.0;
if (Math.Abs(d - d2) < TOLERANCE)
{
    /* some code */
}

但我认为开发人员考虑正确的容忍度确实很复杂.所以我认为这可以在Double.Equals()方法中实现.

但是这种方法是这样实现的

public override bool Equals(Object obj) {
    if (!(obj is Double)) { 
        return false;
    } 
    double temp = ((Double)obj).m_value; 
    // This code below is written this way for performance reasons i.e the != and == …

我有一个巨大的列表,其中有1000万个项目,我试图在列表中找到一个特定的值.

这是我的项目

struct reference
{
    public double GPST;
    public byte cls;
    public ushort fn;
    public int ret_num;
}

这是我的查询代码

 List<reference> ref_pts;

 List<reference> result = ref_pts.FindAll(delegate(reference obj) { return obj.GPST == pt.GPST; });

其中pt.GPST是我想在List中找到的值

是因为尺寸太大,Find方法不起作用(总是什么都不返回)？