MetaTrader 5 herunterladen

Hat Dir der Artikel gefallen?
Teile ihn mit den anderen -
poste einen Link zu diesem Beitrag!

Nutze neue Möglichkeiten der Plattform MetaTrader 5

Zeichnen von Indikatoremissionen in MQL5

11 Februar 2016, 12:29
Sergey Pavlov
0
232

Einleitung

Sicherlich stellen sich viele Händler und Entwickler von Handelsstrategien diese Fragen:
  • Wie entstehen starke Marktbewegungen?
  • Wie kann die richtige Richtung anstehender Veränderungen bestimmt werden?
  • Wie kann eine gewinnbringende Position für den Handel geöffnet werden?
  • Wie kann eine Position mit maximalem Gewinn geschlossen werden?

Die Suche nach den Antworten hat mich zur Erschaffung einer neuen Herangehensweise an die Marktforschung geführt: die Konstruktion und Analyse von Indikatoremissionen. Sehen wir uns zur Verdeutlichung die folgenden Abbildungen an:

Abb. 1 Emission des DCMV-Indikators.

Abb. 2 Emission eines auf iMA-Envelopes basierenden Indikators.

Hier sind die Emissionen verschiedener Indikatoren abgebildet, doch das Grundprinzip ihrer Konstruktion ist das gleiche. Nach jedem Tick erscheinen immer mehr Punkte mit verschiedenen Farben und Formen. Sie formen zahlreiche Cluster wie Nebel, Wolken, Bahnen, Linien, Bögen usw. Diese Formen helfen uns beim Finden der unsichtbaren Kräfte, die die Bewegung von Marktpreisen beeinflussen. Die Erforschung und Analyse dieser Emissionen ist in vielerlei Hinsicht wie Handlesen.

Emissionen und ihre Eigenschaften

Eine Emission ist eine Reihe von Punkten, die sich an den Schnittpunkten bestimmter Linien des Indikators befinden.

Die Eigenschaften von Emissionen sind bisher nicht vollständig geklärt und warten immer noch auf ihre Erforschung. Hier ist eine Liste der bekannten Eigenschaften:

  • Punkte des gleichen Typen versuchen, Cluster zu bilden;
  • die Emission hat eine eindeutige Richtung: von der Gegenwart in die Zukunft oder in die Vergangenheit;
  • Cluster sind wichtig: Dichte Cluster können den Preis anziehen oder, umgekehrt, abstoßen.

Berechnung der Emission des Indikators

Betrachten wir die Grundlagen der Berechnung von Emissionen anhand eines Beispiels. Nehmen wir zwei Indikatoren, iBands und iMA, und suchen die Schnittstellen ihrer Linien. Diese nutzen wir für die Zeichnung der Emissionspunkte. Dazu benötigen wir grafische Objekte. Der Algorithmus wird in Expert Advisors umgesetzt, es ist aber auch im Indikator möglich.

Die Ausgangsindikatoren sind in Abb. 3 abgebildet:

Abb. 3 Die Indikatoren iBands (grün) und iMA (rot).

Zur Erstellung von Emissionspunkten brauchen wir einen Expert Advisor. Zur Erstellung eines Expert-Advisor-Templates wird der MQL5 Wizard empfohlen.

Abb. 4 Erstellung eines Expert-Advisor-Templates mithilfe des MQL5 Wizard.

//+------------------------------------------------------------------+
//|                                      Emission of Bands && MA.mq5 |
//|                                                 Copyright DC2008 |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "DC2008"
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+

Zuerst brauchen wir einige Hilfsdarstellungen. Wir müssen die Darstellung von Indikatorlinien als Strahlen fortsetzen (Abb. 5). Dadurch können wir die Richtigkeit der Berechnung und der Visualisierung von Emissionspunkten kontrollieren. Später entfernen wir diese Linien aus dem Diagramm.

Abb. 5 Hilfsdarstellungen. Fortsetzung der Indikatorlinien mithilfe von Strahlen.

Fügen wir also die grafischen Objekte (horizontale und Trendlinien) zum Code unseres Expert Advisors hinzu.

