MetaTrader 5 herunterladen

Seil-Indikator von Erik Nayman

14 März 2016, 13:02
Alexander Puzikov
0
522

Inhalt

Einleitung

Der Artikel und der Indikator beruhen auf dem Buch von Erik L. Nayman (The Small Encyclopedia of Trader — К . VIRA-R Alfa Kapital, 1999. —236 S.). Der Artikel beschäftigt sich mit den Grundlagen der technischen Analyse und der Fundamentalanalyse der Märkte, aus welchen diese Methode, der Seil-Indikator vom Autor genannt, ausgewählt wurde. Im Allgemeinen kann man vom Indikator sagen, dass er auf der Relation zwischen der Geschwindigkeit der Preisänderung für den ausgewählten Zeitraum und der Anzahl dieser Änderungen.

Der vorliegende Beitrag wurde anhand der Tabellen und Diagrammen geschrieben, die die Analyse des Autors im Buch veranschaulichen. Der Autor analysiert den Markt anhand des Zusammenspiels zwischen Bären und Bullen, dabei gehören die Geschwindigkeit der Preisveränderung, Anzahl der Trades und die Menge der Veränderung zum Objekt der Analyse. Die Geschwindigkeit wird mit der Zahl der Trades gemessen, und die Differenz zweier benachbarten Notierungen (der laufenden und der vorherigen) macht die Menge aus. Als Notierung gilt der letzte bekannte Preis (im ersten Kapitel wird darauf ausführlicher eingegangen).

Das Ziel der Marktanalyse besteht darin, die Stärke und die Trendrichtung zu berechnen, wo der Markt gleichzeitig der Stärke der Bullen und der Bären ausgesetzt ist. Wenn man den Wert der Stärke berechnet, kann man einschätzen, welcher Trend auf dem Markt herrscht. Der Autor bezeichnet diese Interaktion als Seilziehen zwischen zwei entgegengesetzten Stärken, und veranschaulicht dies mit der Seil-Größe, die anhand der Summe der Stärke der Bullen und der Bären berechnet wird:

Der Autor beschreibt zwei Ansätze zur Marktanalyse und Berechnungen anhand statischer und dynamischer Methoden. Die Berechnung des Seils durchläuft im Buch folgende Etappen:

1. Die "Stärke" der Bullen und Bären einschätzen und berechnen, Richtung finden.

Die Formel der Bullen-Stärke (nach dem Buch):

BuF = SPCi, wobei:

  • BuF — Stärke der Bullen;
  • SPCi — Summe positiver Veränderungen innerhalb des zu analysierenden Zeitraums.

Die Formel der Bären-Stärke (nach dem Buch):

BeF = SNCi, wobei:

  • BeF — Stärke der Bären;
  • SNCi — Summe negativer Veränderungen innerhalb des zu analysierenden Zeitraums.

Danach werden die Werte der BuF und BeF verglichen. Die Stärke, deren Wert größer ist, dominiert auf dem Markt.

Wenn man die Werte der Stärke auf zwei benachbarten Balken innerhalb des zu analysierenden Zeitraums vergleicht, bekommt man eine dynamische Einschätzung. In der Originalquelle wird dies folgenderweise analysiert:

Wenn BuF > BeF und (BuF1 - BuFО) > (BeF1 - BeFО), dann nimmt die Stärke der Bullen zu (mit dem Index 1 wird der aktuelle Wert der Stärke bezeichnet, und mit dem Index 0 — der vorherige Wert).

Wenn BuF > BeF und (BuF1 - BuFО) < (BeF1 - BeFО), dann zeugt dies von der allgemeinen Stärke der Bullen, die aber abnimmt.

Wenn BuF < BeF und (BuF1 - BuFО) > (BeF1 - BeFО), dann zeugt dies von der allgemeinen aber abnehmenden Stärke der Bären.

Wenn BuF < BeF und (BuF1 - BuFО) < (BeF1 - BeFО), dann zeugt dies von einer steigenden Stärke der Bären.

Neben der statischen Größe der Stärke, wird auch die Dynamik der Veränderung dieses Wertes in benachbarten Punkten berücksichtigt.

2. Bewertung, Berechnung und Vergleich der "Beweglichkeit" (Anzahl der Veränderungen) der Bullen und der Bären. Die Berechnung der Beweglichkeit der Bullen und Bären in der Originalquelle:

BuV = NPCi, wobei:

  • BuV — Beweglichkeit der Bullen;
  • NPCi — Anzahl positiver Veränderungen innerhalb des zu analysierenden Zeitraums.

BeV = NNCi, wobei:

  • BeV — Beweglichkeit der Bären;
  • NNCi — Anzahl negativer Veränderungen innerhalb des zu analysierenden Zeitraums.

Wenn man die Größe der Beweglichkeit vergleicht, bekommt man eine dynamische Einschätzung. Die Dynamik wird durch den Vergleich der statischen Größe mit der dynamischen eingeschätzt, gleich wie auf der letzten Etappe der Analyse.

3. Bewertung, Berechnung und der Vergleich der "Fähigkeiten" der Bullen und Bären. Die Berechnung der Fähigkeiten der Bullen und Bären sieht im Buch folgenderweise aus:

Die Fähigkeiten der Bullen und Bären, ihre Politik durchzuführen, zeigen sich in folgenden Formeln:

BuS = SPC1/NPC1;

BeS = SNC1 / NNC1.

So wird die statische Größe berechnet, die dynamische wird am Beispiel der ersten Etappe berechnet.

4. Endgültige Einschätzung der Bullen und Bären. Nach der Berechnung aller Werte in den letzten drei Etappen und dem Vergleich der Daten miteinander, kann man Schlussfolgerung über die Richtung und den Charakter des Trends ziehen. Die endgültige Einschätzung stützt sich auf den Vergleich aller drei Werte. Im Buch sieht die Endeinschätzung folgendermaßen aus:

Wenn BuF > BeF, BuV > BeV und BuS > BeS (bei der Einhaltung der oben beschriebenen dynamischen Relation), dann sind die Bullen mit ihrer Beweglichkeit vorteilhafter als die Bären, und man sollte nur Buy-Orders in Betracht ziehen.

 Für eine dynamische Einschätzung des Marktes sollte man den statischen Daten noch einen dynamischen Wert der zwei "benachbarten Punkten für die Berechnung der Seillinie" hinzufügen.

Anhand dieser Etappen der Analyse kann man drei Hauptwerte für die Erstellung eines Indikators hervorheben:

  • Stärke — Summe der Veränderungen innerhalb des zu analysierenden Zeitraums;
  • Beweglichkeit — Anzahl der Veränderungen innerhalb des zu analysierenden Zeitraums;
  • Fähigkeiten = Stärke / Beweglichkeit.

Der dynamische Teil wurde vom Autor als besonders empfindlich und beweglich eingeschätzt. In diesem Beitrag und im Code wird nur die statische Methode für Berechnungen verwendet. Auf diese Weise vergleicht der Autor Stärke, Beweglichkeit und Fähigkeiten miteinander und zieht Schlussfolgerung über die Stärke und Trendrichtung, berechnet statische und dynamische Daten und führt verschiedene Methoden zu ihren Anwendung an. Nun gehen wir auf die Erstellung des Seil-Indikators nach Erik L. Nayman ausführlicher ein.

