floats auf Null prüfen (C++)

[SnuffMaster23]

Ich denke mal das ist ein eher verbreitetes Problem, eine Gleitkommazahl auf Null zu prüfen. Allerdings gibt es ja nicht >die< Null wie bei Integers also gestaltet sich das etwas schwieriger.
Mit x == 0.0 gehts jedenfalls nicht, und die Null als doch recht kleines Intervall (z.B. [-0.000001|0.000001]) zu interpretieren ist auch nicht sonderlich sinnvoll :D
Wie stell ich das an, außer etwas damit zu berechnen (1.0/x oder so) und zu gucken ob -1.#IND rauskommt? Eventuell Kann man das Ergebnis mit 1.0 ja noch darstellen, mit 100.0 aber nicht mehr. Exceptions werden nicht geworfen und ich möchte sie eigentlich auch vermeiden, es geht doch ein bisschen um Performance^^
cout gibt mir diese Nullen als '0' und nicht 1.0e-308 oder so, also muss es ja eine Möglichkeit geben.

[busybyte]

RoundTo Routine

Rounds a floating-point value to a specified digit or power of ten using "Banker's rounding".

Unit
Math

Syntax


[Delphi] function RoundTo(const AValue: Double; const ADigit: TRoundToRange): Double;


Description
Call RoundTo to round AValue to a specified power of ten.

AValue is the value to round.

ADigit indicates the power of ten to which you want AValue rounded. It can be any value from –37 to 37 (inclusive).

RoundTo uses "Banker's Rounding" to determine how to round values that are exactly midway between the two values that have the desired number of significant digits. This method rounds to an even number in the case that AValue is not nearer to either value.

The following examples illustrate the use of RoundTo:
Expression Value
RoundTo(1234567, 3)
1234000

RoundTo(1.234, -2)
1.23

RoundTo(1.235, -2)
1.24

RoundTo(1.245, -2)
1.24










SimpleRoundTo Routine

Rounds a floating-point value to a specified digit or power of ten using asymmetric arithmetic rounding.

Unit
Math

Syntax


[Delphi] function SimpleRoundTo(const AValue: Double; const ADigit: TRoundToRange): Double;


Description
Call SimpleRoundTo to round AValue to a specified power of ten.

AValue is the value to round.

ADigit indicates the power of ten to which you want AValue rounded. It can be any value from –37 to 37 (inclusive).

SimpleRoundTo uses asymmetric arithmetic rounding to determine how to round values that are exactly midway between the two values that have the desired number of significant digits. This method always rounds to the larger value.

The following examples illustrate the use of SimpleRoundTo:
Expression Value
SimpleRoundTo(1234567, 3)
1234000

SimpleRoundTo(1.234, -2)
1.23

SimpleRoundTo(1.235, -2)
1.24

SimpleRoundTo(-1.235, -2)
-1.23


Related Information
Math.RoundTo

[Muetze1]

@busybyte: Und was nützen einem diese Delphi Funktionen in C++?

Wenn er den C++Builder nutzen würde, dann könnte er direkt die Funktion SameValue() nutzen. Diese wäre in diesem Falle selbst bei Delphi deutlich passender und besser geeignet. Somit: er hätte bestimmt nicht gefragt, wenn es der C++Builder wäre bzw. ein Studio...

[busybyte]

@Muetze1
ok wenn er das für c++ haben will,dann ist wohl ein c++ Forum erfolgversprechender.
:wiejetzt: andere Baustelle

wenn er genau 0 haben will kann er auch IsZero verwenden,wollte es halt flexibel halten.

[JasonDX]

Ich glaube, auf Intervall prüfen ist die beste Möglichkeit - was anderes außer die Stellen, die durch Konvertierungsfehler ungenau werden könnten, zu ignorieren gibts in meinen Augen nicht. ;)
Ein

Code:

(abs(x) < e)

dürfte dabei auch performant eine akzeptable Lösung sein.

