Quand utiliser DBL_EPSILON/epsilon

Question

DBL_EPSILON/std :: numeric_limits :: epsilon me donnera la plus petite valeur qui fera la différence lors de l'ajout d'un seul.

J'ai de la difficulté à comprendre comment appliquer ces connaissances à quelque chose d'utile.

L'epsilon est beaucoup plus grand que la plus petite valeur que l'ordinateur peut gérer, donc il semblerait comme une supposition correcte qu'il est sûr d'utiliser des valeurs plus petites que epsilon?

Le rapport entre les valeurs avec lesquelles je travaille doit-il être inférieur à 1/epsilon?

Answer 1

La définition de DBL_EPSILON n'est pas cela. C'est la différence entre le nombre représentable suivant après 1 et 1 (votre définition suppose que le mode d'arrondi est réglé sur "vers 0" ou "vers moins l'infini", ce n'est pas toujours vrai).

C'est quelque chose d'utile si vous en savez assez sur l'analyse numérique. Mais je crains que cet endroit ne soit pas le meilleur pour en apprendre davantage à ce sujet. À titre d'exemple, vous pouvez l'utiliser dans la construction d'une fonction de comparaison qui dira si deux nombres à virgule flottante sont approximativement égales comme celui-ci

bool approximatively_equal(double x, double y, int ulp) 
{ 
    return fabs(x-y) <= ulp*DBL_EPSILON*max(fabs(x), fabs(y)); 
} 

(mais sans savoir comment déterminer ULP, vous serez perdu, et ce fonction a probablement des problèmes si les résultats intermédiaires sont dénormalisés; calcul fp est compliqué à fabriquer robuste)

Answer 2

la différence entre X et la valeur suivante de XX varie en fonction.
DBL_EPSILON est seulement la différence entre 1 et la valeur suivante de 1.

Vous pouvez utiliser std::nextafter pour tester deux double avec une différence de epsilon:

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

Si vous souhaitez tester deux double avec une différence de facteur * epsilon, vous pouvez utiliser:

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