input bool     H_line=true;   // flag to enable drawing of the horizontal lines
input bool     I_line=true;   // flag to enable drawing of the indicator's lines
//---
string         name;
//---- indicator buffers
double      MA[];    // array for iMA indicator 
double      BBH[];   // array for iBands indicator  - UPPER_BAND 
double      BBL[];   // array for iBands indicator - LOWER_BAND
double      BBM[];   // array for iBands indicator - BASE_LINE
datetime    T[];     // array for time coordinates
//---- handles for indicators
int         MAHandle;   // iMA indicator handle
int         BBHandle;   // iBands indicator handle
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   MAHandle=iMA(Symbol(),0,21,0,MODE_EMA,PRICE_CLOSE);
   BBHandle=iBands(Symbol(),0,144,0,2,PRICE_CLOSE);
//---
   if(H_line)     // Horizontal lines of iBands indicator
      {
         //--- iBands - UPPER_BAND
         name="Hi";
         ObjectCreate(0,name,OBJ_HLINE,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,Red);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         //--- iBands - LOWER_BAND
         name="Lo";
         ObjectCreate(0,name,OBJ_HLINE,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,Blue);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         //--- iBands - BASE_LINE
         name="MIDI";
         ObjectCreate(0,name,OBJ_HLINE,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,DarkOrange);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
      }
//---
   if(I_line)     // Indicator lines
      {
         //--- iMA
         name="MA";
         ObjectCreate(0,name,OBJ_TREND,0,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,Red);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,2);
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_LEFT,1);
         //--- iBands - UPPER_BAND
         name="BH";
         ObjectCreate(0,name,OBJ_TREND,0,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,MediumSeaGreen);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_LEFT,1);
         //--- iBands - LOWER_BAND
         name="BL";
         ObjectCreate(0,name,OBJ_TREND,0,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,MediumSeaGreen);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_LEFT,1);
         //--- iBands - BASE_LINE
         name="BM";
         ObjectCreate(0,name,OBJ_TREND,0,0,0,0);           
         ObjectSetInteger(0,name,OBJPROP_COLOR,MediumSeaGreen);
         ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_SOLID);
         ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,1);
         ObjectSetInteger(0,name,OBJPROP_RAY_LEFT,1);
      }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   //--- filling the arrays with current values
   CopyBuffer(MAHandle,0,0,2,MA);
   ArraySetAsSeries(MA,true);  
   CopyBuffer(BBHandle,0,0,2,BBM);
   ArraySetAsSeries(BBM,true);  
   CopyBuffer(BBHandle,1,0,2,BBH);
   ArraySetAsSeries(BBH,true);  
   CopyBuffer(BBHandle,2,0,2,BBL);
   ArraySetAsSeries(BBL,true);
   CopyTime(Symbol(),0,0,10,T);
   ArraySetAsSeries(T,true);
     
   //--- Horizontal lines of iBands indicator (correction)
   if(H_line)
      {
      name="Hi";
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBH[0]);
      name="Lo";
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBL[0]);
      name="MIDI";
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBM[0]);
      }
   //--- Indicator's lines (correction)
   if(I_line)
      {
      name="MA";  //--- iMA
      ObjectSetInteger(0,name,OBJPROP_TIME,T[1]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,MA[1]);
      ObjectSetInteger(0,name,OBJPROP_TIME,1,T[0]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,1,MA[0]);
      name="BH";  //--- iBands - UPPER_BAND
      ObjectSetInteger(0,name,OBJPROP_TIME,T[1]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBH[1]);
      ObjectSetInteger(0,name,OBJPROP_TIME,1,T[0]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,1,BBH[0]);
      name="BL";  //--- iBands - LOWER_BAND
      ObjectSetInteger(0,name,OBJPROP_TIME,T[1]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBL[1]);
      ObjectSetInteger(0,name,OBJPROP_TIME,1,T[0]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,1,BBL[0]);
      name="BM";  //--- iBands - BASE_LINE
      ObjectSetInteger(0,name,OBJPROP_TIME,T[1]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,BBM[1]);
      ObjectSetInteger(0,name,OBJPROP_TIME,1,T[0]);
      ObjectSetDouble(0,name,OBJPROP_PRICE,1,BBM[0]);
      }
  }
