Kann Preis != Preis ? - Seite 4

Neuer Kommentar
 
rfb:
Dasselbe wie "int intCheck", aber der Wert wird vor der Funktion zugewiesen, wie bei anderen Variablen.

Wird dies funktionieren?

intCheck = 1.1000000000001 /point;
intRecord = 1.0999999999999 /point;

if (intRecord > intCheck) Print("Prices are the same.");
 
RaptorUK:

Wird das funktionieren?

Natürlich NEIN, es ist nur für einfache Berechnungen für Börsenkurse oder ähnliches mit weniger Ziffern. Nichts wird funktionieren, wenn mehr als 10 Ziffern auf beiden Seiten des Dezimalpunktes zusammen gezählt werden, Grenzen. Nur Spielzeug.
 
rfb:
Natürlich NEIN, es ist nur für einfache Berechnungen für Börsenkurse oder ähnliches mit weniger Ziffern. Nichts wird funktionieren, wenn mehr als 10 Ziffern auf beiden Seiten des Dezimalpunktes zusammen gezählt werden, Grenzen. Nur Spielzeug.
Mein Code funktioniert sehr gut.
 
WHRoeder:

Machen Sie die Dinge nicht zu kompliziert

Ob etwas (oder eine Idee) kompliziert oder komplex ist, ist, glaube ich, eine Frage der individuellen Interpretation.

Eine Fließkommadivision, eine Fließkommaddition, eine Konvertierung nach int, ein Funktionsaufruf (Kopieren, Springen, Rückgabe = 3,) * 2, alles mal zwei. (18) Und das setzt voraus, dass Dividieren und Konvertieren mit den anderen Operationen gleichwertig sind - das sind sie nicht.

Ich wollte nie behaupten, dass die von mir entwickelte und verwendete Lösung die effizienteste ist - mir ist klar, dass sie es vielleicht nicht ist, aber wichtig ist, dass ich (1) den zusätzlichen Overhead und die Rechenkosten verstehe (und derzeit tolerieren kann) und (2) das Problem (zumindest für mich) des Vergleichs zweier Preise im doppelpräzisen Gleitkommaformat löst.

Letztendlich verstehe ich das Problem, das mit dem Vergleich zweier reeller Zahlen im Fließkommaformat mit doppelter Genauigkeit verbunden ist, aber ich denke, dass Sie und ich das Problem in diesem Zusammenhang etwas anders angegangen sind. Sie verwenden das, was ich als "Epsilon-Vergleich" bezeichnen würde, um festzustellen, ob zwei Paschas nahe genug beieinander liegen, um als gleich zu gelten - d. h., wenn die Differenz zwischen zwei Paschas innerhalb der maximalen Abweichung (Punkt / 2.) liegt, dann sind die beiden Paschas gleich. Andererseits habe ich mich dafür entschieden, die Preise für den Vergleich in Ints umzuwandeln, indem ich durch Point geteilt, auf die nächste ganze Zahl gerundet, das Ergebnis als Int gespeichert und dann die beiden Ints verglichen habe. Ich habe einen Funktionsaufruf anstelle von Inline-Code verwendet, weil es für mich natürlicher ist - ich neige dazu, Code in Unterprogramme/Funktionen zu gruppieren - und weil es potenziell wiederverwendbar ist (vielleicht von dem kleinen Teil von mir, der in OOP-Begriffen denkt). Ich habe viel von dem übernommen, was Sie am 16. Februar 2012 gesagt haben:

Der doppelte Wert vom Broker könnte irgendwo zwischen 1,234575000000000000 und 1,23458499999999999 liegen und immer noch als derselbe Preis von 1,23458 angesehen werden.

Deshalb habe ich mich entschlossen, auf die nächste ganze Zahl zu runden, anstatt den Dezimalteil nach der Division durch Punkt, aber vor der Umwandlung des Double-Wertes in einen Int-Wert abzuschneiden.

Damit will ich nicht sagen, dass ich mit dem, was Sie gepostet haben, nicht einverstanden bin, sondern vielmehr anerkennen, dass ich das, was Sie gepostet haben, gelesen habe und es für spätere Zwecke (und für eine eventuelle spätere Verwendung, falls erforderlich) speichern werde :)

Wie immer sind lehrreiche/konstruktive Kommentare willkommen. :)

 
Thirteen:

Ob etwas (oder eine Idee) kompliziert oder komplex ist, ist meiner Meinung nach eine Frage der individuellen Interpretation.

Ich wollte nie behaupten, dass die von mir entwickelte und verwendete Lösung die effizienteste ist - mir ist klar, dass sie es vielleicht nicht ist. Aber wichtig ist, dass ich (1) den zusätzlichen Overhead und die Rechenkosten verstehe (und derzeit tolerieren kann) und (2) das Problem (zumindest für mich) des Vergleichs zweier Preise im doppelpräzisen Fließkommaformat löst.


Ich stimme mit Ihnen überein . . und ich stimme auch mitWHRoeder überein

Mein Code wurde geschrieben, weil ich etwas brauchte, das ich in bestehenden Code einfügen konnte, ohne ihn zu zerstören oder viele Stunden mit der Fehlersuche verbringen zu müssen. Ich möchte auch das, wasWHRoeder gepostet hat, zumindest teilweise übernehmen und eine bessere Version dessen entwickeln, was ich tue, ohne dass es für mich unleserlich wird. Wenn ich etwas davon schaffe, werde ich es in diesem Thread veröffentlichen.

 
RaptorUK:

Wenn ich etwas davon schaffe, werde ich es in diesem Thread posten.

Meine Flat() -Funktion war 17 mal langsamer alsWHRoeders Lösung, ich habe einen Vorschlag, der meiner Meinung nach besser lesbar und nur 3 oder 4 mal langsamer ist, je nach Art des Vergleichs. 3 oder 4 mal langsamer ist keine großartige Sache, aber im Vergleich zu 17 mal langsamer ist eine große Verbesserung. Ich habe es ein wenig getestet, aber noch nicht ausführlich.

Verwendung:

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)


for example:

if(Compare(Bid, LT, Ask)) Print("Bid is less than Ask");

if(Compare(Price, EQ, Price)) Print("Price does equal Price");

Die Vergleichstypen sind, EQ für gleich, NEQ für nicht gleich, GT für größer als und LT für kleiner als.

#define LT    0
#define GT    1
#define EQ    2
#define NEQ   4


bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: if ( SecondPrice - FirstPrice > HalfAPoint)
                  return(true);
               else return(false); 
      
      case GT: if ( FirstPrice - SecondPrice > HalfAPoint)
                  return(true);
               else return(false); 
      
      case EQ: if (MathAbs(FirstPrice - SecondPrice) > HalfAPoint)
                  return(false);
               else return(true); 
      
      case NEQ: if (MathAbs(FirstPrice - SecondPrice) > HalfAPoint)
                  return(true);
               else return(false);
      }
   }
 
Einfach Ihre Bools
case GT: if ( FirstPrice - SecondPrice > HalfAPoint)
                  return(true);
               else return(false); 
case GT: 
   return(FirstPrice - SecondPrice > HalfAPoint);
 
WHRoeder:
Einfach Ihre bools

Das ist gut.

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: return( SecondPrice - FirstPrice > HalfAPoint);
      
      case GT: return( FirstPrice - SecondPrice > HalfAPoint);
      
      case EQ: return(!MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
      
      case NEQ: return(MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
      
      }
   }

Die Leistung hat sich nicht wesentlich verändert.

  
  case EQ:  return(!MathAbs(FirstPrice - SecondPrice) > HalfAPoint); // Initially missed the !
  case NEQ: return( MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
Vorrangregeln Nicht (!) ist fast die höchste: wenn erster != zweiter genau, (!ABS(ungleich Null) > nz) == (0 > nz) == falsch. Wenn f==s dann (!0 > nz) == (1 > p/2) == wahr, wenn Punkt < 1
 
WHRoeder:
Vorrangregeln Nicht (!) ist fast das Höchste: wenn erster != zweiter genau, (!ABS(Nicht-Null) > nz) == (0 > nz) == falsch. Wenn f==s dann (!0 > nz) == (1 > p/2) == wahr, wenn Punkt < 1

Ja, gut gefangen...

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: return( SecondPrice - FirstPrice > HalfAPoint );
      
      case GT: return( FirstPrice - SecondPrice > HalfAPoint );
      
      case EQ: return(!( MathAbs(FirstPrice - SecondPrice) > HalfAPoint ) );
      
      case NEQ: return( MathAbs(FirstPrice - SecondPrice) > HalfAPoint );
      
      }
   }
12345678
Neuer Kommentar