Fehler, Irrtümer, Fragen - Seite 443

Neuer Kommentar
 
voix_kas:

Ergebnis:

Entweder mache ich etwas falsch (bitte korrigieren), oder MetaDriver hat einen Fehler in der Theorie gemacht (beim Entwurf des Algorithmus).

:)

Wenn man bedenkt, dass der "Entwurf" des Algorithmus etwa 3 Minuten dauerte (und 7 Minuten für die Implementierung), habe ich mich ziemlich gut geschlagen :) Das Ziel war es, eine funktionierende Idee zu zeigen und die Problemstellung zu verdeutlichen.

Und all dies erwies sich als nützlich - die Entwickler hatten eine echte Chance, die MathFloor()-Funktion zu verbessern - offensichtlich ist sie nicht ganz sauber implementiert.

Am Ende mussten sie daran herumpfuschen. Es hat Spaß gemacht. Eine stabile Funktion (ich meine CountSignedDigits(double x)) habe ich erst nach fast einer Stunde des Experimentierens hinbekommen.

Und selbst jetzt bin ich mir nicht sicher, ob es mit allen Eingabewerten korrekt funktioniert. Ich habe keinen automatischen Stresstest entwickelt, sondern einen manuellen. Bitte testen Sie ihn.

Ich erwarte einen stabilen Betrieb bis zu 10 Dezimalstellen nach dem Fließkomma.

int CountSignedDigits(double x)
{
  for(int i=0; i<1000; i++,x*=10)
  {
    if(x-MathFloor(x+0.000000000005)<double(0.000000000005)) return i;
  }
  return -1;
}
Stresstest angehängt: // Ich habe einige Zwischenrealisierungen nicht aus dem Code entfernt. Ich habe sie in den Kommentaren hinterlassen, damit Sie sie ausprobieren/überlegen können. Das gilt auch für die Entwickler.
Dateien:
CSDigitTest.mq5  2 kb
 
komposter:
1. Sie brauchen dig nicht für eine Menge zu definieren, sondern nur auf die richtige Stufe zu normalisieren:

2. selbst wenn beim Senden einer Handelsanfrage etwas Müll in der Lot-Variable (in der Dezimalstelle) vorhanden ist, sollte dieser vom Terminal selbst verworfen werden.

Zumindest hatte ich in den vielen Jahren, in denen ich ein solches Konstrukt verwende, keine Probleme.

4. wenn Sie sich vergewissern wollen, können Sie sie auf 8 Dezimalstellen normalisieren (mit einer Marge) - wenn es nach der "korrekten" Normalisierung Müll gibt, wird er viel weiter sein.

Die erste Idee ist richtig, die anderen sind verdächtig. :)

Die Umsetzung ist für die Praxis brauchbar, aber für künstliche Bedingungen, die durch den "Problemstarter" (c) definiert sind, ungenau. Bei diskreten Schritten wird nicht relativ zu lot_min erzeugt, sondern relativ zu null. :)

Es ist jedoch leicht zu beheben, wenn Sie es bemerken.

double komposterNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
   lot = NormalizeDouble( lot / lot_step, 0 ) * lot_step;
   if ( lot < lot_min ) lot = lot_min;
   if ( lot > lot_max ) lot = lot_max;
   return lot;
}
double metadriverNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
   lot = NormalizeDouble((lot-lot_min) / lot_step, 0) * lot_step + lot_min;
   if ( lot > lot_max ) lot = lot_max;
   return lot;
}

// Bitte nehmen Sie all diese Perlen nicht zu ernst. Klärungen sind rein theoretisch, für Gehirntraining, weil in der Praxis habe ich nie gesehen lot_step gleich, sagen wir, 0,0231....

;)

  
metadriverNormalizeLot

Variante ist korrekt. Korrekt berücksichtigt durch lot_min wie in meinem NL().

 

Meine Variante ist ebenfalls verfügbar. Beachten Sie, dass bei einigen Instrumenten die Preisänderungsstufe größer ist als der Punkt.

//---------------------------------------------------------------------
//  Нормализация цены:
//---------------------------------------------------------------------
double
NormalizePrice( string _symbol, double _org_price )
{
  double  norm_price = _org_price;

  double  min_price_step = NormalizeDouble( current_tick_size / current_point, 0 );

  norm_price = NormalizeDouble( NormalizeDouble(( NormalizeDouble( _org_price / current_point, 0 )) / min_price_step, 0 ) * min_price_step * current_point, current_digits );

  return( norm_price );
}

