Apa cara paling efektif untuk perbandingan mengambang dan ganda?

Apa cara yang paling efisien untuk membandingkan dua doubleatau dua floatnilai?

Melakukan hal ini tidak benar:

bool CompareDoubles1 (double A, double B)
{
   return A == B;
}

Tetapi sesuatu seperti:

bool CompareDoubles2 (double A, double B) 
{
   diff = A - B;
   return (diff < EPSILON) && (-diff < EPSILON);
}

Tampaknya pengolahan limbah.

Adakah yang tahu komparator float yang lebih pintar?

Berhati-hatilah dalam menggunakan saran lainnya. Itu semua tergantung konteks.

Saya telah menghabiskan waktu yang lama untuk melacak bug dalam sistem yang mungkin a==bjika |a-b|<epsilon. Masalah yang mendasarinya adalah:

1. Anggapan implisit dalam suatu algoritma bahwa jika a==bdan b==ckemudian a==c.

2. Menggunakan epsilon yang sama untuk garis yang diukur dalam inci dan garis yang diukur dalam mils (0,001 inci). Itulah a==btapi 1000a!=1000b. (Inilah sebabnya AlmostEqual2sComplement meminta epsilon atau ULPS maks).

3. Penggunaan epsilon yang sama untuk kosinus sudut dan panjang garis!

4. Menggunakan fungsi perbandingan untuk mengurutkan item dalam koleksi. (Dalam hal ini menggunakan operator C ++ bawaan == untuk ganda menghasilkan hasil yang benar.)

Seperti saya katakan: semuanya tergantung pada konteks dan ukuran yang diharapkan adan b.

BTW, std::numeric_limits<double>::epsilon()adalah "mesin epsilon". Ini adalah perbedaan antara 1,0 dan nilai selanjutnya yang diwakili oleh suatu ganda. Saya kira itu bisa digunakan dalam fungsi bandingkan tetapi hanya jika nilai yang diharapkan kurang dari 1. (Ini sebagai respons terhadap jawaban @ cdv ...)

Juga, jika pada dasarnya Anda memiliki intaritmatika doubles( di sini kami menggunakan ganda untuk menyimpan nilai int dalam kasus-kasus tertentu) aritmatika Anda akan benar. Misalnya 4.0 / 2.0 akan sama dengan 1.0 + 1.0. Ini selama Anda tidak melakukan hal-hal yang menghasilkan pecahan (4.0 / 3.0) atau tidak melampaui ukuran int.

Perbandingan dengan nilai epsilon adalah apa yang dilakukan kebanyakan orang (bahkan dalam pemrograman game).

Anda harus mengubah implementasi Anda sedikit:

bool AreSame(double a, double b)
{
    return fabs(a - b) < EPSILON;
}

Sunting: Christer telah menambahkan setumpuk info hebat tentang topik ini pada posting blog terbaru . Nikmati.

Saya menemukan bahwa Kerangka Pengujian Google C ++ berisi implementasi templat berbasis-platform bagus dari AlmostEqual2sComplement yang bekerja pada doubles dan float. Mengingat bahwa itu dirilis di bawah lisensi BSD, menggunakannya dalam kode Anda sendiri seharusnya tidak menjadi masalah, selama Anda mempertahankan lisensi tersebut. Saya mengekstrak kode di bawah ini dari http://code.google.com/p/googletest/source/browse/trunk/include/gtest/internal/gtest-internal.h https://github.com/google/googletest/blob /master/googletest/include/gtest/internal/gtest-internal.h dan menambahkan lisensi di atas.

Pastikan untuk #define GTEST_OS_WINDOWS ke beberapa nilai (atau untuk mengubah kode di mana ia digunakan untuk sesuatu yang sesuai dengan basis kode Anda - itu BSD dilisensikan setelah semua).

Contoh penggunaan:

double left  = // something
double right = // something
const FloatingPoint<double> lhs(left), rhs(right);

if (lhs.AlmostEquals(rhs)) {
  //they're equal!
}

Berikut kodenya:

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Authors: [email protected] (Zhanyong Wan), [email protected] (Sean Mcafee)
//
// The Google C++ Testing Framework (Google Test)


// This template class serves as a compile-time function from size to
// type.  It maps a size in bytes to a primitive type with that
// size. e.g.
//
//   TypeWithSize<4>::UInt
//
// is typedef-ed to be unsigned int (unsigned integer made up of 4
// bytes).
//
// Such functionality should belong to STL, but I cannot find it
// there.
//
// Google Test uses this class in the implementation of floating-point
// comparison.
//
// For now it only handles UInt (unsigned int) as that's all Google Test
// needs.  Other types can be easily added in the future if need
// arises.
template <size_t size>
class TypeWithSize {
 public:
  // This prevents the user from using TypeWithSize<N> with incorrect
  // values of N.
  typedef void UInt;
};

// The specialization for size 4.
template <>
class TypeWithSize<4> {
 public:
  // unsigned int has size 4 in both gcc and MSVC.
  //
  // As base/basictypes.h doesn't compile on Windows, we cannot use
  // uint32, uint64, and etc here.
  typedef int Int;
  typedef unsigned int UInt;
};

