epsilon für verschiedene float-Werte

Es ist FLT_MIN Konstante nahe null ist. Wie man am nächsten some number Wert?

Als Beispiel:

float nearest_to_1000 = 1000.0f + epsilon;
//epsilon must be the smallest value satisfying condition:
//nearest_to_1000 > 1000.0f

Ich würde es vorziehen, numerische Formel ohne Verwendung von speziellen Funktionen.

  • In IEEE754, interpretieren die float als uint32_t, erhöhen um eins und interpretieren zurück (modulo-endian).
  • Das sollte eine Antwort sein.
  • Siehe auch diese Frage.
  • Durch die Art und Weise, FLT_MIN ist nicht der Schwimmer nächste null. Es ist die kleinste normale Schwimmer. Die denormals kleiner sind. Mit dem IEEE-754, FLT_EPSILON * FLT_MIN ist die kleinste positive float.
InformationsquelleAutor brigadir | 2012-08-09
  1. 2

    Vorsicht: Fehler wurden gefunden, die in diesem code während der Arbeit auf eine andere Antwort. Ich hoffe die aktualisieren das später. In der Zwischenzeit, schlägt es für einige Werte mit subnormals.

    C eine Funktion dafür, in der <math.h> header. nextafterf(x, INFINITY) der nächsten darstellbaren Wert nach x, in die Richtung, in INFINITY.

    Jedoch, wenn Sie es vorziehen, es selbst zu tun:

    Folgenden gibt epsilon, die Sie suchen, für single precision (float), vorausgesetzt, IEEE 754.

    #include <float.h>
#include <math.h>


/*  Return the ULP of q.

    This was inspired by Algorithm 3.5 in Siegfried M. Rump, Takeshi Ogita, and
    Shin'ichi Oishi, "Accurate Floating-Point Summation", _Technical Report
    05.12_, Faculty for Information and Communication Sciences, Hamburg
    University of Technology, November 13, 2005.
*/
float ULP(float q)
{
    //SmallestPositive is the smallest positive floating-point number.
    static const float SmallestPositive = FLT_EPSILON * FLT_MIN;

    /*  Scale is .75 ULP, so multiplying it by any significand in [1, 2) yields
        something in [.75 ULP, 1.5 ULP) (even with rounding).
    */
    static const float Scale = 0.75 * FLT_EPSILON;

    q = fabs(q);

    return fmax(SmallestPositive, q - (q - q * Scale));
}

    Folgende gibt den nächsten darstellbaren Wert in float nach dem Wert, den es übergeben wird (Behandlung von -0 und +0, wie die gleichen).

    #include <float.h>
#include <math.h>


/*  Return the next floating-point value after the finite value q.

    This was inspired by Algorithm 3.5 in Siegfried M. Rump, Takeshi Ogita, and
    Shin'ichi Oishi, "Accurate Floating-Point Summation", _Technical Report
    05.12_, Faculty for Information and Communication Sciences, Hamburg
    University of Technology, November 13, 2005.
*/
float NextAfter(float q)
{
    //SmallestPositive is the smallest positive floating-point number.
    static const float SmallestPositive = FLT_EPSILON * FLT_MIN;

    /*  Scale is .625 ULP, so multiplying it by any significand in [1, 2)
        yields something in [.625 ULP, 1.25 ULP].
    */
    static const float Scale = 0.625 * FLT_EPSILON;

    return q + fmax(SmallestPositive, fabs(q)*Scale);
}
    • Was ist der Sinn von 0.75 und 0.625 ?
    • Die Mantisse von q hat einen Wert zwischen 1 und 2 (ohne 2). Wenn die Mantisse waren genau 1, dann qFLT_EPSILON wäre genau eine ULP - (der Wert der am wenigsten bedeutende bit in der Mantisse von q, gegeben den Exponenten), sodass q+qFLT_EPSILON wäre genau die nächsten darstellbaren Wert. Jedoch nehmen wir an, die Mantisse ist näher an 2. Dann fFLT_EPSILON ist fast 2 ULP, und q+qFLT_EPSILON ist sehr in der Nähe der zweiten nächsten darstellbaren Wert, anstelle der nächsten, und Rundung machen würde, das endgültige Ergebnis, dass die zweite nächste Wert. Aber...
    • q*.625*FLT_EPSILON liegt zwischen .625 ULP (wenn q die Mantisse ist in der Nähe von 1) und 1,25 ULP (wenn q die Mantisse ist in der Nähe 2). Also q+q*.625*FLT_EPSILON immer näher an den nächsten darstellbaren Wert (q + 1 ULP), als es ist q oder q + 2 ULP. So Runden lässt das Ergebnis genau q + 1 ULP, das ist, was wir wollen.
    • Ein weiterer Subtilität ist, wenn q negativ ist, und genau eine Potenz von 2 ist. Dann den nächsten darstellbaren Zahl, in Richtung des unendlichen, nicht die normalen q + 1 ULP ist aber q + 1/2 ULP, weil die nächste Darstellbare Zahl hat einen niedrigeren Exponenten, so dass die bits in deren Mantisse die Hälfte des Wertes, den Sie tun, im Vergleich zu den gleichen bits in q ist die Mantisse. In diesem Fall, fabs(q)*.625*FLT_EPSILON ist .625 ULP, also q + fabs(q)*.625*FLT_EPSILON ist in der Nähe von q + 1/2 ULP, welches eine Darstellbare Zahl ist und die Zahl, die wir wollen.
    • Die .75 in die erste routine ist, da die routine nur dann zurückgeben muss die ULP; Sie nicht brauchen, um deal mit der stepping-zwischen-Mächte-von-zwei-Problem mit der negativen q. So seine Palette von .75 bis 1,5 ist in Ordnung. Aber das wären Runde falsch, für NextAfter routine, da q+fabs(q)*.75*FLT_EPSILON ist q + .75 ULP, das ist gleich in der Nähe der zwei darstellbaren zahlen q + .5 ULP und q + 1 ULP, und die IEEE-754 Rundungsregeln pick-q + 1 ULP (weil die low-bit auch). So NextAfter verwendet .625, um sicherzustellen q + .5 ULP näher ist.
    • Werfen Sie einen Blick auf mein edit in deine Antwort. Die header-Sie haben versucht, die Namen nicht angezeigt werden, da galt es als ein HTML-tag und gezupft.
    • Sieht gut aus, danke.

    InformationsquelleAutor Eric Postpischil
Schreibe einen Kommentar