//---------------------------------------------------------------------
//  Вычисление лота:
//---------------------------------------------------------------------
double
NormalizeLot( double _required_lot )
{
  double        lot, k;

  if( current_min_lot_step > 0 )
  {
    k = 1.0 / current_min_lot_step;
  }
  else
  {
    k = 1.0 / current_min_permitted_lot;
  }

  lot = MathFloor( _required_lot * k ) / k;

  if( lot < current_min_permitted_lot )
  {
   lot = current_min_permitted_lot;
  }

  if( lot > current_max_permitted_lot )
  {
    lot = current_max_permitted_lot;
  }

  lot = NormalizeDouble( lot, 2 );
  return( lot );
}
 

Wenn wir als Axiom annehmen, dass die Schritte nicht von Null, sondern von der Mindestmenge ausgehen, sieht der korrekte Algorithmus wie folgt aus:

double voixkasNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
  if ( lot < lot_min ) lot = lot_min;
  else lot = NormalizeDouble((lot-lot_min) / lot_step, 0) * lot_step + lot_min;

  if ( lot > lot_max ) lot = lot_max;
  return NormalizeDouble(Lot, 8);
}

In der Composter-Version fangen die Schritte bei Null an. Das halte ich nicht für richtig.
Bei der MetaDriver-Variante überspringt der Code einen negativen Wert. =Р

 
voix_kas:
...

Bei der MetaDriver-Variante überspringt der Code einen negativen Wert. =Р

:)) ..... Ach so! Du wirst überhaupt nicht arbeiten! ;-R ;-b ;-R

double voixkasNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
  if ( lot < lot_min ) lot = lot_min;
  else lot = NormalizeDouble((lot-lot_min) / lot_step, 0) * lot_step + lot_min;

  if ( lot > lot_max ) lot = lot_max;
  return NormalizeDouble(L ot, 8);
}

Nun, die kürzeste und zugleich "einigermaßen zutreffende" Variante ist diese:

double mdNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
  lot = MathMin(lot, lot_min);
  lot = NormalizeDouble((lot-lot_min) / lot_step, 0) * lot_step + lot_min;
  return NormalizeDouble(MathMin(lot, lot_max), MathMax(CountSignedDigits(lot_min),CountSignedDigits(lot_step));
}

Und das, ohne zu prüfen, ob lot_step, lot_min und lot_max ungültig oder negativ sind!!......

:))))

 

Äh... einen Nerv getroffen. :)) Die letzte Zeile wurde in einem Forumsbeitrag von Hand korrigiert, ich bitte um Verzeihung. =)
Übrigens, Ihr Code hat sich auch nicht kompilieren lassen (ich habe vergessen, eine schließende Klammer in die letzte Zeile zu setzen). :-Р
Außerdem ist es 2-3 Mal langsamer (jetzt habe ich es mit einem Skript überprüft), aber die Qualität der Prüfung ist die gleiche. :-Р

Wie auch immer, solange es keinen geeigneten Code gibt, um die signifikante ganze Zahl zu bestimmen, werde ich den Rat von Composter befolgen: normalisiere das Volumen auf 8 Dezimalstellen.
Hoffentlich gibt es keine Fallstricke.

Ich danke Ihnen allen für Ihre Hilfe.

 

Ihr seid lustig, wie ich sehe.

in Ihrem ersten Beitrag gab NL(), was Sie erst zwei Seiten später erreicht haben ;)

 

Es gibt noch eine weitere Frage an die Gurus. Wenn ich die Mehrfachwährung teste, erhalte ich Fehler (Screenshot im Anhang).
Ich versuche, eine Handelsoperation durchzuführen, aber ich erhalte die Antwort: Kein Preis. Nach dem Tester kann man sehen, dass die Notierungen für dieses Paar ab 2011.01.0301:00:00 kommen, während EURUSD auch ab 2011.01.0300:00:00 notiert wird Gibt es eine Möglichkeit, die Zeit des Beginns der Notierungen herauszufinden, um diesen Fehler zu umgehen?

Screenshot mit Fehler

 
voix_kas:

Es gibt noch eine weitere Frage an die Gurus. Wenn ich die Mehrfachwährung teste, erhalte ich Fehler (Screenshot im Anhang).
Ich versuche, eine Handelsoperation durchzuführen, aber ich erhalte die Antwort: Kein Preis. Laut Tester kann man sehen, dass die Notierungen für dieses Paar ab 2011.01.0301:00:00 kommen, während EURUSD auch ab 2011.01.0300:00:00 notiert wird.Gibt es eine Möglichkeit, den Zeitpunkt des Beginns der Notierungen herauszufinden, um diesen Fehler zu vermeiden?

Handels- und Börsensitzungen helfen nicht, das Problem zu lösen?
1...436437438439440441442443444445446447448449450...3184
Neuer Kommentar
Grund der Beschwerde: