MetaTrader 5 herunterladen

Das Beispiel einer Experteneinstellung

9 November 2015, 09:48
MetaQuotes Software Corp.
0
1 560

Die Grundlagen der Programmierung der Programmierungssprache-MQL4 werden am Beispiel der Erstellung eines einfachen Experten-Advisor-Systems durch den Standard-Indikator-MACD betrachtet. In diesem Expertensystem werden auch die Beispiele der Realisierung solcher Funktionen betrachtet wie die Umsetzung eines Take-profits mit Unterstützung von Trailing-Stop und die meisten Mittel für die sichere Arbeit. In diesem Beispiel wird der Handel durch die Eröffnung und Verwaltung einer einzigen Position durchgeführt.

Handelsprinzipien:

  • Eingang in Long (BUY) - Der MACD-Indikator ist unter Null und geht von unten nach oben und er wird die Signallinie von oben nach unten gekreuzt .

  • Eingang in Short (SELL) - Der MACD-Indikator ist über Null und geht von oben nach unten und er wird durch die Signallinie von unten nach oben gekreuzt.

  • Ausgang aus Long - nach Ausführung des Take-Profit-Limits, nach Ausführung des Trailing-Stops, oder wenn MACD seine Signallinie kreuzt (Der MACD-Indikator ist über Null und geht von oben nach unten und er wird durch die Signalleitung von unten nach oben gekreuzt).

  • Ausgang aus Short - nach Ausführung des Take-Profit-Limits, nach Ausführung des Trailing-Stops, oder wenn MACD seine Signallinie kreuzt (Der MACD-Indikator ist unter Null und geht von unten nach oben und er wird durch die Signalleitung von oben nach unten gekreuzt).

Wichtiger Hinweis: Um die geringfügigen Änderungen des Indikators MACD (kleine `Hügel` auf der Grafik) aus unserer Analyse auszuschließen, führen wir eine zusätzliche Kontrolle über die Größe der aufgezeichneten 'Hügeln' unter dieser Forderung ein - die Größe des Indikators sollte mindestens aus 5 Einheiten des Mindestpreises bestehen(5 * Punkt, der für die USD / CHF = 0,0005 und für USD / JPY = 0,05 bedeutet).


Der erste Schritt - Die Erstellung der Beschreibung des Expert-Advisors

Bewegen Sie den Mauszeiger zu der Expert-Advisor-Sektion des Navigator-Fensters, drücken Sie die rechte Maustaste und wählen Sie den „Create“-Befehl im auftauchenden Menü aus. Der Initialisierung-Wisard des Expert-Advisors wird zur Eingabe einige Daten auffordern:"Name" - der Name des Programms, "Author" - der Autor des Programms, "Link" - der Link zur Web-Seite.

Der zweite Schritt - Die Erstellung der primären Struktur des Programms

Der Quell-Code des Expertes besteht nur aus einigen Seiten, aber auch ein solcher Umfang ist manchmal schwer greifbar. Insbesondere, wenn wir keine professionelle Programmierer sind... Nicht wahr? Sonst benötigten wir diese Beschreibung überhaupt nicht schreiben:)

Um eine Vorstellung von der Struktur einer Standard-Expert-Advisor zu bekommen, Lass Sie uns einen Blick auf die angebotene Beschreibung werfen:

  1. Initialisieren von Variablen

  2. Die erste Datenüberprüfung

    • Die Überprüfung der Grafik, der Anzahl der Balkens (Bars) auf der Grafik

    • Die Überprüfung der externen Variablen Lots, S/L, T/P, T/S

  3. Die Installierung der internen Variablen zum schnellen Datenzugriff

  4. Die Überprüfung des Handelsterminals - ist es leer? Wenn ja, dann:

    • Die Kontrollen: Verfügbarkeit von Geld auf dem Konto usw...

    • ist es möglich, eine Long-Position(BUY) zu nehmen?

      • öffnen eine Long-Position und verlassen

  5. ist es möglich, eine Short-Position(SELL) zu nehmen?

    • öffnen eine Short-Position und verlassen

