Làm thế nào để so sánh chính xác và tiêu chuẩn phao nổi?

Question

Mỗi lần tôi bắt đầu một dự án mới và khi tôi cần phải so sánh một số float hoặc các biến đôi tôi viết code như thế này:

if (fabs(prev.min[i] - cur->min[i]) < 0.000001 && 
    fabs(prev.max[i] - cur->max[i]) < 0.000001) { 
     continue; 
} 

Sau đó, tôi muốn thoát khỏi những biến kỳ diệu 0.000001 (và ,00000000001 cho double) và fabs, vì vậy tôi viết một hàm nội tuyến và một số xác định:

#define FLOAT_TOL 0.000001 

Vì vậy, tôi tự hỏi nếu có cách nào tiêu chuẩn để làm điều này? Có thể là một số tiêu đề tập tin tiêu đề? Nó cũng sẽ tốt đẹp nếu có giới hạn float và double (min và max)

Answer 1

Cảm ơn câu trả lời của bạn, họ đã giúp tôi rất nhiều.Tôi đã đọc các tài liệu này: first và second

Câu trả lời là để sử dụng chức năng của riêng tôi để so sánh tương đối:

bool areEqualRel(float a, float b, float epsilon) { 
    return (fabs(a - b) <= epsilon * std::max(fabs(a), fabs(b))); 
} 

Đây là giải pháp phù hợp nhất với nhu cầu của tôi. Tuy nhiên tôi đã viết một số bài kiểm tra và các phương pháp so sánh khác. Tôi hy vọng điều này sẽ hữu ích cho ai đó. areEqualRel vượt qua các thử nghiệm này, những người khác thì không.

#include <iostream> 
#include <limits> 
#include <algorithm> 

using std::cout; 
using std::max; 

bool areEqualAbs(float a, float b, float epsilon) { 
    return (fabs(a - b) <= epsilon); 
} 

bool areEqual(float a, float b, float epsilon) { 
    return (fabs(a - b) <= epsilon * std::max(1.0f, std::max(a, b))); 
} 

bool areEqualRel(float a, float b, float epsilon) { 
    return (fabs(a - b) <= epsilon * std::max(fabs(a), fabs(b))); 
} 

int main(int argc, char *argv[]) 
{ 
    cout << "minimum: " << FLT_MIN  << "\n"; 
    cout << "maximum: " << FLT_MAX  << "\n"; 
    cout << "epsilon: " << FLT_EPSILON << "\n"; 

    float a = 0.0000001f; 
    float b = 0.0000002f; 
    if (areEqualRel(a, b, FLT_EPSILON)) { 
     cout << "are equal a: " << a << " b: " << b << "\n"; 
    } 
    a = 1000001.f; 
    b = 1000002.f; 
    if (areEqualRel(a, b, FLT_EPSILON)) { 
     cout << "are equal a: " << a << " b: " << b << "\n"; 
    } 
} 

Answer 2

Bạn nên lưu ý rằng nếu so sánh hai phao cho bình đẳng, bạn thực chất là làm sai. Thêm một yếu tố slop để so sánh là không đủ tốt.

Answer 3

Tiêu chuẩn cung cấp giá trị epsilon. Đó là trong <limits> và bạn có thể truy cập giá trị theo số std::numeric_limits<float>::epsilon và std::numeric_limits<double>::epsilon. Có những giá trị khác trong đó, nhưng tôi không kiểm tra chính xác là gì.

Answer 4

Bạn nên sử dụng tiêu chuẩn xác định trong float.h:

#define DBL_EPSILON  2.2204460492503131e-016 /* smallest float value such that 1.0+DBL_EPSILON != 1.0 */ 

hoặc lớp numeric_limits:

// excerpt 
template<> 
class numeric_limits<float> : public _Num_float_base 
{ 
public: 
    typedef float T; 

    // return minimum value 
    static T (min)() throw(); 

    // return smallest effective increment from 1.0 
    static T epsilon() throw(); 

