Fehler, Irrtümer, Fragen - Seite 2821

[fxsaber]

Igor Makanu:

Normalisierung ist keine Rundung

Ich habe ein A+ in Theorie, wie man mit Double arbeitet und so weiter. Der Algorithmus NormalizeDouble enthält einen Fehler. Das angesprochene Thema hat nur indirekt etwas mit dem Vergleich von Doppelgängern zu tun.

[Alexey Viktorov]

fxsaber:

Ich wiederhole meine Frage.

Die Abbildung zeigt den Wert der nicht-normierten Variablen n und der normierten Variablen m und wie unterschiedlich sie sind. Aber wenn Sie Tangas vergleichen wollen, ist das Ihre Sache.

fxsaber:

Ich kenne mich mit der Theorie aus, weiß, wie man mit Doppelgängern arbeitet und so weiter auf einer A+ Skala. Der Algorithmus NormalizeDouble enthält einen Fehler. Das angesprochene Thema hat nur indirekt etwas mit dem Vergleich von Doppelgängern zu tun.

Auf die Erklärung von Semko können wir hier definitiv nicht verzichten.

[fxsaber]

NormalizeDouble ist nur ein bestimmter Algorithmus, der auf eine Double-Zahl angewendet wird. Leider ist darin ein Fehler enthalten. Wenn der Fehler behoben ist, wird er verschwinden. Die doppelte Darstellung aller anderen wird sich in keiner Weise ändern.

[Igor Makanu]

fxsaber:

Der Algorithmus NormalizeDouble enthält einen Fehler.

ja

Ich glaube, A100 hat darüber geschrieben

aber seit MQL halten die Entwickler an dieser "Funktion" fest, leider

fxsaber:
Wenn sie es korrigieren, wird der Fehler verschwinden.

Ich denke, es wird noch weitere Fehler geben und es wird eine Menge Lärm geben ))))

[fxsaber]

Igor Makanu:

Ich denke, es werden weitere Fehler auftreten und es wird eine Menge Lärm geben ))))

Das werden sie nicht, denn fast jeder vergleicht selbst normalisierte Synchronisationen durch Normalisierung. Das heißt, sie können ihn dort platzieren, wo sie wollen.

Eine ordnungsgemäße Normalisierung sollte unter dieser Bedingung immer wahr ergeben.

Forum für Handel, automatisierte Handelssysteme und Strategietests

Fehler, Irrtümer, Fragen

fxsaber, 2020.08.10 11:37

  Print((double)(string)Norm == Norm);    // false

Dies ist die einzige Überprüfung, ob die Normalisierung korrekt ist. Wenn es immer stimmt, wird nichts kaputtgehen.

[Alexey Navoykov]

fxsaber:
NormalizeDouble ist nur ein bestimmter Algorithmus, der auf eine Double-Zahl angewendet wird. Leider ist darin ein Fehler enthalten. Wenn der Fehler behoben ist, wird er verschwinden. Alle anderen doppelten Vertretungen werden sich dadurch nicht ändern.

Ich denke, es liegt nicht an der Funktion, sondern daran, dass Konstanten vom Compiler nicht normalisiert werden (obwohl sie das sollten).

Dasselbe gilt für die Umwandlung von String in Double.

[fxsaber]

Alexey Navoykov:
Ich denke, es liegt nicht an der Funktion, sondern daran, dass die Konstanten vom Compiler nicht normalisiert werden (obwohl sie das sollten).

Das Gleiche gilt für die Konvertierung von Zeichenketten in Double.

Dann werden die gleichen Konstanten in DLL und MQL nicht übereinstimmen.

[Alexey Navoykov]

fxsaber:

Dann werden die gleichen Konstanten in DLL und MQL nicht übereinstimmen.

Auch wahr. Außerdem bedeutet jede Normalisierung einen Verlust an Genauigkeit, so dass ich mit der Normalisierung der Konstanten vielleicht zu weit gegangen bin.

Generell gibt es für dieses Problem meiner Meinung nach keine eindeutige Lösung, obwohl es eigentlich kein Problem ist.

[fxsaber]

Alexey Navoykov:
Auch wahr. Außerdem bedeutet jede Normalisierung einen Verlust an Genauigkeit, so dass ich es mit der ständigen Normalisierung wahrscheinlich übertreibe.

Generell scheint es für dieses Problem keine eindeutige Lösung zu geben, obwohl es im Grunde genommen kein solches Problem ist.

Es genügt, den derzeitigen Normalisierungsalgorithmus zu optimieren.

[Nikolai Semko]

fxsaber:

Es genügt, den derzeitigen Normalisierungsalgorithmus zu optimieren.

void OnStart() {
   double d1=1.79435;
   double d2=NormalizeDouble(1.79435,5);
   Print(d1==d2);
   Print(is_equal(d1,d2,_Point/2));
}
//+------------------------------------------------------------------+
bool is_equal(double d1, double d2, double e=0.000000001) {return fabs(d1-d2)<e;}

Ich weiß nicht einmal, ob dies ein Fehler im Algorithmus ist.
Wirklich, man kann keine Doppelgänger vergleichen. Nur eine harte Regel.
Oder, wie Slava sagt, durch Epsilon oder durch Multiplikation (z. B. mit 1/_Point) mit Umwandlung in int mit Rundung.

Nur die Rundung erfolgt nicht durch round(), ceil(), floor(), da diese ebenfalls double zurückgeben.

Oder durch diese, zumal sie schneller funktionieren als die normalen:

int Ceil (double x) {return (x-(int)x>0)?(int)x+1:(int)x;}
int Round(double x) {return (x>0)?(int)(x+0.5):(int)(x-0.5);}
int Floor(double x) {return (x>0)?(int)x:((int)x-x>0)?(int)x-1:(int)x;}

Einfacher und schneller geht es natürlich mit epsilon:

bool is_equal(double d1, double d2, double e=0.000000001) {return fabs(d1-d2)<e;}