float/double Gleichstellung mit genau null

Habe ich einen Algorithmus, der verwendet floats oder doubles um einige Berechnungen auszuführen.

Beispiel:

double a;
double b;
double c;
...
double result = c / (b - a);
if ((result > 0) && (result < small_number))
{
    //result is relevant...
} else {
    //result not required...
}

Nun, ich bin besorgt über (b - a) auch null sein kann. Wenn es ist nahe null, aber nicht gleich null ist, es spielt keine Rolle, weil die result werden außerhalb der Reichweite ist, um nützlich zu sein, und ich auch schon feststellen, dass (wie (b - a) null nähert, result Ansatz +/- inf, die nicht in den Bereich 0-small_number...)

Aber wenn das Ergebnis (b - a) genau null, ich erwarte, dass etwas Plattform abhängig wird passieren, wegen Division durch null. Ändern könnte ich die if Anweisung:

if ((!((b-a) == 0.0)) && ((result = c/(b-a)) > 0) && (result < small_number)) {

aber ich weiß nicht, ob (b-a) == 0.0 wird immer erkennen, dass Gleichheit mit null. Ich habe gesehen, es gibt mehrere Darstellungen für exakte null-floating-point? Wie können Sie testen für Sie alle, ohne dabei einige epsilon überprüfen, die ich nicht brauchen (ein kleines epsilon ignoriert werden in meinem Algorithmus)?

Was ist die Plattform-unabhängige Art und Weise zu überprüfen?

EDIT:

Nicht sicher, ob es war deutlich genug zu den Menschen. Im Grunde möchte ich wissen, wie zu finden, wenn ein Ausdruck wie:

double result = numerator / denominator;

Ergebnis wird in eine Fließkomma-Ausnahme, eine cpu-exception, ein signal vom Betriebssystem oder etwas anderes.... ohne tatsächlich die Durchführung der Betriebs-und sehen, ob es "werfen"..., weil das erkennen einer "throw" dieser Art scheint zu sein, kompliziert und Plattform-spezifische.

Ist ( (denominator==0.0) || (denominator==-0.0) ) ? "Will 'throw'" : "Won't 'throw'"; genug?

  • Auch wenn b - a ist nicht genau null ist, wird der Betrieb c / (b - a) könnte noch überlaufen und senden Sie den Wert auf +/-INF.
  • Das ist in Ordnung, man sollte das Ergebnis außerhalb des Bereichs von Interesse für mein problem.
  • Es ist schwer zu finden, eine Umsetzung, die nicht IEEE-floating-point. Also ich denke, es ist sicher anzunehmen, dass die division durch 0 einfach Ertrag +INF oder -INF? Jemand korrigiert mich wenn ich falsch bin?
  • Hängt davon ab, was der Zähler ist. Offenbar 0.0 / 0.0 ist "NaN", und löst eine andere FP Ausnahme bei Ausnahmen aktiviert sind.
  • Ah, guter Punkt. Ich glaube nicht, dass - vor allem die 0.0 / 0.0 Fall.
  • BTW, Mystische teilweise richtig ist. gcc wird einfach ein segmentation fault, das ist (glaube ich) eine un-abfangbare Ausnahme. Auf jeden Fall eine Division durch null darf nie eine Ausnahme gefangen. Ich denke, das ist eine gute Frage und meiner Meinung nach, jede person schriftlich eine division operator sollten Sie immer prüfen, für null unabhängig von der code
  • Versuchen Neuordnung der Zustand so, dass Sie die Division durch small_number statt b-a.

InformationsquelleAutor Bingo | 2012-03-03
  1. 9

    Es hängt davon ab, wie b und a haben Ihre Werte. Zero ist eine exakte Darstellung in floating-point-format, aber das größere problem würde sein, die fast-aber-nicht-ganz-null-Werte. Es würde immer sicher sein, zu überprüfen:

    if (abs(b-a) > 0.00000001  && ...

    Wo 0.00000001 ist was Wert Sinn macht.

    • Warum genau würde eine fast-aber-nicht-ganz-null-Nummer werden, ein problem? Mein Algorithmus schon ablehnt Ergebnisse aus einem fast-aber-nicht-ganz-null-Nenner...
    • Ich sehe nicht, Ihren Algorithmus Ablehnung b - a mit einem Wert von 1e-300. So ein test kostet wenig und ist ideal Versicherung für den Widerstand gegen morphing code, auch wenn eine version davon produzieren kann, dass Wert.
    • der Punkt ist, dass alles, was geteilt durch fast null ist groß... sich außerhalb der Reichweite der 0 zu small_number das ist der Bereich, in dem ich interessiert bin.
    • Sollte das nicht sein fabs statt abs?
    • wenn Sie die Funktion verwenden möchten, die version, das wäre okay. Jedoch, es ist die makro - /template-version abs() die funktioniert mit alle skalaren Typen.
    • Diese Antwort hat mir geholfen bei meiner Suche. War zweifelhaft, über abs-gegen fabs und im gcc, abs funktioniert auf alle skalaren Typen (getestet habe ich es auf qreal und glFloat als gut.) Meine zwei Cent sind inlining der test mit einer ternären (solange du Da bist die Betreuer oder Sie kommentieren viel) double result = c / ((abs((b - a)) > 0.00000001f) ? (b - a) : 0.00000001f) ; diesem Ausdruck ist, aber hässlich wie die Sünde.

    InformationsquelleAutor wallyk
  2. 4

    Hier ist, wie Sie es tun: statt Kontrolle für (result < small_number) überprüfen Sie für

    (abs(c) < abs(b - a) * small_number)

    Dann werden alle Ihre sorgen verschwinden! Die Berechnung der c/(b-a) wird nie überlaufen, wenn dieser test bestanden ist.

    InformationsquelleAutor TonyK
  3. 2

    Ich denke, dass Sie Sie verwenden können,fpclassify(-0.0) == FP_ZERO . Dies ist aber nur sinnvoll, wenn Sie prüfen wollen, wenn jemand hat eine Art von null-in-float-type-variable. Wie viele schon sagten, wenn Sie wollen, um zu überprüfen, Ergebnis der Berechnung erhalten Sie möglicherweise die Werte sehr nahe bei null aufgrund der Art der Darstellung.

    • Kommentieren Sie bitte einen Grund für downvoting. Ich verspreche, dass ist nur zum Verständnis, mein Fehler.
    InformationsquelleAutor ony
  4. 1

    In Kürze, können wir wissen, eine floating-Zahl ist NULL genau dann, wenn wir es kennen, darstellen-format.

    In der Praxis, vergleichen wir x mit einer kleinen Anzahl. Und wenn x weniger als diese Zahl, wir denken x ist die gleiche wie NULL-funktional (aber die meisten der Zeit unsere kleinen Zahl ist immer noch größer als null). Diese Methode ist sehr einfach, effizient und können auf cross-Plattform.

    Eigentlich, die float und double wurden präsentiert von special-format, und die weit verbreitet ist IEEE 754 in aktuelle hardware, die geteilt die Zahl in Vorzeichen, exponent und Mantisse (Mantisse) bits.

    So, wenn wir wollen, um zu überprüfen, ob eine float-Zahl ist NULL genau, können wir überprüfen, ob die beiden Exponenten und die Mantisse NULL ist, siehe hier.

    In IEEE 754 binary floating-point-zahlen, null-Werte sind dargestellt
    durch den exponent und Mantisse als null. Negativ null
    hat das Vorzeichen-bit auf eins gesetzt.

    Nehmen float können wir zum Beispiel schreiben Sie einen einfachen code zu extrahieren, exponent und Mantisse bit und dann überprüfen Sie es.

    #include <stdio.h>   

typedef union {
          float f;
          struct {
              unsigned int mantissa : 23;
              unsigned int exponent : 8;
              unsigned int sign :     1;
          } parts;
} float_cast;


int isZero(float num) {

    int flag = 0;
    float_cast data;
    data.f = num;

    //Check both exponent and mantissa parts
    if(data.parts.exponent == 0u && data.parts.mantissa == 0u) {
       flag = 1;
    } else {
       flag = 0;
   }

   return(flag);
}


int main() {

   float num1 = 0.f, num2 = -0.f, num3 = 1.2f;

   printf("\n is zero of %f -> %d", num1, isZero(num1));
   printf("\n is zero of %f -> %d", num2, isZero(num2));
   printf("\n is zero of %f -> %d", num3, isZero(num3));

   return(0);
}

    Test-Ergebnisse:

    # ist null 0.000000 -> 1

    # ist null -0.000000 -> 1

    # ist null 1.200000 -> 0

    Weitere Beispiele:

    Lassen Sie uns überprüfen, wenn die float wird echt NULL mit code. 

    void test() {
     int i =0;
     float e = 1.f, small = 1.f;
     for(i = 0; i < 40; i++) {
         e *= 10.f;
         small = 1.f/e;
         printf("\nis %e zero? : %d", small, isZero(small));
     }
     return;
}


is 1.0000e-01 zero? : NO
is 1.0000e-02 zero? : NO
is 1.0000e-03 zero? : NO
is 1.0000e-04 zero? : NO
is 1.0000e-05 zero? : NO
is 1.0000e-06 zero? : NO
is 1.0000e-07 zero? : NO
is 1.0000e-08 zero? : NO
is 1.0000e-09 zero? : NO
is 1.0000e-10 zero? : NO
is 1.0000e-11 zero? : NO
is 1.0000e-12 zero? : NO
is 1.0000e-13 zero? : NO
is 1.0000e-14 zero? : NO
is 1.0000e-15 zero? : NO
is 1.0000e-16 zero? : NO
is 1.0000e-17 zero? : NO
is 1.0000e-18 zero? : NO
is 1.0000e-19 zero? : NO
is 1.0000e-20 zero? : NO
is 1.0000e-21 zero? : NO
is 1.0000e-22 zero? : NO
is 1.0000e-23 zero? : NO
is 1.0000e-24 zero? : NO
is 1.0000e-25 zero? : NO
is 1.0000e-26 zero? : NO
is 1.0000e-27 zero? : NO
is 1.0000e-28 zero? : NO
is 1.0000e-29 zero? : NO
is 1.0000e-30 zero? : NO
is 1.0000e-31 zero? : NO
is 1.0000e-32 zero? : NO
is 1.0000e-33 zero? : NO
is 1.0000e-34 zero? : NO
is 1.0000e-35 zero? : NO
is 1.0000e-36 zero? : NO
is 1.0000e-37 zero? : NO
is 1.0000e-38 zero? : NO
is 0.0000e+00 zero? : YES   <-- 1e-39
is 0.0000e+00 zero? : YES   <-- 1e-40
    InformationsquelleAutor Patric
  5. 0

    Ich glaube, dass (b-a)==0 wahr sein wird, genau in den Fällen, wenn die c/(b-a) würde scheitern, weil der (b-a) null ist. Die float-Mathematik ist schwierig, aber hinterfragen, das ist übertrieben meiner Meinung nach. Auch ich glaube, dass die (b-a)==0 wird entspricht b!=a.

    Unterscheidung von positiven und negativen 0 ist auch nicht notwendig. Siehe z.B. hier Nicht-Schwimmer haben eine negative null? (-0f)

    • In Bezug auf "die Reihenfolge der Auswertung der Teilausdrücke in Ihrem Zustand ist nicht definiert, die in c++", in e1 && e2, die Reihenfolge der Auswertung ist definiert. e2 wird immer ausgewertet, nach e1 und nur, wenn e1 zu true ausgewertet/ungleich null.
    • Du hast Recht! stackoverflow.com/questions/7112282/... will ich löschen, dass ein Teil. Rest der Antwort überlasse ich zwar die Löschung war der Grund, warum ich beschlossen, zu Antworten...
    • Die Aufteilung mit Gleitkomma-null ist auch definiert, wenn der compiler folgt IEEE-standards. Lesen Sie mehr auf DAMIT oder Lesen Sie der IEEE floating point standard!
    InformationsquelleAutor David L.
  6. 0

    Für epsilon, in der es eine standard-template-definition std::numeric_limits::epsilon(). Ich denke, die überprüfung der Unterschied größer als der std::numeric_limits::epsilon() sollte sicher genug, um Schutz gegen division durch null. Keine Plattform-Abhängigkeit hier, denke ich.

    • Diese Antwort ist Unsinn. std::numeric_limits::epsilon() ist nicht beabsichtigt, für diese Nutzung, es misst den ULP nur über 1.0. Und bei der Division durch x division durch null tritt nur auf, wenn x == 0 (überlauf kann auftreten, aber das wurde bereits hingewiesen).
    • Richtig, es ist nicht eine Antwort auf das ursprüngliche problem, nur eine Bemerkung in Bezug auf epsilon. Ich sollte haben legen Sie es als einen Kommentar, aber viele der vorherigen posts nach diesem. Aber Ihre Bemerkung ist richtig. Mehr zu diesem [en.cppreference.com/w/cpp/types/numeric_limits/epsilon]
    InformationsquelleAutor mcjoan
  7. 0

    UPDATE (2016-01-04)

    Ich habe einige downvotes auf diese Antwort, und ich fragte mich, ob ich sollte Sie einfach löschen. So scheint es der Konsens (https://meta.stackexchange.com/questions/146403/should-i-delete-my-answers) ist, dass das löschen von Antworten ist nur in extremen Fällen.

    So, meine Antwort ist falsch. Aber ich denke, ich lasse es, weil es sorgt für eine interessante "think out of the box" eine Art Gedankenexperiment.

    ===============

    Bingo,

    Sagen Sie, Sie wollen wissen, wenn b-a == 0.

    Andere Art der Betrachtung dieser ist zu ermitteln, ob a == b ist. Wenn a gleich b, dann ist b-a ist gleich 0.

    Andere interessante Idee die ich gefunden habe:

    http://www.cygnus-software.com/papers/comparingfloats/Comparing%20floating%20point%20numbers.htm

    Im wesentlichen, Sie nehmen die floating-point-Variablen, die Sie haben und sagen Sie dem compiler zu interpretieren Sie neu (bit für bit) Ganzzahlen mit Vorzeichen, wie im folgenden:

    if (*(int*)&b == *(int*)&a)

    Dann vergleichen Sie die zahlen, und nicht schwimmende Punkte. Vielleicht hilft? Vielleicht auch nicht. Viel Glück!

    • Ich würde upvote dies, wenn es nicht für den eher hässlichen casting-Sache. if (a!=b) { /* do the math */ } ist gut genug für diesen Fall; alles andere ist overkill.
    • Danke für deine Antwort. Der Gleichheits-Idee ist es Wert, darüber nachzudenken. Wäre nett für eine Allgemeine Lösung, wenn der Nenner nicht das Ergebnis einer Subtraktion obwohl. Außerdem finde ich den Vergleich bitweise (das ist die integer-Ansatz) ist das problem hier. Unterschiedliche Darstellungen von null verschiedene bit-Muster sowieso.
    • Nicht nur *(int*)&b == *(int*)&a breaks strict-aliasing-Regeln, aber es macht +0. anders erscheinen -0.. Ich sehe keinen Punkt, um mit diesem Vergleich hier.
    • Noch schlimmer ist, auf fast allen Plattformen, int ist 32 bit und double 64, man ist also nur der Vergleich der hoch oder niedrig (je nach Plattform) 32 bits für die Gleichstellung, die ist nutzlos. (Plus, würde es den Vergleich von zwei NaN als gleich, wenn Sie geschehen, um die gleichen bits gesetzt, und ungleich, wenn Sie nicht, das ist definitiv nicht sinnvoll...)
    InformationsquelleAutor Aaron Johnson
  8. -1

    Könnten Sie versuchen,

    if ((b-a)!=(a-b) && ((result = c/(b-a)) > 0) && (result < small_number))) {
...
    • Nicht genau sicher, aber sind Sie sicher, dass (b-a) und (a-b) würde produzieren die gleiche version von zero in floating point?
    InformationsquelleAutor Mark
Schreibe einen Kommentar