MetaTrader 5 herunterladen

MQL5 für Neueinsteiger: Leitfaden zur Verwendung technischer Indikatoren in Expert Advisors

11 Januar 2016, 10:08
Sergey Pavlov
0
492

Einleitung

Ein Expert Advisor oder Indikator, der keine technischen Standardindikatoren nutzt, ist selten. Sie sind sowohl unter Einsteigern als auch unter fortgeschrittenen Entwicklern von Handelsstrategien beliebt. Es ist nicht schwer, die Details der Erstellung von Indikatoren zu verstehen. Ziel dieses Beitrags ist es, Sie dabei zu unterstützen. Wir gehen auf die Verwendung der Funktionen für die Arbeit mit integrierten standardmäßigen technischen Indikatoren ein.

Grundlagen der Verwendung der Funktionen standardmäßiger technischer Indikatoren

Beim Aufruf erstellt jede Funktion eines technischen Indikators ein Handle des erstellten Objekts (Kopie des Indikators) mit festgelegten Eingabeparametern. Der Zweck dieses Handles ist es, ihm dieses Objekt zuzuweisen. Es reicht vollkommen aus, die Daten des Indikatorpuffers abzurufen und sie in Ihren eigenen Berechnungen zu nutzen. Sehen wir uns ein Beispiel an:

double      MA[];                // array for the indicator iMA
int         MA_handle;           // handle of the indicator iMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   //--- creation of the indicator iMA
   MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   //--- filling an array MA[] with current values of iMA
   //--- Copying 100 elements
   CopyBuffer(MA_handle,0,0,100,MA);
   //--- set indexing of elements as series, as in MQL4
   ArraySetAsSeries(MA,true);  
   //--- here you can use the data of MA[] as you wish, for example: 
   if(MA[0]>MA[1])
      {
      //--- some operations
      }
   }

Wie wir sehen können, ist alles ziemlich einfach. Dieses Beispiel zeigt die Verwendung des Indikators iMA – des beliebtesten Indikators unter Händlern.

Das Handle des Indikators sollte innerhalb der Funktion OnInit() erstellt werden.

  1. Was bedeutet "Einstellen der Indizierung von Elementen als Serie wie in MQL4"? In unserem Beispiel haben wir die Indizierung der Elemente als Zeitreihe verwendet. In anderen Worten: Das aktuelle Bar (das noch nicht vervollständigt ist) hat immer den Index [0], das vorherige (bereits vervollständigte) hat den Index [1] usw.
  2. Warum stellen wir die Indizierung ein? Wir haben sie zur Vereinfachung und optimalen Implementierung des Algorithmus verwendet. Die MQL5-Sprache ermöglicht dem Programmierer eine bequeme Indizierung.
  3. Warum ist es besser, einen Indikator innerhalb der Funktion OnInit() zu erstellen? Natürlich kann er an jeder beliebigen Stelle im Programm erstellt werden, da es keine explizite Einschränkung gibt. Allerdings gibt es ein sehr wichtiges Argument für den empfohlenen Weg: Die Funktion OnInit() wird einmal beim Start eines Expert Advisors aufgerufen. Das reicht aus, um die Initialisierung von Indikatoren auszuführen, die ihre Parameter während der Ausführung nicht ändern. In dem Fall, dass sie ihre Eingabeparameter ändern, können sie innerhalb einer anderen Funktion nochmals initialisiert werden, beispielsweise in der Funktion OnTick().

Programmierübungen

Fast jeder Expert Advisor ist darauf ausgelegt, nicht nur auf dem Demokonto Handelstätigkeiten auszuführen, sondern auch auf realen Konten. Wenn Sie ruhig schlafen möchten, während der Expert Advisor handelt, sollten Sie alle möglichen Ergebnisse seines Handels berücksichtigen. Auch die qualifiziertesten Entwickler von automatisierten Handelssystemen machen oft ärgerliche Fehler. Und der Preis eines solchen Fehlers kann sehr hoch sein!

Hier ist zum Beispiel eine Geschichte, die sich beim Automated Trading Championship 2008 ereignet hat. Der Expert Advisor eines Teilnehmers sollte seine Einlagen auf ein bestimmtes Niveau erhöhen und anschließend in den Schlafmodus wechseln. Das hat er auch getan. Der Autor und alle, die der Arbeit des Expert Advisors zusahen, waren überrascht, als er wieder aufwachte und zu handeln begann, wobei er das eingenommene Geld verlor.