Verlassen des Expert-Advisors ...
    • Die Kontrolle der Positionen, die zuvor in der Loop geöffnet wurden

      • Wenn es eine Long-Position ist

        • Soll es geschlossen werden?

        • Soll der Trailing-Stop zurückgesetzt werden?

      • Wenn es eine Short-Position ist

        • Soll es geschlossen werden?

        • Soll der Trailing-Stop zurückgesetzt werden?

    • Es stellt sich ganz einfach heraus, nur 4 Hauptblöcke

      Nun versuchen wir Schritt um Schritt die Teile des Codes für jeden Abschnitt des Strukturschemas zu generieren:

      1. Initialisieren von Variablen
        Alle Variablen, die im Expertenprogramm verwendet werden, müssen zunächst nach der Syntax von MetaQuotes Language 4 definiert werden. Deshalb führen wir am Anfang den Initialisierungsblock für Variablen ein

        extern double TakeProfit = 50;
        extern double Lots = 0.1;
        extern double TrailingStop = 30;
        extern double MACDOpenLevel=3;
        extern double MACDCloseLevel=2;
        extern double MATrendPeriod=26;
        

        In MetaQuotes Language 4 ist ein Begriff eingeführt, das heißt` zusätzliche Benutzer-variable`, die können von außen installiert werden, ohne Änderung im Quelltext des Expertenprogramms. Das stellt zusätzliche Flexibilität zur Verfügung. In unserem Programm wird die Variable MATrendPeriod eben als Benutzer-variable definiert. Fügen wir die Definition dieser Variablen am Anfang des Programms ein.

        extern double MATrendPeriod=26;
      2. Die erste Datenüberprüfung
        Dieser Teil des Codes wird in der Regel von einem Experten zu einem anderen mit kleinen Unterschieden gezogen- praktisch ist es ein Standardüberprüfungsblock:

        // Die erste Datenüberprüfung
        // Wichtig ist es, dass der Experten auf der normalen Grafik arbeitet und
         // der Benutzer hat die externen Variable (Lots, StopLoss,TakeProfit, TrailingStop) richtig erstellt.
        // TakeProfit, TrailingStop)
        //in unserem Fall überprüfen wir nur Takeprofit
           if(Bars<100)
             {
              Print("bars less than 100");
              return(0);  
             }
           if(TakeProfit<10)
             {
              Print("TakeProfit less than 10");
              return(0);  // Überprüfen wir nur Takeprofit
             }
        
      3. Die Installierung der internen Variablen zum schnellen Datenzugriff
        Man muss oft Im Code des Programms, die Indikatorwerte auffordern oder die berechneten Werte handhaben

        int start()
          {
           double MacdCurrent, MacdPrevious, SignalCurrent;
           double SignalPrevious, MaCurrent, MaPrevious;
           int cnt, ticket, total;
        

        Um das Kodieren zu vereinfachen und den Zugriff zu beschleunigen, werden Daten in internen Variablen gesetzt.

           MacdCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0);
           MacdPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
           SignalCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0);
           SignalPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
           MaCurrent=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,0);
           MaPrevious=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,1);
        

        Nun statt der riesigen Notation iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0) im Text des Programms kann MacdCurrent verwendet werden.

      4. Die Überprüfung des Handelsterminals - ist es leer? Wenn ja, dann:
        In unserem Expert-Advirsor verwenden wir nur die Positionen, die nach dem Market geöffnet sind und greifen nicht die Pending Orders. Aber aus Sicherheitsgründen führen wir lieber die Überprüfung des Handelsterminals ein, um die zuvor ausgestellten Orders herauszufinden.

        // nun muss es bestimmt werden - in welchem Zustand ist der Handelsterminal? 
        // Überprüfen wir, ob es früher geöffnete Positionen oder Orders gibt?
           total=OrdersTotal();
           if(total<1) 
             {
        
        • Die Kontrollen: gibt es Geld auf dem Konto zu verfügen usw.
          Vor der Analyse der Marktlage empfiehlt es sich, den Status Ihres Kontos zu überprüfen, um sicherzustellen, ob es freie Mittels für die Eröffnung einer Position gibt?

                // Es gibt keine geöffnete Order 
                // Für alle Fälle überprüfen wir, ob wir freie Mittels auf dem Konto haben?
                // Der Wert 1000 ist für das Beispiel genommen, in der Regel kann man 1 Lot eröffnen.
                if(AccountFreeMargin()<(1000*Lots))
                  {
                   Print("We have no money. Free Margin = ", AccountFreeMargin());
                   return(0);  
                  }
          
        • Die Überprüfung der Möglichkeit, eine Long-Position(BUY) zu nehmen? (BUY)
          Die Bedingung des Eingangs in die Long-Position - Der MACD-Indikator ist unter Null und wird von unten nach oben und er wird die Signallinie von oben nach unten gekreuzt . Dies ist, wie es in MQL4 aufgenommen (Anmerkung, dass die Arbeit mit den Indikatorwerten, die bisher in Variablen gespeichert wurden) wird:

                // Überprüfen die Möglichkeit, eine Long-Position(BUY) zu nehmen(BUY)
                if(MacdCurrent<0 && MacdCurrent>SignalCurrent && 
                   MacdPrevious<SingnalPrevious &&
                   MathAbs(MacdCurrent)>(MACDOpenLevel*Point) && 
                   MaCurrent>MaPrevious)
                  {
                   ticket=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,0,
                                    Ask+TakeProfit*Point,"macd sample",
                                    16384,0,Green);
                   if(ticket>0)
                     {
                      if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) 
                         Print("BUY order opened : ",OrderOpenPrice());
                     }
                   else Print("Error opening BUY order : ",GetLastError()); 
                   return(0); 
                  }
          

          Es wurde schon oben über die zusätzliche Kontrolle über die Größe der gezogenen `Hügel` erwähnt. Die Variable MACDOpenLevel ist eine Benutzer-Variable, die man ändern kann, um eine größere Flexibilität ohne Änderungen im Programmtext zu gewährleisten. Am Anfang des Programms fügen wir die Beschreibung dieser Variable ein (sowie die Beschreibung der Variable, die unten verwendet wird).

        • Die Überprüfung der Möglichkeit, eine Short-Position(SELL) zu nehmen?
          Die Bedingung des Eingangs in die Short-Position:Der MACD-Indikator ist über Null und geht von oben nach unten und er wird die Signallinie von unten nach oben gekreuzt . Es wird so geschrieben:

                // Überprüfen die Möglichkeit, eine Short-Position(SELL) zu nehmen?
                if(MacdCurrent>0 && MacdCurrent<SignalCurrent &&
                   MacdPrevious>SignalPrevious && 
                   MacdCurrent>(MACDOpenLevel*Point) && 
                   MaCurrent<MaPrevious)
                  {
                   ticket=OrderSend(Symbol(),OP_SELL,Lots,Bid,3,0,
                                    Bid-TakeProfit*Point,"macd sample",
                                    16384,0,Red);
                   if(ticket>0)
                     {
                      if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) 
                         Print("SELL order opened : ",OrderOpenPrice());
                     }
                   else Print("Error opening SELL order : ",GetLastError()); 
                   return(0); 
                  }
          
              // Hier beenden wir die Überprüfung der Möglichkeit , neue Positionen zu nehmen. 
              // Neue Positionen wurden nicht geöffnet und wir verlassen es einfach  
              return(0);
             }
      5. Die Kontrolle der Positionen, die zuvor in der Loop geöffnet wurden

           // Nun schneiden wir zum wichtigsten Teil des Expertes an - die Kontrolle über die geöffneten Positionen.  
           // Wichtig ist, in den Markt richtig einzugehen, aber den Markt richtig zu verlassen ist noch wichtiger...' 
           for(cnt=0;cnt<total;cnt++)
             {
              OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
              if(OrderType()<=OP_SELL &&   // Ist es eine geöffnete Position? OP_BUY oder OP_SELL 
                 OrderSymbol()==Symbol())  // Stimmt das Werkzeug?
        
                {
        

        "Cnt" – ist eine Variable der Loop, die am Anfang des Programms nach dieser Art definiert werden muss :

         int cnt = 0; 
        • Wenn es eine Long-Position ist

          if(OrderType()==OP_BUY)   // Die Long-Position ist geöffnet 
            {
          
          • Soll es geschlossen werden?
            Die Bedingung des Ausgangs aus der Long-Position: Während der MACD-Indikator seiner Signalleitung kreuzt, der MACD-Indikator ist über Null und wird von oben nach unten und er wird durch die Signalleitung von unten nach oben gekreuzt.

            // Lassen Sie uns überprüfen, vielleicht soll es schon geschlossen werden?
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent &&
               MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // Schließen wir die Position zu
               return(0); // Verlassen
              }
            
          • Soll der Trailing-Stop zurückgesetzt werden?
            Wir setzen den Trailing-Stop erst dann, wenn die Position bereits einen Gewinn hat, der mehr als der Trailing-Stop in den Punkten ist,und wenn der neue Stop-Level besser ist als der vorherige Stop-Level.

            // Lassen Sie uns überprüfen - vielleicht soll oder muss der Trailing-Stop schon gesetzt werden?
            if(TrailingStop>0)  
              {                 
               if(Bid-OrderOpenPrice()>Point*TrailingStop)
                 {
                  if(OrderStopLoss()
                    {
                     OrderModify(OrderTicket(),OrderOpenPrice(),
                                 Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
                     return(0);
                    }
                 }
              }
            

          Schließen die Operator-Klammer zu

          }
      6. Wenn es eine Short-Position ist

        else // sonst ist es eine Short-Position 
          {
        
        • Soll es geschlossen werden?
          Die Bedingung des Ausgangs aus der Short-Position: Während des MACD-Indikators durch seine Signalleitung gekreuzt wird, der MACD-Indikator ist unter Null und wird von unten nach oben und er wird durch die Signalleitung von oben nach unten gekreuzt

          // Lassen Sie uns überprüfen, vielleicht soll es schon geschlossen werden?
          if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
             MacdPrevious<SignalPrevious &&
             MathAbs(MacdCurrent)>(MACDCloseLevel*Point))
            {
             OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // Schließen wir die Position zu
             return(0); // Verlassen
            }
          
        • Soll der Trailing-Stop zurückgesetzt werden?
          Wir setzen den Trailing-Stop erst dann, wenn die Position bereits einen Gewinn hat, der mehr als der Trailing-Stop in den Punkten ist,und wenn der neue Stop-Level besser ist als der vorherige Stop-Level.

          // Lassen Sie uns überprüfen - vielleicht soll oder muss der Trailing-Stop schon gesetzt werden?
          if(TrailingStop>0)  
            {                 
             if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
               {
                if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
                  {
                   OrderModify(OrderTicket(),OrderOpenPrice(),
                               Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
                   return(0);
                  }
               }
            }
          

        Schließen allen gebliebenen geöffneten Operator-Klammern zu

                   }
                }
             }
           return(0);
          }
        

