MetaTrader 5 herunterladen

Bewertung von Handelssystemen - die Effektivität von Einstieg, Ausstieg und Handel im Allgemeinen

14 Januar 2016, 08:46
Nikolay Demko
0
344

Einleitung

Es gibt eine Menge Maßnahmen zur Bestimmung der Effektivität eines Handelssystems, und Händler wählen diejenigen, die ihnen am besten passen. Dieser Beitrag befasst sich mit den, im Buch "Statistika dlya traderov" ("Statistics for Traders") von S.V. Bulashev beschriebenen Vorgehensweisen. Leider ist dieses Werk nicht in ausreichender Auflage vorhanden und wurde seit geraumer Zeit auch nicht wieder neu aufgelegt, doch seine EDV-Version ist auf vielen Websites immer noch abrufbar.


Vorbemerkung

Ich möchte an dieser Stelle daran erinnern, dass dieses Buch bereits 2003 veröffentlicht wurde, also zur Zeit von MetaTrader 3 mit der MQL-II Programmiersprache. Für damalige Verhältnisse war die Plattform reichlich fortschrittlich, daher können wir die Veränderungen der Handelsbedingungen an sich durch ihren Vergleich mit modernen MetaTrader 5 Client-Terminal verfolgen. Des Weiteren sollte darauf hingewiesen werden, dass der Autor dieses Buchs für viele Händler-Generationen quasi zu einem 'Guru' geworden ist (und das bei dem raschen Wechsel Generationen in diesem Bereich). Doch die Zeit steht nicht still, daher müssen die entsprechenden Ansätze, trotz der Tatsache, dass die in diesem Buch beschriebenen Prinzipien immer noch anwendbar sind, durchaus angepasst werden.

S.V. Bulashev verfasste dieses Buch zunächst auf Grundlage damals aktueller Handelsbedingungen, deswegen können wir die vom Autor beschriebenen Statistiken eben nicht ohne Umwandlung anwenden. Zur Verdeutlichung: Erinnern wir uns an die Handelsmöglichkeiten - marginales Handeln auf einem Spotmarkt impliziert, dass sich der Kauf einer Währung zum Zweck eines spekulativen Gewinns, nach gewisser Zeit in ihren Verkauf wandelt.

Das sind die Grundlagen, daher sollte man sie auch nicht vergessen. Und diese exakte Interpretation wurde verwendet, als das Buch "Statistics for Traders" entstand. Jeder Abschluss von 1 Posten sollte durch den umgekehrten Abschluss desselben Volumens geschlossen werden. Doch nach zwei Jahren (2005) bedurften diese Statistiken bereits einer Neuorganisation. Grund war, dass das teilweise Schließen von Abschlüssen in MetaTrader 4 möglich wurde. Um daher, die von Bulashev beschriebenen Statistiken anzuwenden, müssen wir das Interpretationssystem erweitern, insbesondere sollte die Interpretation vor dem Hintergrund der Tatsache des Schließens und nicht der Eröffnung stattfinden.

Und nach weiteren 5 Jahren veränderte sich die Situation dramatisch. Was passierte mit dem so bekannten Begriff Order? Er verschwand. Angesichts der Unmengen Fragen in diesem Forum, ist es besser, das exakte System der Interpretation inMetaTrader5 zu beschreiben.

Heutzutage gibt es also keine Order im klassischen Sinne mehr; heute ist eine Order eine Handelsanfrage an einen Makler-Server, die entweder von einem Händler oder MTS getätigt wird, und die Eröffnung oder Veränderung einer Handelsposition umfasst. Sie ist jetzt eine Position, und um ihre Bedeutung zu verstehen, habe ich den marginalen Handel erwähnt. Tatsache ist, dass marginales Handeln mit geliehenem Geld abläuft, und es deshalb eine Position so lange gibt, wie es auch dieses geliehene Geld gibt.

Sobald man dem Geldgeber durch Abschluss dieser Position die Außenstände bezahlt und als Ergebnis einen Gewinn/Verlust macht, besteht dieses Position nicht mehr. Übrigens ist das auch die Erklärung dafür, warum eine Umkehrung der Position diese nicht schließt, denn das geliehene Geld bleibt nämlich sowieso bestehen und deshalb macht es keinen Unterschied, ob man sich Geld zum Kaufen oder Verkaufen geliehen hat. Ein Abschluss ist nur die Historie einer ausgeführten Order.

Doch kommen wir nun zu den Merkmalen des Handelns. Derzeit kann man inMetaTrader5 sowohl eine Handelsposition teilweise schließen oder eine bestehende erhöhen. Und deshalb gehört das klassische Interpretationssystem, in dem jede Eröffnung einer Position eines gewissen Volumens vom Schließen desselben Volumens gefolgt wird, der Vergangenheit an. Doch kann man sie wirklich nicht mehr von den, inMetaTrader5 gespeicherten Informationen, erneut erhalten? Also organisieren wir als ersten Schritt die Interpretation neu.


Die Effektivität des Einstiegs

Jeder weiß, dass viele Menschen ihren Handel effektiver machen wollen, doch wie beschreibt man den Begriff 'Effektivität' formal? Geht man davon aus, dass ein Abschluss ein Pfad ist, der durch den Kurs verfolgt wird, wird es schnell klar, dass sich auf diesem Pfad zwei Extrempunkte befinden: Minimal- und Maximalkurs innerhalb des beobachteten Abschnitts. Jeder versucht so nahe wie möglich am Minimalkurs in den Markt einzusteigen (zumindest beim Kaufen), und dies kann als Hauptregel jedes Handels gelten - bei niedrigem Kurs kaufen, bei hohem verkaufen.

Die Effektivität des Einstiegs legt fest, wie nahe am Minimalkurs man kauft. Die Effektivität des Einstiegs ist also das Verhältnis des Abstands zwischen dem Maximalkurs und dem Kurs bei Einstieg in den kompletten Pfad. Warum messen wir den Abstand zum Minimum mit Hilfe der Differenz des Maximums? Für uns muss die Effektivität beim Einstieg zum Minimum = 1 sein (und = 0 beim Einstieg zum Maximum).

Deshalb nehmen wir für unser Verhältnis den restlichen Abstand und nicht den Abstand zwischen Minimum und Einstieg selbst. Lassen Sie mich an dieser Stelle darauf hinweisen, dass die Situation für Verkauf im Vergleich zum Kauf spiegelbildlich ist.

 

Die Effektivität des Einstiegs bei einer Position zeigt, wie gut ein MTS den potenziellen Gewinn im Verhältnis zum Einstiegskurs während eines gewissen Handels realisiert. Seiner Berechnung liegen folgende Formeln zugrunde:

for long positions
enter_efficiency=(max_price_trade-enter_price)/(max_price_trade-min_price_trade);

for short positions
enter_efficiency=(enter_price-min_price_trade)/(max_price_trade-min_price_trade);

The effectiveness of entering can have a value within the range from 0 to 1.


Die Effektivität des Ausstiegs

Bei einem Ausstieg verhält es sich ähnlich:


Die Effektivität des Ausstiegs von einer Position zeigt, wie gut ein MTS den potenziellen Gewinn im Verhältnis zum Ausstiegskurs während eines gewissen Handels realisiert. Seiner Berechnung liegen folgende Formeln zugrunde:


for lone positions
exit_efficiency=(exit_price - min_price_trade)/(max_price_trade - min_price_trade);

for short positions
exit_efficiency=(max_price_trade - exit_price)/(max_price_trade - min_price_trade);

The effectiveness of exiting can have a value withing the range from 0 to 1.


Die Effektivität eines Handels

Insgesamt wird die Effektivität eines Handels durch sowohl Einstieg als auch Ausstieg bestimmt, und kann als das Verhältnis des Pfads zwischen Einstieg und Ausstieg zum maximalen Abstand währendes Handels berechnet werden (also die Differenz zwischen Minimum und Maximum). Die Effektivität eines Handels lässt sich daher auf zweierlei Arten berechnen: direkt, mit Hilfe der primären Informationen über den Handel, oder mittels der bereits berechneten Ergebnisse von früher bewerteten Einstiegen und Ausstiegen (mit einer Intervallverschiebung).

Die Effektivität eines Handels zeigt, wie gut ein MTS den potenziellen Gewinn während eines gewissen Handels realisiert, Seiner Berechnung liegen folgende Formeln zugrunde:

for long positions
trade_efficiency=(exit_price-enter_price)/(max_price_trade-min_price_trade);

for short positions
trade_efficiency=(enter_price-exit_price)/(max_price_trade-min_price_trade);

general formula
trade_efficiency=enter_efficiency+exit_efficiency-1;

The effectiveness of trade can have a value within the range from -1 to 1.
The effectiveness of trade must be greater than 0,2. 
The analysis of effectiveness visually shows the direction for enhancing the system, because it allows evaluating the quality of signals for entering and exiting a position separately from each other.


Die Umwandlung der Interpretation

Um Verwirrungen zu vermeiden, müssen wir zunächst die Namen der Objekte der Interpretation klären. Da sowohl in MetaTrader5, als auch bei Bulachev mit denselben Begriffen gearbeitet wird - Order, Abschluss, Position - müssen wir sie unterscheiden. In diesem Beitrag werde ich das Objekt der Interpretation von Bulachev "Handel" nennen. Ein Handel ist also ein Abschluss. Bulachev verwendet dafür auch den Begriff "Order"; in diesem Kontext sind beide identisch. Bulachev nennt einen nicht abgeschlossenen Abschluss 'Position', wir bezeichnen ihn als nicht geschlossenen Handel.

Man sieht hier klar, dass alle drei Begriffe leicht im Wort "Handel" verschwinden. Die Interpretation in MetaTrader5 werden wir nicht umbenennen, und die Bedeutung dieser drei Begriffe beleibt genauso, wie sie von den Entwicklern des Client-Terminals konzipiert wurden. Wir haben daher also vier Begriffe, mit denen wir arbeiten werden: Position, Abschluss, Order und Trade.

Da eine Order ja ein Befehl an den Server ist, eine Position zu eröffnen/verändern, betrifft sie die Statistiken nicht direkt, indirekt jedoch schon, und zwar durch einen Abschluss (das liegt daran, dass das Absenden einer Order nicht immer zur Ausführung des entsprechenden Abschlusses eines spezifischen Volumens und Kurses führt). Daher ist es angebracht, die Statistiken nach Abschlüssen und nicht nach Order zu sammeln.

Betrachten wir uns ein Beispiel einer Interpretation derselben Position (um das oben Erklärte klarer zu machen):

interpretation in МТ-5
deal[ 0 ]  in      0.1   sell   1.22218   2010.06.14 13:33
deal[ 1 ]  in/out  0.2   buy    1.22261   2010.06.14 13:36
deal[ 2 ]  in      0.1   buy    1.22337   2010.06.14 13:39
deal[ 3 ]  out     0.2   sell   1.22310   2010.06.14 13:41
interpretation by Bulachev
trade[ 0 ]  in 0.1  sell 1.22218 2010.06.14 13:33   out 1.22261 2010.06.14 13:36
trade[ 1 ]  in 0.1  buy  1.22261 2010.06.14 13:36   out 1.22310 2010.06.14 13:41
trade[ 2 ]  in 0.1  buy  1.22337 2010.06.14 13:39   out 1.22310 2010.06.14 13:41


Jetzt zeige ich Ihnen wie diese Bearbeitungen ausgeführt wurden. Abschluss[ 0 ] öffnet die Position: wir schreiben dies als Start des neuen Handels:

trade[ 0 ]  in 0.1  sell 1.22218 2010.06.14 13:33

Danach folgt die Umkehrung der Position, d.h. alle vorigen Handel sollten geschlossen werden, und entsprechend wird die Information über den Umkehr- Abschluss[ 1 ] sowohl beim Abschluss als auch bei der Eröffnung des neuen Handels berücksichtigt. Sobald alle nicht abgeschlossenen Handel vor dem Abschluss mit Richtung hinein/heraus geschlossen sind, müssen wir den neuen Handel eröffnen. Das heißt, wir verwenden zum Schließen nur die Kurs- und die Zeitinformation des für ein Schließen ausgewählten Abschlusses, eben genau entgegengesetzt wie bei der Eröffnung eines Handels, wenn Art und Volumen zusätzlich verwendet werden. An dieser Stelle muss muss darauf hingewiesen werden, dass nun ein bislang noch nicht verwendeter Begriff in der neuen Interpretation auftaucht - die Richtung des Abschlusses, Zuvor haben wir mit "Richtung" entweder einen Kauf oder Verkauf gemeint, die gleiche Bedeutung wie der Begriff "Art". Doch ab jetzt und in Zukunft sind Art und Richtung zwei unterschiedliche Begriffe:

Art ist ein Kauf oder Verkauf; Richtung hingegen bezeichnet den Einstieg oder Ausstieg einer Position. Deshalb wird eine Position immer mit einem Abschluss der Richtung in eröffnet, und mit einem der Richtung out geschlossen, Doch ist die Richtung nicht nur auf Eröffnung oder Schließen von Positionen begrenzt. Mit diesem Begriff werden auch der Anstieg des Volumens einer Position (wenn der "in" Abschluss nicht der erste in der Liste ist) und das teilweise Schließen einer Position (die "out" Abschlüsse sind nicht die letzten in der Liste) bezeichnet. Da uns jetzt auch teilweises Schließen zur Verfügung steht, ist es nur logisch, ebenfalls die Umkehrung einer Position einzuführen. Eine Umkehrung tritt dann auf, wenn ein Gegen-Abschluss mit einer Größe ausgeführt wird, die die aktuelle Position übersteigt - also ein in/out Abschluss,

Daher haben wir die zuvor eröffneten Handel geschlossen (um die Position umzukehren):

trade[ 0 ]  in 0.1  sell 1.22218 2010.06.14 13:33   out 1.22261 2010.06.14 13:36

Das Restvolumen ist 0,1 Posten und wird zur Eröffnung des neuen Handels verwendet:

trade[ 1 ]  in 0.1  buy  1.22261 2010.06.14 13:36

Nun folgt Abschluss[ 2 ] mit der Richtung in, zur Eröffnung eines weiteren Handels:

trade[ 2 ]  in 0.1  buy  1.22337 2010.06.14 13:39

Und schließlich der Abschluss, der die Position schließt - Abschluss[ 3 ] schließt alle Handel in der Position, die bislang noch offen sind.

trade[ 1 ]  in 0.1  buy  1.22261 2010.06.14 13:36   out 1.22310 2010.06.14 13:41
trade[ 2 ]  in 0.1  buy  1.22337 2010.06.14 13:39   out 1.22310 2010.06.14 13:41

Die o.g. Beschreibung verdeutlicht die Quintessenz, der von Bulachev verwendeten Interpretation: jeder offene Handel hat einen gewissen Einstiegspunkt und einen gewissen Ausstiegspunkt, und er hat sein Volumen und seine Art. Doch dieses Interpretationssystem berücksichtigt eine Nuance eben nicht - das teilweise Schließen. Sieht man genauer hin, erkennt man, dass die Anzahl der Handel gleich der Anzahl der in Abschlüsse ist (unter Berücksichtigung der In/Out Abschlüsse). In diesem Fall sollte man nach in Abschlüssen interpretieren. Doch beim teilweisen Schließen wird es mehr out Abschlüsse geben (es kann aber auch die Situation eintreten, wo die Anzahl der In- und Out-Abschlüsse gleich ist, sie sich jedoch in Bezug auf ihr Volumen unterscheiden).

Um alle out Abschlüsse zu verarbeiten, sollten wir nach out Abschlüssen interpretieren. Und dieser Widerspruch scheint unlösbar. wenn wir die Abschlüsse separat verarbeiten - also zuerst alle in und danach alle out Abschlüsse (oder umgekehrt). Doch verarbeiten wir die Abschlüsse sequentiell. und wenden bei jedem Abschluss eine bestimmte Verarbeitungsregel an, dann kommt es zu keinen Widersprüchen mehr.

Hier folgt ein Beispiel, wo die Anzahl der out Abschlüsse größer ist als die der in Abschlüsse (mit Beschreibung):

interpretation in МТ-5
deal[ 0 ]  in      0.3   sell      1.22133   2010.06.15 08:00
deal[ 1 ]  out     0.2   buy       1.22145   2010.06.15 08:01
deal[ 2 ]  in/out  0.4   buy       1.22145   2010.06.15 08:02
deal[ 3 ]  in/out  0.4   sell      1.22122   2010.06.15 08:03
deal[ 4 ]  out     0.1   buy       1.2206    2010.06.15 08:06
interpretation by Bulachev                                       
trade[ 0 ]  in 0.2  sell    1.22133 2010.06.15 08:00   out 1.22145 2010.06.15 08:01   
trade[ 1 ]  in 0.1  sell    1.22133 2010.06.15 08:00   out 1.22145 2010.06.15 08:02   
trade[ 2 ]  in 0.3  buy     1.22145 2010.06.15 08:02   out 1.22122 2010.06.15 08:03   
trade[ 3 ]  in 0.1  sell    1.22122 2010.06.15 08:03   out 1.2206  2010.06.15 08:06    

Folgende Situation: ein schließender Abschluss kommt vor einem eröffnenden Abschluss, besitzt jedoch nicht das ganze Volumen, sondern nur einen Teil (0,3 Posten sind eröffnet und 0,2 sind geschlossen). Was macht man jetzt? Wird jeder Handel mit demselben Volumen geschlossen, kann man die Situation als Eröffnung mehrerer Handel mit einem einzelnen Abschluss betrachten. Sie haben daher alle die gleichen Eröffnungspunkte und unterschiedlichen Abschlusspunkte (es ist klar, dass das Volumen jedes Handels durch sein Abschlussvolumen bestimmt ist). Nehmen wir z.B. Abschluss[ 0 ] für eine Verarbeitung und öffnen den Handel:

trade[ 0 ]  in 0.3  sell 1.22133 2010.06.15 08:00

Dann wählen wir Abschluss[ 1 ], schließen den offenen Handel, und finden während des Schließens heraus, dass das Volumen nicht ausreicht., Jetzt legt man eine Kopie des zuvor eröffneten Handels an und gibt in seinem "Volumen"-Parameter genau das fehlende Volumen an. Anschließend schließt man den ersten Handel mit dem Abschlussvolumen (d.h. wir ändern das Volumen des ersten Handels, das bei der Eröffnung angegeben wurde, durch das Abschlussvolumen):

trade[ 0 ]  in 0.2  sell 1.22133 2010.06.15 08:00   out 1.22145 2010.06.15 08:01   
trade[ 1 ]  in 0.1  sell 1.22133 2010.06.15 08:00

So eine Umwandlung mag einem Händler nicht sinnvoll erscheinen, da er einen anderen Handel schließen möchte, jedoch nicht diesen. Egal, die Bewertung von Systemen wird als Folge einer korrekten Umwandlung nicht beeinträchtigt. Das einzige was beeinträchtigt werden kann, ist das Vertrauen des Händlers in Handel ohne Verluste in MetaTrader 4, denn dieses System der Neuberechnung zeigt jetzt alle Täuschungen auf.

Das von Bulachev in seinem Buch beschriebene System der statistischen Interpretation ist komplett emotionslos und erlaubt die ehrliche Bewertung von Entscheidungen bzgl. der Position bei Einstieg, Ausstieg und beide Verhältnisse insgesamt. Und die Möglichkeit einer Umwandlung der Interpretation (eins ins andere ohne Datenverlust) belegt klar, dass die Behauptung, ein für MetaTrader 4 entwickeltes MTS könne nicht für das Interpretationssystem des MetaTrader5 umgemodelt werden, nicht stimmt. Der einzige Verlust bei der Umwandlung der Interpretation ist, dass das Volumen nun zu unterschiedlichen Ordern gehört (MetaTrader 4). Doch wenn keine weiteren Order (im alten Begriffssinn) ausgewiesen werden müssen, dann ist das nur jeden Händlers eigene, subjektive Schätzung.


Code für die Umwandlung der Interpretation

Sehen wir uns nun den Code an sich an. Zur Vorbereitung eines Übersetzers brauchen wir das Vererbungs-Feature des OOP. Deshalb empfehle ich jedem, der sich damit noch nicht gut auskennt, den MQL5 Benutzerleitfaden zu öffnen und etwas Theorie zu studieren. Zunächst beschreiben wir also die Struktur der Interpretation eines Abschlusses (wir könnten das Schrieben des Codes ein bisschen beschleunigen, und uns diese Werte direkt mittels der Standardfunktion von MQL5 holen, doch sins sie weniger gut lesbar und könnten verwirren).

//+------------------------------------------------------------------+
//| structure of deal                                                |
//+------------------------------------------------------------------+
struct S_Stat_Deals
  {
public:
   ulong             DTicket;         // ticket of deal   
   ENUM_DEAL_TYPE     deals_type;      // type of deal
   ENUM_DEAL_ENTRY    deals_entry;     // direction of deal 
   double            deals_volume;    // volume of deal    
   double            deals_price;     // price of opening of deal   
   datetime          deals_date;      // time of opening of deal  

                     S_Stat_Deals(){};
                    ~S_Stat_Deals(){};
  };

Diese Struktur umfasst alle wichtigen Details über einen Abschluss; abgeleitete Details sind nicht enthalten, da wir sie ggf. berechnen können. Da die Entwickler bereits viele Methoden von Bulachevs Statistiken im Strategie-Tester implementiert haben, müssen wir ihn nur noch durch angepassten Methoden ergänzen. Und deshalb implementieren wir sie als die Effektivität eines Handels insgesamt ,und als die Effektivität einer Eröffnung und eines Abschlusses.

Um diese Werte zu erhalten, müssen wir die Interpretation der Primärinformationen implementieren, wie z.B. Eröffnungs-/Abschlusskurs, Eröffnungs-/Abschlusszeit, Minimum-/Maximalkurs während eines Handels. Wenn wir derartige Primärinformationen haben, können wir daraus eine Menge abgeleiteter Informationen erhalten. Ich möchte Sie hier auch auf die unten beschriebene Handelsstruktur aufmerksam machen: sie ist die Hauptstruktur auf der alle Interpretations-Umwandlungen beruhen.

//+------------------------------------------------------------------+
//| structure of trade                                               |
//+------------------------------------------------------------------+
struct S_Stat_Trades
  {
public:
   ulong             OTicket;         // ticket of opening deal
   ulong             CTicket;         // ticket of closing deal     
   ENUM_DEAL_TYPE     trade_type;     // type of trade
   double            trade_volume;    // volume of trade
   double            max_price_trade; // maximum price of trade
   double            min_price_trade; // minimum price of trade
   double            enter_price;     // price of opening of trade
   datetime          enter_date;      // time of opening of trade
   double            exit_price;      // price of closing of trade/s22>
   datetime          exit_date;       // time of closing of trade

   double            enter_efficiency;// effectiveness of entering
   double            exit_efficiency; // effectiveness of exiting
   double            trade_efficiency;// effectiveness of trade

                     S_Stat_Trades(){};
                    ~S_Stat_Trades(){};
  };


Da wir jetzt bereits zwei Hauptstrukturen erzeugt haben, definieren wir nun die neue Klasse C_Pos, die die Interpretation umwandelt. Deklarieren wir also als erstes die Zeiger für die Interpretationsstrukturen von Abschlüssen und Handel. Da diese Information bei vererbten Funktionen wichtig sein kann, sollte sie als public deklariert werden. Und da es eine Menge Abschlüsse und Handel geben kann, sollte man als Struktur-Zeiger ein Array anstelle einer Variable verwenden. Denn dann ist die Information strukturiert und von überall aus verfügbar,

Als nächstes müssen wir die History in separate Postionen unterteilen und alle Umwandlungen innerhalb einer Position wie in einem kompletten Handelszyklus ausführen. Dazu muss man die Variablen für die Interpretation der Eigenschaften der Position deklarieren (Position-ID, Symbole einer Position, Anzahl der Abschlüsse und Anzahl der Handel).

//+------------------------------------------------------------------+
//| class for transforming deals into trades                         |
//+------------------------------------------------------------------+
class C_Pos
  {
public:
   S_Stat_Deals      m_deals_stats[];  // structure of deals
   S_Stat_Trades     m_trades_stats[]; // structure of trades
   long              pos_id;          // id of position
   string            symbol;          // symbol of position
   int               count_deals;     // number of deals
   int               count_trades;    // number of trades
   int               trades_ends;     // number of closed trades
   int               DIGITS;          // accuracy of minimum volume by the symbols of position  
                     C_Pos()
     {
      count_deals=0;
      count_trades=0;
      trades_ends=0;
     };
                    ~C_Pos(){};
   void              OnHistory();         // creation of history of position
   void              OnHistoryTransform();// transformation of position history into the new system of interpretation
   void              efficiency();        // calculation of effectiveness by Bulachev's method

private:
   void              open_pos(int c);
   void              copy_pos(int x);
   void              close_pos(int i,int c);
   double            nd(double v){return(NormalizeDouble(v,DIGITS));};// normalization to minimum volume
   void              DigitMinLots(); // accuracy of minimum volume
   double            iHighest(string          symbol_name,// symbol name
                              ENUM_TIMEFRAMES  timeframe,  // period
                              datetime         start_time, // start date
                              datetime         stop_time   // end date
                              );
   double            iLowest(string          symbol_name,// symbol name
                             ENUM_TIMEFRAMES  timeframe,  // period
                             datetime         start_time, // start date
                             datetime         stop_time   // end date
                             );
  };


Die Klasse besitzt drei public Methoden, die die Positionen verarbeiten.

OnHistory() erzeugt die Positions-History:
//+------------------------------------------------------------------+
//| filling the structures of history deals                          |
//+------------------------------------------------------------------+
void C_Pos::OnHistory()
  {
   ArrayResize(m_deals_stats,count_deals);
   for(int i=0;i<count_deals;i++)
     {
      m_deals_stats[i].DTicket=HistoryDealGetTicket(i);
      m_deals_stats[i].deals_type=(ENUM_DEAL_TYPE)HistoryDealGetInteger(m_deals_stats[i].DTicket,DEAL_TYPE);   // type of deal
      m_deals_stats[i].deals_entry=(ENUM_DEAL_ENTRY)HistoryDealGetInteger(m_deals_stats[i].DTicket,DEAL_ENTRY);// direction of deal
      m_deals_stats[i].deals_volume=HistoryDealGetDouble(m_deals_stats[i].DTicket,DEAL_VOLUME);              // volume of deal
      m_deals_stats[i].deals_price=HistoryDealGetDouble(m_deals_stats[i].DTicket,DEAL_PRICE);                // price of opening
      m_deals_stats[i].deals_date=(datetime)HistoryDealGetInteger(m_deals_stats[i].DTicket,DEAL_TIME);        // time of opening
     }
  };

Die Methode erzeugt für jeden Abschluss eine Kopie der Struktur und befüllt diese mit der Information zum Abschluss. Und genau das habe ich gemeint, als ich vorhin sagte, dass wir auch ohne sie auskommen können, dass es jedoch mit ihr viel bequemer ist (diejenigen, die jede Zeitersparnis in Mikrosekunden berechnen, ersetzen den Aufruf dieser Strukturen einfach durch die Zeile, die rechts neben dem "=" Zeichen steht).

OnHistoryTransform() wandelt die Positions-History in das neue Interpretationssystem um:

  • Ich habe vorhin schon erklärt, wie die Informationen umgewandelt werden sollten, daher sehen wir uns jetzt mal ein entsprechendes Beispiel an. Zur Umwandlung benötigen wir einen Wert auf dessen Exaktheit wir das Volumen des Abschlusses berechnen sollten (Mindest-Volume) und DigitMinPosten()-Abschlüsse damit. Weiß jedoch ein Programmierer ganz genau, dass dieser Code in keiner anderen Bedingung ausgeführt werden wird, kann dieser Parameter im XConstructor spezifiziert und die Funktion ausgelassen werden.
  • Dann müssen die count_trades und trades_ends Zähler genullt, und danach das Memory für die Interpretationsstruktur der Handel erneut zugewiesen werden. Da wir die genau Zahl der Handel nicht kennen, sollten wir das Memory entsprechend der Zahl an Abschlüssen in Position zuweisen. Sollte es des Weiteren klar werden, dass es mehr Handel gibt, müssen wir das Memory halt einfach öfters neu zuweisen. Doch die meisten Handel besitzen zugleich genügend Memory und die Zuweisung von Memory für das ganze Array spart unserer Maschine wertvolle Zeit.

Ich empfehle diese Methode überall dort einzusetzen, wo es nötig ist - Zuweisung des Memorys, jedes Mal wenn ein neues Interpretationsobjekt auftaucht. Wird keine präzise Information über die Memory-Menge verlangt, müssen wir ihm einem ungefähren Wert zuweisen. Das geht auf jeden Fall schneller, als bei jedem Schritt das gesamte Array erneut zuweisen zu müssen.

Danach folgt die Schleife, in der alle Abschlüsse einer Position mit Hilfe von drei Filtern gefiltert werden: ob der der Abschluss in, in/out oder out ist. Für jede Variante werden spezifische Handlungen implementiert. Die Filter sind sequentiell und verschachtelt. Wenn also ein Filter false liefert, dann, und nur dann, prüfen wir den nächsten Filter. Eine derartige Bauweise ist bei Ressourcen wirtschaftlich, da alle unnötigen Handlungen unterbunden werden. Für eine bessere Lesbarkeit des Codes werden viele Handlungen den in der Klasse als private Funktionen deklarierten Funktionen übertragen. Ach übrigens: Während der Entwicklung waren diese Funktionen public, doch ich habe später gemerkt habe, dass sie in anderen Teilen des Codes nicht gebraucht werden, und daher wurden sie als private um-deklariert. So leicht kann man den Geltungsbereich von Daten in OOP verändern.

Also: Im in Filter wird die Erzeugung eines neuen Handels ausgeführt (die open_pos() Funktion). Deshalb erhöhen wir die Größe des Zeiger-Arrays um 1 und kopieren die Struktur des Abschlusses in die entspr. Felder der Struktur des Handels. Und da überdies die Struktur des Handels zweimal mehr Felder für Kurs und Zeit hat, werden nur Eröffnungsfelder bei der Eröffnung eines Handels befüllt, damit er als nicht abgeschlossen gilt. Dies wird angesichts der Differenz von count_trades und trades_ends einsichtig. Worum es hier geht ist, dass die Zähler zu Beginn Null-Werte haben. Sobald ein Handel auftaucht, erhöht sich der count_trades Zähler; wird ein Handel abgeschlossen, erhöht sich der trades_ends Zähler. Daher zeigt die Differenz zwischen count_trades und trades_ends an, wie viele Handel zu jedem beliebigen Zeitpunkt eben nicht abgeschlossen sind.

Die open_pos() Funktion ist ziemlich einfach: sie öffnet nur Handel und löst den entspr. Zähler aus. Andere ähnliche Funktionen sind nicht so einfach. Wenn also ein Abschluss kein in Abschluss ist, kann er entweder ein in/out oder out Abschluss sein. Von diesen zwei Varianten sollte zunächst diejenige überprüft werden, die leichter ausgeführt wird (zwar kein grundlegendes Problem, doch habe ich die Prüfung in der Reihenfolge zunehmender Schwierigkeit ihrer Ausführung angelegt).

Die Funktion, die den in/out Filter verarbeitet, summiert die offenen Positionen nach allen nicht abgeschlossen Handel (ich habe bereits darauf hingewiesen, wie man mittels der Differenz zwischen count_trades und trades_ends herausfindet, welche Handel noch offen sind). Also berechnen wir das Gesamtvolumen, das durch jeden gegebenen Abschluss geschlossen wird (und das restliche Volumen wird erneut eröffnet, doch mit der Art des aktuellen Abschlusses). Hier muss darauf hingewiesen werden, dass der Abschluss die in/out Richtung hat, d.h. sein Volumen nicht das Gesamtvolumen aller zuvor eröffneten Positionen übersteigt. Nur logisch also, die Differenz zwischen der Position und des in/out Abschlusses zu berechnen, um das Volumen des neuen Handels zu kennen, der erneut eröffnet werden soll.

Weist ein Abschluss die out Richtung auf, wird es leider noch komplizierter. Zunächst besitzt der letzte Abschluss in einer Position immer die out Richtung, also sollten wir hier mal eine Ausnahme machen - ist es der letzte Abschluss, wird alles was wir haben, geschlossen. Ansonsten (wenn der Abschluss nicht der letzte ist), sind zwei Varianten möglich. Da der Abschluss keine in/out Richtung besitzt, sondern ein out-Abschluss ist, ergeben sich folgende Varianten: die erste Variante ist exakt die gleiche wie die Eröffnungs-Variante, d.h. das Volumen des Eröffnungs-Abschlusses ist gleich dem Volumen des schließenden Abschlusses; Variante 2 ist: beide Volumen sind nicht gleich.

Die erste Variante wird durch Schließen verarbeitet. Die zweite Variante ist komplizierter - hier gibt es wieder zwei Möglichkeiten: entweder das Volumen ist größer oder das Volumen ist geringer als das der Eröffnung. Ist das Volumen größer, schließen wir den nächsten Handel, bis das Volumen des Schließens gleich oder größer wird als das Volumen des Öffnens. Reicht das Volumen für einen Schließen des kompletten nächsten Handels nicht aus (weniger Volumen), dann tritt teilweises Schließen in Kraft. Hier müssen wir den Handel mit dem neuen Volumen schließen (dasjenige, das nach vorherigen Operationen noch übrig ist). Doch zuvor sollte man eine Kopie des Handels mit dem fehlenden Volumen anlegen. Und natürlich die Zähler nicht vergessen!

Beim Handeln kann oft eine Situation auftreten, in der nach der Wiedereröffnung eines Handels bereits spätere Handel für teilweises Schließen in der Warteschlange stehen. Um hier Verwirrung zu vermeiden, sollten sie alle um einen verschoben werden, damit die Chronologie des Schließens beibehalten wird.