// The specialization for size 8.
template <>
class TypeWithSize<8> {
 public:
#if GTEST_OS_WINDOWS
  typedef __int64 Int;
  typedef unsigned __int64 UInt;
#else
  typedef long long Int;  // NOLINT
  typedef unsigned long long UInt;  // NOLINT
#endif  // GTEST_OS_WINDOWS
};


// This template class represents an IEEE floating-point number
// (either single-precision or double-precision, depending on the
// template parameters).
//
// The purpose of this class is to do more sophisticated number
// comparison.  (Due to round-off error, etc, it's very unlikely that
// two floating-points will be equal exactly.  Hence a naive
// comparison by the == operation often doesn't work.)
//
// Format of IEEE floating-point:
//
//   The most-significant bit being the leftmost, an IEEE
//   floating-point looks like
//
//     sign_bit exponent_bits fraction_bits
//
//   Here, sign_bit is a single bit that designates the sign of the
//   number.
//
//   For float, there are 8 exponent bits and 23 fraction bits.
//
//   For double, there are 11 exponent bits and 52 fraction bits.
//
//   More details can be found at
//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
//
// Template parameter:
//
//   RawType: the raw floating-point type (either float or double)
template <typename RawType>
class FloatingPoint {
 public:
  // Defines the unsigned integer type that has the same size as the
  // floating point number.
  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;

  // Constants.

  // # of bits in a number.
  static const size_t kBitCount = 8*sizeof(RawType);

  // # of fraction bits in a number.
  static const size_t kFractionBitCount =
    std::numeric_limits<RawType>::digits - 1;

  // # of exponent bits in a number.
  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;

  // The mask for the sign bit.
  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);

  // The mask for the fraction bits.
  static const Bits kFractionBitMask =
    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);

  // The mask for the exponent bits.
  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);

  // How many ULP's (Units in the Last Place) we want to tolerate when
  // comparing two numbers.  The larger the value, the more error we
  // allow.  A 0 value means that two numbers must be exactly the same
  // to be considered equal.
  //
  // The maximum error of a single floating-point operation is 0.5
  // units in the last place.  On Intel CPU's, all floating-point
  // calculations are done with 80-bit precision, while double has 64
  // bits.  Therefore, 4 should be enough for ordinary use.
  //
  // See the following article for more details on ULP:
  // http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm.
  static const size_t kMaxUlps = 4;

  // Constructs a FloatingPoint from a raw floating-point number.
  //
  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
  // around may change its bits, although the new value is guaranteed
  // to be also a NAN.  Therefore, don't expect this constructor to
  // preserve the bits in x when x is a NAN.
  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }

  // Static methods

  // Reinterprets a bit pattern as a floating-point number.
  //
  // This function is needed to test the AlmostEquals() method.
  static RawType ReinterpretBits(const Bits bits) {
    FloatingPoint fp(0);
    fp.u_.bits_ = bits;
    return fp.u_.value_;
  }

  // Returns the floating-point number that represent positive infinity.
  static RawType Infinity() {
    return ReinterpretBits(kExponentBitMask);
  }

  // Non-static methods

  // Returns the bits that represents this number.
  const Bits &bits() const { return u_.bits_; }

  // Returns the exponent bits of this number.
  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }

  // Returns the fraction bits of this number.
  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }

  // Returns the sign bit of this number.
  Bits sign_bit() const { return kSignBitMask & u_.bits_; }

  // Returns true iff this is NAN (not a number).
  bool is_nan() const {
    // It's a NAN if the exponent bits are all ones and the fraction
    // bits are not entirely zeros.
    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
  }

  // Returns true iff this number is at most kMaxUlps ULP's away from
  // rhs.  In particular, this function:
  //
  //   - returns false if either number is (or both are) NAN.
  //   - treats really large numbers as almost equal to infinity.
  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
  bool AlmostEquals(const FloatingPoint& rhs) const {
    // The IEEE standard says that any comparison operation involving
    // a NAN must return false.
    if (is_nan() || rhs.is_nan()) return false;

    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
        <= kMaxUlps;
  }

 private:
  // The data type used to store the actual floating-point number.
  union FloatingPointUnion {
    RawType value_;  // The raw floating-point number.
    Bits bits_;      // The bits that represent the number.
  };

  // Converts an integer from the sign-and-magnitude representation to
  // the biased representation.  More precisely, let N be 2 to the
  // power of (kBitCount - 1), an integer x is represented by the
  // unsigned number x + N.
  //
  // For instance,
  //
  //   -N + 1 (the most negative number representable using
  //          sign-and-magnitude) is represented by 1;
  //   0      is represented by N; and
  //   N - 1  (the biggest number representable using
  //          sign-and-magnitude) is represented by 2N - 1.
  //
  // Read http://en.wikipedia.org/wiki/Signed_number_representations
  // for more details on signed number representations.
  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
    if (kSignBitMask & sam) {
      // sam represents a negative number.
      return ~sam + 1;
    } else {
      // sam represents a positive number.
      return kSignBitMask | sam;
    }
  }

  // Given two numbers in the sign-and-magnitude representation,
  // returns the distance between them as an unsigned number.
  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
                                                     const Bits &sam2) {
    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
  }

  FloatingPointUnion u_;
};