So wurde der Expert-Advisor Schritt um Schritt geschrieben...

Der dritte Schritt - Die Zusammenbau der resultierenden Codes des Programms

Wir öffnen die Expert-Advisor-Einstellungen (auf der Tastatur F7 oder im Menü ist es in den "Eigenschaften"..."). Es taucht vor uns ein Fenster auf,in dem wir die externen Einstellungen der Betriebsparameter definieren müssen:


Bauen wir den ganzen Code aus dem letzten Abschnitt zusammen...


//+------------------------------------------------------------------+
//|                                                  MACD Sample.mq4 |
//|                      Copyright © 2005, MetaQuotes Software Corp. |
//|                                       https://www.metaquotes.net/ |
//+------------------------------------------------------------------+
 
extern double TakeProfit = 50;
extern double Lots = 0.1;
extern double TrailingStop = 30;
extern double MACDOpenLevel=3;
extern double MACDCloseLevel=2;
extern double MATrendPeriod=26;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt=0, ticket, total;
//Anfangsdatenüberprüfungen 
// Es ist wichtig, sicherzustellen, dass der Experte auf der normalen Grafik arbeitet und  
// der Benutzer hat die richtigen externen Variablen(Lots, StopLoss,
// TakeProfit, TrailingStop) gesetzt
// in unserem Fall überprüfen wir nur TakeProfit
   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }
   if(TakeProfit<10)
     {
      Print("TakeProfit less than 10");
      return(0);  // Überprüfen wir TakeProfit
     }
// Um ​​den Code zu vereinfachen und zu beschleunigen, Speichern wir 
// die nötigen Indikator-Daten in vorübergehenden Variablen 
   MacdCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0);
   MacdPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
   SignalCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0);
   SignalPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
   MaCurrent=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,0);
   MaPrevious=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,1);
 
   total=OrdersTotal();
   if(total<1) 
     {
      // Es gibt keine geöffnete Order
      if(AccountFreeMargin()<(1000*Lots))
        {
         Print("We have no money. Free Margin = ", AccountFreeMargin());
         return(0);  
        }
      // Überprüfen die Möglichkeit, eine Long-Position(BUY) zu nehmen.
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel*Point) && MaCurrent>MaPrevious)
        {
         ticket=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,0,Ask+TakeProfit*Point,
                          "macd sample",16384,0,Green);
         if(ticket>0)
           {
            if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
               Print("BUY order opened : ",OrderOpenPrice());
           }
         else Print("Error opening BUY order : ",GetLastError()); 
         return(0); 
        }
      // Überprüfen die Möglichkeit, eine Short-Position(SELL) zu nehmen
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel*Point) && MaCurrent<MaPrevious)
        {
         ticket=OrderSend(Symbol(),OP_SELL,Lots,Bid,3,0,Bid-TakeProfit*Point,
                          "macd sample",16384,0,Red);
         if(ticket>0)
           {
            if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
               Print("SELL order opened : ",OrderOpenPrice());
           }
         else Print("Error opening SELL order : ",GetLastError()); 
         return(0); 
        }
      return(0);
     }
   // Nun schneiden wir zum wichtigsten Teil des Expertes an - die Kontrolle über die geöffneten Positionen.
   // 'Wichtig ist, in den Markt richtig einzugehen, aber den Markt richtig zu verlassen ist noch wichtiger...'
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderType()<=OP_SELL &&   // Ist es eine geöffnete Position? OP_BUY oder OP_SELL 
         OrderSymbol()==Symbol())  // Stimmt das Werkzeug?
        {
         if(OrderType()==OP_BUY)   // Die Long-Position ist geöffnet
           {
            // Lass uns überprüfen, vielleicht soll es schon geschlossen werden?
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); //Schließen wir die Position zu
                 return(0); // Verlassen
                }
            // Lass uns überprüfen - vielleicht soll oder muss der Trailing-Stop schon gesetzt werden?
            if(TrailingStop>0)  
              {                 
               if(Bid-OrderOpenPrice()>Point*TrailingStop)
                 {
                  if(OrderStopLoss()<Bid-Point*TrailingStop)
                    {
                     OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,
                                 OrderTakeProfit(),0,Green);
                     return(0);
                    }
                 }
              }
           }
         else // sonst ist es eine Short-Position 
           {
            // Lass uns überprüfen, vielleicht soll es schon geschlossen werden?
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // Schließen wir die Position zu
               return(0); // Verlassen
              }
            // Lass uns überprüfen - vielleicht soll oder muss der Trailing-Stop schon gesetzt werden?
            if(TrailingStop>0)  
              {                 
               if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
                 {
                  if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
                    {
                     OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,
                                 OrderTakeProfit(),0,Red);
                     return(0);
                    }
                 }
              }
           }
        }
     }
   return(0);
  }
// Das Ende.

Um unser Experte endgültig einzustellen, ist es nötig, die Werte von externen Variablen anzugeben "Lots = 1", "Stop Loss (S/L) = 0" (nicht verwendet), "Take Profit (T/P) = 120" (Geeignet für einen einstündigen Takt), "Trailing Stop (T/S) = 30" Natürlich können Sie auch Ihre eigenen Werte setzten.
Drücken Sie auf "Kompilieren" ("Compile"), und wenn keine Fehler gefunden werden,(Übrigens, können Sie den Text aus dem oben genannten Ausdruck des Programms in den MetaEditor kopieren) drücken Sie die Taste "Speichern""(Save"), um den Expert-Advisor zu speichern.

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

Der Fehler 146 ("Trade-Context ist besetzt") und was man dagegen tun kann Der Fehler 146 ("Trade-Context ist besetzt") und was man dagegen tun kann

Der Artikel ist dem konfliktfreien Handel von mehreren Experten an einem Terminal MT 4 gewidmet und baut auf einen Benutzer, der grundlegende Arbeitsfähigkeiten und Programierungserfahrung mit dem Terminal MQL4 hat.

Besonderheiten und Einschränkungen beim Testen von Handelstrategien in MetaTrader 4 Besonderheiten und Einschränkungen beim Testen von Handelstrategien in MetaTrader 4

Dieser Artikel erläutert Besonderheiten und Einschränkungen beim Testen von Handelsstrategien in MetaTrader 4...

Die Einschätzung der Modellierungsqualität von Minutendaten Die Einschätzung der Modellierungsqualität von Minutendaten

Die Formel der Einschätzung und der Berechnung der Modellierungsqualität von Minutendaten.

Der grafische Expert Advisor:AutoGraf Der grafische Expert Advisor:AutoGraf

Es werden die Verwendungsmöglichkeiten der grafischen Mittel betrachtet, um ein bequemes Interface (Benutzeroberfläche) des Kontrollhandels zu erstellen.