Kapitel 1. Grundlagen der Erstellung und Berechnung des Seil-Indikators mit Code-Beispielen

Für die Erstellung des Indikators wurden die lineare Methode und die Histogramm-Methode ausgewählt. Die lineare Methode stellt die Summe der berechneten Größen der Bullen und der Bären dar. Die Histogramm-Methode zeigt die Berechnungen für die Bullen und Bären separat an.

Schauen wir uns den Code des Indikators an, in welchem es zu jedem Schritt einen Kommentar gibt. Beginnen wir mit der Deklaration der Variablen und der Anzeige-Charakteristiken des Indikators via #property. Der Code enthält eine Beschreibung von Farbcharakteristiken des Indikators für eine bequemere Datenanalyse.

//+------------------------------------------------------------------+
//|                                             RopebyEricNaiman.mq5 |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property description "RopebyEricNaiman by Im_hungry (https://login.mql5.com/en/users/Im_hungry)"
#property description "RopebyEricNaiman - shows the direction of the desire of the market action and the power of this desire."
#property version   "1.00"
#property strict
//--- including МА calculation function from the MovingAverages.mqh file
#include <MovingAverages.mqh>
//---
#property indicator_separate_window // sets drawing in a separate window
#property indicator_buffers 12 // sets 12 indicator buffers
#property indicator_plots   5 // sets 5 indicator buffers to be drawn by the indicator
//--- bull histogram
#property indicator_label1  "BULL"
#property indicator_type1   DRAW_COLOR_HISTOGRAM
// 0 - clrDarkGreen - color index "only buy", buy order with high category of confirmation
// 1 - clrMediumSeaGreen - color index "buy order allowed", buy order with average category of confirmation
// 2 - clrLightGreen - color index "buy order allowed", buy order with low category of confirmation
// 3 - clrGray - color index "buy order prohibited"
#property indicator_color1  clrDarkGreen,clrMediumSeaGreen,clrLightGreen,clrGray
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2
//--- bear histogram
#property indicator_label2  "BEAR"
#property indicator_type2   DRAW_COLOR_HISTOGRAM
// 0 - clrDarkRed - color index "only sell", sell order with high category of confirmation
// 1 - clrIndianRed - color index "sell order allowed", sell order with average category of confirmation
// 2 - clrLightPink - color index "sell order allowed", sell order with low category of confirmation
// 3 - clrGray - color index "sell order prohibited"
#property indicator_color2  clrDarkRed,clrIndianRed,clrLightPink,clrGray
#property indicator_style2  STYLE_SOLID
#property indicator_width2  2
//--- MAIN line of indicator
#property indicator_label3  "main line"
#property indicator_type3   DRAW_COLOR_LINE
// 0 - clrDarkGreen - color index "only buy", buy order with high category of confirmation
// 1 - clrDarkRed - color index "only sell", sell order with high category of confirmation
// 2 - clrGray - color index "no strict confirmation"
#property indicator_color3  clrDarkGreen,clrDarkRed,clrGray
#property indicator_style3  STYLE_SOLID
#property indicator_width3  2
//--- drawing indicator of fast МА on data of the main line of indicator
#property indicator_label4  "ma fast"
#property indicator_type4   DRAW_LINE
#property indicator_color4  clrAqua
#property indicator_style4  STYLE_SOLID
#property indicator_width4  1
//--- drawing indicator of slow МА on data of the main line of indicator
#property indicator_label5  "ma slow"
#property indicator_type5   DRAW_LINE
#property indicator_color5  clrYellow
#property indicator_style5  STYLE_SOLID
#property indicator_width5  1

Der Autor beschreibt Farbcharakteristiken nicht und analysiert den Trend anhand voller/teilweiser Übereinstimmung der drei Werte:

  • Stärke der Bullen > Stärke der Bären — Bullenmarkt, das kleiner Zeichen zeugt vom Bärenmarkt.
  • Beweglichkeit der Bullen > Beweglichkeit der Bären — Bullenmarkt.
  • Fähigkeiten der Bullen > Fähigkeiten der Bären — Bullenmarkt.

Wenn man diese Werte miteinander vergleicht, kann man von der Stärke des Trends sprechen. Je mehr Werte an den Trend zeigen, desto stärker ist er. Bei der Initialisierung der Variablen wird das Farbschema des Histogramms anhand der drei Werte beschrieben. Die drei Berechnungsgrößen können in jeder Kombination miteinander verglichen werden.

0 — clrDarkGreen, Farbindex "Nur Buy", Kauf mit hoher Kategorie der Bestätigung.

1 — clrMediumSeaGreen, Farbindex "Buy-Order möglich", Kauf mit mittlerer Kategorie der Bestätigung.

2 — clrLightGreen, Farbindex "Buy-Order möglich", Buy-Order mit niedriger Kategorie der Bestätigung.

3 — clrGray, Farbindex "Buy-Order verboten".

Laut dem Buch wird die Hauptlinie des Indikators nur bei der Übereinstimmung aller drei Berechnungsgrößen in Farbe angezeigt:

"Wenn BuF > BeF, BuV > BeV und BuS > BeS (bei der Einhaltung der oben beschriebenen dynamischen Relation), dann sind die Bullen mit ihrer Beweglichkeit vorteilhafter als die Bären, und man sollte nur Buy-Orders in Betracht ziehen.

Wenn BuF < BeF, BuV < BeV und BuS < BeS (bei der Einhaltung der oben beschriebenen dynamischen Relation), dann sind die Bären vorteilhafter als die Bullen. Nur Sell-Orders sind zu empfehlen."

Deklarieren wir die externen Variablen des Indikators. Für eine bequemere Arbeit mit dem Indikator wurde die Möglichkeit hinzugefügt, die Linie bzw. das Histogramm mit den draw_line und draw_histogram Eingangsvariablen anzuzeigen. Damit die Berechnungen universell gelten, wurde die Möglichkeit hinzugefügt, Preise durch den _price Parameter auszuwählen. Die Einstellungen des MA-Indikators können auch deaktiviert werden.

//--- input parameters
input string section_1="___ main settings";
//--- enable drawing a histogram of bulls and bears
input bool draw_histogram=true;
//--- enable drawing a main line of the indicator
input bool draw_line=true;
//--- period of the indicator
input int _period=76;
//--- price used for calculations
input ENUM_APPLIED_PRICE _price=PRICE_CLOSE;
//--- restrictions in the bar calculations deeper in the history from the current bar
input int max_bars=0;
//--- brief shift of the line and МА from the histogram for better clarity of the indicator. All values of the main line and МА are multiplied by line_deviation
input double line_deviation=3.0;
//---
input string section_2="___ MA fast";
//--- enable drawing the fast МА
input bool draw_MA_fast=false;
//--- period of the quick МА calculation based on the indicator
input int period_MA_fast=25;
//--- calculation method of the fast moving average
input ENUM_MA_METHOD method_MA_fast=MODE_SMA;
//---
input string section_3="___ MA slow";
//--- enable drawing the fast МА
input bool draw_MA_slow=false;
//--- calculation period of the slow МА based on the indicator
input int period_MA_slow=143;
//--- calculation method of the fast moving average
input ENUM_MA_METHOD method_MA_slow=MODE_SMA;
//---- buffers
...