//+------------------------------------------------------------------+
Da die Emission sich in die Vergangenheit und in die Zukunft fortsetzt, sollten die Eigenschaften der Trendlinie die folgenden sein:
  • OBJPROP_RAY_LEFT = 1 (Strahl nach links);
  • OBJPROP_RAY_RIGHT = 1 (Strahl nach rechts).

Als Ergebnis sieht das Diagramm mit den zusätzlichen Linien aus, wie in Abb. 6 dargestellt.

Die Vorbereitungsphase ist somit abgeschlossen. Fahren wir mit der Emission fort. Wir erstellen die erste Serie von Punkten am Schnittpunkt der folgenden Linien:

  • zwischen der Linie "MA" (iMA) und der Linie "BH" (iBands = UPPER_BAND);
  • zwischen der Linie "MA" (iMA) und der Linie "BL" (iBands = LOWER_BAND);
  • zwischen der Linie "MA" (iMA) und der Linie "BM" (iBands = BASE_BAND).

Abb. 6 Hilfsdarstellungen. Fortsetzung der Indikatorlinien mithilfe von geraden Linien.

Jetzt ist es an der Zeit, die Koordinaten des Schnittpunkts zu berechnen und die Emissionspunkte zu zeichnen. Erstellen wir folgende Funktion:

void Draw_Point(
                string   P_name,     // Object name (OBJ_ARROW)
                double   P_y1,       // Y-coordinate of the 1st line at the [1] bar
                double   P_y0,       // Y-coordinate of the 1st line at the [0] bar
                double   P_yy1,      // Y-coordinate of the 2nd line at the [1] bar 
                double   P_yy0,      // Y-coordinate of the 2nd line at the [0] bar
                char     P_code1,    // Char at the right side of the [0] bar
                char     P_code2,    // Char at the left side of the [0] bar
                color    P_color1,   // Color of point at the right side of the [0] bar
                color    P_color2    // color of point at the left side of the [0] bar
                )
  {
   double   P,X;
   datetime P_time;
   if(MathAbs((P_yy0-P_yy1)-(P_y0-P_y1))>0)
     {
      P=P_y1+(P_y0-P_y1)*(P_y1-P_yy1)/((P_yy0-P_yy1)-(P_y0-P_y1));
      X=(P_y1-P_yy1)/((P_yy0-P_yy1)-(P_y0-P_y1));
      if(X>draw_period)
        {
         P_time=T[0]+(int)(X*PeriodSeconds());
         ObjectCreate(0,P_name,OBJ_ARROW,0,0,0);
         ObjectSetDouble(0,P_name,OBJPROP_PRICE,P);
         ObjectSetInteger(0,P_name,OBJPROP_TIME,P_time);
         ObjectSetInteger(0,P_name,OBJPROP_WIDTH,0);
         ObjectSetInteger(0,P_name,OBJPROP_ARROWCODE,P_code1);
         ObjectSetInteger(0,P_name,OBJPROP_COLOR,P_color1);
         if(X<0)
           {
            ObjectSetInteger(0,P_name,OBJPROP_ARROWCODE,P_code2);
            ObjectSetInteger(0,P_name,OBJPROP_COLOR,P_color2);
           }
        }
     }
  }

Und die folgenden Codezeilen der Funktion OnTick:

//+------------------------------------------------------------------+
   int GTC=GetTickCount();                                                    
//+------------------------------------------------------------------+
   name="H"+(string)GTC;
   Draw_Point(name,BBH[1],BBH[0],MA[1],MA[0],170,178,Red,Red);
   name="L"+(string)GTC;
   Draw_Point(name,BBL[1],BBL[0],MA[1],MA[0],170,178,Blue,Blue);
   name="M"+(string)GTC;
   Draw_Point(name,BBM[1],BBM[0],MA[1],MA[0],170,178,Green,Green);
