Quel est le moyen le plus efficace pour la comparaison flottante et double?

Quelle serait la façon la plus efficace de comparer deux doubleou deux floatvaleurs?

Faire cela n'est pas correct:

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

Mais quelque chose comme:

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

Semble au traitement des déchets.

Quelqu'un connaît-il un comparateur de flotteurs plus intelligent?

Soyez extrêmement prudent en utilisant l'une des autres suggestions. Tout dépend du contexte.

J'ai passé beaucoup de temps à retracer un bogue dans un système qui présumait a==bsi |a-b|<epsilon. Les problèmes sous-jacents étaient les suivants:

1. La présomption implicite dans un algorithme que si a==bet b==calors a==c.

2. Utiliser le même epsilon pour les lignes mesurées en pouces et les lignes mesurées en mils (0,001 pouce). Ce n'est a==bque 1000a!=1000b. (C'est pourquoi AlmostEqual2sComplement demande le epsilon ou le max ULPS).

3. L'utilisation du même epsilon pour le cosinus des angles et la longueur des lignes!

4. Utiliser une telle fonction de comparaison pour trier les éléments d'une collection. (Dans ce cas, l'utilisation de l'opérateur C ++ intégré == pour les doubles a produit des résultats corrects.)

Comme je l'ai dit: tout dépend du contexte et de la taille attendue de aet b.

BTW, std::numeric_limits<double>::epsilon()c'est la "machine epsilon". C'est la différence entre 1.0 et la valeur suivante représentable par un double. Je suppose que cela pourrait être utilisé dans la fonction de comparaison, mais uniquement si les valeurs attendues sont inférieures à 1. (C'est en réponse à la réponse de @ cdv ...)

De plus, si vous avez essentiellement de l' intarithmétique doubles(ici, nous utilisons des doubles pour contenir des valeurs int dans certains cas), votre arithmétique sera correcte. Par exemple, 4.0 / 2.0 sera identique à 1.0 + 1.0. C'est aussi longtemps que vous ne faites pas de choses qui aboutissent à des fractions (4.0 / 3.0) ou ne sortez pas de la taille d'un int.

La comparaison avec une valeur epsilon est ce que la plupart des gens font (même dans la programmation de jeux).

Vous devez cependant modifier un peu votre implémentation:

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

Edit: Christer a ajouté une pile d'excellentes informations sur ce sujet dans un récent article de blog . Prendre plaisir.

J'ai trouvé que le cadre de test Google C ++ contient une belle implémentation basée sur un modèle multiplateforme d'AlmostEqual2sComplement qui fonctionne à la fois sur les doubles et les flottants. Étant donné qu'il est publié sous la licence BSD, son utilisation dans votre propre code ne devrait pas poser de problème, tant que vous conservez la licence. J'ai extrait le code ci-dessous de 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 et ajouté la licence en haut.

Assurez-vous de #define GTEST_OS_WINDOWS à une certaine valeur (ou de changer le code où il est utilisé pour quelque chose qui correspond à votre base de code - c'est une licence BSD après tout).

Exemple d'utilisation:

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

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

Voici le code:

// 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: wan@google.com (Zhanyong Wan), eefacm@gmail.com (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: Ce poste a 4 ans. Il est probablement toujours valide et le code est agréable, mais certaines personnes ont trouvé des améliorations. Il vaut mieux obtenir la dernière version du AlmostEqualsdroit à partir du code source de Google Test, et non celle que j'ai collée ici.

La comparaison des nombres à virgule flottante pour dépend du contexte. Étant donné que même changer l'ordre des opérations peut produire des résultats différents, il est important de savoir dans quelle mesure vous voulez que les nombres soient «égaux».

La comparaison des nombres à virgule flottante par Bruce Dawson est un bon point de départ lorsque l'on regarde la comparaison à virgule flottante.

Les définitions suivantes sont tirées de L'art de la programmation informatique par 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);
}

