为什么我的比较运算符没有比较我的点长和双精度值？

Question

I create new operator to compare my point vector length and double value. I have condition to tolerate different which is less than 0.01. When i using this operator to compare my Point and my double value (both values after approaching are same) but the operator == is not returning true.

class Point {
private:
    double x, y, z;
public:
    Point() { x = y = z = 0.0; }
    Point(double v) { x = y = z = v; }
    Point(double x, double y, double z){
        this->x = x; this->y = y; this->z = z;
    }
    double getLength(){
        return sqrt(pow(x,2)+pow(y,2)+pow(z,2));
    }
    friend const bool operator== (double &d, Point &v);
};

double approach(double num){
    return floor(num*100)/100;
}

const bool operator== (const double &d, Point &v){
    return (approach(d) == approach(v.getLength()));
}

int main()
{
    Point p1(3,4,1);
    cout << p1.getLength() << endl; // 5.09902
    cout << approach(p1.getLength()) << endl;
    cout << approach(5.091) << endl;
    if(5.091 == p1)
        cout << "True";
    return 0;
}

Answer 1

This issue can be reproduced on gcc with 32 bit Intel architecture, without optimization. Here is an example of it happening: compiler explorer example .

This is due to the infamous 323 bug of gcc, which struggles to work with Intel's 80 bit floating point registers, which are wider than the 64 bits of type double . Some of the values end up in the 80-bit register, and some values in the 64-bit memory value.

In your case, approach(d) is called first, and then get spilled to memory when v.getLength() is called. The value of approach(v.getLength()) , on the other hand, is not getting spilled and gets all of register's 80-bit precision.

When you compare an 80-bit accurate value, and a truncated 64-bit value, the comparison result is false .

A possible solution is to avoid the division by 100 in approach() , since it is what introduces the extra bits. Instead, you can try:

static constexpr double magnitude = 100.0;
const bool operator== (double d, const Point &v){
    return floor(d * magnitude) == floor(v.getLength() * magnitude));
}