//---
   ChartRedraw(0);

Führen wir nun den Expert Advisor aus und sehen uns das Ergebnis an (Abb. 7).

Das Ergebnis ist gut, doch es gibt weitere Schnittpunktvarianten, die wir nicht berücksichtigt haben. Zum Beispiel hat der Indikator iBands drei Linien, die sich schneiden und das Gesamtbild ergänzen könnten.

Abb. 7 Emission der Indikatoren iMA und iBands (3 Schnittpunkte).

Versuchen wir nun, eine weitere Serie von Punkten zur berechneten Emission hinzuzufügen, nämlich den Schnittpunkt zwischen den folgenden Linien:
  • zwischen der Linie "BH" (iBands = UPPER_BAND) und der Linie "BL" (iBands = LOWER_BAND);
  • zwischen der Linie "BH" (iBands = UPPER_BAND) und der Linie "BM" (iBands = BASE_BAND);
  • zwischen der Linie "BL" (iBands = LOWER_BAND) und der Linie "BM" (iBands = BASE_BAND).

Anhand dieser Schnittpunkte würden wir 3 Punkte erhalten, doch diese hätten alle dieselben Koordinaten. Deshalb ist es ausreichend, nur den Schnittpunkt zwischen der Linie "BH" und der Linie "BL" zu verwenden.

Fügen wir diese Codezeilen zu unserem Expert Advisor hinzu und sehen uns das Ergebnis an (Abb. 8).

 name="B"+(string)GTC;
   Draw_Point(name,BBH[1],BBH[0],BBL[1],BBL[0],170,178,Magenta,Magenta);

Abb. 8 Emission der Indikatoren iMA und iBands (4 Schnittpunkte).

Nun haben wir also die Emission, doch es scheint, als hätten wir etwas Wichtiges vergessen. Was haben wir vergessen?

Warum haben wir solche Eingabeparameter verwendet? Was erhalten wir, wenn wir sie ändern? Und überhaupt, welche Rollen spielen sie bei der Emission?

Es stimmt, die Emission, die wir erhalten, entspricht einer einzelnen Frequenz, die sich aus den Eingabeparametern des Indikators ergibt. Zur Berechnung des vollständigen Spektrums aus mehreren Frequenzen müssen die gleichen Berechnungen für die anderen Frequenzen durchgeführt werden. Hier sehen Sie beispielsweise meine Version des möglichen Emissionsspektrums:

//---- handles for indicators
int         MAHandle[5];   // handles array of iMA indicators
int         BBHandle[7];   // handles array of iBands indicator
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   MAHandle[0]=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
   MAHandle[1]=iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE);
   MAHandle[2]=iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE);
   MAHandle[3]=iMA(NULL,0,89,0,MODE_EMA,PRICE_CLOSE);
   MAHandle[4]=iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE);
//---
   BBHandle[0]=iBands(NULL,0,55,0,2,PRICE_CLOSE);
   BBHandle[1]=iBands(NULL,0,89,0,2,PRICE_CLOSE);
   BBHandle[2]=iBands(NULL,0,144,0,2,PRICE_CLOSE);
   BBHandle[3]=iBands(NULL,0,233,0,2,PRICE_CLOSE);
   BBHandle[4]=iBands(NULL,0,377,0,2,PRICE_CLOSE);
   BBHandle[5]=iBands(NULL,0,610,0,2,PRICE_CLOSE);
   BBHandle[6]=iBands(NULL,0,987,0,2,PRICE_CLOSE);
//---
   return(0);
  }

Fügen wir den folgenden Code zum Expert Advisor hinzu, um alle möglichen Kombinationen zu berücksichtigen:

//+------------------------------------------------------------------+
   CopyTime(NULL,0,0,10,T);
   ArraySetAsSeries(T,true);
   int GTC=GetTickCount();