    // return largest rounding error 
    static T round_error() throw(); 

    // return minimum denormalized value 
    static T denorm_min() throw(); 
}; 

[EDIT:. Made nó dễ đọc hơn một chút]

Nhưng ngoài ra, nó phụ thuộc vào những gì bạn đang sau.

Answer 5

Từ The Floating-Point Guide:

Đây là một cách xấu để làm điều đó bởi vì một epsilon cố định chọn vì nó “có vẻ nhỏ” thực sự có thể là cách quá lớn khi những con số được so sánh là rất nhỏ cũng. So sánh sẽ trả về “true” cho các số hoàn toàn khác nhau. Và khi số lượng rất lớn, epsilon có thể kết thúc nhỏ hơn lỗi làm tròn nhỏ nhất, để việc so sánh luôn trả về “sai”.

Vấn đề với "số ma thuật" ở đây không phải là mã cứng nhưng đó là "ma thuật": bạn không thực sự có lý do chọn 0,000001 trên 0,000005 hoặc 0,0000000000001, phải không? Lưu ý rằng float có thể xấp xỉ đại diện cho giá trị thứ hai và vẫn nhỏ hơn - chỉ khoảng 7 số thập phân chính xác sau chữ số không đầu tiên đầu tiên!

Nếu bạn định sử dụng epsilon cố định, bạn thực sự nên chọn nó theo yêu cầu của đoạn mã cụ thể mà bạn sử dụng nó. Cách khác là sử dụng lề lỗi tương đối (xem liên kết ở trên cùng để biết chi tiết) hoặc thậm chí tốt hơn, hoặc compare the floats as integers.

Answer 6

bài này có một lời giải thích toàn diện về cách so sánh số dấu chấm động: http://www.altdevblogaday.com/2012/02/22/comparing-floating-point-numbers-2012-edition/

Trích:

• Nếu bạn đang so sánh với zero, sau đó epsilons tương đối và ULPs dựa so sánh thường vô nghĩa. Bạn sẽ cần sử dụng một eps2on tuyệt đối , có giá trị có thể là một số bội số nhỏ của FLT_EPSILON và các yếu tố đầu vào cho phép tính của bạn. Có lẽ.
• Nếu bạn so sánh với số khác 0 thì so sánh tương đối epsilons hoặc ULPs có lẽ là những gì bạn muốn. Bạn sẽ có thể muốn một số lượng nhỏ FLT_EPSILON cho người thân của bạn epsilon hoặc một số lượng nhỏ ULP. Một epsilon tuyệt đối có thể là được sử dụng nếu bạn biết chính xác số lượng bạn đã so sánh.

Answer 7

Bạn có thể sử dụng để thử nghiệm std::nextafter hai double với epsilon nhỏ nhất trên một giá trị (hoặc một yếu tố của epsilon nhỏ nhất).

bool nearly_equal(double a, double b) 
{ 
    return std::nextafter(a, std::numeric_limits<double>::lowest()) <= b 
    && std::nextafter(a, std::numeric_limits<double>::max()) >= b; 
} 

bool nearly_equal(double a, double b, int factor /* a factor of epsilon */) 
{ 
    double min_a = a - (a - std::nextafter(a, std::numeric_limits<double>::lowest())) * factor; 
    double max_a = a + (std::nextafter(a, std::numeric_limits<double>::max()) - a) * factor; 

    return min_a <= b && max_a >= b; 
} 

Answer 8

Đây là một giải pháp C++ 11 của giải pháp @geotavros. Nó sử dụng chức năng std::numeric_limits<T>::epsilon() mới và thực tế là std::fabs() và std::fmax() hiện đang bị quá tải cho float, double và long float.

template<typename T> 
static bool AreEqual(T f1, T f2) { 
    return (std::fabs(f1 - f2) <= std::numeric_limits<T>::epsilon() * std::fmax(fabs(f1), fabs(f2))); 
}