Bien sûr, choisir epsilon dépend du contexte et détermine dans quelle mesure vous voulez que les nombres soient égaux.

Une autre méthode de comparaison des nombres à virgule flottante consiste à examiner les ULP (unités à la dernière place) des nombres. Bien qu'il ne traite pas spécifiquement des comparaisons, le document Ce que tout informaticien devrait savoir sur les nombres à virgule flottante est une bonne ressource pour comprendre comment fonctionne le virgule flottante et quels sont les pièges, y compris ce qu'est ULP.

Pour une approche plus approfondie, lisez Comparaison des nombres à virgule flottante . Voici l'extrait de code de ce lien:

// 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;    
}

Réalisant que c'est un vieux fil, mais cet article est l'un des plus simples que j'ai trouvé en comparant les nombres à virgule flottante et si vous voulez en savoir plus, il contient également des références plus détaillées et le site principal couvre une gamme complète de problèmes gestion des nombres à virgule flottante Le guide des virgules flottantes: comparaison .

Nous pouvons trouver un article un peu plus pratique dans Tolérances en virgule flottante revisité et note qu'il existe un test de tolérance absolue , qui se résume à cela en C ++:

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

et test de tolérance relative :

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 ;
}

L'article note que le test absolu échoue quand xet ysont grands et échoue dans le cas relatif quand ils sont petits. En supposant que la tolérance absolue et relative est la même, un test combiné ressemblerait à ceci:

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 ;
}

La façon portable d'obtenir epsilon en C ++ est

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

Ensuite, la fonction de comparaison devient

#include <cmath>
#include <limits>

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

J'ai fini par passer pas mal de temps à parcourir le matériel dans ce grand fil. Je doute que tout le monde veuille passer autant de temps, je voudrais donc souligner le résumé de ce que j'ai appris et la solution que j'ai mise en œuvre.

Résumé rapide

1. 1e-8 est-il approximativement identique à 1e-16? Si vous regardez des données de capteurs bruyantes, alors probablement oui, mais si vous faites de la simulation moléculaire, ce n'est peut-être pas le cas! Conclusion: vous devez toujours penser à la valeur de tolérance dans le contexte d'un appel de fonction spécifique et pas seulement en faire une constante codée en dur générique à l'échelle de l'application.
2. Pour les fonctions de bibliothèque générales, il est toujours agréable d'avoir un paramètre avec une tolérance par défaut . Un choix typique numeric_limits::epsilon()est le même que FLT_EPSILON dans float.h. Ceci est cependant problématique car epsilon pour comparer des valeurs comme 1.0 n'est pas identique à epsilon pour des valeurs comme 1E9. Le FLT_EPSILON est défini pour 1.0.
3. L'implémentation évidente pour vérifier si le nombre est dans la tolérance est fabs(a-b) <= epsiloncependant que cela ne fonctionne pas car epsilon par défaut est défini pour 1.0. Nous devons augmenter ou diminuer epsilon en termes de a et b.
4. Il existe deux solutions à ce problème: soit vous définissez epsilon proportionnellement à, max(a,b)soit vous pouvez obtenir les prochains nombres représentables autour de a, puis voir si b tombe dans cette plage. La première est appelée méthode "relative" et plus tard est appelée méthode ULP.
5. Les deux méthodes échouent en fait de toute façon lors de la comparaison avec 0. Dans ce cas, l'application doit fournir une tolérance correcte.

Implémentation des fonctions utilitaires (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;
}

Le code que vous avez écrit est buggé:

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

Le code correct serait:

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