//+------------------------------------------------------------------+
   int iMax=ArraySize(BBHandle)-1;
   int jMax=ArraySize(MAHandle)-1;
   for(int i=0; i<iMax; i++)
     {
      for(int j=0; j<jMax; j++)
        {
         //--- filling the arrays with current values
         CopyBuffer(MAHandle[j],0,0,2,MA);
         ArraySetAsSeries(MA,true);
         CopyBuffer(BBHandle[i],0,0,2,BBM);
         ArraySetAsSeries(BBM,true);
         CopyBuffer(BBHandle[i],1,0,2,BBH);
         ArraySetAsSeries(BBH,true);
         CopyBuffer(BBHandle[i],2,0,2,BBL);
         ArraySetAsSeries(BBL,true);

         name="H"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBH[1],BBH[0],MA[1],MA[0],250,158,Aqua,Aqua);
         name="L"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBL[1],BBL[0],MA[1],MA[0],250,158,Blue,Blue);
         name="M"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBM[1],BBM[0],MA[1],MA[0],250,158,Green,Green);
         name="B"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBH[1],BBH[0],BBL[1],BBL[0],250,158,Magenta,Magenta);
        }
     }
//---
   ChartRedraw(0);

Je mehr Frequenzen am Emissionsspektrum beteiligt sind, desto besser ist das Bild im Diagramm, doch Sie sollten dies nicht überstrapazieren, denn damit werden Computerressourcen schnell aufgebraucht und im Diagramm entsteht Chaos. Die Anzahl an Frequenzen kann experimentell festgelegt werden. Für die bessere visuelle Darstellung des Diagramms müssen wir besonders auf den Zeichenstil achten.

Abb. 9 Emissionsspektrum mit mehreren Frequenzen.

Über die Zeichenstile von Emissionen

MQL5 bietet eine große Auswahl an websicheren Farben und Windings-Zeichen für die Zeichnung von Emissionen. Ich möchte meine Ansichten darüber kurz schildern:  
  1. Jede Person nimmt Bilder anders wahr, also müssen Sie sich etwas Zeit nehmen, um die Emissionen zu personalisieren.
  2. Wegen des "Chaos" in Abb. 9 ist es unmöglich, Regelmäßigkeiten oder Muster in den Bildern zu erkennen. Das ist ein Beispiel für eine schlechte Zeichnung.
  3. Versuchen Sie, benachbarte Farben aus dem Regenbogen-Spektrum zu wählen.
  4. Die Zeichencodes für Vergangenheit (links von Balken [0]) und Zukunft (rechts von Balken [0]) sollten sich unterscheiden.
  5. Dank einer harmonischen Kombination von Farben und Formen kann aus einer Emission ein Meisterwerk werden, das nicht nur den Handel unterstützt, sondern auch dem Auge schmeichelt.
Als Beispiel sehen Sie hier meine Version des Zeichenstils für die Emission (siehe Abbildungen 10-17):
         name="H"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBH[1],BBH[0],MA[1],MA[0],250,158,Aqua,Aqua);
         name="L"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBL[1],BBL[0],MA[1],MA[0],250,158,Blue,Blue);
         name="M"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBM[1],BBM[0],MA[1],MA[0],250,158,Magenta,Magenta);
         name="B"+(string)GTC+(string)i+(string)j;
         Draw_Point(name,BBH[1],BBH[0],BBL[1],BBL[0],250,158,DarkOrchid,DarkOrchid);

iMA- und iBands-Emissionsgalerie

In diesem Abschnitt finden Sie Bilder mit diesen Emissionen.

 

Abb. 10

 

Abb. 11.

Abb. 12.

Abb. 13.

Abb. 14.

 

Abb. 15.

Abb. 16.

 

Abb. 17.

Analyse von Emissionen

Die Analyse von Emissionen ist eine eigenständige Aufgabe. Am sinnvollsten ist es, ihre Dynamik in Echtzeit zu betrachten. So können viele Effekte und Muster am einfachsten verstanden werden.

Achten Sie besonders auf Preiskorrekturen: Die Emission scheint den Zielpreis zu "kennen". Zusätzlich können Sie die Niveaus für Unterstützung, Widerstand und Gleichgewicht erkennen.