Natürlich wollen Sie keine solchen Fehler machen, wenn der Roboter außer Kontrolle gerät. Sehen wir uns also die Stolpersteine an, die bei der Nutzung von technischen Standardindikatoren auftreten können:

  1. Der Objekt-Pointer wird im Initialisierungsblock erstellt. Was, wenn dies nicht erfolgreich war? In diesem Fall erhalten wir einen leeren Bezugswert. Nutzen wir also die uns von den MQL5-Entwicklern zur Verfügung gestellte Möglichkeit, die Gültigkeit des Pointers zu überprüfen. Falls der Pointer nicht erstellt wurde, entspricht der Wert des von der Funktion ausgegebenen Handles der Standardkonstante INVALID_HANDLE = -1.
  2. Wenn wir Daten vom Indikator erhalten, kopieren wir ihre Werte in den Indikatorpuffer und nutzen sie in unseren Berechnungen. Was, wenn dieser Vorgang fehlschlägt? Wenn der Kopiervorgang fehlschlägt, kann ein Handelssystem falsche Handelssignale generieren. Für solche Fälle stellen die MQL5-Entwickler die Möglichkeit zur Verfügung, die Anzahl kopierter Elemente sofort zu prüfen. Im Falle eines Fehlers ist die Anzahl kopierter Elemente gleich -1.

Überlegen wir, wie das alles als Code aussehen könnte:

//---- arrays for indicators
double      MA[];                // array for the indicator iMA
//---- handles for indicators
int         MA_handle;           // handle of the indicator iMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   //--- creation of the indicator iMA
   MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
  //--- report if there was an error in object creation
   if(MA_handle<0)
      {
      Print("The creation of iMA has failed: MA_handle=",INVALID_HANDLE);
      Print("Runtime error = ",GetLastError());
      //--- forced program termination
      return(-1);
      }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
    //--- filling an array MA[] with current values of iMA
    //--- 100 elements should be written to the array
    //--- if there was an error, we terminate the execution of program
   if(CopyBuffer(MA_handle,0,0,100,MA)<=0) return;
   //--- set indexation of array MA[] as timeseries
   ArraySetAsSeries(MA,true);
   //--- here you can use the data of MA[] as you wish
   if(MA[0]>MA[1])
      {
      //--- some operations
      }
  }

Beachten Sie, dass eine kleine Änderung am Code seine Sicherheit und Zuverlässigkeit erhöht hat. Doch das ist noch nicht alles. Nun kann das Verfahren zum Kopieren der Indikatorwerte in ein Array verbessert werden. Dafür muss die geschriebene Funktion genutzt werden:

//+------------------------------------------------------------------------------+
//| The function copies the values of the indicator,the elements                 |
//| will be indexed depending on the value of the input parameter asSeries       |
//+------------------------------------------------------------------------------+
bool CopyBufferAsSeries(
                        int handle,      // indicator's handle
                        int bufer,       // buffer index
                        int start,       // start index
                        int number,      // number of elements to copy
                        bool asSeries,   // if it's true, the elements will be indexed as series
                        double &M[]      // target array
                        )
  {
//--- filling the array M with current values of the indicator
   if(CopyBuffer(handle,bufer,start,number,M)<=0) return(false);
//--- the elements will be indexed as follows:
//--- if asSeries=true, it will be indexed as timeseries
//--- if asSeries=false, it will be indexed as default
   ArraySetAsSeries(M,asSeries);
//---
   return(true);
  }