(... et oui c'est différent)

Je me demande si les fabs ne vous feraient pas perdre l'évaluation paresseuse dans certains cas. Je dirais que cela dépend du compilateur. Vous voudrez peut-être essayer les deux. S'ils sont en moyenne équivalents, prenez l'implémentation avec des fabs.

Si vous avez des informations sur lequel des deux flotteurs est plus susceptible d'être plus grand que les autres, vous pouvez jouer dans l'ordre de la comparaison pour mieux profiter de l'évaluation paresseuse.

Enfin, vous pourriez obtenir de meilleurs résultats en intégrant cette fonction. Peu susceptible de s'améliorer cependant ...

Edit: OJ, merci d'avoir corrigé votre code. J'ai effacé mon commentaire en conséquence

`retour fabs (a - b) <EPSILON;

C'est très bien si:

• l'ordre de grandeur de vos entrées ne change pas grand-chose
• un très petit nombre de signes opposés peut être considéré comme égal

Mais sinon, cela vous mènera à des ennuis. Les nombres à double précision ont une résolution d'environ 16 décimales. Si les deux nombres que vous comparez sont plus grands que EPSILON * 1.0E16, alors vous pourriez aussi bien dire:

return a==b;

J'examinerai une approche différente qui suppose que vous devez vous soucier du premier problème et que le second convient à votre application. Une solution serait quelque chose comme:

#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;
}

C'est coûteux en calcul, mais c'est parfois ce qui est demandé. C'est ce que nous devons faire dans mon entreprise car nous avons affaire à une bibliothèque d'ingénierie et les intrants peuvent varier de quelques dizaines d'ordre de grandeur.

Quoi qu'il en soit, le point est le suivant (et s'applique à pratiquement tous les problèmes de programmation): Évaluez vos besoins, puis trouvez une solution pour répondre à vos besoins - ne présumez pas que la réponse facile répondra à vos besoins. Si après votre évaluation, vous trouvez que fabs(a-b) < EPSILONcela suffira, parfait - utilisez-le! Mais soyez conscient de ses lacunes et des autres solutions possibles.

Comme d'autres l'ont souligné, l'utilisation d'un epsilon à exposant fixe (tel que 0,000000001) sera inutile pour les valeurs éloignées de la valeur epsilon. Par exemple, si vos deux valeurs sont 10000.000977 et 10000, il n'y a AUCUNE valeur à virgule flottante de 32 bits entre ces deux nombres - 10000 et 10000.000977 sont aussi proches que possible sans être identiques bit par bit. Ici, un epsilon inférieur à 0,0009 n'a pas de sens; vous pourriez aussi bien utiliser l'opérateur d'égalité directe.

De même, à mesure que les deux valeurs approchent epsilon, l'erreur relative augmente à 100%.

Ainsi, essayer de mélanger un nombre à virgule fixe tel que 0,00001 avec des valeurs à virgule flottante (où l'exposant est arbitraire) est un exercice inutile. Cela ne fonctionnera que si vous pouvez être assuré que les valeurs d'opérande se trouvent dans un domaine étroit (c'est-à-dire près d'un exposant spécifique) et si vous sélectionnez correctement une valeur epsilon pour ce test spécifique. Si vous sortez un numéro de l'air ("Hé! 0.00001 est petit, donc ça doit être bon!"), Vous êtes condamné à des erreurs numériques. J'ai passé beaucoup de temps à déboguer un mauvais code numérique où un pauvre schmuck lance des valeurs epsilon aléatoires pour faire fonctionner un autre cas de test.

Si vous effectuez une programmation numérique de quelque nature que ce soit et que vous pensez que vous devez atteindre des epsilons à virgule fixe, LISEZ L'ARTICLE DE BRUCE SUR LA COMPARAISON DES NUMÉROS À POINTS FLOTTANTS .

Comparaison des nombres à virgule flottante

Qt implémente deux fonctions, vous pouvez peut-être en tirer des leçons:

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)));
}

Et vous pourriez avoir besoin des fonctions suivantes, puisque

Notez que la comparaison des valeurs où p1 ou p2 est 0.0 ne fonctionnera pas, pas plus que la comparaison des valeurs où l'une des valeurs est NaN ou l'infini. Si l'une des valeurs est toujours 0,0, utilisez plutôt qFuzzyIsNull. Si l'une des valeurs est probablement 0,0, une solution consiste à ajouter 1,0 aux deux valeurs.

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

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

La comparaison à usage général des nombres à virgule flottante n'a généralement aucun sens. Comment comparer dépend vraiment d'un problème à portée de main. Dans de nombreux problèmes, les nombres sont suffisamment discrétisés pour permettre de les comparer à l'intérieur d'une tolérance donnée. Malheureusement, il y a autant de problèmes, où une telle astuce ne fonctionne pas vraiment. Par exemple, envisagez de travailler avec une fonction Heaviside (étape) d'un nombre en question (les options sur actions numériques viennent à l'esprit) lorsque vos observations sont très proches de la barrière. Effectuer une comparaison basée sur la tolérance ne serait pas très utile, car cela déplacerait efficacement le problème de la barrière d'origine à deux nouvelles. Encore une fois, il n'y a pas de solution générale à de tels problèmes et la solution particulière pourrait nécessiter d'aller jusqu'à changer la méthode numérique afin d'atteindre la stabilité.

Malheureusement, même votre code "inutile" est incorrect. EPSILON est la plus petite valeur qui pourrait être ajoutée à 1.0 et changer sa valeur. La valeur 1.0 est très importante - les nombres plus importants ne changent pas lorsqu'ils sont ajoutés à EPSILON. Maintenant, vous pouvez adapter cette valeur aux nombres que vous comparez pour savoir s'ils sont différents ou non. L'expression correcte pour comparer deux doubles est:

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

C'est au minimum. En général, cependant, vous voudriez tenir compte du bruit dans vos calculs et ignorer quelques-uns des bits les moins significatifs, donc une comparaison plus réaliste ressemblerait à:

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

Si les performances de comparaison sont très importantes pour vous et que vous connaissez la plage de vos valeurs, vous devez plutôt utiliser des nombres à virgule fixe.

Ma classe basée sur les réponses précédemment publiées. Très similaire au code de Google mais j'utilise un biais qui pousse toutes les valeurs NaN au-dessus de 0xFF000000. Cela permet une vérification plus rapide de NaN.

Ce code est destiné à démontrer le concept, et non à être une solution générale. Le code de Google montre déjà comment calculer toutes les valeurs spécifiques à la plate-forme et je ne voulais pas dupliquer tout cela. J'ai fait des tests limités sur ce code.

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 );
                  }
};

Voici la preuve que l'utilisation std::numeric_limits::epsilon() n'est pas la réponse - elle échoue pour les valeurs supérieures à un:

Preuve de mon commentaire ci-dessus:

#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);
}

L'exécution donne cette sortie:

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

Notez que dans le second cas (un et juste supérieur à un), les deux valeurs d'entrée sont aussi proches que possible, et comparent toujours comme non proches. Ainsi, pour des valeurs supérieures à 1,0, vous pourriez tout aussi bien utiliser un test d'égalité. Les epsilons fixes ne vous sauveront pas lors de la comparaison de valeurs à virgule flottante.

Trouvé une autre implémentation intéressante sur: 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";
}

Je me méfierais beaucoup de ces réponses qui impliquent une soustraction à virgule flottante (par exemple, fabs (ab) <epsilon). Premièrement, les nombres à virgule flottante deviennent plus clairsemés à de plus grandes amplitudes et à des amplitudes suffisamment élevées où l'espacement est supérieur à epsilon, vous pourriez tout aussi bien faire a == b. Deuxièmement, la soustraction de deux nombres à virgule flottante très proches (comme ceux-ci auront tendance à l'être, étant donné que vous recherchez une quasi-égalité) est exactement la façon dont vous obtenez une annulation catastrophique .

Bien que non portable, je pense que la réponse de grom fait le meilleur travail pour éviter ces problèmes.

Il existe en fait des cas dans les logiciels numériques où vous voulez vérifier si deux nombres à virgule flottante sont exactement égaux. J'ai posté ceci sur une question similaire

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

Vous ne pouvez donc pas dire que "CompareDoubles1" est faux en général.

Cela dépend de la précision de la comparaison. Si vous souhaitez comparer exactement le même nombre, choisissez simplement ==. (Vous ne voulez presque jamais faire cela à moins que vous ne vouliez réellement exactement le même nombre.) Sur n'importe quelle plate-forme décente, vous pouvez également faire ce qui suit:

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

comme a fabstendance à être assez rapide. Par assez rapide, je veux dire que c'est essentiellement un bit ET, donc il vaut mieux être rapide.

Et les astuces entières pour comparer les doubles et les flottants sont agréables mais tendent à rendre plus difficile la gestion efficace des différents pipelines CPU. Et ce n'est certainement pas plus rapide sur certaines architectures en ordre de nos jours en raison de l'utilisation de la pile comme zone de stockage temporaire pour les valeurs fréquemment utilisées. (Load-hit-store pour ceux qui s'en soucient.)

En termes d'échelle de quantités:

Si epsilonest la petite fraction de la grandeur de la quantité (ie valeur relative) dans une certain sens physique et Aet Btypes est comparable dans le même sens, que je pense que ce qui suit est tout à fait correct:

#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;
}

J'utilise ce code:

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

J'écris ceci pour Java, mais peut-être que vous le trouvez utile. Il utilise des longs au lieu de doubles, mais prend en charge les NaN, les sous-normales, etc.

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; }

Gardez à l'esprit qu'après un certain nombre d'opérations en virgule flottante, le nombre peut être très différent de ce que nous attendons. Il n'y a pas de code pour résoudre ce problème.

Que dis-tu de ça?

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

J'ai vu différentes approches - mais je n'ai jamais vu cela, donc je suis curieux d'entendre des commentaires aussi!

/// 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;
}

J'ai utilisé cette fonction pour mon petit projet et cela fonctionne, mais notez ce qui suit:

Une erreur de double précision peut vous surprendre. Disons que epsilon = 1.0e-6, alors 1.0 et 1.000001 ne doivent PAS être considérés comme égaux selon le code ci-dessus, mais sur ma machine, la fonction les considère comme égaux, c'est parce que 1.000001 ne peut pas être précisément traduit en format binaire, il s'agit probablement de 1.0000009xxx. Je le teste avec 1.0 et 1.0000011 et cette fois j'obtiens le résultat attendu.

Voici une autre solution avec lambda:

#include <cmath>
#include <limits>

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

Ma manière n'est peut-être pas correcte mais utile

Convertissez les deux flottants en chaînes, puis comparez les chaînes

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;

}

la superposition d'opérateurs peut également être effectuée

Vous ne pouvez pas comparer deux doubleavec un fixe EPSILON. Selon la valeur de double, EPSILONvarie.

Une meilleure double comparaison serait:

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;
}

De manière plus générique:

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

Pourquoi ne pas effectuer XOR au niveau du bit? Deux nombres à virgule flottante sont égaux si leurs bits correspondants sont égaux. Je pense que la décision de placer les bits d'exposant avant la mantisse a été prise pour accélérer la comparaison de deux flotteurs. Je pense que de nombreuses réponses ici manquent le point de comparaison epsilon. La valeur d'Epsilon dépend uniquement de la précision avec laquelle les nombres à virgule flottante sont comparés. Par exemple, après avoir fait de l'arithmétique avec des flottants, vous obtenez deux nombres: 2,5642943554342 et 2,5642943554345. Ils ne sont pas égaux, mais pour la solution, seuls 3 chiffres décimaux comptent donc ils sont égaux: 2,564 et 2,564. Dans ce cas, vous choisissez epsilon égal à 0,001. La comparaison d'Epsilon est également possible avec XOR au niveau du bit. Corrigez-moi si je me trompe.