Das Buch beschreibt mehrere Varianten der Arbeit mit der "Seil-Größe". Wir haben die folgenden ausgewählt:

  • Indikator kreuzt die Nulllinie.
  • Trades nur bei der Übereinstimmung aller drei Werte: Stärke, Beweglichkeit und Fähigkeiten. Als Farben der Hauptlinie umgesetzt.
  • Kreuzung des Indikators mit dem MA.
  • Kreuzung zwei МА.

Ein МА-Indikator (aus der Bibliothek MovingAverages.mqh geladen) wird nach den Werten der Hauptlinie des Indikators erstellt, die der Buffer_calcLINE Puffer-Array enthält. Dieses Array wurde den Daten vor der Übergabe in die Funktionsbibliothek der MA-Berechnung für einen bequemeren Zugriff hinzugefügt.

Die grundlegenden Daten für die Berechnung und Erstellung des Indikators werden in der OnInit Funktion initialisiert. Für den Fall wenn der Zeitraum des Charts geändert wird oder wenn der Indikator aus anderen Gründen neugestartet wird, ist es sehr wichtig für die Berechnungen, die prev_rates_total und _tm_prev Variablen auf Null zu setzen. Der _tm_prev Wert ist für die Zeit des letzten Balkens der Berechnungen verantwortlich, ab dem die Berechnungen bei der nächsten Bildung des Balkens beginnen. Der prev_rates_total Parameter speichert den vorherigen rates_total Wert (am vorherigen Tick). Wenn man ihn mit dem laufenden rates_total (Anzahl der Balken oder Array-Größe von price[]) vergleicht, kann man feststellen, dass die Daten umgerechnet und nicht alle Balken hochgeladen wurden; um die Nachladung von Lücken der Historie und als Folge eine falsche Anzeige der Daten auf dem Chart zu vermeiden, werden die Daten umgerechnet.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- log message for running the indicator for the first time
   Print(__FUNCTION__+"\\ Initialization | _period: ",_period);
//--- number of digits after the decimal point for the current symbol
   _digits=(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS);
//---accurate display of indicator values
   IndicatorSetInteger(INDICATOR_DIGITS,_digits);
//--- setting the indicator name, displayed in the indicator window
   IndicatorSetString(INDICATOR_SHORTNAME,"RopebyEricNaiman");
//--- INDICATOR_DATA - stores data for drawing
//--- INDICATOR_COLOR_INDEX - stores color indexes
//--- INDICATOR_CALCULATIONS - stores data for intermediate calculations not intended for drawing
   SetIndexBuffer(0,Buffer_main_bull,INDICATOR_DATA); // data buffer of bull histogram
   SetIndexBuffer(1,Buffer_color_bull,INDICATOR_COLOR_INDEX);  // data buffer of bull colors
   SetIndexBuffer(2,Buffer_main_bear,INDICATOR_DATA); // data buffer of bear histogram
   SetIndexBuffer(3,Buffer_color_bear,INDICATOR_COLOR_INDEX);  // data buffer of bear color
   SetIndexBuffer(4,Buffer_mainline,INDICATOR_DATA); // data buffer of indicator main line
   SetIndexBuffer(5,Buffer_mainline_color,INDICATOR_COLOR_INDEX); // data buffer of colors of the indicator main line
   SetIndexBuffer(6,Buffer_MAfast,INDICATOR_DATA); // data buffer of fast МА
   SetIndexBuffer(7,Buffer_MAslow,INDICATOR_DATA); // data buffer of slow МА
   SetIndexBuffer(8,Buffer_calc,INDICATOR_CALCULATIONS); // data buffer of price calculations
   SetIndexBuffer(9,Buffer_calc_bull,INDICATOR_CALCULATIONS); // calculated bull data buffer 
   SetIndexBuffer(10,Buffer_calc_bear,INDICATOR_CALCULATIONS); // calculated bear data buffer 
   SetIndexBuffer(11,Buffer_calcLINE,INDICATOR_CALCULATIONS); // calculated data buffer for МА
//--- nulling time of the last calculated bar and prev_rates_total (rates_total at the previous call // rates_total = size of array price[])
   _tm_prev=0;
   prev_rates_total=0;
//---
   return(INIT_SUCCEEDED);
  }

Weiter folgen die Berechnungen in der OnCalculate Funktion für Anzeige auf dem Chart. Laut der Berechnungstabelle auf der Seite 147 im Buch, wird ein positives Ergebnis der Differenz zweier Preise als positive Veränderungen bezeichnet, als Preis gilt der Preis bei der Schließung des Balkens (bei der Anwendung des Preises _price=PRICE_CLOSE). Solche Differenz zeugt entweder vom Bullenmarkt (positive Veränderung) oder vom Bärenmarkt (negative Veränderung). Weiter wird solche Differenz als "Balken" gelten, der aus einem Eröffnungspreis, der dem Schließungspreis des vorherigen Balkens gleich ist, und einem Schließungspreis des Berechnungs-Balkens (i) besteht, der mit der folgenden Funktion gesetzt wird:

for(int i=1; i<bars_calc && !IsStopped(); i++)
        {
         ...

Für die Berechnung der drei Werte muss man ein Preis-Array in Übereinstimmung mit der _price Einstellung auswählen und den Wert der _period Variablen mit dem for Operator berechnen. Positive Preisänderungen innerhalb dieses Zeitraums für Bullen und negative für Bären berechnen, Anzahl dieser Änderungen berechnen und ihre Relation finden, indem man die Summe durch die Anzahl dividiert:

  • if(total_bull>0) Buffer_calc_bull[i]=sum_bull/total_bull; — für Bullen.
  • if(total_bear>0) Buffer_calc_bear[i]=sum_bear/total_bear; — für Bären.

Unten ist die Berechnung (live auf dem Chart) am Beispiel des Histogramms der Bullen, Bären und der Hauptlinie mit dem Zeitraum _period=5 dargestellt:

Auf diese Weise entsteht infolge der Addition der Bullen und Bären ein Seil-Wert auf jedem Balken, der später bei den Berechnungen verwendet wird. Dies wurde im Indikator berücksichtigt und als eine Linie mit drei Farben dargestellt, die der Farbpuffer des Indikators Buffer_mainline_color[] anzeigt. Unten sind Berechnungen in OnCalculate() zu sehen.

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // size of price[] array
                const int prev_calculated,// processed bars at the previous call
                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[])
  {
   ArraySetAsSeries(time,true);
//--- setting array indexing as in timeseries, the lowest index 0 has the last known calculated value in history
   ArraySetAsSeries(open,true);
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   ArraySetAsSeries(close,true);
   ArraySetAsSeries(Buffer_main_bull,true);
   ArraySetAsSeries(Buffer_color_bull,true);
   ArraySetAsSeries(Buffer_main_bear,true);
   ArraySetAsSeries(Buffer_color_bear,true);
   ArraySetAsSeries(Buffer_mainline,true);
   ArraySetAsSeries(Buffer_mainline_color,true);
   ArraySetAsSeries(Buffer_MAfast,true);
   ArraySetAsSeries(Buffer_MAslow,true);
   ArraySetAsSeries(Buffer_calc,true);
   ArraySetAsSeries(Buffer_calc_bull,true);
   ArraySetAsSeries(Buffer_calc_bear,true);
   ArraySetAsSeries(Buffer_calcLINE,true);
//--- 
   int copy=0;
   bars_calc=0;
//--- calculation of indicator data
//--- when prev_calculated = 0 all data is calculated on all bars once again , =0 may equal zero after the gap in history, for example, when disconnected from Internet for a long time
   if(prev_calculated==0) _tm_prev=0;
//---if the previous size is bigger than the current size, it indicates failure and all data must be recalculated
   if(prev_rates_total>rates_total) _tm_prev=0;
   if(_tm_prev<time[0]) // calculation when a new bar appears
     {
      if(_tm_prev>0) // if the indicator already has previously calculated data
        {
         copy=TakeShift_byTime(Symbol(),PERIOD_CURRENT,_tm_prev); // the current symbol bar shifting along the last calculated bar time
         if(copy<=0) // if the shift is not found, then calculations are deviated and repeated at the next tick
           {
            return 0;
           }
         bars_calc=copy+1; // setting the bar shift to start calculations from the current unclosed indicator bar
         //--- nulling the first current unclosed bar, i.e. its data is not calculated
         Buffer_main_bull[0]=0.0;
         Buffer_color_bull[0]=5; // setting color index in number 5 corresponds to empty color, therefore color is not drawn
         Buffer_main_bear[0]=0.0;
         Buffer_color_bear[0]=5; // setting color index in number 5 corresponds to empty color, therefore color is not drawn
         Buffer_mainline[0]=0.0;
         Buffer_mainline_color[0]=5; // setting color index in number 5 corresponds to empty color, therefore color is not drawn
         Buffer_MAfast[0]=0.0;
         Buffer_MAslow[0]=0.0;
         Buffer_calc[0]=0.0;
         Buffer_calc_bull[0]=0.0;
         Buffer_calc_bear[0]=0.0;
         Buffer_calcLINE[0]=0.0;
        }
      else // if indicator is set up for the first time and values are not calculated
        {
         bars_calc=Bars(Symbol(),PERIOD_CURRENT)-1; // bar shift to start calculations is set as the total amount of bars -1
         //--- nulling all data on all bars to avoid drawing errors 
         for(int i=0; i<Bars(Symbol(),PERIOD_CURRENT) && !IsStopped(); i++)
           {
            Buffer_main_bull[i]=0.0;
            Buffer_main_bear[i]=0.0;
            Buffer_mainline[i]=0.0;
            Buffer_MAfast[i]=0.0;
            Buffer_MAslow[i]=0.0;
            Buffer_calc[i]=0.0;
            Buffer_calc_bull[i]=0.0;
            Buffer_calc_bear[i]=0.0;
            Buffer_calcLINE[i]=0.0;
           }
        }
      //--- if the amount of bars for indicator calculations falls below zero, then calculation should be aborted
      if(bars_calc<0) return 0;
      //--- restriction of the amount of bars to calculate the max_bars value
      if(bars_calc>max_bars && max_bars!=0) bars_calc=max_bars;
      for(int i=1; i<bars_calc && !IsStopped(); i++)
        {
         //--- calculation of difference between two bars' quotes according to the _price setting
         switch(_price)
           {
            case PRICE_CLOSE:
               Buffer_calc[i]=close[i]-close[i+1];
               break;
            case PRICE_OPEN:
               Buffer_calc[i]=open[i]-open[i+1];
               break;
            case PRICE_HIGH:
               Buffer_calc[i]=high[i]-high[i+1];
               break;
            case PRICE_LOW:
               Buffer_calc[i]=low[i]-low[i+1];
               break;
            case PRICE_MEDIAN:
               Buffer_calc[i]=((high[i]+low[i])/2)-((high[i+1]+low[i+1])/2);
               break;
            case PRICE_TYPICAL:
               Buffer_calc[i]=((high[i]+low[i]+close[i])/3)-((high[i+1]+low[i+1]+close[i+1])/3);
               break;
            case PRICE_WEIGHTED:
               Buffer_calc[i]=((high[i]+low[i]+close[i]+close[i])/4)-((high[i+1]+low[i+1]+close[i+1]+close[i+1])/4);
               break;
            default: return 0;
           }
        }
      //--- running iteration of uncalculated bars until the loop ends and the IsStopped=true command for ending the program doesn't appear (as in the case when deleting the indicator from the chart)
      for(int i=1; i<=bars_calc && !IsStopped(); i++)
        {
         //--- nulling data 
         sum_bull=0.0; // sum variable of positive changes (for bulls) over the analyzed period of time
         total_bull=0; // sum variable of quantity of positive changes over the analyzed period of time
         sum_bear=0.0; // sum variable of negative changes (for bears) over the analyzed period of time
         total_bear=0; // sum variable of negative changes over the analyzed period of time

         Buffer_main_bull[i]=0.0;
         Buffer_color_bull[i]=5;
         Buffer_main_bear[i]=0.0;
         Buffer_color_bear[i]=5;
         Buffer_mainline[i]=0.0;
         Buffer_mainline_color[0]=5;

         Buffer_calc_bull[i]=0.0;
         Buffer_calc_bear[i]=0.0;
         Buffer_calcLINE[i]=0.0;
         //--- stop calculation for the bar, if it falls beyond the available data according to the analyzed period 
         if(i>=(rates_total-_period)) continue;
         //--- data iteration over the analyzed period (_period) from the current bar deeper in the history
         for(int i2=i; i2<i+_period; i2++)
           {
            //--- calculation for bulls
            if(Buffer_calc[i2]>0)
              {
               sum_bull+=Buffer_calc[i2]; // summing up the prices of positive bars ("sum of positive changes over the analyzed period of time")
               total_bull++; // calculation of the amount of positive bars ("amount of positive changes over the analyzed period of time")
              }
            //--- calculation for bears
            if(Buffer_calc[i2]<0)
              {
               sum_bear+=Buffer_calc[i2]; // summing up the prices of negative bars ("sum of negative changes over the analyzed period of time")
               total_bear++; // calculation of the amount of negative bars ("amount of negative changes over the analyzed period of time")
              }
           }
         //--- calculation of "bulls' skill", dividing the bar value in points by the amount of such bars
         if(total_bull>0) Buffer_calc_bull[i]=sum_bull/total_bull;
         //--- calculation of "bears' skills"
         if(total_bear>0) Buffer_calc_bear[i]=sum_bear/total_bear;
         //--- drawing histogram with filling colors by categories of signal confirmation
         if(draw_histogram)
           {
            //--- drawing bulls' histogram, dividing the bar value in points by the amount of such bars
            if(total_bull>0) Buffer_main_bull[i]=sum_bull/total_bull;
            //--- drawing histogram of bears, dividing the size of bar in points by the amount of such bars
            if(total_bear>0) Buffer_main_bear[i]=sum_bear/total_bear;
            //--- 0 color of clrDarkGreen histogram- color index "only buy", buy order with high category of confirmation
            //--- category of confirmation - all three indicators reveal bullish tendency
            //--- bull vigor > bear vigor and bull force > bear force and bull skill > bear skill
            //--- vigor - amount of bars
            //--- force - summing up the bar size in points
            //--- skill - average calculated value of all bar sums over the indicated period force/vigor
            if(total_bull>total_bear && MathAbs(sum_bull)>MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])>MathAbs(Buffer_main_bear[i])) Buffer_color_bull[i]=0;
            else
              {
               //--- 1 color of clrMediumSeaGreen histogram - color index "buy order allowed", buy order with average category of confirmation
               //--- category of confirmation - with two bullish indicators and one bearish indicator, in any combination
               if((total_bull>total_bear && MathAbs(sum_bull)>MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])<MathAbs(Buffer_main_bear[i])) || 
                  (total_bull>total_bear && MathAbs(sum_bull)<MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])>MathAbs(Buffer_main_bear[i])) || 
                  (total_bull<total_bear && MathAbs(sum_bull)>MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])>MathAbs(Buffer_main_bear[i]))) Buffer_color_bull[i]=1;
               else
                 {
                  //--- 2 color of clrLightGreen histogram - color index "buy order allowed", buy order with low category of confirmation
                  //--- category of confirmation - with one bullish indicator and two bearish indicators, in any combination 
                  if((total_bull>total_bear && MathAbs(sum_bull)<MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])<MathAbs(Buffer_main_bear[i])) || 
                     (total_bull<total_bear && MathAbs(sum_bull)>MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])<MathAbs(Buffer_main_bear[i])) || 
                     (total_bull<total_bear && MathAbs(sum_bull)<MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])>MathAbs(Buffer_main_bear[i]))) Buffer_color_bull[i]=2;
                  else
                    {
                     //--- 3 color of clrGray histogram - color index "buy order prohibited"
                     //--- category of confirmation - when bullish indicator is missing
                     Buffer_color_bull[i]=3;
                    }
                 }
              }
            //--- 0 color of clrDarkRed histogram - color index "only sell", sell order with high category of confirmation
            //--- category of confirmation - all three indicators reveal bullish tendency
            if(total_bull<total_bear && MathAbs(sum_bull)<MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])<MathAbs(Buffer_main_bear[i])) Buffer_color_bear[i]=0;
            else
              {
               //--- 1 color of clrIndianRed histogram - color index "sell order allowed", sell order with average category of confirmation
               //--- category of confirmation - with two bullish indicators and one bullish indicator, in any combination
               if((total_bull<total_bear && MathAbs(sum_bull)<MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])>MathAbs(Buffer_main_bear[i])) || 
                  (total_bull<total_bear && MathAbs(sum_bull)>MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])<MathAbs(Buffer_main_bear[i])) || 
                  (total_bull>total_bear && MathAbs(sum_bull)<MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])<MathAbs(Buffer_main_bear[i]))) Buffer_color_bear[i]=1;
               else
                 {
                  //--- 2 color of clrLightPink histogram - color index "sell order allowed", sell order with low category of confirmation
                  //--- category of confirmation - with one bearish indicator and two bullish indicators, in any combination
                  if((total_bull<total_bear && MathAbs(sum_bull)>MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])>MathAbs(Buffer_main_bear[i])) || 
                     (total_bull>total_bear && MathAbs(sum_bull)<MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])>MathAbs(Buffer_main_bear[i])) || 
                     (total_bull>total_bear && MathAbs(sum_bull)>MathAbs(sum_bear) && MathAbs(Buffer_main_bull[i])<MathAbs(Buffer_main_bear[i]))) Buffer_color_bear[i]=2;
                  else
                    {
                     //--- 3 color of clrGray histogram - color index "sell order prohibited"
                     //--- category of confirmation - with bearish indicator missing
                     Buffer_color_bear[i]=3;
                    }
                 }
              }
           }
         //--- calculated value of the main line, summing up the skills of bears and bulls
         Buffer_calcLINE[i]=(Buffer_calc_bull[i]+Buffer_calc_bear[i])*line_deviation;
         //--- drawing line with filling colors by signal confirmation categories
         // 0 - clrDarkGreen - color index "only buy", buy order with high category of confirmation
         // 1 - clrDarkRed - color index "only sell", sell order with high category of confirmation
         // 2 - clrGray - color index "no strict confirmation"
         if(draw_line)
           {
            //--- drawing main line values, summing up the skills of bears and bulls
            Buffer_mainline[i]=(Buffer_calc_bull[i]+Buffer_calc_bear[i])*line_deviation;
            //--- setting the line of indefinite color (2 - clrGray)
            Buffer_mainline_color[i]=2;
            //--- setting the line of bullish color (0 - clrDarkGreen) when all three bullish indicators match (bull>bear)
            if(total_bull>total_bear && MathAbs(sum_bull)>MathAbs(sum_bear) && MathAbs(Buffer_calc_bull[i])>MathAbs(Buffer_calc_bear[i])) Buffer_mainline_color[i]=0;
            //--- setting the line of bearish color (1 - clrDarkRed) when all three bearish indicators match (bear>bull)
            if(total_bull<total_bear && MathAbs(sum_bull)<MathAbs(sum_bear) && MathAbs(Buffer_calc_bull[i])<MathAbs(Buffer_calc_bear[i])) Buffer_mainline_color[i]=1;
           }
        }
      //--- calculation and drawing the МA
      if(draw_MA_fast || draw_MA_slow)
        {
         //--- disabling indexing as in timeseries to transfer into the library MovingAverages.mqh (indexing is changed to have a current history bar in the end of array)
         ArraySetAsSeries(Buffer_calcLINE,false);
         ArraySetAsSeries(Buffer_MAfast,false);
         ArraySetAsSeries(Buffer_MAslow,false);
         //--- iteration of all uncalculated bars. Iteration = All bars (rates_total) - bar shift from the last known calculated time _tm_prev (bars_calc)
         for(int i=rates_total-bars_calc; i<rates_total && !IsStopped(); i++)
           {
            //--- restriction of calculations set in parameters max_bars, calculation only for the set amount of max_bars as the total difference of all bars (rates_total) minus the set amount (max_bars)
            if(max_bars>0?(i<(rates_total-max_bars)):false)
              {
               //--- if the current index i falls beyond the permitted value, we proceed to the allowed index
               i=rates_total-max_bars;
               continue;
              }
            //--- nulling the array in case МА data is not received
            Buffer_MAfast[i]=0.0;
            Buffer_MAslow[i]=0.0;
            //--- selection of the fast МА calculation method based on the method_MA_fast parameter
            if(draw_MA_fast)
              {
               switch(method_MA_fast)
                 {
                  case MODE_SMA: // Simple averaging
                     Buffer_MAfast[i]=SimpleMA(i,period_MA_fast,Buffer_calcLINE); // obtaining data of the calculated SimpleMA i index from the library Include\\MovingAverages.mqh based on Buffer_calcLINE data buffer and period_MA_fast period
                     break;
                  case MODE_EMA: // Exponential averaging
                     Buffer_MAfast[i]=ExponentialMA(i,period_MA_fast,Buffer_MAfast[i-1],Buffer_calcLINE);
                     break;
                  case MODE_SMMA: // Smoothed averaging
                     Buffer_MAfast[i]=SmoothedMA(i+period_MA_fast,period_MA_fast,Buffer_MAfast[i-1],Buffer_calcLINE);
                     break;
                  case MODE_LWMA: // Linear weighted averaging
                     Buffer_MAfast[i]=LinearWeightedMA(i+period_MA_fast,period_MA_fast,Buffer_calcLINE);
                     break;
                  default: return 0;
                 }
              }
            //--- selection of the slow MA calculation method based on method_MA_slow parameter
            if(draw_MA_slow)
              {
               switch(method_MA_slow)
                 {
                  case MODE_SMA: // Simple averaging
                     Buffer_MAslow[i]=SimpleMA(i,period_MA_slow,Buffer_calcLINE);
                     break;
                  case MODE_EMA: // Exponential averaging
                     Buffer_MAslow[i]=ExponentialMA(i,period_MA_slow,Buffer_MAslow[i-1],Buffer_calcLINE);
                     break;
                  case MODE_SMMA: // Smoothed averaging
                     Buffer_MAslow[i]=SmoothedMA(i,period_MA_slow,Buffer_MAslow[i-1],Buffer_calcLINE);
                     break;
                  case MODE_LWMA: // Linear weighted averaging
                     Buffer_MAslow[i]=LinearWeightedMA(i,period_MA_slow,Buffer_calcLINE);
                     break;
                  default: return 0;
                 }
              }
           }
         //--- enabling indexing as in timeseries for drawing
         ArraySetAsSeries(Buffer_calcLINE,true);
         ArraySetAsSeries(Buffer_MAfast,true);
         ArraySetAsSeries(Buffer_MAslow,true);
         //--- nulling МА data for the current bar, i.e. not calculated
         Buffer_MAfast[0]=EMPTY_VALUE;
         Buffer_MAslow[0]=EMPTY_VALUE;
         Buffer_calcLINE[0]=EMPTY_VALUE;
        }
      //--- memorize time of the last calculated bar
      _tm_prev=time[0];
     }
//--- return value of prev_calculated for next call
   prev_rates_total=rates_total;
   return(rates_total);
  }

Für eine bequemere Ansicht bei aktiver Anzeige von Linien und Histogrammen kann man den Wert der Hauptlinie (Wert der Hauptlinie * line_deviation) erhöhen, um die Grenzen des Histogramms zu überschreiten. Beschränkung anhand der Zahl berechneter Balken (max_bars) hinzugefügt, um Berechnungen auf solchen kleineren Zeiträumen wie М1 zu beschleunigen. Das letzte Block des Codes TakeShift_byTime wird für die Verschiebung des Balkens in der Zeit verwendet, um die Zahl der Balken für die Berechnungen in bars_calc festzulegen.

Kapitel 2. Praktische Anwendung des Seil-Indikators und Erstellung eines Expert Advisors

Dieses Kapitel beschäftigt sich mit der Erstellung des Expert Advisors EARopebyEricNaiman nach dem Seil-Indikator (der Name des Quellcodes des Indikators klingt RopebyEricNaiman). Diesen Indikator kann man sowohl in einer separaten Strategie am Beispiel von EARopebyEricNaiman, als auch als einen Filter für die Bestimmung der Trendrichtung verwenden. Der Autor betrachtet in seinem Buch mehrere Möglichkeiten, wie die vom Indikator berechneten Daten verwendet werden können. Darunter wurden die folgenden ausgewählt:

  • Kreuzung der Hauptlinie und der Nulllinie 0 (main line cross zero). Kreuzung nach oben — Buy, nach unten — Sell.

  • Eröffnung beim Farbwechsel der Hauptlinie (main line color) von grau zu grün (Buy) oder zu rot (Sell).

  • Eröffnung bei der Kreuzung der Hauptlinie und des schnellen MA (main line cross MAfast). Hauptlinie kreuzt MA von unten nach oben— Buy, von oben nach unten — Sell.

  • Eröffnung bei der Kreuzung von zwei МА (two MA cross). Der schnelle МА kreuzt den langsamen МА von unten nach oben — Buy, von oben nach unten — Sell.

Neben den Grundeinstellungen kann man vier Schließungstypen im Expert Advisor separat einstellen, die den Eröffnungssignalen entsprechen, aber in einer entgegengesetzten Richtung hinsichtlich des Typs der eröffneten Position:

//---  settings for closing the position
input string section_5="___ Close settings";
//--- closing at the main line intersection with zero / BUY closing at the below intersection
input bool close1=true; // Close main line cross zero
//--- closing when the color is changed to the opposite color of the open position / BUY closing when changed to red
input bool close2=false; // Close main line color
//--- closing at the main line intersection with the МА line/ BUY closing at the main line intersection below МА
input bool close3=false; // Close main line cross MAfast
//---  closing at the intersection of two МАs / BUY closing at the fast МА intersection with the slow МА below
input bool close4=true; // Close two MA cross

Auf diese Weise wird die Position nach einer der ausgewählten Methoden in der trade_mode Variablen eröffnet, und nach Stop Loss/Take Profit/ "einer der oben genannten" geschlossen. Man kann den ganzen Quellcode des Expert Ardisors und des Indikators aus den unten angehängten Dateien herunterladen und sich genau anschauen. Im Beitrag wird der Hauptteil der Berechnungen für Signale der Eröffnung und Schließung erläutert.

  • Die Hauptvariablen und der RopebyEricNaiman Indikator selbst werden im Block OnInit() initialisiert.
  • Das OnTick() Block enthält das Steuerungsblock der Eröffnung/Schließung einer Position.
  • Im Berechnungsblock der Eröffnung Check_Indi_Open() werden die Daten des Indikators geladen und es wird nach dem Signal gesucht:
//+------------------------------------------------------------------+
//| Check_Indi_Open                                                  |
//+------------------------------------------------------------------+
int Check_Indi_Open()
  {
   //--- declaration of arrays to obtain indicator data
   int copy=0;
   double _arr_ind_1[];
   double mafast[];
   double mainline[];
   double maslow[];
   //--- using the switch function to select the opening method based on the external variable parameter trade_mode
   switch((int)trade_mode)
     {
      case 0:
         //--- indicator's main line comparison on the last two bars, except the current one
         copy=Copy_indi_Buffer(RbEN_handle,4,1,2,_arr_ind_1,"RbEN");
         if(copy!=2) return 4;
         if(_arr_ind_1[0]!=EMPTY_VALUE && _arr_ind_1[1]!=EMPTY_VALUE && 
            _arr_ind_1[0]>0 && _arr_ind_1[1]<=0)
           {
            return 0;
           }
         if(_arr_ind_1[0]!=EMPTY_VALUE && _arr_ind_1[1]!=EMPTY_VALUE && 
            _arr_ind_1[0]<0 && _arr_ind_1[1]>=0)
           {
            return 1;
           }
         break;
      case 1:
         //--- obtaining the indicator color index from the indicator buffer No5 on the last two bars, except the current one
         copy=Copy_indi_Buffer(RbEN_handle,5,1,2,_arr_ind_1,"RbEN");
         if(copy!=2) return 5;
         if(_arr_ind_1[0]!=EMPTY_VALUE && _arr_ind_1[1]!=EMPTY_VALUE && 
            _arr_ind_1[0]==0 && _arr_ind_1[1]!=0)
           {
            return 0;
           }
         if(_arr_ind_1[0]!=EMPTY_VALUE && _arr_ind_1[1]!=EMPTY_VALUE && 
            _arr_ind_1[0]==1 && _arr_ind_1[1]!=1)
           {
            return 1;
           }
         break;
      case 2:
         //--- receipt and comparison of mafast (МА on the main indicator line) and mainline (main line of indicator) values on the last two bars, except the current one.
         copy=Copy_indi_Buffer(RbEN_handle,6,1,2,mafast,"RbEN");
         if(copy!=2) return 6;
         copy=Copy_indi_Buffer(RbEN_handle,4,1,2,mainline,"RbEN");
         if(copy!=2) return 7;
         if(mafast[0]!=EMPTY_VALUE && mafast[1]!=EMPTY_VALUE && 
            mainline[0]!=EMPTY_VALUE && mainline[1]!=EMPTY_VALUE && 
            mainline[0]>mafast[0] && mainline[1]<=mafast[1])
           {
            return 0;
           }
         if(mafast[0]!=EMPTY_VALUE && mafast[1]!=EMPTY_VALUE && 
            mainline[0]!=EMPTY_VALUE && mainline[1]!=EMPTY_VALUE && 
            mainline[0]<mafast[0] && mainline[1]>=mafast[1])
           {
            return 1;
           }
         break;
      case 3:
         //--- receipt and comparison of mafast (fast МА on the main indicator line) and maslow (slow МА on the main indicator line) values on the last two bars, except the current one
         copy=Copy_indi_Buffer(RbEN_handle,6,1,2,mafast,"RbEN");
         if(copy!=2) return 8;
         copy=Copy_indi_Buffer(RbEN_handle,7,1,2,maslow,"RbEN");
         if(copy!=2) return 9;
         if(mafast[0]!=EMPTY_VALUE && mafast[1]!=EMPTY_VALUE &&
            maslow[0]!=EMPTY_VALUE && maslow[1]!=EMPTY_VALUE &&
            maslow[0]<mafast[0] && maslow[1]>=mafast[1])
           {
            return 0;
           }
         if(mafast[0]!=EMPTY_VALUE && mafast[1]!=EMPTY_VALUE &&
            maslow[0]!=EMPTY_VALUE && maslow[1]!=EMPTY_VALUE &&
            maslow[0]>mafast[0] && maslow[1]<=mafast[1])
           {
            return 1;
           }
         break;
      default: return 3;
     }
//---
   return 2;
  }

Iteration im Check_Indi_Close() Block entsprechend den Einstellungen aller vier Methoden der Schließung einer offenen Position:

//+------------------------------------------------------------------+
//| Check_Indi_Close                                                 |
//+------------------------------------------------------------------+
int Check_Indi_Close()
  {
   //--- declaration of arrays to obtain indicator data
   int copy=0;
   double _arr_ind_1[];
   double mafast[];
   double mainline[];
   double maslow[];
   _str_close="";
   //--- receipt and comparison with the zero line of the main line on the last two bars, except the current one
   if(close1)
     {
      copy=Copy_indi_Buffer(RbEN_handle,4,1,2,_arr_ind_1,"RbEN");
      if(copy!=2) return 4;
      _str_close="Close main line cross zero";
      if(_arr_ind_1[0]!=EMPTY_VALUE && _arr_ind_1[1]!=EMPTY_VALUE && 
         _arr_ind_1[0]>0 && _arr_ind_1[1]<=0)
        {
         return 0;
        }
      if(_arr_ind_1[0]!=EMPTY_VALUE && _arr_ind_1[1]!=EMPTY_VALUE && 
         _arr_ind_1[0]<0 && _arr_ind_1[1]>=0)
        {
         return 1;
        }
     }
   //--- obtaining the indicator color index from the indicator buffer No5 on the last two bars, except the current one
   if(close2)
     {
      copy=Copy_indi_Buffer(RbEN_handle,5,1,2,_arr_ind_1,"RbEN");
      if(copy!=2) return 5;
      _str_close="Close main line color";
      if(_arr_ind_1[0]!=EMPTY_VALUE && _arr_ind_1[1]!=EMPTY_VALUE && 
         _arr_ind_1[0]==0 && _arr_ind_1[1]!=0)
        {
         return 0;
        }
      if(_arr_ind_1[0]!=EMPTY_VALUE && _arr_ind_1[1]!=EMPTY_VALUE && 
         _arr_ind_1[0]==1 && _arr_ind_1[1]!=1)
        {
         return 1;
        }
     }
   //--- receipt and comparison of mafast (МА on the main indicator line) and mainline (main line of indicator) values on the last two bars, except the current one.
   if(close3)
     {
      copy=Copy_indi_Buffer(RbEN_handle,6,1,2,mafast,"RbEN");
      if(copy!=2) return 6;
      copy=Copy_indi_Buffer(RbEN_handle,4,1,2,mainline,"RbEN");
      if(copy!=2) return 7;
      _str_close="Close main line cross MAfast";
      if(mafast[0]!=EMPTY_VALUE && mafast[1]!=EMPTY_VALUE && 
         mainline[0]!=EMPTY_VALUE && mainline[1]!=EMPTY_VALUE && 
         mainline[0]>mafast[0] && mainline[1]<=mafast[1])
        {
         return 0;
        }
      if(mafast[0]!=EMPTY_VALUE && mafast[1]!=EMPTY_VALUE && 
         mainline[0]!=EMPTY_VALUE && mainline[1]!=EMPTY_VALUE && 
         mainline[0]<mafast[0] && mainline[1]>=mafast[1])
        {
         return 1;
        }
     }
   //--- receipt and comparison of mafast (fast МА on the main indicator line) and maslow (slow МА on the main indicator line) values on the last two bars, except the current one
   if(close4)
     {
      copy=Copy_indi_Buffer(RbEN_handle,6,1,2,mafast,"RbEN");
      if(copy!=2) return 8;
      copy=Copy_indi_Buffer(RbEN_handle,7,1,2,maslow,"RbEN");
      if(copy!=2) return 9;
      _str_close="Close two MA cross";
      if(mafast[0]!=EMPTY_VALUE && mafast[1]!=EMPTY_VALUE &&
         maslow[0]!=EMPTY_VALUE && maslow[1]!=EMPTY_VALUE &&
         maslow[0]<mafast[0] && maslow[1]>=mafast[1])
        {
         return 0;
        }
      if(mafast[0]!=EMPTY_VALUE && mafast[1]!=EMPTY_VALUE &&
         maslow[0]!=EMPTY_VALUE && maslow[1]!=EMPTY_VALUE &&
         maslow[0]>mafast[0] && maslow[1]<=mafast[1])
        {
         return 1;
        }
     }
//---
   return 2;
  }

  • Der Copy_indi_Buffer() Block wurde erstellt, um die Daten des Indikators über die Funktion CopyBuffer() zu erhalten.
  • Der TakeLastOpenTime() Block dient zum Erhalten der Zeit der letzten eröffneten Position, um diese mit der Eröffnungszeit des Balkens (im OnTick) zu vergleichen (um eine eine mehrfache Eröffnung einer Position auf einem Balken zu vermeiden).
  • OpenPosition() — Funktion zur Eröffnung einer Position.
  • #Copy_Time() kopiert die Zeit des angegebenen Balkens.
  • CloseAllPosition() schließt alle Positionen.

Nach der Erstellung des Expert Advisors wird die Optimierung der Eingangsparameter im nächsten Kapitel durchgeführt.

Kapitel 3. Optimierung der Eingangsparameter des Experten nach dem Seil-Indikator

Vor dem Start des Expert Advisors müssen alle wichtigen Eingangsparameter optimiert werden. Als Beispiel wurde das Symbol EURUSD H1 2005-2015 (genetischer Algorithmus der Optimierung) ausgewählt. Für jeden der vier Eröffnungstypen wurde Optimierung vorgenommen.

1. trade_mode = Close main line cross zero (Kreuzung Hauptlinie und 0: Kreuzung von unten nach oben — Kauf, Kreuzung nach unten — Verkauf).

Optimierungsparameter:

Wert Start Schritt Stopp Schritte
StopLoss 0 50 10000 201
TakeProfit 0 50 10000 201
_period 1 1 200 200
close1 false true 2
Gesamtzahl der Durchläufe 16160400

Die Ergebnisse der Optimierung und des besten Tests sind in der angehängten ZIP-Datei optimization.zip im Ordner "EURUSD H1 2005-2015\test1 - main line cross zero\" zu finden.

2. trade_mode = Close main line color (eröffnen, wenn sich die Farbe der Hauptlinie von grau in grün (Buy) oder in rot (Sell) ändert).

Optimierungsparameter:

Wert Start Schritt Stopp Schritte
StopLoss 0 50 10000 201
TakeProfit 0 50 10000 201
_period 1 1 200 200
close2 false true 2
Gesamtzahl der Durchläufe 16160400

Die Ergebnisse der Optimierung und des besten Tests sind in der angehängten ZIP-Datei optimization.zip om Ordner "EURUSD H1 2005-2015\test2 - main line color\" zu finden.

3. trade_mode = main line cross MAfast (Eröffnung bei der Kreuzung der Hauptlinie und des schnellen МА: die Hauptlinie kreuzt den MA von unten nach oben — Buy, von oben nach unten — Sell).

Optimierungsparameter:

Wert Start Schritt Stopp Schritte
StopLoss 0 50 10000 201
TakeProfit 0 50 10000 201
_period 1 1 200 200
period_MA_fast 1 1 300 300
close3 false true 2
Gesamtzahl der Durchläufe 4848120000

Die Ergebnisse der Optimierung und des besten Tests sind in der angehängten ZIP-Datei optimization.zip im Ordner "EURUSD H1 2005-2015\test3 - main line cross MAfast\" zu finden.

4. trade_mode = two MA cross (Eröffnung bei der Kreuzung zwei MA: de schnelle MA kreuzt den langsamen МА von unten nach oben — Buy, von oben nach unten — Sell).

Optimierungsparameter:

Wert Start Schritt Stopp Schritte
StopLoss 0 50 10000 201
TakeProfit 0 50 10000 201
_period 1 1 200 200
period_MA_fast 1 1 300 300
period_MA_slow 1 1 400 400
close4 false true 2
Gesamtzahl der Durchläufe 1939248000000

Die Ergebnisse der Optimierung und des besten Tests sind sind in der angehängten Zip-Datei optimization.zip im Ordner "EURUSD H1 2005-2015\test4 - two MA cross\" zu finden.

Fazit

Die Ergebnisse der Optimierung zeugen von der Existenzfähigkeit dieser Strategie, dabei wurde der Expert Advisor anhand der reinen Logik des Indikators ohne Anwendung zusätzlicher Funktionen der Kapitalverwaltung erstellt. Mit der reinen Logik ist die vom Autor hervorgehobene Strategie zur Bestimmung des Trends gemeint, die auf der statischen Einschätzung der Bewegung der Bullen und Bären innerhalb des angegebenen Zeitraums beruht. Mit diesem Indikator kann man Schlüsselpunkte des Einstiegs in den Markt festlegen; auf diese Weise kann man den Indikator sowohl als einen Filter in eigener Strategie, als auch als Basissignal zur Eröffnung von Trades anwenden.

In den angehängten Dateien finden Sie den Quellcode des Indikators und des Expert Advisors, den Sie bei eigenen Entwicklungen im Bereich Programmieren und Trading nutzen können. Diese Strategie wurde umgesetzt und anhand geringer Anwendungsbereiche vorgestellt (Basissignale für Einstieg/Ausstieg) und hat bereits ihr Potential bewiesen.

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

Beigefügte Dateien |
optimization.zip (2230.41 KB)
Anlegen eines Spektrumanalysators Anlegen eines Spektrumanalysators

Der hier vorliegende Beitrag möchte seine Leser mit einer möglichen Variante der Verwendung der grafischen Objekte der Programmiersprache MQL5 vertraut machen. Es wird ein Indikator analysiert, der mithilfe grafischer Objekte ein Feld zur Steuerung eines einfachen Spektrumanalysators anlegt. Der Beitrag richtet sich an Leser mit Grundkenntnissen in MQL5.

Bildung von Kursreihenmittelwerten für Zwischenberechnungen ohne zusätzliche Puffer Bildung von Kursreihenmittelwerten für Zwischenberechnungen ohne zusätzliche Puffer

In diesem Beitrag geht es sowohl um traditionelle als auch um neuartige Mittelwertbildungsalgorithmen verpackt in einfachste Klassen mit jeweils nur einer Datenart. Sie sind zur universellen Verwendung bei nahezu jeder Indikatorentwicklung gedacht. Ich hoffe, dass die vorgeschlagenen Klassen sich als gute Alternative zu den „unhandlichen“ Aufrufen benutzerdefinierter und technischer Indikatoren erweisen werden.

William Blaus Indikatoren und Handelssysteme in MQL5. Teil 1: Indikatoren William Blaus Indikatoren und Handelssysteme in MQL5. Teil 1: Indikatoren

In diesem Artikel werden die von William Blau in seinem Buch „Momentum, Direction, and Divergence“ (Momentum, Richtung und Divergenz) vorgestellten Indikatoren. Blaus Ansatz ermöglicht die schnelle und exakte Annäherung an die Schwankungen der Kurskurve zur Bestimmung der Richtung der Kursentwicklung und der Wendepunkte sowie zur Beseitigung des Kursrauschens. Unterdessen sind wir auch in der Lage, die Marktzustände des Überkaufs/Überverkaufs sowie die auf eine Richtung und die Umkehrung der Kursbewegung hinweisenden Signale zu ermitteln.

Einen interaktiven, halbautomatischen Drag-and-Drop Expert Advisor auf Grundlage vorab festgelegter Risiken und dem R/R-Verhältnis (relatives Risiko) bauen Einen interaktiven, halbautomatischen Drag-and-Drop Expert Advisor auf Grundlage vorab festgelegter Risiken und dem R/R-Verhältnis (relatives Risiko) bauen

Einige Händler führen all ihre Handel automatisch aus und einige arbeiten sowohl mit automatischen als auch manuellem Handeln auf Grundlage der Ergebnisse verschiedener Indikatoren. Da ich zur zweiten Gruppe gehöre, wollte ich ein interaktives Tool, mit dem ich Risiko- und Prämien-Levels direkt vom Chart aus dynamisch abschätzen kann. In diesem Beitrag wird erläutert, wie man einen interaktiven, halb-automatischen Expert Advisor mit vorab festgelegten Eigenkapitalrisiko und einem R/R-Verhältnis (relatives Risiko) implementiert. Das Expert Advisor Risiko sowie die Parameter für relativer Risiko und die Postengrößen können während der EA-Laufzeit in seinem Bedienfeld verändert werden.