Sie finden die Funktion CopyBufferAsSeries in der an diesen Beitrag angehängten Datei GetIndicatorBuffers.mqh. Für ihre Verwendung müssen wir die Direktive include in unseren Code einfügen. Wir müssen Sie in das Verzeichnis ..\ MQL5\Include\ kopieren. Der letztendliche Code, der den Indikator iMA aufruft und die Daten aus dem Indikatorpuffer in das entsprechende Array kopiert, sieht wie folgt aus:

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      MA[];                // array for the indicator iMA
//---- handles for indicators
int         MA_handle;           // handle for the indicator iMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iMA
   MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(MA_handle<0)
     {
      Print("The creation of iMA has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array MA[] with current values of iMA
//--- set indexation of array MA[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(MA_handle,0,0,100,true,MA)) return;
//--- here you can use the data of MA[] as you wish, for example: 
   if(MA[0]>MA[1])
     {
      //--- some operations
     }
  }


Merkmale von Indikatoren mit mehreren Puffern

Betrachten wir beispielsweise den Indikator iAlligator, der über 3 Indikatorpuffer verfügt:

  • 0-Puffer – GATORJAW_LINE
  • 1. Puffer – GATORTEETH_LINE
  • 2. Puffer – GATORLIPS_LINE

Um den Empfang von Daten aus diesen Indikatorpuffern mit einem Aufruf durchzuführen, nutzen wir die folgende Funktion, die Sie in der an diesen Beitrag angehängten Datei finden:

//+------------------------------------------------------------------------------+
//| The function copies the values of the indicator Alligator to three arrays:   |
//| Jaws[], Teeth[], Lips[] (with elements indexed as timeaseries).              |
//+------------------------------------------------------------------------------+
bool GetAlligatorBuffers(int Alligator_handle,
                         int start,
                         int number,
                         double &Jaws[],
                         double &Teeth[],
                         double &Lips[],
                         bool asSeries=true  // (elements indexed as timeaseries)
                         )
  {
//--- filling an array Jaws with current values of GATORJAW_LINE
   if(!CopyBufferAsSeries(Alligator_handle,0,start,number,asSeries,Jaws)) return(false);
//--- filling an array Teeth with current values of GATORTEETH_LINE
   if(!CopyBufferAsSeries(Alligator_handle,1,start,number,asSeries,Teeth)) return(false);
//--- filling an array Lisp with current values of GATORLIPS_LINE
   if(!CopyBufferAsSeries(Alligator_handle,2,start,number,asSeries,Lips)) return(false);
//---
   return(true);
  }

auf die folgende Art:

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Jaws[];   // array for GATORJAW_LINE of iAlligator
double      Teeth[];  // array for GATORTEETH_LINE of iAlligator
double      Lips[];   // array for GATORLIPS_LINE of iAlligator
//---- handles for indicators
int         Alligator_handle;           // handle of the indicator iAlligator
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iAlligator
   Alligator_handle=iAlligator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN);