Fazit

  1. Die Emissionen der Indikatoren könnten für Händler und Entwickler von Handelssystemen interessant sein, die nach einer neuen Herangehensweise an Marktforschung und -analyse suchen.
  2. Dieser Beitrag dient nur als Einführung und bietet keine fertigen Lösungen. Allerdings kann die vorgestellte Technologie für die Berechnung von Emissionen in anderen Indikatoren oder Kombinationen von Indikatoren genutzt werden.
  3. Beim Verfassen dieses Beitrags habe ich mehr Fragen als Antworten gesammelt. Hier sind einige davon: Wie kann der Algorithmus der Emissionszeichen optimiert werden? Welche Rolle spielen die Merkmale des Emissionsspektrums in der Struktur der Emissionen? Wie können die Emissionen im automatisierten Handel genutzt werden?

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

Sehr einfach: Der Datenaustausch zwischen Indikatoren Sehr einfach: Der Datenaustausch zwischen Indikatoren

Wir möchten eine Umgebung erschaffen, die den Zugriff auf Daten von Indikatoren ermöglicht, die an ein Diagramm angehängt sind, und deshalb die folgenden Eigenschaften aufweist: kein Kopieren von Daten; minimale Veränderung des Codes verfügbarer Methoden, wenn wir sie nutzen müssen; MQL-Code ist zu bevorzugen (natürlich müssen wir DLL nutzen, doch wir verwenden nur ein Dutzend Strings C++-Code). Dieser Beitrag beschreibt eine einfache Methode zur Entwicklung einer Programmumgebung für das MetaTrader-Terminal, die eine Zugriffsmöglichkeit auf Indikatorpuffer aus anderen MQL-Programmen bietet.

Datenaustausch: Erstellen einer DLL f&#252;r MQL5 in 10 Minuten Datenaustausch: Erstellen einer DLL f&#252;r MQL5 in 10 Minuten

Nicht allzu viele Entwickler erinnern sich noch daran, wie eine simple DLL geschrieben wird und was die Besonderheiten der unterschiedlichen Systemanbindungen sind. Anhand mehrerer Beispiele werde ich versuchen, Ihnen den gesamten Prozess zur Erstellung einer simplen DLL in 10 Minuten zu zeigen, sowie einige technische Einzelheiten der Umsetzung unserer Anbindung zu besprechen. Ich zeige Ihnen den Prozess der DLL-Erstellung in Visual Studio Schritt für Schritt mit Beispielen für den Austausch unterschiedlicher Typen von Variablen (Zahlen, Arrays, Strings usw.). Außerdem erkläre ich, wie Sie Ihr Client Terminal vor Abstürzen in benutzerdefinierten DLLs schützen können.

Exportieren von Angeboten aus MetaTrader 5 in .NET-Anwendungen mithilfe von WCF-Services Exportieren von Angeboten aus MetaTrader 5 in .NET-Anwendungen mithilfe von WCF-Services

Möchten Sie den Export von Angeboten aus MetaTrader 5 in Ihre eigene Anwendung aktualisieren? Mit der MQL5-DLL-Verbindung können Sie solche Lösungen erschaffen! Dieser Beitrag zeigt Ihnen eine der Möglichkeiten zum Exportieren von Angeboten aus MetaTrader 5 in .NET-Anwendungen. Für mich war es interessanter, sinnvoller und einfacher, den Export von Angeboten mithilfe dieser Plattform umzusetzen. Leider wird .NET von Version 5 weiterhin nicht unterstützt, sodass wir wie in den alten Tagen win32 dll mit .NET-Unterstützung als Zwischenlösung nutzen werden.

Genetische Algorithmen - Leicht gemacht! Genetische Algorithmen - Leicht gemacht!

Der Verfasser behandelt in diesem Beitrag evolution&auml;re Berechnungen mit Hilfe eines pers&ouml;nlich entwickelten, genetischen Algorithmus. Er zeigt die Funktionsweise dieses Algorithmus anhand von Beispielen und gibt praktische Empfehlungen f&uuml;r seine Verwendung.