//+------------------------------------------------------------------+
//| transformation of deals into trades (engine classes)             |
//+------------------------------------------------------------------+
void C_Pos::OnHistoryTransform()
  {
   DigitMinLots();// fill the DIGITS value
   count_trades=0;trades_ends=0;
   ArrayResize(m_trades_stats,count_trades,count_deals);
   for(int c=0;c<count_deals;c++)
     {
      if(m_deals_stats[c].deals_entry==DEAL_ENTRY_IN)
        {
         open_pos(c);
        }
      else// else in
        {
         double POS=0;
         for(int i=trades_ends;i<count_trades;i++)POS+=m_trades_stats[i].trade_volume;

         if(m_deals_stats[c].deals_entry==DEAL_ENTRY_INOUT)
           {
            for(int i=trades_ends;i<count_trades;i++)close_pos(i,c);
            trades_ends=count_trades;
            open_pos(c);
            m_trades_stats[count_trades-1].trade_volume=m_deals_stats[c].deals_volume-POS;
           }
         else// else in/out
           {
            if(m_deals_stats[c].deals_entry==DEAL_ENTRY_OUT)
              {
               if(c==count_deals-1)// if it's the last deal
                 {
                  for(int i=trades_ends;i<count_trades;i++)close_pos(i,c);
                  trades_ends=count_trades-1;
                 }
               else// if it's not the last deal
                 {
                  double out_vol=nd(m_deals_stats[c].deals_volume);
                  while(nd(out_vol)>0)
                    {
                     if(nd(out_vol)>=nd(m_trades_stats[trades_ends].trade_volume))
                       {
                        close_pos(trades_ends,c);
                        out_vol-=nd(m_trades_stats[trades_ends].trade_volume);
                        trades_ends++;
                       }
                     else// if the remainder of closed position is less than the next trade
                       {
                        // move all trades forward by one
                        count_trades++;
                        ArrayResize(m_trades_stats,count_trades);
                        for(int x=count_trades-1;x>trades_ends;x--)copy_pos(x);
                        // open a copy with the volume equal to difference of the current position and the remainder
                        m_trades_stats[trades_ends+1].trade_volume=nd(m_trades_stats[trades_ends].trade_volume-out_vol);
                        // close the current trade with new volume, which is equal to remainder
                        close_pos(trades_ends,c);
                        m_trades_stats[trades_ends].trade_volume=nd(out_vol);
                        out_vol=0;
                        trades_ends++;
                       }
                    }// while(out_vol>0)
                 }// if it's not the last deal
              }// if out
           }// else in/out
        }// else in
     }
  };


Berechnung der Effektivität

Ist das Interpretationssystem umgewandelt, können wir die Effektivität der Handel gemäß Bulachevs Methode durchführen. Die für eine solche Bewertung erforderlichen Funktionen befinden sich in der efficiency() Methode, und das Befüllen der Handelsstruktur mit den berechneten Daten findet ebenfalls dort statt. Die Effektivität von Einstieg und Ausstieg wird von 0 - 1 und für den gesamten Handel von -1 - 1gemessen.

//+------------------------------------------------------------------+
//| calculation of effectiveness                                     |
//+------------------------------------------------------------------+
void C_Pos::efficiency()
  {
   for(int i=0;i<count_trades;i++)
     {
      m_trades_stats[i].max_price_trade=iHighest(symbol,PERIOD_M1,m_trades_stats[i].enter_date,m_trades_stats[i].exit_date); // maximal price of trade
      m_trades_stats[i].min_price_trade=iLowest(symbol,PERIOD_M1,m_trades_stats[i].enter_date,m_trades_stats[i].exit_date);  // minimal price of trade
      double minimax=0;
      minimax=m_trades_stats[i].max_price_trade-m_trades_stats[i].min_price_trade;// difference between maximum and minimum
      if(minimax!=0)minimax=1.0/minimax;
      if(m_trades_stats[i].trade_type==DEAL_TYPE_BUY)
        {
         //Effectiveness of entering a position
         m_trades_stats[i].enter_efficiency=(m_trades_stats[i].max_price_trade-m_trades_stats[i].enter_price)*minimax;
         //Effectiveness of exiting from a position
         m_trades_stats[i].exit_efficiency=(m_trades_stats[i].exit_price-m_trades_stats[i].min_price_trade)*minimax;
         //Effectiveness of trade
         m_trades_stats[i].trade_efficiency=(m_trades_stats[i].exit_price-m_trades_stats[i].enter_price)*minimax;
        }
      else
        {
         if(m_trades_stats[i].trade_type==DEAL_TYPE_SELL)
           {
            //Effectiveness of entering a position
            m_trades_stats[i].enter_efficiency=(m_trades_stats[i].enter_price-m_trades_stats[i].min_price_trade)*minimax;
            //Effectiveness of exiting from a position
            m_trades_stats[i].exit_efficiency=(m_trades_stats[i].max_price_trade-m_trades_stats[i].exit_price)*minimax;
            //Effectiveness of trade
            m_trades_stats[i].trade_efficiency=(m_trades_stats[i].enter_price-m_trades_stats[i].exit_price)*minimax;
           }
        }
     }
  }


Diese Methode verwendet zwei private Methoden: iHighest() und iLowest(), Sie ähneln sich sehr, ihr einziger Unterschied liegt in den angefragten Daten und der Suchfunktion fmin oder fmax.

//+------------------------------------------------------------------+
//| searching maximum within the period start_time --> stop_time     |
//+------------------------------------------------------------------+
double C_Pos::iHighest(string           symbol_name,// symbols name
                       ENUM_TIMEFRAMES  timeframe,  // period
                       datetime         start_time, // start date
                       datetime         stop_time   // end date
                       )
  {
   double  buf[];
   datetime  start_t=(start_time/60)*60;// normalization of time of opening
   datetime  stop_t=(stop_time/60+1)*60;// normaliztion of time of closing  
   int period=CopyHigh(symbol_name,timeframe,start_t,stop_t,buf);
   double res=buf[0];
   for(int i=1;i<period;i++)
      res=fmax(res,buf[i]);
   return(res);
  }

Diese Methode sucht nach dem Maximum innerhalb der Zeitspanne zwischen zwei festgelegter Daten, die dann an die Funktion als start_time und stop_time Parameter übertragen werden. Und da die Handelsdaten an die Funktion übertragen werden und eine Handels-Anfrage sogar in der Mitte eines 1-Minuten Bars auftauchen kann, werden die Daten auf den nächsten Wert des Bars innerhalb der Funktion normalisiert. Das gleiche passiert auch in der iLowest() Funktion. Mit der nun entwickelten efficiency()-Methode haben wir die komplette Funktionalität vor uns, um mit einer Position arbeiten zu können. Die Position an sich ist bislang allerdings noch nicht angerührt worden. Dies kann durch die Festlegung einer neuen Klasse übergangen werden, der alle vorherigen Methoden zur Verfügung stehen, daher muss diese Klasse als ein Derivativ der C_Pos deklariert werden.


Derivative Klasse (Maschinenklassen)

class C_PosStat:public C_Pos

Zur Berücksichtigung von statistischer Information muss eine Struktur erzeugt werden, die der neuen Klasse gegeben wird, und natürlich

//+------------------------------------------------------------------+
//| structure of effectiveness                                       |
//+------------------------------------------------------------------+
struct S_efficiency

  {
   double            enter_efficiency; // effectiveness of entering
   double            exit_efficiency;  // effectiveness of exiting
   double            trade_efficiency; // effectiveness of trade
                     S_efficiency()
     {
      enter_efficiency=0;
      exit_efficiency=0;
      trade_efficiency=0;
     };
                    ~S_efficiency(){};
  };


der Körper der Klasse selbst:

//+------------------------------------------------------------------+
//| class of statistics of trade in whole                            |
//+------------------------------------------------------------------+
class C_PosStat:public C_Pos
  {
public:
   int               PosTotal;         // number of positions in history
   C_Pos             pos[];            // array of pointers to positions
   int               All_count_trades; // total number of trades in history
   S_efficiency      trade[];          // array of pointers to the structure of effectiveness of entering, exiting and trades
   S_efficiency      avg;              // pointer to the structure of average value of effectiveness of entering, exiting and trades
   S_efficiency      stdev;            // pointer to the structure of standard deviation from
                                       // average value of effectiveness of entering, exiting and trades

                     C_PosStat(){PosTotal=0;};
                    ~C_PosStat(){};
   void              OnPosStat();                         // engine classes
   void              OnTradesStat();                      // gathering information about trades into the common array
   
   // functions of writing information to a file
   void              WriteFileDeals(string folder="deals");
   void              WriteFileTrades(string folder="trades");
   void              WriteFileTrades_all(string folder="trades_all");
   void              WriteFileDealsHTML(string folder="deals");
   void              WriteFileDealsHTML2(string folder="deals");
   void              WriteFileTradesHTML(string folder="trades");
   void              WriteFileTradesHTML2(string folder="trades");
   string            enum_translit(ENUM_DEAL_ENTRY x,bool latin=true);// transformation of enumeration into string
   string            enum_translit(ENUM_DEAL_TYPE x,bool latin=true); 
                                                              // transformation of enumeration into string (overloaded)
private:   

   S_efficiency      AVG(int count);                                        // arithmetical mean
   S_efficiency      STDEV(const S_efficiency &mo,int count);               // standard deviation
   S_efficiency      add(const S_efficiency &a,const S_efficiency &b);      //add
   S_efficiency      take(const S_efficiency &a,const S_efficiency &b);     //subtract
   S_efficiency      multiply(const S_efficiency &a,const S_efficiency &b); //multiply
   S_efficiency      divided(const S_efficiency &a,double b);               //divide
   S_efficiency      square_root(const S_efficiency &a);                    //square root
   string            Head_style(string title);
  };  


Mein Vorschlag: eine Analyse dieser Klasse in umgekehrter Richtung, also vom Ende bis zum Anfang. Denn alles endet mit dem Schreiben einer Abschluss- und Handel-Tabelle in Dateien. Dazu wird eine Reihe von Funktionen geschrieben (ihr jeweiliger Zweck lässt sich aus dem jeweiligen Namen der Funktion ablesen). Diese Funktionen erstellen einen csv-Bericht zu Abschlüssen und Handel sowie auch html-Berichte zweierlei Arten (unterscheiden sich nur vom Aussehen her, ihr Inhalt ist gleich).

      void              WriteFileDeals();      // writing csv report on deals
      void              WriteFileTrades();     // writing csv report on trade
      void              WriteFileTrades_all(); // writing summary csv report of fitness functions
      void              WriteFileDealsHTML2(); // writing html report on deals, 1 variant
      void              WriteFileTradesHTML2();// writing html report on trades, 2 variant

Die enum_translit() Funktion übernimmt die Umwandlung der Werte der Aufzählungen in String-Typen, um sie in die Log-Datei zu schreiben. Der private Bereich enthält mehrere Funktionen der S_efficiency-Struktur. All diese Funktionen bügeln die Nachteile der Sprache aus, insb. die arithmetischen Operationen mit Strukturen. Da die Meinungen zur Implementierung dieser Methoden auseinander gehen, können sie auf unterschiedliche Art und Weise realisiert werden. Ich habe mich für Methoden arithmetischer Operationen an den Strukturfeldern entschieden. Klar kann man jetzt sagen, es sei besser jedes Strukturfeld einzeln mit Hilfe einer individuellen Methode zu verarbeiten. Hier gilt wahrscheinlich, dass es so viele Meinungen gibt wie Programmierer. Ich hoffe sehr, dass wir in Zukunft derartige Operationen mit Hilfe eingebauter Methoden durchführen können.

Die AVG() Methode berechnet den arithmetischen Mittelwert eines übertragenen Arrays, zeigt jedoch nicht das gesamte Bild der Verteilung an. Deswegen wird sie durch eine andere Methode, der STDEV()-Methode, die die Standard-Abweichungen berechnet, unterstützt. Die OnTradesStat() Funktion holt sich die Werte der Effektivität (zuvor in OnPosStat() berechnet) und verarbeitet sie mit Statistikmethoden. Und zu guter Letzt, die Hauptfunktion der Klasse - OnPosStat().

Diese Funktion sollte man sich detaillierter ansehen. Sie besteht aus zwei Teilen und kann daher leicht unterteilt werden. Ihr erster Teil sucht nach allen Positionen und verarbeitet ihre ID via Speichern in das temporäre Array id_pos. Gehen wir Schritt für Schritt vor: die gesamte, vorhandene History auswählen, die Anzahl der Abschlüsse berechnen und den Verarbeitungszyklus der Abschlüsse ablaufen lassen. Verarbeitungszyklus: handelt es sich um einen Abschluss der 'Saldo'-Art, kann er übersprungen werden (ein Start-Abschluss muss nicht interpretiert werden). Ansonsten bitte die Positions-ID in der Variable speichern und die Suche ausführen, Gibt es die gleiche ID in der Basis bereits (das id_pos Array), zum nächsten Abschluss gehen; ansonsten die ID in die Basis schreiben. Auf diese Art haben wir nach der Verarbeitung aller Abschlüsse ein Array, das mit den bestehendenID s der Positionen und ihrer Anzahl befüllt ist.

   long  id_pos[];// auxiliary array for creating the history of positions
   if(HistorySelect(0,TimeCurrent()))
     {
      int HTD=HistoryDealsTotal();
      ArrayResize(id_pos,PosTotal,HTD);
      for(int i=0;i<HTD;i++)
        {
         ulong DTicket=(ulong)HistoryDealGetTicket(i);
         if((ENUM_DEAL_TYPE)HistoryDealGetInteger(DTicket,DEAL_TYPE)==DEAL_TYPE_BALANCE)
            continue;// if it's a balance deal, skip it
         long id=HistoryDealGetInteger(DTicket,DEAL_POSITION_ID);
         bool present=false; // initial state, there's no such position           
         for(int j=0;j<PosTotal;j++)
           { if(id==id_pos[j]){ present=true; break; } }// if such position already exists break

         if(!present)// write id as a new position appears
           {
            PosTotal++;
            ArrayResize(id_pos,PosTotal);
            id_pos[PosTotal-1]=id;
           }
        }
     }
   ArrayResize(pos,PosTotal);

Ihr zweiter Teil zeigt uns alle zuvor in der Basis-Klasse C_Pos beschriebenen Methoden. Sie besteht aus einem Zyklus, der die Positionen durchgeht und die entsprechenden Methoden zur Verarbeitung der Positionen ablaufen lässt. Eine Beschreibung der Methode findet sich im unten stehenden Code,

   for(int p=0;p<PosTotal;p++)
     {
      if(HistorySelectByPosition(id_pos[p]))// select position
        {
         pos[p].pos_id=id_pos[p]; // assigned id of position to the corresponding field of the class C_Pos
         pos[p].count_deals=HistoryDealsTotal();// assign the number of deal in position to the field of the class C_Pos
         pos[p].symbol=HistoryDealGetString(HistoryDealGetTicket(0),DEAL_SYMBOL);// the same actions with symbol
         pos[p].OnHistory();          // start filling the structure sd with the history of position
         pos[p].OnHistoryTransform(); // transformation of interpretation, filling the structure st.
         pos[p].efficiency();         // calculation of the effectiveness of obtained data
         All_count_trades+=pos[p].count_trades;// save the number of trades for displaying the total number
        }
     }


Aufruf der Methoden der Klasse

Jetzt haben wir also die komplette Klasse behandelt. Bleibt noch, ein Beispiel eines Aufrufs zu präsentieren. Um alle Möglichkeiten des Bauens offen zuhalten, habe ich den Aufruf absichtlich nicht in einer Funktion deklariert. Zusätzlich können Sie die Klasse für Ihren Bedarf erweitern und neue Methoden statistischer Datenverarbeitung implementieren. Dies ist ein Beispiel des Aufrufs der Methode der Klasse aus dem Script:

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
#include <Bulaschev_Statistic.mqh> void OnStart()
  {
   C_PosStat  start;
   start.OnPosStat();
   start.OnTradesStat();
   start.WriteFileDeals();
   start.WriteFileTrades();
   start.WriteFileTrades_all();
   start.WriteFileDealsHTML2();
   start.WriteFileTradesHTML2();
   Print("cko tr ef=" ,start.stdev.trade_efficiency);
   Print("mo  tr ef=" ,start.avg.trade_efficiency);
   Print("cko out ef=",start.stdev.exit_efficiency);
   Print("mo  out ef=",start.avg.exit_efficiency);
   Print("cko in ef=" ,start.stdev.enter_efficiency);
   Print("mo  in ef=" ,start.avg.enter_efficiency);
  }

Das Script erzeugt 5 Berichtsdateien, gemäß der Zahl der Funktionen, die Daten in die Datei im Files\OnHistory Directory schreiben. Hier findet man die folgenden Hauptfunktionen: OnPosStat() und OnTradesStat(). Mit ihnen werden alle notwendigen Methoden aufgerufen. Das Script schließt mit dem Ausdruck des erhaltenen Effektivitätswerts des Handels insgesamt. Jeder einzelne Wert kann für eine genetische Optimierung genutzt werden.

Da es nicht nötig ist, jeden Bericht währen der Optimierung in eine Datei zu schreiben, sieht der Aufruf der Klasse in einem Expert Advisor etwas anders aus. Zunächst kann ein Expert Advisor, im Gegensatz zu einem Script, im Tester laufen gelassen werden (dafür haben wir ihn ja auch vorbereitet). Doch die Arbeit im Strategie-Tester hat so ihre Besonderheiten. Bei der Optimierung haben wir Zugriff auf die OnTester() Funktion, da sie hier vor der Ausführung der OnDeinit() Funktion ausgeführt wird. Daher kann der Aufruf der Hauptmethoden der Umwandlung getrennt werden. Aus Gründen einer bequemen Modifizierung der Eignungsfunktion von den Parametern eines Expert Advisors aus, habe ich eine Aufzählung gobal deklariert und nicht als Teil der Klasse. So steht diese Aufzählung auf dem gleichen Blatt wie die Methoden der Klasse C_PosStat.

//+------------------------------------------------------------------+
//| enumeration of fitness functions                                 |
//+------------------------------------------------------------------+
enum Enum_Efficiency
  {
   avg_enter_eff,
   stdev_enter_eff,
   avg_exit_eff,
   stdev_exit_eff,
   avg_trade_eff,
   stdev_trade_eff
  };

 Und das sollte der Überschrift des Expert Advisors hinzugefügt werden.

#include <Bulaschev_Statistic.mqh>
input Enum_Efficiency result=0;// Fitness function


Jetzt können wir die Übertragung der notwendigen Parameter mittels des Switch Operators beschreiben.

//+------------------------------------------------------------------+
//| Expert optimization function                                     |
//+------------------------------------------------------------------+
double OnTester()
  {
   start.OnPosStat();
   start.OnTradesStat();
   double res;
   switch(result)
     {
      case 0: res=start.avg.enter_efficiency;    break;
      case 1: res=-start.stdev.enter_efficiency; break;
      case 2: res=start.avg.exit_efficiency;     break;
      case 3: res=-start.stdev.exit_efficiency;  break;
      case 4: res=start.avg.trade_efficiency;    break;
      case 5: res=-start.stdev.trade_efficiency; break;
      default : res=0; break;
     }  
   return(res);
  }

Hier möchte ich besonders darauf hinweisen. dass die OnTester() Funktion zur Maximierung der angepassten Funktion verwendet wird. Wenn Sie also das Minimum der angepassten Funktion finden müssen, empfiehlt es sich, die Funktion als solches umzukehren und mit -1 zu multiplizieren. Wie im Beispiel mit der Standardabweichung, versteht hier jeder, dass je kleiner die stdev (Standardabweichung) ist, umso geringer auch die Differenz zwischen der Effektivität von Handel ist, und somit ihre Stabilität höher. Daher sollte stdev minimiert werden. Wir haben uns jetzt mit dem Aufruf der Klassenmethode beschäftigt, daher werfen wir nun einen Blick auf das Schreiben von Berichten in eine Datei.

Ich habe vorhin die Klassenmethoden erwähnt, die den Bericht erzeugen. Sehen wir uns jetzt an, wo und wann man sie aufrufen sollte. Die Berichte sollten nur dann erzeugt werden, wenn der EA für einen einzigen Ablauf gestartet wird. Denn sonst erzeugt der Expert Advisor die Dateien im Optimierungs-Modus, d.h. anstatt einer Datei erzeugt er eine Menge Dateien (wenn unterschiedliche Dateinamen jedes Mal übertragen werden) oder nur eine, doch dies ist dann die letzte mit demselben Namen für alle Durchläufe. Und das ist absolut bedeutungslos, da für Informationen, die später sowieso gelöscht werden, hier nur Ressourcen verschwendet werden.

Also, bitte keine Berichtsdateien während der Optimierung erzeugen. Sollten Sie viele Dateien mit unterschiedlichen Namen erhalten, dann wollen Sie die meisten sowieso nicht öffnen. Die zweite Variante verschwendet eben nur Unmengen Ressourcen zum Erhalt von Informationen, die sofort wieder gelöscht wird.

Daher ist es am besten einen Filter anzulegen (den Bericht also nur im Optimierung [deaktiviert] Modus starten). Dadurch wird die Festplatte des Rechners nicht mit Berichten, die sich niemand jemals ansieht, zugemüllt. Zudem erhöht sich auch die Optimierungsgeschwindigkeit (jeder weiß doch, dass die langsamsten Abläufe Datei-Abläufe sind). Also bleibt die Möglichkeit, schnell einen Bericht mit den notwendigen Parametern zu erhalten, gewahrt. Es spielt in der Tat keine Rolle, wo man den Filter platziert - entweder in der OnTester oder der OnDeinit Funktion. Das Wichtigste ist, dass dies die Klassenmethoden sind, die den Bericht erzeugen, und sie daher nach den Hauptmethoden, die die Umwandlung ausführen, aufgerufen werden sollten. Ich habe den Filter in OnDeinit() platziert, um den Code nicht zu überladen:

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   if(!(bool)MQL5InfoInteger(MQL5_OPTIMIZATION))
     {
      start.WriteFileDeals();      // writing csv report on deals
      start.WriteFileTrades();     // writing csv report on trades
      start.WriteFileTrades_all(); // writing summary csv report on fitness functions
      start.WriteFileDealsHTML2(); // writing html report on deals
      start.WriteFileTradesHTML2();// writing html report on trades
     }
  }
//+------------------------------------------------------------------+

Die Abfolge des Aufrufs der Methoden ist ebenfalls unwichtig. Alles was zur Erstellung von Berichten erforderlich ist, wird in den OnPosStat und OnTradesStat Methoden vorbereitet. Es spielt ebenfalls keine Rolle, ob Sie alle Methoden zur Berichtsverfassung aufrufen oder nur einige. Jede Methode wird separat betrieben, es handelt sich nur um die Interpretation von Informationen, die bereits in der Klasse gespeichert sind.

Prüfung im Strategie-Tester

Unten stehen die Ergebnisse eines einzigen Testlaufs im Strategie-Tester:

Handels-Bericht Gleitende Mittelwert-Statistik
# Ticket Art Volumen Eröffnung Schluss Kurs Effizienz
offen geschlossen Kurs Zeit Kurs Zeit max min Einstieg Ausstieg Handel
Pos[0] ID 2 EURUSD
0 2 3 Buy 0,1 1,37203 15.03.2010 13:00:00 1,37169 15.03.2010 14:00:00 1,37236 1,37063 0,19075 0,61272 -0,19653
Pos[1] ID 4 EURUSD
1 4 5 Sell 0,1 1,35188 23.03.2010 08:00:00 1,35243 23.03.2010 10:00:00 1,35292 1,35025 0,61049 0,18352 -0,20599
Pos[2] ID 6 EURUSD
2 6 7 Sell 0,1 1,35050 23.03.2010 12:00:00 1,35343 23.03.2010 16:00:00 1,35600 1,34755 0,34911 0,30414 -0,34675
Pos[3] ID 8 EURUSD
3 8 9 Sell 0,1 1,35167 23.03.2010 18:00:00 1,33343 2010,03,26 05:00:00 1,35240 1,32671 0,97158 0,73842 0,71000
Pos[4] ID 10 EURUSD
4 10 11 Sell 0,1 1,34436 30.03.2010 16:00:00 1,33616 08.04.2010 23:00:00 1,35904 1,32821 0,52384 0,74213 0,26597
Pos[5] ID 12 EURUSD
5 12 13 Buy 0,1 1,35881 13.04.2010 08:00:00 1,35936 13.04.2010 15 10:00:00 1,36780 1,35463 0,68261 0,35915 0,04176
Pos[6] ID 14 EURUSD
6 14 15 Sell 0,1 1,34735 13.04.2010 20 04:00:00 1,34807 13.04.2010 20 10:00:00 1,34890 1,34492 0,61055 0,20854 -0,18090
Pos[7] ID 16 EURUSD
7 16 17 Sell 0,1 1,34432 13.04.2010 20 18:00:00 1,33619 13.04.2010 23 17:00:00 1,34491 1,32016 0,97616 0,35232 0,32848
Pos[8] ID 18 EURUSD
8 18 19 Sell 0,1 1,33472 13.04.2010 27 10:00:00 1,32174 13.04.2010 29 05:00:00 1,33677 1,31141 0,91916 0,59267 0,51183
Pos[9] ID 20 EURUSD
9 20 21 Sell 0,1 1,32237 03.05.2010 04:00:00 1,27336 07.05.2010 20:00:00 1,32525 1,25270 0,96030 0,71523 0,67553

Effektivitäts-Bericht
Eignungs-Funktion Mittelwert Standardabweichung
Einstieg 0,68 0,26
Ausstieg 0,48 0,21
Handel 0,16 0,37


Und so sieht der Saldo-Graph aus:


Man erkennt auf dem Chart eindeutig, dass die angepasste Optimierungsfunktion nicht versucht, die Parameter mit den größeren Mengen an Abschlüssen zu wählen, sondern die Abschlüsse mit längerer Dauer, denn da haben die Abschlüsse fast den gleichen Gewinn, d.h. die Sprünge sind nicht so hoch.

Da der Moving Averages Code die Merkmale des ansteigenden Volumens der Position oder ihres teilweisen Abschlusses nicht enthält, scheint das Ergebnis der Umwandlung nicht sehr nahe an dem zu liegen, was ich oben beschrieben habe. Doch wenn Sie das Script im Account starten, der extra zum Testen der Codes eröffnet wude, dann ergibt sich ein anderes Ergebnis. Und das sehen Sie hier:

Pos[286] ID 1019514 EURUSD
944 1092288 1092289 Buy 0,1 1,26733 08.07.2010 21:14:49 1,26719 08.07.2010 21:14:57 1,26752 1,26703 0,38776 0,32653 -0,28571
Pos[287] ID 1019544 EURUSD
945 1092317 1092322 Sell 0,2 1,26761 08.07.2010 21:21:14 1,26767 08.07.2010 21:22:29 1,26781 1,26749 0,37500 0,43750 -0,18750
946 1092317 1092330 Sell 0,2 1,26761 08.07.2010 21:21:14 1,26792 08.07.2010 21:24:05 1,26782 1,26749 0,36364 -0,30303 -0,93939
947 1092319 1092330 Sell 0,3 1,26761 08.07.2010 21:21:37 1,26792 2010,07,08 21:24:05 1,26782 1,26749 0,36364 -0,30303 -0,93939
Pos[288] ID 1019623 EURUSD
948 1092394 1092406 Buy 0,1 1,26832 08.07.2010 21:36:43 1,26843 08.07.2010 21:37:38 1,26882 1,26813 0,72464 0,43478 0,15942
Pos[289] ID 1019641 EURUSD
949 1092413 1092417 Buy 0,1 1,26847 08.07.2010 21:38:19 1,26852 08.07.2010 21:38:51 1,26910 1,26829 0,77778 0,28395 0,06173
950 1092417 1092433 Sell 0,1 1,26852 08.07.2010 21:38:51 1,26922 08.07.2010 21:39:58 1,26916 1,26829 0,26437 -0,06897 -0,80460
Pos[290] ID 1150923 EURUSD
951 1226007 1226046 Buy 0,2 1,31653 05.08.2010 16:06:20 1,31682 05.08.2010 16:10:53 1,31706 1,31611 0,55789 0,74737 0,30526
952 1226024 1226046 Buy 0,3 1,31632 05.08.2010 16:08:31 1,31682 05.08.2010 16:10:53 1,31706 1,31611 0,77895 0,74737 0,52632
953 1226046 1226066 Sell 0,1 1,31682 05.08.2010 16:10:53 1,31756 05.08.2010 16:12:49 1,31750 1,31647 0,33981 -0,05825 -0,71845
954 1226046 1226078 Sell 0,2 1,31682 05.08.2010 16:10:53 1,31744 05.08.2010 16:15:16 1,31750 1,31647 0,33981 0,05825 -0,60194
Pos[291] ID 1155527 EURUSD
955 1230640 1232744 Sell 0,1 1,31671 06.08.2010 13:52:11 1,32923 06.08.2010 17:39:50 1,33327 1,31648 0,01370 0,24062 -0,74568
956 1231369 1232744 Sell 0,1 1,32584 06.08.2010 14:54:53 1,32923 06.08.2010 17:39:50 1,33327 1,32518 0,08158 0,49938 -0,41904
957 1231455 1232744 Sell 0,1 1,32732 06.08.2010 14:58:13 1,32923 06.08.2010 17:39:50 1,33327 1,32539 0,24492 0,51269 -0,24239
958 1231476 1232744 Sell 0,1 1,32685 06.08.2010 14:59:47 1,32923 06.08.2010 17:39:50 1,33327 1,32539 0,18528 0,51269 -0,30203
959 1231484 1232744 Sell 0,2 1,32686 06.08.2010 15:00:20 1,32923 06.08.2010 17:39:50 1,33327 1,32539 0,18655 0,51269 -0,30076
960 1231926 1232744 Sell 0,4 1,33009 06.08.2010 15:57:32 1,32923 06.08.2010 17:39:50 1,33327 1,32806 0,38964 0,77543 0,16507
961 1232591 1232748 Sell 0,4 1,33123 06.08.2010 17:11:29 1,32850 06.08.2010 17:40:40 1,33129 1,32806 0,98142 0,86378 0,84520
962 1232591 1232754 Sell 0,4 1,33123 06.08.2010 17:11:29 1,32829 06.08.2010 17:42:14 1,33129 1,32796 0,98198 0,90090 0,88288
963 1232591 1232757 Sell 0,2 1,33123 06.08.2010 17:11:29 1,32839 06.08.2010 17:43:15 1,33129 1,32796 0,98198 0,87087 0,85285
Pos[292] ID 1167490 EURUSD
964 1242941 1243332 Sell 0,1 1,31001 10.08.2010 15:54:51 1,30867 10.08.2010 17:17:51 1,31037 1,30742 0,87797 0,57627 0,45424
965 1242944 1243333 Sell 0,1 1,30988 10.08.2010 15:55:03 1,30867 10.08.2010 17:17:55 1,31037 1,30742 0,83390 0,57627 0,41017
Pos[293] ID 1291817 EURUSD
966 1367532 1367788 Sell 0,4 1,28904 06.09.2010 00:24:01 1,28768 06.09.2010 02:53:21 1,28965 1,28710 0,76078 0,77255 0,53333


So sieht also die umgewandelte Information aus. Damit sich jeder Leser das alles hier ganz in Ruhe ansehen kann (und Verständnis kommt durch Vergleichen), speichere ich die Original-History der Abschlüsse in einer extra Datei. Das ist die History, die so viele Händler jetzt so sehr vermissen, die bislang daran gewöhnt waren, sie im Abschnitt [Ergebnisse] in MetaTrader 4 zu finden.

Fazit

Zusammenfassend möchte ich allen Entwicklern vorschlagen, eine Möglichkeit hinzuzufügen, Expert Advisors nicht nur durch angepasste Parameter optimieren zu können, sondern dies in Kombination mit den Standardparametern machen zu können, so wie es auch bei den anderen Optimierungsfunktionen der Fall ist. Als Zusammenfassung dieses Beitrag bleibt zu sagen, dass hier nur die Grundlagen angesprochen wurden - das Anfangspotenzial - und ich sehr hoffe, dass jeder Leser in der Lage sein wird, die Klasse je nach seinen eignen Bedürfnissen erweitern zu können. Viel Erfolg!

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/137

Beigefügte Dateien |
posstat.mq5 (1.71 KB)
Verschiedene Wege zur Ermittlung eines Trends in MQL5 Verschiedene Wege zur Ermittlung eines Trends in MQL5

Welcher Händler würde nicht alles für die Möglichkeit geben, das Vorliegen eines Trends zu jedem beliebigen Zeitpunkt exakt zu ermitteln? Das ist möglicherweise der Heilige Gral, nach dem alle suchen. In diesem Beitrag werden wir verschiedene Wege zur Ermittlung eines Trends betrachten. Genauer gesagt sehen wir uns an, wie wir mithilfe von MQL5 einige klassische Arten der Trendermittlung programmieren können.

Mehrfarbige Indikatoren in MQL5 - Erstellung und Anwendung Mehrfarbige Indikatoren in MQL5 - Erstellung und Anwendung

In diesem Beitrag geht es um die Erstellung mehrfarbiger Indikatoren bzw. um die Umwandlung der vorhandenen in mehrfarbige. MQL5 ermöglicht die Darstellung der Informationen in der angemessenen Form. Es ist jetzt nicht nötig, sich dutzende Diagramme mit Indikatoren anzuschauen und Analysen der Oszillatoren RSI oder Stochastik durchzuführen, stattdessen ist es besser, die Kerzen einfach je nach Indikatorwert in unterschiedlichen Farben abzubilden.

Expert Advisor auf Grundlage der New Trading Dimensions von Bill Williams Expert Advisor auf Grundlage der New Trading Dimensions von Bill Williams

In diesem Beitrag geht es um die Entwicklung des Expert Advisors, auf Grundlage des Buchs "New Trading Dimensions: How to Profit from Chaos in Stocks, Bonds, and Commodities" von Bill Williams. Die Strategie selbst ist wohl bekannt, ihre Anwendung jedoch unter Händlern immer noch umstritten. Dieser Beitrag behandelt die Handelssignale des Systems, die spezifischen Charakteristika seiner Implementierung und die Testergebnisse vor dem Hintergrund historischer Daten.

Adaptive Handelssysteme und ihre Verwendung im MetaTrader 5 Client-Terminal Adaptive Handelssysteme und ihre Verwendung im MetaTrader 5 Client-Terminal

Dieser Beitrag möchte eine Variante eines adaptiven Systems vorstellen, die aus vielen Strategien besteht, von denen jede ihre eigenen "virtuellen" Handels-Operationen durchführt. Echter Handel wird in Übereinstimmung mit den Signalen der in diesem Augenblick gewinnbringendsten Strategie ausgeführt. Dank der Verwendung des Objekt-orientierten Ansatzes, der Klassen zur Arbeit mit Daten und der Handelsklassen der Standardbibliothek, macht die Architektur des Systems einen einfachen und aufrüstbaren Eindruck. Jetzt kann man leicht adaptive Systeme mit Hunderten von Handelsstrategien erzeugen und analysieren.