MetaTrader 5 herunterladen

iGator

Gibt das Handle des Indikators Gator zurück. Oscillator zeigt den Unterschied zwischen der blauen und der roten Linien des Alligators (oberer Chart) und Unterschied zwischen der roten und der grünen Linien (unterer Chart).

int  iGator(
   string              symbol,            // Symbolname
   ENUM_TIMEFRAMES     period,            // Periode
   int                 jaw_period,        // Periode für Berechnung der Kiefer 
   int                 jaw_shift,         // horizontale Verschiebung der Kiefer 
   int                 teeth_period,      // Periode für Berechnung der Zähne 
   int                 teeth_shift,       // horizontale Verschiebung der Kiefer 
   int                 lips_period,       // Periode für Berechnung der Zähne 
   int                 lips_shift,        // horizontale Verschiebung der Lippen  
   ENUM_MA_METHOD      ma_method,         // Glättungstyp
   ENUM_APPLIED_PRICE  applied_price      // Preistyp oder Handle
   );

Parameter

symbol

[in]  Symbolname des Instrumentes, dessen Daten für Berechnung des Indikators verwendet werden. NULL bedeutet das laufende Symbol.

period

[in]  Wert der Periode kann einer der Enumerationswerte ENUM_TIMEFRAMES sein, 0 bedeutet das laufende Timeframe.

jaw_period

[in]  Mittelungsperiode der blauen Linie (Kiefer des Alligators).

jaw_shift

[in]  Verschiebung der blauen Linie des Alligators in Bezug auf das Preischart. Nicht direkt verbunden mit der visuellen Verschiebung des Histogramms des Indikators.

teeth_period

[in]  Mittelungsperiode der roten Linie (Zähne des Alligators).

teeth_shift

[in]  Verschiebung der roten Linie des Alligators in Bezug auf das Preischart. Nicht direkt verbunden mit der visuellen Verschiebung des Histogramms des Indikators.

lips_period

[in]  Mittelungsperiode der grünen Linie (Lippen des Alligators).

lips_shift

[in]  Verschiebung der gruenen Linie des Alligators in Bezug auf das Preischart. Nicht direkt verbunden mit der visuellen Verschiebung des Histogramms des Indikators.

ma_method

[in]  Mittelungsmethode. Kann einer der Werte ENUM_MA_METHOD sein.

applied_price

[in]  Der verwendete Preis. Kann eine der Preiskonstanten ENUM_APPLIED_PRICE oder Handle eines anderen Indikators sein.

Rückgabewert

Gibt das Handle des angegebenen technischen Indikators zurück, beim Misserfolg gibt INVALID_HANDLE zurück. Um Computerspeicher aus nicht genutzten Indikatoren zu befreien, wird die Funktion IndicatorRelease() verwendet, zu deren Indikatorhandle passiert wird.

Hinweis

Puffernummern: 0 - UPPER_HISTOGRAM, 1- Farbenpuffer des oberen Histogramms, 2 - LOWER_HISTOGRAM, 3- Farbenuffer des unteren Histogramms.

Beispiel:

//+------------------------------------------------------------------+
//|                                                  Demo_iGator.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property description "Der Indikator zeigt, wie Daten erhalten werden sollen"
#property description "Indikator-Puffer für den technischen Indikator iGator."
#property description "Symbol und Zeitrahmen, in denen der Indikator berechnet wird,"
#property description "sind durch die Parameter symbol und period angegeben."
#property description "Erstellungsweise des Handles ist durch den 'type' Parameter (Typ der Funktion) angegeben."
#property description "Alle andere Parameter sind wie im normalen Indikator Gator Oscillator."
 
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_plots   2
//--- GatorUp bauen
#property indicator_label1  "GatorUp"
#property indicator_type1   DRAW_COLOR_HISTOGRAM
#property indicator_color1  clrGreen, clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- GatorDown bauen
#property indicator_label2  "GatorDown"
#property indicator_type2   DRAW_COLOR_HISTOGRAM
#property indicator_color2  clrGreen, clrRed
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
//+------------------------------------------------------------------+
//| Enumeration der Erstellungsweisen des Handles                     |
//+------------------------------------------------------------------+
enum Creation
  {
   Call_iGator,            // iGator verwenden
   Call_IndicatorCreate    // IndicatorCreate verwenden
  };
//--- Eingabeparameter
input Creation             type=Call_iGator;       // Funktionstyp 
input string               symbol=" ";             // Symbol 
input ENUM_TIMEFRAMES      period=PERIOD_CURRENT;  // Zeitrahmen
input int                  jaw_period=13;          // Zeitraum für die Kiefer-Linie
input int                  jaw_shift=8;            // Verschiebung der Kiefer-Linie
input int                  teeth_period=8;         // Zeitraum für die Zähne-Linie
input int                  teeth_shift=5;          // Verschiebung der Zähne-Linie
input int                  lips_period=5;          // Zeitraum für die Lippen-Linie
input int                  lips_shift=3;           // Verschiebung der Lippen-Linie
input ENUM_MA_METHOD       MA_method=MODE_SMMA;    // Methode der Mittelung der Alligator-Linie
input ENUM_APPLIED_PRICE   applied_price=PRICE_MEDIAN;// Typ der Preise aus der der Alligator gebaut wird
//--- Indicator-Puffer
double         GatorUpBuffer[];
double         GatorUpColors[];
double         GatorDownBuffer[];
double         GatorDownColors[];
//--- Eine Variable um Handle des Indikators iGator zu speichern
int    handle;
//--- Variable für Speicherung
string name=symbol;
//--- Name des Indikators auf dem Chart
string short_name;
//--- Verschiebung für die obere und untere Histogramme
int shift;
//--- die Anzahl der Werte im Indikator Gator Oscillator gespeichert wird
int    bars_calculated=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Bindung von Arrays zu den Indikator-Puffern
   SetIndexBuffer(0,GatorUpBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,GatorUpColors,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(2,GatorDownBuffer,INDICATOR_DATA);
   SetIndexBuffer(3,GatorDownColors,INDICATOR_COLOR_INDEX);
/*
  Alle Verschiebungen, die in den Parametern angegeben werden, gehören zum Indikator Alligator, auf den Gator Oscillator gebaut wird!
  Daher produzieren diese Verschiebungen keine Verschiebung des Indikators Gator, und verschieben die Linien von Alligator,
  auf dessen Werte die Indikatorwerte von Gator Oscillator konstruiert sind!
*/
//--- Berechnung der Verschiebung für den oberen und unteren Histogramm, die die Abweichung zwischen der Jaws-Linie und der Teeth-Linie ist
   shift=MathMin(jaw_shift,teeth_shift);
   PlotIndexSetInteger(0,PLOT_SHIFT,shift);
//--- Trotz der Tatsache, dass der Indikator zwei Histogramme hat, die gleiche Verschiebung verwendet wird - das ist die Realisierung des Indikators iGator
   PlotIndexSetInteger(1,PLOT_SHIFT,shift);
 
//--- das Symbol, auf das der Indikator gebaut wird, definieren
   name=symbol;
//--- Leerzeichen aus dem linken und rechten löschen
   StringTrimRight(name);
   StringTrimLeft(name);
//--- Wenn nach diesem die Länge des String name ist Null
   if(StringLen(name)==0)
     {
      //--- das Symbol aus dem Chart, auf dem der Indikator läuft, nehmen
      name=_Symbol;
    ;}
//--- Erstellen ein Handel des Indikators
   if(type==Call_iGator)
      handle=iGator(name,period,jaw_period,jaw_shift,teeth_period,teeth_shift,
                    lips_period,lips_shift,MA_method,applied_price);
   else
     {
      //--- die Struktur mit Werten von Indikatorparametern ausfüllen
      MqlParam pars[8];
      //--- Perioden und Verschiebungen der Alligator-Linien
      pars[0].type=TYPE_INT;
      pars[0].integer_value=jaw_period;
      pars[1].type=TYPE_INT;
      pars[1].integer_value=jaw_shift;
      pars[2].type=TYPE_INT;
      pars[2].integer_value=teeth_period;
      pars[3].type=TYPE_INT;
      pars[3].integer_value=teeth_shift;
      pars[4].type=TYPE_INT;
      pars[4].integer_value=lips_period;
      pars[5].type=TYPE_INT;
      pars[5].integer_value=lips_shift;
      //--- Art der Glättung
      pars[6].type=TYPE_INT;
      pars[6].integer_value=MA_method;
      //--- Preistyp
      pars[7].type=TYPE_INT;
      pars[7].integer_value=applied_price;
      //--- Handle erstellen
      handle=IndicatorCreate(name,period,IND_GATOR,8,pars);
    ;}
//--- Wenn Handle konnte nicht erstellt werden
   if(handle==INVALID_HANDLE)
     {
      //--- darüber schreiben und Nummer des Fehlers anzeigen
      PrintFormat("Handle des Indikators iGator für das Paar %s/%s konnte nicht erstellt werden. Fehlercode ist %d",
                  name,
                  EnumToString(period),
                  GetLastError());
      //--- Arbeit des Indikators ist früher geendet
      return(INIT_FAILED);
    ;}
//--- Das Paar, Symbol/Zeitrahmen, auf deren Gator Oscillator berechnet war, zeigen
   short_name=StringFormat("iGator(%s/%s, %d, %d ,%d, %d, %d, %d)",name,EnumToString(period),
                           jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift);
   IndicatorSetString(INDICATOR_SHORTNAME,short_name);
//--- normale Initialisierung des Indikators  
   return(INIT_SUCCEEDED);
 ;}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- Anzahl der Werte des Indikators iGator zu kopieren
   int values_to_copy;
//--- Anzahl der berechneten Werte im Indikator finden
   int calculated=BarsCalculated(handle);
   if(calculated<=0)
     {
      PrintFormat("BarsCalculated() hat %d zurückgegeben, Fehlercode ist %d",calculated,GetLastError());
      return(0);
    ;}
//--- wenn dies der erste Start der Berechnung des Indikators ist oder die Anzahl der Werte im Indikator iGator geändert hat
//--- oder wenn Sie brauchen den Indikator für zwei oder mehr Balken (was bedeutet, dass etwas in der Geschichte verändert hat) zu berechnen
   if(prev_calculated==0 || calculated!=bars_calculated || rates_total>prev_calculated+1)
     {
      //--- wenn Array GatorUpBuffer größer als die Anzahl der Werte in iGator auf symbol/period ist, dann kopieren wir nicht alles
      //--- sonst kopieren wir weniger als Größe der Indikator-Puffer
      if(calculated>rates_total) values_to_copy=rates_total;
      else                       values_to_copy=calculated;
    ;}
   else
     {
      //--- dann ist unser Indikator nicht das erste Mal berechnet, und seit dem letzten Aufruf von OnCalculate())
      //--- nicht mehr als ein Balken für die Berechnung hinzugefügt war
      values_to_copy=(rates_total-prev_calculated)+1;
    ;}
//--- Die Arrays mit den Werten aus dem Indikator Gator Oscillator ausfüllen
//--- Wenn FillArraysFromBuffer false zurückgegeben hat, dann die Daten nicht bereit sind - das Werk vollenden
   if(!FillArraysFromBuffers(GatorUpBuffer,GatorUpColors,GatorDownBuffer,GatorDownColors,
      shift,handle,values_to_copy)) return(0);
//--- Nachricht bilden
   string comm=StringFormat("%s ==> Aktualisierte Werte im Indikator %s: %d",
                            TimeToString(TimeCurrent(),TIME_DATE|TIME_SECONDS),
                            short_name,
                            values_to_copy);
//--- Hilfsnachrichtung auf dem Chart anzeigen
   Comment(comm);
//--- die Anzahl der Werte im Indikator Gator Oscillator speichern
   bars_calculated=calculated;
//--- den Wert prev_calculated für den nächsten Anruf zurückgeben
   return(rates_total);
 ;}
//+------------------------------------------------------------------+
//| Indikator-Puffer aus dem Indikator iGator ausfüllen              |
//+------------------------------------------------------------------+
bool FillArraysFromBuffers(double &ups_buffer[],         // Indikator-Puffer für die obere Histogramm
                           double &up_color_buffer[],    // Indikator-Puffer für die Preisindizes der oberen Histogramm
                           double &downs_buffer[],       // Indikator-Puffer für die untere Histogramm
                           double &downs_color_buffer[], // Indikator-Puffer für die Preisindizes der unteren Histogramm
                           int u_shift,                  // Verschiebung für die obere und untere Histogramme
                           int ind_handle,               // Handle des Indikators iGator
                           int amount                    // Anzahl der Werte, die kopiert werden
                           )
  {
//--- Fehlercode rücksetzen
   ResetLastError();
//--- Teil des Arrays GatorUpBuffer mit Werten auf Indikator-Puffer mit Index 0 ausfüllen
   if(CopyBuffer(ind_handle,0,-u_shift,amount,ups_buffer)<0)
     {
      //--- wenn die Kopie fehlschlägt, Fehlercode anzeigen
      PrintFormat("Daten konnte nicht aus dem Indikator iGator kopiert werden, Fehlercode ist %d",GetLastError());
      //--- Beenden mit Null-Ergebnis - dies bedeutet, dass der Indikator nicht berechnet wird
      return(false);
    ;}
 
//--- Teil des Arrays GatorUpColors mit Werten auf Indikator-Puffer mit Index 1 ausfüllen
   if(CopyBuffer(ind_handle,1,-u_shift,amount,up_color_buffer)<0)
     {
      //--- wenn die Kopie fehlschlägt, Fehlercode anzeigen
      PrintFormat("Daten konnte nicht aus dem Indikator iGator kopiert werden, Fehlercode ist %d",GetLastError());
      //--- Beenden mit Null-Ergebnis - dies bedeutet, dass der Indikator nicht berechnet wird
      return(false);
    ;}
 
//--- Teil des Arrays GatorDownBuffer mit Werten auf Indikator-Puffer mit Index 2 ausfüllen
   if(CopyBuffer(ind_handle,2,-u_shift,amount,downs_buffer)<0)
     {
      //--- wenn die Kopie fehlschlägt, Fehlercode anzeigen
      PrintFormat("Daten konnte nicht aus dem Indikator iGator kopiert werden, Fehlercode ist %d",GetLastError());
      //--- Beenden mit Null-Ergebnis - dies bedeutet, dass der Indikator nicht berechnet wird
      return(false);
    ;}
 
//--- Teil des Arrays GatorDownColors mit Werten auf Indikator-Puffer mit Index 3 ausfüllen
   if(CopyBuffer(ind_handle,3,-u_shift,amount,downs_color_buffer)<0)
     {
      //--- wenn die Kopie fehlschlägt, Fehlercode anzeigen
      PrintFormat("Daten konnte nicht aus dem Indikator iGator kopiert werden, Fehlercode ist %d",GetLastError());
      //--- Beenden mit Null-Ergebnis - dies bedeutet, dass der Indikator nicht berechnet wird
      return(false);
    ;}
//--- Alles gelang
   return(true);
 ;}
//+------------------------------------------------------------------+
//| Indicator deinitialization function                              |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Das Chart nach der Löschung des Indikators leeren
   Comment("");
 ;}