[Edit]Man darf hier auch gerne C-Fragen stellen. Schließlich ist eine entsprechende Personality auch im BDS enthalten ;)
@busbyte: Du kannst auch gerne einfach eine Hilfe-Referenz angeben, statt den gesamten Inhalt zu kopieren ;)

greetz
Mike

[SnuffMaster23]

@busybyte: Damit hätte ich ja eine Null die von -0.5 bis 0.5 geht, das ist doch ein bisschen groß :D
Runden kann ich schon :D

Und ob es jetz um C++ oder um Delphi geht ist doch egal, das Problem hat man in jeder Sprache wo man floats benutzen kann.

@JasonDX: Jo dann werd ich das so machen, nur den Funktionssprung von abs kann ich mir noch sparen. Entweder (x<e || x>-e) oder ((x&0x7FFFFFFF)<e). Bleibt nur die Frage welches da jetzt schneller ist :D
Auf Delphi, zum nachvollziehen: ((x<e) or (x<-e)) und ((x and $7FFFFFFF) < e)

[busybyte]

@snuffmaster dann schreib es doch in Hebräisch oder Russisch bzw. assembler wenn dir die sprache egal ist und
Gratulation das Du schon runden kannst, suchen scheint ja nicht Deine Stärke zu sein.
Off

[Daniel]

Hey busybyte,

Zitat:

Zitat von busybyte

@snuffmaster dann schreib es doch in Hebräisch oder Russisch bzw. assembler wenn dir die sprache egal ist und
Gratulation das Du schon runden kannst, suchen scheint ja nicht Deine Stärke zu sein.
Off

ich bitte um einen gemäßigteren Tonfall. Das Vergleichen von Fließkommazahlen ist tatsächlich ein grundsätzliches Problem, das prinzipbedingt sprach-übergreifend existiert. Und die gängigen Lösungsansätze sind in der Tat bei allen Sprachen vergleichbar.

[DMW]

Zitat:

Zitat von SnuffMaster23

Entweder (x<e || x>-e) oder ((x&0x7FFFFFFF)<e).

Letzteres ist mit C++ syntaktisch so nicht möglich, da für Gleitkommatypen keine Bitoperatoren exisiteren. Da Gleitkommazahlen aber genormt sind, braucht dich das nicht daran zu hindern, es trotzdem so zu machen:

Code:

inline bool isNull (float val, float e = 0.00001f)
{
    *reinterpret_cast <int*> (&val) &= 0x7FFFFFFF;
    return (val < e);
}
inline bool isNull (double val, double e = 0.000000001)
{
    *reinterpret_cast <long long*> (&val) &= 0x7FFFFFFFFFFFFFFFul;
    return (val < e);
}

Für vorzeichenbehaftete Integerwerte funktioniert deine Vergleichsmethode übrigens auch nicht, da diese anders dargestellt werden, als du annimmst; hier am Beispiel einer 1-Byte-Zahl:
http://img138.imageshack.us/img138/9...gnedintml7.gif
Aus diesem Grund ist ~0 (der unäre Operator ~ in C negiert den Parameter bitweise) gleichwertig mit -1, unabhängig davon, wie breit der Datentyp ist.

[Chemiker]

Hallo SnuffMaster23,

mit [C++]

Code:

bool IsZero (long double A, long double Epsilon);

kann man Prüfen ob die Gleitkommazahl den Wert Null oder beinahe Null hat.
Bis bald Chemiker

[shmia]

Man kann den Epsilonwert berechnen lassen.
Man nimmt die Zahl 1.0 und halbiert so lange, bis 1.0+Epsilon = 1.0 ergibt:

Delphi-Quellcode:

var
   Epsilon : Double;
procedure CalcMachineEpsilon;   // abgekupfert aus der JCL und vereinfacht
var
  One: Double;
  T: Double;