EDIT: Posting ini berumur 4 tahun. Mungkin masih valid, dan kodenya bagus, tetapi beberapa orang menemukan peningkatan. Best go dapatkan versi terbaru AlmostEqualslangsung dari kode sumber Google Test, dan bukan yang saya tempel di sini.

Membandingkan angka floating point tergantung pada konteksnya. Karena bahkan mengubah urutan operasi dapat menghasilkan hasil yang berbeda, penting untuk mengetahui seberapa "sama" Anda inginkan angka-angkanya.

Membandingkan angka floating point oleh Bruce Dawson adalah tempat yang baik untuk memulai ketika melihat perbandingan floating point.

Definisi-definisi berikut berasal dari Seni pemrograman komputer oleh Knuth :

bool approximatelyEqual(float a, float b, float epsilon)
{
    return fabs(a - b) <= ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}

bool essentiallyEqual(float a, float b, float epsilon)
{
    return fabs(a - b) <= ( (fabs(a) > fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}

bool definitelyGreaterThan(float a, float b, float epsilon)
{
    return (a - b) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}

bool definitelyLessThan(float a, float b, float epsilon)
{
    return (b - a) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}

Tentu saja, memilih epsilon tergantung pada konteksnya, dan menentukan seberapa setara angka yang Anda inginkan.

Metode lain untuk membandingkan angka floating point adalah dengan melihat ULP (unit di tempat terakhir) dari angka-angka tersebut. Meskipun tidak berurusan secara khusus dengan perbandingan, makalah Apa yang harus diketahui oleh setiap ilmuwan komputer tentang angka floating point adalah sumber yang bagus untuk memahami bagaimana floating point bekerja dan apa jebakannya, termasuk apa ULP itu.

Untuk pendekatan yang lebih mendalam, baca Membandingkan angka floating point . Berikut ini cuplikan kode dari tautan itu:

// Usable AlmostEqual function    
bool AlmostEqual2sComplement(float A, float B, int maxUlps)    
{    
    // Make sure maxUlps is non-negative and small enough that the    
    // default NAN won't compare as equal to anything.    
    assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024);    
    int aInt = *(int*)&A;    
    // Make aInt lexicographically ordered as a twos-complement int    
    if (aInt < 0)    
        aInt = 0x80000000 - aInt;    
    // Make bInt lexicographically ordered as a twos-complement int    
    int bInt = *(int*)&B;    
    if (bInt < 0)    
        bInt = 0x80000000 - bInt;    
    int intDiff = abs(aInt - bInt);    
    if (intDiff <= maxUlps)    
        return true;    
    return false;    
}

Menyadari ini adalah utas lama tetapi artikel ini adalah salah satu yang paling lurus ke depan yang saya temukan dalam membandingkan angka floating point dan jika Anda ingin menjelajahi lebih banyak ia memiliki referensi yang lebih rinci juga dan itu situs utama mencakup berbagai masalah lengkap berurusan dengan angka floating point Panduan Floating-Point: Perbandingan .

Kita dapat menemukan artikel yang agak lebih praktis dalam toleransi titik Teraput ditinjau kembali dan mencatat ada tes toleransi absolut , yang bermuara pada ini di C ++:

bool absoluteToleranceCompare(double x, double y)
{
    return std::fabs(x - y) <= std::numeric_limits<double>::epsilon() ;
}

dan uji toleransi relatif :

bool relativeToleranceCompare(double x, double y)
{
    double maxXY = std::max( std::fabs(x) , std::fabs(y) ) ;
    return std::fabs(x - y) <= std::numeric_limits<double>::epsilon()*maxXY ;
}

Artikel tersebut mencatat bahwa tes absolut gagal ketika xdan ybesar dan gagal dalam kasus relatif ketika mereka kecil. Dengan asumsi ia mutlak dan relatif toleran sama tes gabungan akan terlihat seperti ini:

bool combinedToleranceCompare(double x, double y)
{
    double maxXYOne = std::max( { 1.0, std::fabs(x) , std::fabs(y) } ) ;

    return std::fabs(x - y) <= std::numeric_limits<double>::epsilon()*maxXYOne ;
}

Cara portabel untuk mendapatkan epsilon di C ++ adalah

#include <limits>
std::numeric_limits<double>::epsilon()

Maka fungsi perbandingan menjadi

#include <cmath>
#include <limits>

bool AreSame(double a, double b) {
    return std::fabs(a - b) < std::numeric_limits<double>::epsilon();
}

Saya akhirnya menghabiskan cukup banyak waktu untuk menelusuri materi di utas hebat ini. Saya ragu semua orang ingin menghabiskan begitu banyak waktu sehingga saya akan menyoroti ringkasan dari apa yang saya pelajari dan solusi yang saya terapkan.

Ringkasan Cepat

1. Apakah 1e-8 kira-kira sama dengan 1e-16? Jika Anda melihat data sensor bising maka mungkin ya tetapi jika Anda melakukan simulasi molekuler maka mungkin tidak! Intinya: Anda selalu perlu memikirkan nilai toleransi dalam konteks pemanggilan fungsi khusus dan tidak hanya membuatnya konstan-kode generik seluruh aplikasi.
2. Untuk fungsi perpustakaan umum, masih bagus untuk memiliki parameter dengan toleransi default . Pilihan tipikal adalah numeric_limits::epsilon()yang sama dengan FLT_EPSILON di float.h. Namun ini bermasalah karena epsilon untuk membandingkan nilai seperti 1.0 tidak sama dengan epsilon untuk nilai seperti 1E9. FLT_EPSILON didefinisikan untuk 1.0.
3. Implementasi yang jelas untuk memeriksa apakah angka dalam toleransi adalah fabs(a-b) <= epsilonnamun ini tidak berfungsi karena default epsilon didefinisikan untuk 1.0. Kita perlu meningkatkan epsilon ke atas atau ke bawah dalam hal a dan b.
4. Ada dua solusi untuk masalah ini: Anda menetapkan epsilon proporsional max(a,b)atau Anda bisa mendapatkan angka representatif berikutnya di sekitar a dan kemudian melihat apakah b termasuk dalam kisaran itu. Yang pertama disebut metode "relatif" dan kemudian disebut metode ULP.
5. Kedua metode ini sebenarnya gagal ketika membandingkan dengan 0. Dalam hal ini, aplikasi harus memberikan toleransi yang benar.

Implementasi Fungsi Utilitas (C ++ 11)

//implements relative method - do not use for comparing with zero
//use this most of the time, tolerance needs to be meaningful in your context
template<typename TReal>
static bool isApproximatelyEqual(TReal a, TReal b, TReal tolerance = std::numeric_limits<TReal>::epsilon())
{
    TReal diff = std::fabs(a - b);
    if (diff <= tolerance)
        return true;

    if (diff < std::fmax(std::fabs(a), std::fabs(b)) * tolerance)
        return true;

    return false;
}

//supply tolerance that is meaningful in your context
//for example, default tolerance may not work if you are comparing double with float
template<typename TReal>
static bool isApproximatelyZero(TReal a, TReal tolerance = std::numeric_limits<TReal>::epsilon())
{
    if (std::fabs(a) <= tolerance)
        return true;
    return false;
}


//use this when you want to be on safe side
//for example, don't start rover unless signal is above 1
template<typename TReal>
static bool isDefinitelyLessThan(TReal a, TReal b, TReal tolerance = std::numeric_limits<TReal>::epsilon())
{
    TReal diff = a - b;
    if (diff < tolerance)
        return true;

    if (diff < std::fmax(std::fabs(a), std::fabs(b)) * tolerance)
        return true;

    return false;
}
template<typename TReal>
static bool isDefinitelyGreaterThan(TReal a, TReal b, TReal tolerance = std::numeric_limits<TReal>::epsilon())
{
    TReal diff = a - b;
    if (diff > tolerance)
        return true;

    if (diff > std::fmax(std::fabs(a), std::fabs(b)) * tolerance)
        return true;

    return false;
}

//implements ULP method
//use this when you are only concerned about floating point precision issue
//for example, if you want to see if a is 1.0 by checking if its within
//10 closest representable floating point numbers around 1.0.
template<typename TReal>
static bool isWithinPrecisionInterval(TReal a, TReal b, unsigned int interval_size = 1)
{
    TReal min_a = a - (a - std::nextafter(a, std::numeric_limits<TReal>::lowest())) * interval_size;
    TReal max_a = a + (std::nextafter(a, std::numeric_limits<TReal>::max()) - a) * interval_size;

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

Kode yang Anda tulis disadap:

return (diff < EPSILON) && (-diff > EPSILON);

Kode yang benar adalah:

return (diff < EPSILON) && (diff > -EPSILON);

(... dan ya ini berbeda)

Saya ingin tahu apakah hebat tidak akan membuat Anda kehilangan evaluasi malas dalam beberapa kasus. Saya akan mengatakan itu tergantung pada kompiler. Anda mungkin ingin mencoba keduanya. Jika rata-rata setara, ambil implementasinya dengan fab.

Jika Anda memiliki beberapa info yang mana dari kedua float lebih cenderung lebih besar daripada yang lain, Anda dapat bermain di urutan perbandingan untuk mengambil keuntungan lebih baik dari evaluasi malas.

Akhirnya, Anda mungkin mendapatkan hasil yang lebih baik dengan menguraikan fungsi ini. Tidak mungkin untuk meningkatkan banyak ...

Sunting: OJ, terima kasih telah memperbaiki kode Anda. Saya menghapus komentar saya sesuai

`return fabs (a - b) <EPSILON;

Ini bagus jika:

• urutan besarnya input Anda tidak banyak berubah
• jumlah yang sangat kecil dari tanda yang berlawanan dapat diperlakukan sama

Tetapi sebaliknya itu akan membawa Anda ke dalam masalah. Angka presisi ganda memiliki resolusi sekitar 16 desimal. Jika dua angka yang Anda bandingkan besarnya lebih besar daripada EPSILON * 1.0E16, maka Anda mungkin juga mengatakan:

return a==b;

Saya akan memeriksa pendekatan yang berbeda yang menganggap Anda perlu khawatir tentang masalah pertama dan menganggap yang kedua baik-baik saja aplikasi Anda. Sebuah solusi akan menjadi seperti:

#define VERYSMALL  (1.0E-150)
#define EPSILON    (1.0E-8)
bool AreSame(double a, double b)
{
    double absDiff = fabs(a - b);
    if (absDiff < VERYSMALL)
    {
        return true;
    }

    double maxAbs  = max(fabs(a) - fabs(b));
    return (absDiff/maxAbs) < EPSILON;
}

Ini mahal secara komputasi, tetapi kadang-kadang itulah yang disebut. Inilah yang harus kita lakukan di perusahaan saya karena kita berurusan dengan perpustakaan teknik dan input dapat bervariasi dengan beberapa lusin pesanan besar.

Pokoknya, intinya adalah ini (dan berlaku untuk hampir semua masalah pemrograman): Mengevaluasi apa kebutuhan Anda, kemudian datang dengan solusi untuk memenuhi kebutuhan Anda - jangan menganggap jawaban mudah akan memenuhi kebutuhan Anda. Jika setelah evaluasi Anda menemukan itu fabs(a-b) < EPSILONsudah cukup, sempurna - gunakan! Namun waspadai kekurangannya dan kemungkinan solusi lainnya juga.

Seperti yang telah ditunjukkan orang lain, menggunakan epsilon eksponen tetap (seperti 0,0000001) tidak akan berguna untuk nilai yang jauh dari nilai epsilon. Sebagai contoh, jika dua nilai Anda adalah 10.000.000977 dan 10000, maka ada nilai floating-point NO 32-bit antara dua angka ini - 10000 dan 10000.000977 sedekat yang Anda bisa dapatkan tanpa bit-for-bit identik. Di sini, epsilon kurang dari 0,0009 tidak ada artinya; Anda mungkin juga menggunakan operator kesetaraan lurus.

Demikian juga, ketika kedua nilai mendekati ukuran epsilon, kesalahan relatif tumbuh hingga 100%.

Dengan demikian, mencoba untuk mencampur nomor titik tetap seperti 0,00001 dengan nilai-nilai floating-point (di mana eksponen sewenang-wenang) adalah latihan sia-sia. Ini hanya akan bekerja jika Anda dapat yakin bahwa nilai operan terletak di dalam domain sempit (yaitu, dekat dengan beberapa eksponen tertentu), dan jika Anda memilih nilai epsilon dengan benar untuk tes tertentu. Jika Anda mengeluarkan angka dari udara ("Hei! 0,00001 kecil, jadi pasti bagus!"), Anda akan mengalami kesalahan numerik. Saya telah menghabiskan banyak waktu men-debug kode numerik yang buruk di mana beberapa bodoh bodoh melemparkan nilai-nilai epsilon acak untuk membuat lagi kasus uji bekerja.

Jika Anda melakukan pemrograman numerik dalam bentuk apa pun dan yakin Anda perlu meraih epsil titik tetap, BACA PASAL BRUCE PADA PERBANDINGAN NOMOR TITIK .

Membandingkan Nomor Floating Point

Qt mengimplementasikan dua fungsi, mungkin Anda bisa belajar darinya:

static inline bool qFuzzyCompare(double p1, double p2)
{
    return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2)));
}

static inline bool qFuzzyCompare(float p1, float p2)
{
    return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
}

Dan Anda mungkin perlu fungsi-fungsi berikut, karena

Perhatikan bahwa membandingkan nilai di mana p1 atau p2 adalah 0,0 tidak akan berfungsi, juga tidak membandingkan nilai di mana salah satu nilai adalah NaN atau infinity. Jika salah satu nilai selalu 0,0, gunakan qFuzzyIsNull sebagai gantinya. Jika salah satu nilai cenderung 0,0, satu solusi adalah menambahkan 1,0 ke kedua nilai.

static inline bool qFuzzyIsNull(double d)
{
    return qAbs(d) <= 0.000000000001;
}

static inline bool qFuzzyIsNull(float f)
{
    return qAbs(f) <= 0.00001f;
}

Perbandingan tujuan umum angka floating-point umumnya tidak ada artinya. Cara membandingkan sangat tergantung pada masalah yang dihadapi. Dalam banyak masalah, angka cukup didiskritisasi untuk memungkinkan membandingkannya dalam toleransi yang diberikan. Sayangnya, ada banyak masalah, di mana trik seperti itu tidak berhasil. Sebagai satu contoh, pertimbangkan bekerja dengan fungsi (langkah) Heaviside dari sejumlah pertanyaan (opsi stok digital muncul di benak) ketika pengamatan Anda sangat dekat dengan penghalang. Melakukan perbandingan berbasis toleransi tidak akan banyak gunanya, karena secara efektif akan mengubah masalah dari penghalang asli ke dua yang baru. Sekali lagi, tidak ada solusi tujuan umum untuk masalah-masalah seperti itu dan solusi khusus mungkin perlu sejauh mengubah metode numerik untuk mencapai stabilitas.

Sayangnya, bahkan kode "boros" Anda salah. EPSILON adalah nilai terkecil yang dapat ditambahkan ke 1.0 dan mengubah nilainya. Nilai 1.0 sangat penting - angka yang lebih besar tidak berubah ketika ditambahkan ke EPSILON. Sekarang, Anda dapat mengatur nilai ini ke angka yang Anda bandingkan untuk mengetahui apakah mereka berbeda atau tidak. Ekspresi yang benar untuk membandingkan dua ganda adalah:

if (fabs(a - b) <= DBL_EPSILON * fmax(fabs(a), fabs(b)))
{
    // ...
}

Ini minimal. Namun, secara umum, Anda ingin memperhitungkan kebisingan dalam perhitungan Anda dan mengabaikan beberapa bit yang paling tidak signifikan, sehingga perbandingan yang lebih realistis akan terlihat seperti:

if (fabs(a - b) <= 16 * DBL_EPSILON * fmax(fabs(a), fabs(b)))
{
    // ...
}

Jika kinerja perbandingan sangat penting bagi Anda dan Anda tahu rentang nilai Anda, maka Anda harus menggunakan angka titik tetap.

Kelas saya berdasarkan jawaban yang diposting sebelumnya. Sangat mirip dengan kode Google tetapi saya menggunakan bias yang mendorong semua nilai NaN di atas 0xFF000000. Itu memungkinkan pemeriksaan yang lebih cepat untuk NaN.

Kode ini dimaksudkan untuk menunjukkan konsep, bukan menjadi solusi umum. Kode Google sudah menunjukkan cara menghitung semua nilai spesifik platform dan saya tidak ingin menduplikasi semua itu. Saya telah melakukan pengujian terbatas pada kode ini.

typedef unsigned int   U32;
//  Float           Memory          Bias (unsigned)
//  -----           ------          ---------------
//   NaN            0xFFFFFFFF      0xFF800001
//   NaN            0xFF800001      0xFFFFFFFF
//  -Infinity       0xFF800000      0x00000000 ---
//  -3.40282e+038   0xFF7FFFFF      0x00000001    |
//  -1.40130e-045   0x80000001      0x7F7FFFFF    |
//  -0.0            0x80000000      0x7F800000    |--- Valid <= 0xFF000000.
//   0.0            0x00000000      0x7F800000    |    NaN > 0xFF000000
//   1.40130e-045   0x00000001      0x7F800001    |
//   3.40282e+038   0x7F7FFFFF      0xFEFFFFFF    |
//   Infinity       0x7F800000      0xFF000000 ---
//   NaN            0x7F800001      0xFF000001
//   NaN            0x7FFFFFFF      0xFF7FFFFF
//
//   Either value of NaN returns false.
//   -Infinity and +Infinity are not "close".
//   -0 and +0 are equal.
//
class CompareFloat{
public:
    union{
        float     m_f32;
        U32       m_u32;
    };
    static bool   CompareFloat::IsClose( float A, float B, U32 unitsDelta = 4 )
                  {
                      U32    a = CompareFloat::GetBiased( A );
                      U32    b = CompareFloat::GetBiased( B );

                      if ( (a > 0xFF000000) || (b > 0xFF000000) )
                      {
                          return( false );
                      }
                      return( (static_cast<U32>(abs( a - b ))) < unitsDelta );
                  }
    protected:
    static U32    CompareFloat::GetBiased( float f )
                  {
                      U32    r = ((CompareFloat*)&f)->m_u32;

                      if ( r & 0x80000000 )
                      {
                          return( ~r - 0x007FFFFF );
                      }
                      return( r + 0x7F800000 );
                  }
};

Inilah bukti bahwa menggunakan std::numeric_limits::epsilon()bukanlah jawabannya - gagal untuk nilai yang lebih dari satu:

Bukti komentar saya di atas:

#include <stdio.h>
#include <limits>

double ItoD (__int64 x) {
    // Return double from 64-bit hexadecimal representation.
    return *(reinterpret_cast<double*>(&x));
}

void test (__int64 ai, __int64 bi) {
    double a = ItoD(ai), b = ItoD(bi);
    bool close = std::fabs(a-b) < std::numeric_limits<double>::epsilon();
    printf ("%.16f and %.16f %s close.\n", a, b, close ? "are " : "are not");
}

int main()
{
    test (0x3fe0000000000000L,
          0x3fe0000000000001L);

    test (0x3ff0000000000000L,
          0x3ff0000000000001L);
}

Menjalankan menghasilkan output ini:

0.5000000000000000 and 0.5000000000000001 are  close.
1.0000000000000000 and 1.0000000000000002 are not close.

Perhatikan bahwa dalam kasus kedua (satu dan hanya lebih besar dari satu), dua nilai input sedekat mungkin, dan masih membandingkan sebagai tidak dekat. Dengan demikian, untuk nilai yang lebih besar dari 1,0, Anda mungkin juga menggunakan tes kesetaraan. Epsilon yang diperbaiki tidak akan menyelamatkan Anda saat membandingkan nilai floating-point.

Menemukan implementasi lain yang menarik di: https://en.cppreference.com/w/cpp/types/numeric_limits/epsilon

#include <cmath>
#include <limits>
#include <iomanip>
#include <iostream>
#include <type_traits>
#include <algorithm>



template<class T>
typename std::enable_if<!std::numeric_limits<T>::is_integer, bool>::type
    almost_equal(T x, T y, int ulp)
{
    // the machine epsilon has to be scaled to the magnitude of the values used
    // and multiplied by the desired precision in ULPs (units in the last place)
    return std::fabs(x-y) <= std::numeric_limits<T>::epsilon() * std::fabs(x+y) * ulp
        // unless the result is subnormal
        || std::fabs(x-y) < std::numeric_limits<T>::min();
}

int main()
{
    double d1 = 0.2;
    double d2 = 1 / std::sqrt(5) / std::sqrt(5);
    std::cout << std::fixed << std::setprecision(20) 
        << "d1=" << d1 << "\nd2=" << d2 << '\n';

    if(d1 == d2)
        std::cout << "d1 == d2\n";
    else
        std::cout << "d1 != d2\n";

    if(almost_equal(d1, d2, 2))
        std::cout << "d1 almost equals d2\n";
    else
        std::cout << "d1 does not almost equal d2\n";
}

Saya akan sangat waspada terhadap salah satu jawaban ini yang melibatkan pengurangan floating point (mis., Fabs (ab) <epsilon). Pertama, angka floating point menjadi lebih jarang pada magnitudo lebih besar dan pada magnitudo cukup tinggi di mana jarak lebih besar dari epsilon, Anda mungkin juga melakukan a == b. Kedua, mengurangi dua angka floating point yang sangat dekat (karena ini akan cenderung, mengingat bahwa Anda sedang mencari kesetaraan dekat) adalah persis bagaimana Anda mendapatkan pembatalan bencana .

Meskipun tidak portabel, saya pikir jawaban grom melakukan pekerjaan terbaik untuk menghindari masalah ini.

Sebenarnya ada kasus dalam perangkat lunak numerik di mana Anda ingin memeriksa apakah dua angka floating point persis sama. Saya memposting ini pada pertanyaan serupa

https://stackoverflow.com/a/10973098/1447411

Jadi Anda tidak bisa mengatakan bahwa "CompareDoubles1" salah secara umum.

Itu tergantung pada seberapa tepat perbandingan yang Anda inginkan. Jika Anda ingin membandingkan dengan angka yang persis sama, maka cukup dengan ==. (Anda hampir tidak pernah ingin melakukan ini kecuali Anda benar-benar menginginkan nomor yang sama persis.) Pada platform yang layak Anda juga dapat melakukan hal berikut:

diff= a - b; return fabs(diff)<EPSILON;

karena fabscenderung cukup cepat. Maksud saya cukup cepat pada dasarnya adalah bitwise AND, jadi lebih baik cepat.

Dan trik integer untuk membandingkan ganda dan float bagus tetapi cenderung membuatnya lebih sulit untuk menangani berbagai pipa CPU secara efektif. Dan tentu saja ini tidak lebih cepat pada arsitektur pesanan tertentu karena menggunakan stack sebagai area penyimpanan sementara untuk nilai-nilai yang sering digunakan. (Load-hit-store untuk mereka yang peduli.)

Dalam hal skala jumlah:

Jika epsilonsebagian kecil dari besaran kuantitas (yaitu nilai relatif) dalam beberapa pengertian Adan Bjenis fisik tertentu dapat dibandingkan dalam arti yang sama, daripada yang saya pikir, bahwa yang berikut ini cukup benar:

#include <limits>
#include <iomanip>
#include <iostream>

#include <cmath>
#include <cstdlib>
#include <cassert>

template< typename A, typename B >
inline
bool close_enough(A const & a, B const & b,
                  typename std::common_type< A, B >::type const & epsilon)
{
    using std::isless;
    assert(isless(0, epsilon)); // epsilon is a part of the whole quantity
    assert(isless(epsilon, 1));
    using std::abs;
    auto const delta = abs(a - b);
    auto const x = abs(a);
    auto const y = abs(b);
    // comparable generally and |a - b| < eps * (|a| + |b|) / 2
    return isless(epsilon * y, x) && isless(epsilon * x, y) && isless((delta + delta) / (x + y), epsilon);
}

int main()
{
    std::cout << std::boolalpha << close_enough(0.9, 1.0, 0.1) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0, 1.1, 0.1) << std::endl;
    std::cout << std::boolalpha << close_enough(1.1,    1.2,    0.01) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0001, 1.0002, 0.01) << std::endl;
    std::cout << std::boolalpha << close_enough(1.0, 0.01, 0.1) << std::endl;
    return EXIT_SUCCESS;
}

Saya menggunakan kode ini:

bool AlmostEqual(double v1, double v2)
    {
        return (std::fabs(v1 - v2) < std::fabs(std::min(v1, v2)) * std::numeric_limits<double>::epsilon());
    }

Saya menulis ini untuk java, tetapi mungkin Anda merasa berguna. Ia menggunakan long bukannya double, tetapi merawat NaN, subnormal, dll.

public static boolean equal(double a, double b) {
    final long fm = 0xFFFFFFFFFFFFFL;       // fraction mask
    final long sm = 0x8000000000000000L;    // sign mask
    final long cm = 0x8000000000000L;       // most significant decimal bit mask
    long c = Double.doubleToLongBits(a), d = Double.doubleToLongBits(b);        
    int ea = (int) (c >> 52 & 2047), eb = (int) (d >> 52 & 2047);
    if (ea == 2047 && (c & fm) != 0 || eb == 2047 && (d & fm) != 0) return false;   // NaN 
    if (c == d) return true;                            // identical - fast check
    if (ea == 0 && eb == 0) return true;                // ±0 or subnormals
    if ((c & sm) != (d & sm)) return false;             // different signs
    if (abs(ea - eb) > 1) return false;                 // b > 2*a or a > 2*b
    d <<= 12; c <<= 12;
    if (ea < eb) c = c >> 1 | sm;
    else if (ea > eb) d = d >> 1 | sm;
    c -= d;
    return c < 65536 && c > -65536;     // don't use abs(), because:
    // There is a posibility c=0x8000000000000000 which cannot be converted to positive
}
public static boolean zero(double a) { return (Double.doubleToLongBits(a) >> 52 & 2047) < 3; }

Ingatlah bahwa setelah beberapa operasi floating-point, angka bisa sangat berbeda dari yang kita harapkan. Tidak ada kode untuk memperbaikinya.

Bagaimana dengan ini?

template<typename T>
bool FloatingPointEqual( T a, T b ) { return !(a < b) && !(b < a); }

Saya telah melihat berbagai pendekatan - tetapi tidak pernah melihat ini, jadi saya penasaran ingin mendengar komentar juga!

/// testing whether two doubles are almost equal. We consider two doubles
/// equal if the difference is within the range [0, epsilon).
///
/// epsilon: a positive number (supposed to be small)
///
/// if either x or y is 0, then we are comparing the absolute difference to
/// epsilon.
/// if both x and y are non-zero, then we are comparing the relative difference
/// to epsilon.
bool almost_equal(double x, double y, double epsilon)
{
    double diff = x - y;
    if (x != 0 && y != 0){
        diff = diff/y; 
    }

    if (diff < epsilon && -1.0*diff < epsilon){
        return true;
    }
    return false;
}

Saya menggunakan fungsi ini untuk proyek kecil saya dan berfungsi, tetapi perhatikan hal berikut:

Kesalahan presisi ganda dapat membuat kejutan bagi Anda. Katakanlah epsilon = 1.0e-6, maka 1.0 dan 1.000001 TIDAK boleh dianggap sama dengan kode di atas, tetapi pada mesin saya fungsinya menganggap mereka sama, ini karena 1.000001 tidak dapat secara tepat diterjemahkan ke format biner, mungkin 1,0000009xxx. Saya mengujinya dengan 1.0 dan 1.0000011 dan kali ini saya mendapatkan hasil yang diharapkan.

Ini adalah solusi lain dengan lambda:

#include <cmath>
#include <limits>

auto Compare = [](float a, float b, float epsilon = std::numeric_limits<float>::epsilon()){ return (std::fabs(a - b) <= epsilon); };

Cara saya mungkin tidak benar tetapi bermanfaat

Konversikan kedua float menjadi string lalu lakukan perbandingan string

bool IsFlaotEqual(float a, float b, int decimal)
{
    TCHAR form[50] = _T("");
    _stprintf(form, _T("%%.%df"), decimal);


    TCHAR a1[30] = _T(""), a2[30] = _T("");
    _stprintf(a1, form, a);
    _stprintf(a2, form, b);

    if( _tcscmp(a1, a2) == 0 )
        return true;

    return false;

}

overlay operator juga bisa dilakukan

Anda tidak dapat membandingkan dua doubledengan yang diperbaiki EPSILON. Tergantung pada nilai double, EPSILONbervariasi.

Perbandingan ganda yang lebih baik adalah:

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

Dengan cara yang lebih umum:

template <typename T>
bool compareNumber(const T& a, const T& b) {
    return std::abs(a - b) < std::numeric_limits<T>::epsilon();
}

Mengapa tidak melakukan XOR bitwise? Dua angka floating point sama jika bit yang sesuai sama. Saya pikir, keputusan untuk menempatkan bit eksponen sebelum mantissa dibuat untuk mempercepat perbandingan dua pelampung. Saya pikir, banyak jawaban di sini tidak memiliki titik perbandingan epsilon. Nilai Epsilon hanya tergantung pada angka presisi floating point mana yang dibandingkan. Misalnya, setelah melakukan beberapa aritmatika dengan pelampung Anda mendapatkan dua angka: 2.5642943554342 dan 2.5642943554345. Mereka tidak sama, tetapi untuk solusinya hanya 3 angka desimal sehingga mereka sama: 2.564 dan 2.564. Dalam hal ini Anda memilih epsilon sama dengan 0,001. Perbandingan Epsilon juga dimungkinkan dengan bitor XOR. Koreksi saya jika saya salah.