//--- report if there was an error in object creation
   if(Alligator_handle<0)
     {
      Print("The creation of iAlligator has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- fill arrays with current values of Alligator
//--- return if there was an error
   if(!GetAlligatorBuffers(Alligator_handle,0,100,Jaws,Teeth,Lips,true)) return;
  }

Nun haben wir die wichtigsten Punkte angesprochen und sind bereit, die Beispiele für alle Standardindikatoren zu betrachten.

Beispiele für die Verwendung von Standardindikatoren

iAC

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      AC[];                // array for the indicator iAC
//---- handles for indicators
int         AC_handle;           // handle of the indicator iAC
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iAC
   AC_handle=iAC(NULL,0);
//--- report if there was an error in object creation
   if(AC_handle<0)
     {
      Print("The creation of iAC has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array AC[] with current values of iAC
//--- set indexation of array AC[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(AC_handle,0,0,100,true,AC)) return;
  }


iAD

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      AD[];                // array for the indicator iAD
//---- handles for indicators
int         AD_handle;           // handle for the indicator iAD
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iAD
   AD_handle=iAD(NULL,0,VOLUME_TICK);
//--- report if there was an error in object creation
   if(AD_handle<0)
     {
      Print("The creation of iAD has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array AD[] with current values of iAD
//--- set indexation of array AD[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(AD_handle,0,0,100,true,AD)) return;
  }


iADX

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Main[];    // array for MAIN_LINE of iADX
double      PlusDI[];  // array for PLUSDI_LINE of iADX
double      MinusDI[]; // array for MINUSDI_LINE of iADX
//---- handles for indicators
int         ADX_handle;           // handle of the indicator iADX
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iADX
   ADX_handle=iADX(NULL,0,14);
//--- report if there was an error in object creation
   if(ADX_handle<0)
     {
      Print("The creation of iADX has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error 
   if(!GetADXBuffers(ADX_handle,0,100,Main,PlusDI,MinusDI,true)) return;
  }


iADXWilder

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Main[];    // array for MAIN_LINE of iADXWilder
double      PlusDI[];  // array for PLUSDI_LINE of iADXWilder
double      MinusDI[]; // array for MINUSDI_LINE of iADXWilder
//---- handles for indicators
int         ADXWilder_handle;           // handle of the indicator iADXWilder
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iADXWilder
   ADXWilder_handle=iADXWilder(NULL,0,14);
//--- report if there was an error in object creation
   if(ADXWilder_handle<0)
     {
      Print("The creation of iADXWilder has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetADXWilderBuffers(ADXWilder_handle,0,100,Main,PlusDI,MinusDI,true)) return;
  }


iAlligator

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Jaws[];   // array for GATORJAW_LINE of iAlligator
double      Teeth[];  // array for GATORTEETH_LINE of iAlligator
double      Lips[];   // array for GATORLIPS_LINE of iAlligator
//---- handles for indicators
int         Alligator_handle;           // handle of the indicator iAlligator
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iAlligator
   Alligator_handle=iAlligator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN);
//--- report if there was an error in object creation
   if(Alligator_handle<0)
     {
      Print("The creation of iAlligator has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetAlligatorBuffers(Alligator_handle,0,100,Jaws,Teeth,Lips,true)) return;
  }


iAMA

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      AMA[];                // array for the indicator iAMA
//---- handles for indicators
int         AMA_handle;           // handle for the indicator iAMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iAMA
   AMA_handle=iAMA(NULL,0,21,5,8,0,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(AMA_handle<0)
     {
      Print("The creation of iAMA has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array AMA[] with current values of iAMA
//--- set indexation of array AMA[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(AMA_handle,0,0,100,true,AMA)) return;
  }


iAO

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      AO[];                // array for the indicator iAO
//---- handles for indicators
int         AO_handle;           // handle of the indicator iAO
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iAO
   AO_handle=iAO(NULL,0);
//--- report if there was an error in object creation
   if(AO_handle<0)
     {
      Print("The creation of iAO has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array AO[] with current values of iAO
//--- set indexation of array AO[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(AO_handle,0,0,100,true,AO)) return;
  }


iATR

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      ATR[];                // array for the indicator iATR
//---- handles for indicators
int         ATR_handle;           // handle of the indicator iATR
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iATR
   ATR_handle=iATR(NULL,0,14);
//--- report if there was an error in object creation
   if(ATR_handle<0)
     {
      Print("The creation of iATR has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array ATR[] with current values of iATR
//--- set indexation of array ATR[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(ATR_handle,0,0,100,true,ATR)) return;
  }


iBearsPower

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      BearsPower[];                // array for the indicator iBearsPower
//---- handles for indicators
int         BearsPower_handle;           // handle for the indicator iBearsPower
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iBearsPower
   BearsPower_handle=iBearsPower(NULL,0,14);
//--- report if there was an error in object creation
   if(BearsPower_handle<0)
     {
      Print("The creation of iBearsPower has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array BearsPower[] with current values of iBearsPower
//--- set indexation of array BearsPower[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(BearsPower_handle,0,0,100,true,BearsPower)) return;
  }


iBands

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Base[];     // array for BASE_LINE of iBands
double      Upper[];    // array for UPPER_BAND of iBands
double      Lower[];    // array for LOWER_BAND of iBands
//---- handles for indicators
int         Bands_handle;           // handle of the indicator iBands
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iBands
   Bands_handle=iBands(NULL,0,144,0,2,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(Bands_handle<0)
     {
      Print("The creation of iBands has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetBandsBuffers(Bands_handle,0,100,Base,Upper,Lower,true)) return;
  }


iBullsPower

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      BullsPower[];                // array for the indicator iBullsPower
//---- handles for indicators
int         BullsPower_handle;           // handle for the indicatoriBullsPower
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iBullsPower
   BullsPower_handle=iBullsPower(NULL,0,14);
//--- report if there was an error in object creation
   if(BullsPower_handle<0)
     {
      Print("The creation of iBullsPower has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array BullsPower[] with current values of iBullsPower
//--- set indexation of array BullsPower[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(BullsPower_handle,0,0,100,true,BullsPower)) return;
  }


iCCI

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      CCI[];                // array for the indicator iCCI
//---- handles for indicators
int         CCI_handle;           // handle for the indicator iCCI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iCCI
   CCI_handle=iCCI(NULL,0,14,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(CCI_handle<0)
     {
      Print("The creation of iCCI has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array CCI[] with current values of iCCI
//--- set indexation of array CCI[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(CCI_handle,0,0,100,true,CCI)) return;
  }


iChaikin

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Chaikin[];                // array for the indicator iChaikin
//---- handles for indicators
int         Chaikin_handle;           // handle for the indicator iChaikin
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iChaikin
   Chaikin_handle=iChaikin(NULL,0,8,14,MODE_EMA,VOLUME_TICK);
//--- report if there was an error in object creation
   if(Chaikin_handle<0)
     {
      Print("The creation of iChaikin has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array Chaikin[] with current values of iChaikin
//--- set indexation of array AC[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(Chaikin_handle,0,0,100,true,Chaikin)) return;
  }


iDEMA

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      DEMA[];                // array for the indicator iDEMA
//---- handles for indicators
int         DEMA_handle;           // handle for the indicator iDEMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iDEMA
   DEMA_handle=iDEMA(NULL,0,8,0,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(DEMA_handle<0)
     {
      Print("The creation of iDEMA has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array DEMA[] with current values of iDEMA
//--- set indexation of array DEMA[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(DEMA_handle,0,0,100,true,DEMA)) return;
  }

iDeMarker

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      DeMarker[];                // array for the indicator iDeMarker
//---- handles for indicators
int         DeMarker_handle;           // handle for the indicator iDeMarker
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iDeMarker
   DeMarker_handle=iDeMarker(NULL,0,21);
//--- report if there was an error in object creation
   if(DeMarker_handle<0)
     {
      Print("The creation of iDeMarker has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array DeMarker[] with current values of iDeMarker
//--- set indexation of array DeMarker[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(DeMarker_handle,0,0,100,true,DeMarker)) return;
  }


iEnvelopes

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Upper[];    // array for UPPER_LINE of iEnvelopes
double      Lower[];    // array for LOWER_LINE of iEnvelopes
//---- handles for indicators
int         Envelopes_handle;           // handle of the indicator iEnvelopes
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iEnvelopes
   Envelopes_handle=iEnvelopes(NULL,0,14,0,MODE_SMA,PRICE_CLOSE,0.1);
//--- report if there was an error in object creation
   if(Envelopes_handle<0)
     {
      Print("The creation of iEnvelopes has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation for arrays as timeseries
//--- return if there was an error
//--- filling the arrays with current values of iEnvelopes
   if(!GetEnvelopesBuffers(Envelopes_handle,0,100,Upper,Lower,true)) return;
  }

iForce

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Force[];                // array for the indicator iForce
//---- handles for indicators
int         Force_handle;           // handle for the indicator iForce
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iForce
   Force_handle=iForce(NULL,0,21,MODE_SMA,VOLUME_TICK);
//--- report if there was an error in object creation
   if(Force_handle<0)
     {
      Print("The creation of iForce has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array Force[] with current values of iForce
//--- set indexation of array Force[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(Force_handle,0,0,100,true,Force)) return;
  }


iFractals

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Upper[];    // array for UPPER_LINE of iFractals
double      Lower[];    // array for LOWER_LINE of iFractals
//---- handles for indicators
int         Fractals_handle;           // handle of the indicator iFractals
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iFractals
   Fractals_handle=iFractals(NULL,0);
//--- report if there was an error in object creation
   if(Fractals_handle<0)
     {
      Print("The creation of iFractals has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetFractalsBuffers(Fractals_handle,0,100,Upper,Lower,true)) return;
  }


iFrAMA

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      FrAMA[];                // array for the indicator iFrAMA
//---- handles for indicators
int         FrAMA_handle;           // handle for the indicator iFrAMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iFrAMA
   FrAMA_handle=iFrAMA(NULL,0,21,0,MODE_SMA);
//--- report if there was an error in object creation
   if(FrAMA_handle<0)
     {
      Print("The creation of iFrAMA has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array FrAMA[] with current values of iFrAMA
//--- set indexation of array FrAMA[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(FrAMA_handle,0,0,100,true,FrAMA)) return;
  }


iGator

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Upper[];    // array for UPPER_LINE of iGator
double      Lower[];    // array for LOWER_LINE of iGator
//---- handles for indicators
int         Gator_handle;           // handle of the indicator iGator
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iGator
   Gator_handle=iGator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN);
//--- report if there was an error in object creation
   if(Gator_handle<0)
     {
      Print("The creation of iGator has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetGatorBuffers(Gator_handle,0,100,Upper,Lower,true)) return;
  }


iIchimoku

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double   Tenkansen[];   // array for TENKANSEN_LINE of iIchimoku
double   Kijunsen[];    // array for KIJUNSEN_LINE of iIchimoku
double   SenkouspanA[]; // array for SENKOUSPANA_LINE of iIchimoku
double   SenkouspanB[]; // array for SENKOUSPANB_LINE of iIchimoku
double   Chinkouspan[]; // array for CHINKOUSPAN_LINE of iIchimoku
//---- handles for indicators
int      Ichimoku_handle;            // handle of the indicator iIchimoku
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iIchimoku
   Ichimoku_handle=iIchimoku(NULL,0,9,26,52);
//--- report if there was an error in object creation
   if(Ichimoku_handle<0)
     {
      Print("The creation of iIchimoku has failed: Runtime error =",GetLastError());
      //--- forced program terminatio
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetIchimokuBuffers(Ichimoku_handle,0,100,
      Tenkansen,
      Kijunsen,
      SenkouspanA,
      SenkouspanB,
      Chinkouspan,
      true)) return;
  }


iBWMFI

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      BWMFI[];                // array for the indicator iBWMFI
//---- handles for indicators
int         BWMFI_handle;           // handle of the indicato iBWMFI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iBWMFI
   BWMFI_handle=iBWMFI(NULL,0,VOLUME_TICK);
//--- report if there was an error in object creation
   if(BWMFI_handle<0)
     {
      Print("The creation of iBWMFI has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array BWMFI[] with current values of iBWMFI
//--- set indexation of array BWMFI[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(BWMFI_handle,0,0,100,true,BWMFI)) return;
  }


iMomentum

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Momentum[];                // array for the indicator iMomentum
//---- handles for indicators
int         Momentum_handle;           // handle for the indicator iMomentum
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iMomentum
   Momentum_handle=iMomentum(NULL,0,14,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(Momentum_handle<0)
     {
      Print("The creation of iMomentum has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array Momentum[] with current values of iMomentum
//--- set indexation of array Momentum[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(Momentum_handle,0,0,100,true,Momentum)) return;
  }

iMFI

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      MFI[];                // array for the indicator iMFI
//---- handles for indicators
int         MFI_handle;           // handle of the indicator iMFI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iMFI
   MFI_handle=iMFI(NULL,0,14,VOLUME_TICK);
//--- report if there was an error in object creation
   if(MFI_handle<0)
     {
      Print("The creation of iMFI has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array MFI[] with current values of iMFI
//--- set indexation of array MFI[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(MFI_handle,0,0,100,true,MFI)) return;
  }


iMA

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      MA[];                // array for the indicator iMA
//---- handles for indicators
int         MA_handle;           // handle of the indicator iMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iMA
   MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(MA_handle<0)
     {
      Print("The creation of iMA has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array MA[] with current values of iMA
//--- set indexation of array MA[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(MA_handle,0,0,100,true,MA)) return;
  }

iOsMA

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      OsMA[];                // array for the indicator iOsMA
//---- handles for indicators
int         OsMA_handle;           // handle of the indicator iOsMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iOsMA
   OsMA_handle=iOsMA(NULL,0,8,21,14,PRICE_MEDIAN);
//--- report if there was an error in object creation
   if(OsMA_handle<0)
     {
      Print("The creation of iOsMA has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array OsMA[] with current values of iOsMA
//--- set indexation of array OsMA[] timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(OsMA_handle,0,0,100,true,OsMA)) return;
  }


iMACD

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Main[];    // array for MAIN_LINE of iMACD
double      Signal[];  // array for SIGNAL_LINE of iMACD
//---- handles for indicators
int         MACD_handle;           // handle of the indicator iMACD
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iMACD
   MACD_handle=iMACD(NULL,0,12,26,9,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(MACD_handle<0)
     {
      Print("The creation of iMACD has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetMACDBuffers(MACD_handle,0,100,Main,Signal,true)) return;
  }

iOBV

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      OBV[];                // array for the indicator iOBV
//---- handles for indicators
int         OBV_handle;           // handle for the indicator iOBV
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iOBV
   OBV_handle=iOBV(NULL,0,VOLUME_TICK);
//--- report if there was an error in object creation
   if(OBV_handle<0)
     {
      Print("The creation of iOBV has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array OBV[] with current values of iOBV
//--- set indexation of array AC[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(OBV_handle,0,0,100,true,OBV)) return;
  }

iSAR

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      SAR[];                // array for the indicator iSAR
//---- handles for indicators
int         SAR_handle;           // handle of the indicator iSAR
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iSAR
   SAR_handle=iSAR(NULL,0,0.02,0.2);
//--- report if there was an error in object creation
   if(SAR_handle<0)
     {
      Print("The creation of iSAR has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array SAR[] with current values of iSAR
//--- set indexation of array SAR[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(SAR_handle,0,0,100,true,SAR)) return;
  }

iRSI

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      RSI[];                // array for the indicator iRSI
//---- handles for indicators
int         RSI_handle;           // handle of the indicator iRSI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iRSI
   RSI_handle=iRSI(NULL,0,21,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(RSI_handle<0)
     {
      Print("The creation of iRSI has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array RSI[] with current values of iRSI
//--- set indexation of array RSI[] as timeserie
//--- return if there was an error
   if(!CopyBufferAsSeries(RSI_handle,0,0,100,true,RSI)) return;
  }

iRVI

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Main[];    // array for MAIN_LINE of iRVI
double      Signal[];  // array for SIGNAL_LINE of iRVI
//---- handles for indicators
int         RVI_handle;           // handle of the indicator iRVI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iRVI
   RVI_handle=iRVI(NULL,0,14);
//--- report if there was an error in object creation
   if(RVI_handle<0)
     {
      Print("The creation of iRVI has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetRVIBuffers(RVI_handle,0,100,Main,Signal,true)) return;
  }

iStdDev

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      StdDev[];                // array for the indicator iStdDev
//---- handles for indicators
int         StdDev_handle;           // handle for the indicator iStdDev
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iStdDev
   StdDev_handle=iStdDev(NULL,0,20,0,MODE_SMA,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(StdDev_handle<0)
     {
      Print("The creation of iStdDev has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array StdDev[] with current values of iStdDev
//--- set indexation of array StdDev[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(StdDev_handle,0,0,100,true,StdDev)) return;
  }


iStochastic

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Main[];    // array for MAIN_LINE of iStochastic
double      Signal[];  // array for SIGNAL_LINE of iStochastic
//---- handles for indicators
int         Stochastic_handle;           // handle of the indicator iStochastic
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iStochastic
   Stochastic_handle=iStochastic(NULL,0,5,3,3,MODE_SMA,STO_LOWHIGH);
//--- report if there was an error in object creation
   if(Stochastic_handle<0)
     {
      Print("The creation of iStochastic has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- set indexation of arrays as timeseries
//--- filling the arrays with current values of all indicator's buffers
//--- return if there was an error
   if(!GetStochasticBuffers(Stochastic_handle,0,100,Main,Signal,true)) return;
  }


iTEMA

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      TEMA[];                // array for the indicator iTEMA
//---- handles for indicators
int         TEMA_handle;           // handle of the indicator iTEMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iTEMA
   TEMA_handle=iTEMA(NULL,0,20,0,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(TEMA_handle<0)
     {
      Print("The creation of iTEMA has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array TEMA[] with current values of iTEMA
//--- set indexation of array TEMA[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(TEMA_handle,0,0,100,true,TEMA)) return;
  }


iTriX

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      TriX[];                // array for the indicator iTriX
//---- handles for indicators
int         TriX_handle;           // handle of the indicator iTriX
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iTriX
   TriX_handle=iTriX(NULL,0,20,PRICE_CLOSE);
//--- report if there was an error in object creation
   if(TriX_handle<0)
     {
      Print("The creation of iTriX has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array TriX[] with current values of iTriX
//--- set indexation of array TriX[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(TriX_handle,0,0,100,true,TriX)) return;
  }


iWPR

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      WPR[];                // array for the indicator iWPR
//---- handles for indicators
int         WPR_handle;           // handle of the indicator iWPR
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iWPR
   WPR_handle=iWPR(NULL,0,14);
//--- report if there was an error in object creation
   if(WPR_handle<0)
     {
      Print("The creation of iWPR has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array WPR[] with current values of iWPR
//--- set indexation of array WPR[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(WPR_handle,0,0,100,true,WPR)) return;
  }


iVIDyA

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      VIDyA[];                // array for the indicator iVIDyA
//---- handles for indicators
int         VIDyA_handle;           // handle of the indicator iVIDyA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iVIDyA
   VIDyA_handle=iVIDyA(NULL,0,14,21,0,PRICE_MEDIAN);
//--- report if there was an error in object creation
   if(VIDyA_handle<0)
     {
      Print("The creation of iVIDyA has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array VIDyA[] with current values of iVIDyA
//--- set indexation of array VIDyA[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(VIDyA_handle,0,0,100,true,VIDyA)) return;
  }


iVolumes

#include <GetIndicatorBuffers.mqh>
//---- arrays for indicators
double      Volumes[];                // array for the indicator iVolumes
//---- handles for indicators
int         Volumes_handle;           // handle of the indicator iVolumes
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- creation of the indicator iVolumes
   Volumes_handle=iVolumes(NULL,0,VOLUME_TICK);
//--- report if there was an error in object creation
   if(Volumes_handle<0)
     {
      Print("The creation of iVolumes has failed: Runtime error =",GetLastError());
      //--- forced program termination
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- filling an array Volumes[] with current values of iVolumes
//--- set indexation of array Volumes[] as timeseries
//--- return if there was an error
   if(!CopyBufferAsSeries(Volumes_handle,0,0,100,true,Volumes)) return;
  }

Fazit

  1. Die Verwendung von technischen Standardindikatoren in Expert Advisors in MQL5 ist genauso einfach wie in der Vorgängerversion.
  2. Nutzen Sie in Ihren Expert Advisors nur sichere Programmiermethoden. Analysieren und beseitigen Sie alle potenziellen Fehler. Der Preis von Fehlern ist zu hoch, denn es ist Ihre Einlage!

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

Beigefügte Dateien |
Die Reihenfolge der Erstellung und Zerstörung von Objekten in MQL5 Die Reihenfolge der Erstellung und Zerstörung von Objekten in MQL5

Jedes Objekt, ob es sich um ein benutzerdefiniertes Objekt, ein dynamisches Array oder ein Array von Objekten handelt, wird im MQL5-Programm auf seine festgelegte Art erstellt und gelöscht. Oft sind bestimmte Objekte Teil anderer Objekte und die Reihenfolge der Löschung von Objekten bei der Deinitialisierung wird besonders wichtig. In diesem Beitrag finden Sie einige Beispiele, die die Mechanismen der Arbeit mit Objekten behandeln.

Beschränkungen und Überprüfungen in Expert Advisors Beschränkungen und Überprüfungen in Expert Advisors

Darf dieses Symbol montags gehandelt werden? Ist genug Geld vorhanden, um die Position zu öffnen? Wie groß ist der Verlust, wenn Stop Loss ausgelöst wird? Wie kann die Anzahl ausstehender Aufträge begrenzt werden? Wurde die Handelstätigkeit beim aktuellen oder beim vorherigen Bar ausgeführt? Wenn ein Handelsroboter diese Arten von Überprüfungen nicht durchführen kann, kann jede mögliche Handelsstrategie zu Verlusten führen. Dieser Beitrag beinhaltet Beispiele für Überprüfungen, die in jedem Expert Advisor nützlich sind.

Einführung in MQL5: Schreiben eines einfachen Expert Advisor und benutzerdefinierten Indikators Einführung in MQL5: Schreiben eines einfachen Expert Advisor und benutzerdefinierten Indikators

Die im MetaTrader 5 Client Terminal enthaltene MetaQuotes Programming Language 5 (MQL5) bietet im Vergleich zu MQL4 zahlreiche neue Möglichkeiten und bessere Performance. Dieser Beitrag hilft Ihnen dabei, sich mit dieser neuen Programmiersprache vertraut zu machen. In diesem Beitrag werden einfache Beispiele zum Schreiben eines Expert Advisors und eines benutzerdefinierten Indikators vorgestellt. Wir werden auch auf einige Details der MQL5-Sprache eingehen, die notwendig sind, um diese Beispiele zu verstehen.

Verwendung von Objektzeigern in MQL5 Verwendung von Objektzeigern in MQL5

In MQL5 werden alle Objekte standardmäßig per Verweis übertragen, doch gibt es eine Möglichkeit, Objektzeiger zu verwenden. Dazu muss jedoch eine Prüfung des Zeigers durchgeführt werden, da das Objekt u.U. nicht initialisiert ist. In diesem Fall wird das MQL5-Programm mit schwerwiegendem Fehler beendet und entladen. Die automatisch erzeugten Objekte verursachen diesen Fehler nicht, sind in diesem Sinn also recht sicher. In diesem Beitrag versuchen wir den Unterschied zwischen Objektverweis und Objektzeiger zu erklären und werfen einen Blick darauf, wie man sichere Codes schreibt, die diese Zeiger verwenden.