begin
  One := 1.0;
  Epsilon := One;  // vielleicht sollte man mit einem deutlich kleineren Wert beginnen
  repeat
    Epsilon := 0.5 * Epsilon;
    T := One + Epsilon;
  until One = T;
end;

[SnuffMaster23]

@DMW: Hm, das geht tatsächlich nicht so. Das war nur schnell in der Vorlesung hingeschrieben, ich hab irgendwie gedacht ein double wäre 32 Bits lang und der Compiler wirds schon machen^^
Das mit den ints is mir klar, ich kenn das Zweierkomplement (und die float-Normen, drum wollt ich das vorderste Bit wegmachen).

Soa, ich habs grad mal schnell ausprobiert, es macht keinen Unterschied^^

Code:

#include <iostream>
#include <conio.h>
#include <windows.h>

using namespace std;

#define e 0.00001
#define NUM 999999999

inline bool isNull (double val, double ep = 0.000000001)
{
    *reinterpret_cast <long long*> (&val) &= 0x7FFFFFFFFFFFFFFFull;
    return (val < ep);
}

int main()
{
  LARGE_INTEGER Freq,
                Start,
                End;
  int i;
  double Zero = 0.0;

  QueryPerformanceFrequency(&Freq);
  cout << "Plx auf Echtzeit schalten und Taster drücken...";
  getch();
  cout << endl;

  QueryPerformanceCounter(&Start);
  for (i=0; i<NUM; i++)
    (Zero<e || Zero>-e);
  QueryPerformanceCounter(&End);
  cout << "(x<e || x>-e): " << (Start.QuadPart / (double)End.QuadPart) << " Sek." << endl;

  QueryPerformanceCounter(&Start);
  for (i=0; i<NUM; i++)
    isNull(Zero, e);
  QueryPerformanceCounter(&End);
  cout << "isNull: " << (Start.QuadPart / (double)End.QuadPart) << " Sek." << endl;

  return 0;
}

Die Priorität des Prozesses hab ich auf Echtzeit geschaltet um Einflüsse vom Multitasking weitestgehend auszuschließen und es kommt immer bei beiden das gleiche raus.

Code:

Plx auf Echtzeit schalten und Taster dr³cken...
(x<e || x>-e): 0.999548 Sek.
isNull: 0.999548 Sek.

@Chemiker: Wo ist IsZero drin? Die hab ich nicht gefunden, auch nicht beim fix googeln.

Aber ich denk ich pack einfach die zwei Vergleiche in ne inline Funktion, die versteh ich später gleich wieder^^. Es macht ja eh keinen Unterschied.

MfG,
SnuffMaster23

[Muetze1]

Zitat:

Zitat von SnuffMaster23

@Chemiker: Wo ist IsZero drin? Die hab ich nicht gefunden, auch nicht beim fix googeln.

IsZero() wie auch SameValue() sind Funktionen die die VCL nur beim C++Builder bietet.

[busybyte]

Unit Math
bei Delphi for Win32

[Muetze1]

Zitat:

Zitat von busybyte

Unit Math
bei Delphi for Win32

Ja, wie gesagt, VCL Funktionalität. Somit auch #include <Math.hpp> im C++Builder, aber es soll nichts Borland spezifisches werden, das hatten wir doch nun schon geklärt...

[DMW]

Zitat:

Zitat von SnuffMaster23

Soa, ich habs grad mal schnell ausprobiert, es macht keinen Unterschied^^

Dein Testprogramm solltest du noch etwas modifizieren:

• im Optimalfall kann der Compiler beide Schleifen wegoptimieren, da er die Inline-Funktion erweitern darf und somit in beiden Fällen feststellen kann, daß keine Nebenwirkungen auftreten und das Ergebnis verworfen wird. Um die Ausführung der Schleife zu erzwingen, solltest du den Ausdruck an eine Dummyfunktion in einem anderen Modul übergeben, so daß der Compiler sie nicht wegoptimieren kann. Bei dir scheinen aber beide ausgeführt worden zu sein, weshalb ich vermute, daß du deine Tests im Debug Mode machst - das ist nicht empfehlenswert.
• Die Priorität des Prozesses kannst du auch mittels SetPriorityClass und GetCurrentProcess setzen.
• Vielleicht die Schleife ein klein wenig öfter durchlaufen lassen.
• Unter Umständen solltest du die Genauigkeit des Streamoperators mittels std::setprecision erhöhen.
• Weiterhin wäre vielleicht der generierte Assemblercode sowie die Optimierungsoptionen interessant (und natürlich der Compiler, den du verwendest). Es ist durchaus möglich, daß der Compiler bei beiden Versionen die gleiche Absicht erkennt und zum gleichen Resultat hinoptimiert.
• Haltepunkte im Release Mode zwecks Inspektion des generierten Codes kannst du in BCC und MSVC mit
  
  Code:

  asm int 3;

  einbauen.

Edit: siehe unten

[busybyte]

@#15
folglich Maschinensprache=Assembler =Rad neu erfinden,
jetzt bin ich aber wirklich raus aus diesem Thread

[Muetze1]

Zitat:

Zitat von busybyte

@#15
folglich Maschinensprache=Assembler =Rad neu erfinden,
jetzt bin ich aber wirklich raus aus diesem Thread

Irgendwie verstehe ich dich nicht. Es geht um die STL bzw. Standard C(++) Lösung, ohne Borland-spezifische Erweiterungen. Wie kommst du somit auf Assembler? Was ist dein Problem?

[DMW]

Ein paar Dinge muß ich noch ergänzen:

• Müßte das
  
  Zitat:

  Zitat von SnuffMaster23

  Code:

    cout << "(x<e || x>-e): " << (Start.QuadPart / (double)End.QuadPart) << " Sek." << endl;

  nicht viel eher so
  
  Code:

    cout << "(x<e || x>-e): " << ((End.QuadPart - Start.QuadPart) / (double)Freq.QuadPart) << " Sek." << endl;

  lauten?
• Es heißt _asm, nicht asm (das geht nur beim BCC).
• Zudem glaube ich nach einigen Tests nun, daß die Schleife eher ein paar Durchläufe weniger brauchen könnte :roll:
• Mit den genannten Änderungen bekomme ich auf meinem Rechner (XP SP2, Athlon XP 2400+) folgende Ergebnisse (im Bereich der Meßschwankungen gerundet):
  VC2008, Release Mode:
  (x<e || x>-e): 5.013 s
  isNull: 20.325 s
  
  BCB6, Release Mode:
  (x<e || x>-e): 7.768 s
  isNull: 22.384 s
  
  Bei genauerem Hinsehen ist das auch schlüssig, denn unsere Trickserei mit reinterpret_cast wird im Speicher ausgeführt, wohingegen beispielsweise der BCC im ersten Fall den FCHS-Opcode verwendet, um das Vorzeichen des Gleitkommawertes in einem Register zu verändern. Hinzu kommt, daß auf 32-Bit-Systemen das Schreiben von 64-Bit-Werten in den Speicher länger dauert - und das ist bei unserem Trick nur verzichtbar, wenn wir wissen, ob wir mit einem Big- oder Little-Endian-System arbeiten. Außerdem sind weder MSVC noch BCC in der Lage, von der inline-Funktion viel mehr als die CALL-Anweisung wegzuoptimieren.
  
  Für Fälle wie diesen prägte Donald Knuth den Begriff "premature optimization". Er hat Recht: offensichtlich kommen wir hier viel besser weg, wenn wir dem Compiler eindeutig sagen, was wir haben wollen, anstatt vermeintliche Low-Level-Optimierungen einzubauen.

Zitat:

Zitat von busybyte

jetzt bin ich aber wirklich raus aus diesem Thread

Das wäre, glaube ich, für alle Beteiligten ganz angenehm.

[Chemiker]

Hallo,

@Mutetze1:

Zitat:

Ja, wie gesagt, VCL Funktionalität. Somit auch #include <Math.hpp> im C++Builder, aber es soll nichts Borland spezifisches werden, das hatten wir doch nun schon geklärt...

Wann? Doch erst im #12 Beitrag. Zuerst ist gefragt worden, wie man mit einer Gleitkommazahl einen Vergleich auf Null, oder beinah Null macht und darauf habe ich eine Lösungsmöglichkeit gegeben.

Bis bald Chemiker

[Apollonius]

Sollte das nicht x<e && x>-e heißen? Wenn eines erfüllt ist, heißt das doch nicht, dass die Zahl nahe Null ist.

[DMW]

Zitat:

Zitat von Apollonius

Sollte das nicht x<e && x>-e heißen? Wenn eines erfüllt ist, heißt das doch nicht, dass die Zahl nahe Null ist.

Du hast natürlich vollkommen recht. Das habe ich glatt übersehen :roll:

Somit verändern sich die Meßergebnisse auch ein wenig:

BCB6:
(x<e && x>-e): 11.525 s
isNull: 22.651 s

VC2008:
(x<e && x>-e): 7.492 s
isNull: 20.045 s

Meine Aussagen zur Interpretation der Ergebnisse scheinen aber nach wie vor zuzutreffen.

[Chemiker]

Hallo DMW,

bei mir führt das aber zu falschen Ergebnissen.

Code:

#define EPSILON 0.0000000000000001    // Genauigkeit

#pragma argsused
int main(int argc, char* argv[])
{
   double zahl1, zahl2;
   zahl1= 4.072300000000000;
   zahl2= 4.072300000000000;
                            //1
   if ((((zahl2 - EPSILON) < zahl1) && (zahl1 < (zahl2 + EPSILON))))
     printf("Die Werte sind Gleich\n");
    else  
     printf("Die Werte sind ungleich!! ");
//---------------------------------------------------------------------------
   if ((zahl1<EPSILON) && (zahl2>-EPSILON))
    printf("Die Werte sind Gleich\n");
   else
     printf("Die Werte sind ungleich!! ");
     getch();
     return 0;

Wenn ich mit x<e && x>-e den Vergleich in diesem Beispiel durchführe, so ergibt der Vergleich ungleich bei gleichen Zahlen.

Bis bald Chemiker

[SnuffMaster23]

uiuiui, da habt ihr beide Recht mit den Fehlern :oops:

Also ich habs mit MinGW im Release Mode (code::blocks) gebaut.
Hier die 'richtigen' Werte:

Code:

(x<e && x>-e): 1.35776 Sek.
isNull: 1.35791 Sek.

Also trotzdem ein unwesentlicher Unterschied.

Zitat:

Zitat von Chemiker

Wenn ich mit x<e && x>-e den Vergleich in diesem Beispiel durchführe, so ergibt der Vergleich ungleich bei gleichen Zahlen.

ganz klar^^
Das x sollte eine Art Null und nicht eine Art 4 sein. Wir versuchen ja kein a == b zu machen, sondern ein x == 0 ;)

[DMW]

Zitat:

Zitat von Chemiker

bei mir führt das aber zu falschen Ergebnissen.

Das liegt daran, daß du es falsch benutzt.

x < ε ^ x > -ε ist ja eine Überprüfung auf Null, nicht ein Vergleich zweier Zahlen. Um damit zwei Zahlen vergleichen zu können, bildet man die Differenz. Und mit ein wenig Mathematik kommt man dann auf das, was du im ersten Teil des Programmes benutzt:

x := b - a
=> b - a < ε ^ b - a > -ε
<=> b - ε < a ^ a < b + ε

Wie du aber auf a < ε ^ b > -ε kommst, kann ich nicht nachvollziehen.