MetaTrader 5 herunterladen

Das Handelssystem DiNapoli

10 Mai 2017, 09:45
Roman Vashchilin
0
484

Inhalt

  1. Einführung
  2. Die Ebene DiNapoli: Die Grundlage
  3. Die Hauptprinzipien und die Begriffe
  4. DiNapoli/Fibonacci-Erweiterung
  5. Die Handelstechnik nach den Ebenen DiNapoli
  6. Die Strategien "Pionier A" und "Pionier B"
  7. Der Indikator der Ebenen DiNapoli
  8. Fazit
  9. Referenzen

1. Einführung

Jeden Tag erscheinen im Trading die neuen Strategien und es finden die zahlreichen Nacharbeitungen der klassischen Handelssysteme statt. Eine der bekanntesten Methoden hat in seinem Gegenwart der Trader, der Ökonom und der Autor der populären Bücher Joes DiNapoli geschaffen. Er hat das System auf den Ebenen Fibonatcci aufgebaut, und bis heute benutzen seine Nutzungsdauern viele Trader weltweit.

Ich schlage vor, sein System besser zu betrachten. Ich habe mich bemüht, die grundlegenden Begriffe und die Prinzipien des Handels nach dieser Methodik maximal nachvollziehbar darzustellen, die man nicht beschreiben kann, ohne enge Vorstellung der Ebenen Fibonatcci. Welche Ebenen sind sie es? Wie soll man sie nachvollziehen und in der Praxis umsetzen? Und das Wichtigste, wie sie im Trading funktionieren?

2. Die Ebene DiNapoli: Die Grundlage



Die Darstellung der Ebenen DiNapoli


Wir betrachten die Grundprinzipien des Handels nach den Ebenen DiNapoli. In Kürze werden wir ordnen, wie sie richtig auf den Charts geordnet werden müssen, damit sie die Preise bezüglich der Bewegung zeigen, und wie die Punkte des Eintritts in den Markt mit ihrer Hilfe bestimmt werden.

Wie ich höher schon sagte, wird die Strategie DiNapoli auf den Fibonacci-Ebenen gegründet. In dieser Methode wird lediglich die horizontale Markierung verwendet, und die Bögen und die Fächer Fibonacci haben keine besondere Anwendung in dieser Strategie.



Das Beispiel der falschen Setzung der Fibonacci-Ebenen



Das Beispiel der richtigen Setzung der Fibonacci-Ebenen


Die Ebenen DiNapoli seiner Natur nach sind die Ebenen der Unterstützung und des Widerstandes, aber sind mehr interpretierbar, als bei einem klassischen Fall. Sie werden aufgrund der Fibonacci-Ebenen gebaut. Zugrunde ihrer liegt der sogenannte Market Swing(siehe unten), oder, einfacher gesagt, Trend. Für den Aufbau der DiNapoli-Ebenen brauchen wir nur drei Fibonacci-Ebenen: 61,8%, 50% und 38,2%. Eben sie werden auf unserem Chart als Unterstützung/Widerstandslevels funktionieren. Auf dem Chart werden die Fibonacci-Linien von unten nach oben im Falle des steigenden Trends aufgetragen und von oben nach unten — wenn es ein absteigender Trend ist.

Idealerweise werden die Linien von 0% bis 100% in die Richtung des laufenden Trends aufgebaut. Alle Fibonacci-Ebenen, welche die Werte mehr als 100% haben, werden für die Setzung der Schließungspunkte einer Position verwendet.



Market Swing


Die Ebenen DiNapoli kann man in zwei Weisen verwenden — in Form einer Erweiterung und in Form einer Korrektion. 

Eine Korrektion wird für die Suche der zweckbestimmten Punkte des Eintritts in die Handelspositionen verwendet, das Netz der Erweiterungen wird für die Suche der Punkte des Verlassens aus dem Markt gebaut.


3. Die Hauptprinzipien und die Begriffe

  • Der Knoten Fibonacci — ist der Punkt auf dem Chart, auf dem die Bewegung der Korrektion zu Ende geht. Joe DiNapoli hat beraten, nur mit den Knoten zu arbeiten, die sich im Bereich von 38,2% bis 61,8% befinden. Alles was unter 38,2% ist — viel zu unbedeutend, und alles was über 61,8% ist — viel zu stark (d.h. der Trend wird möglicherweise nicht wieder hergestellt).
  • Market Swing (die Entfernung zwischen Extremums) — die Entfernung vom Anfang bis zum Ende der Preisbewegung, auf der die Fibonacci-Ebenen ziehen. Wenn der Preis nach dem Abschluss der Korrektion den Punkt Maximums oder Minimums wechselt, ist es auch nötig, den letzten Punkt unserer Ebenen zu versetzen. In diesem Fall wird das Market Swing zunehmen.
  • die Anhäufung — ist es die Stelle auf dem Chart, in dem die Anhäufung einiger Fibonacci-Knoten, d.h. eine Menge der Korrekturebenen nahe zueinander beobachtet werden.
  • Der Brennweitpunkt (Extremum) — ist der äußerste Punkt des Market Swings, die Ebene, von der die Korrektion des Preises beginnt. Beim Wechsel eines Extremums auf dem Chart erscheint noch ein Brennweitpunkt, deshalb können sie viel auf dem Chart im Bereich eines Market Swings sein.  
  • die zweckbestimmte Ebene — der Punkt auf dem Chart des Preises, in dem Sie planen, Take-Profit zu setzen.
  • der zweckbestimmte Punkt — ein beliebiger Punkt auf dem Chart, in dem Sie planen, eine Aktion durchzuführen (der Eintritt in den Markt, das Verlassen aus ihn u.s.w ).
  • Reaktiondie erledigte Korrektion in der Trend-Bewegung. Im Radius eines Market Swings können ein paar Reaktionen gebildet werden.


Die Erweiterung, die Korrektion und der Brennweitpunkt


Das Chart des Preises bewegt sich ständig, und jedesmal muss man bezüglich des Charts korrigieren. Dabei wird jedesmal die Erweiterung des Market Swings stattfinden, so kann die Anzahl der Brennweitpunkte auf dem Chart ändern. In der Mitte der Market Swing erscheinen die Korrektionen des Preises, die "die Reaktionen" heißen. Jeder von ihnen hat seine eigene Nummer.



Die Reaktionen auf dem Chart


Die Tipps vom DiNapoli

  • Die Signale, die von diesen Ebenen kommen, sind in diesem Fall nützlich, wenn die Korrekturebenen, sowie die Ebenen Anhäufung/Unterstützung im Bereich der Ebenen 38,2%-61,8% sind. Auf die übrigen Signale Acht zu geben, lohnt es sich nicht.
  • Die Ebenen für die Fixierung des Gewinns werden gewöhnliche Fibonacci-Erweiterungen sein, die sich bis zur letzten Korrektion ausbreiten, um auf den Ebenen 161,8% und 261,8% Stopp-Loss setzen zu können.
  • Die Anzahl der Market Swings auf dem Chart ist immer gleich der Anzahl der Brennweitzahlen.
  • Die Brennweitzahlen befinden sich immer rechter als die Reaktionen, mit denen sie verbunden sind. D.h. die Korrektionen des Preises, die sich auf dem Market Swing der Ebenen gebildet haben, sollen sich linker als die Brennweitzahl befinden.
  • Je höher die Timeframe ist, desto weniger ist die Zahl der Reaktionen. Wenn Sie auf verschiedenen vorübergehenden Intervallen arbeiten, können Sie bemerken, dass auf kleinen Timeframes die Bewegung des Preises sehr schnell ist, und auf älteren Timeframes diese kleinen Bewegungen nicht mal dargestellt werden. Diese Regel wird auch andersherum verwendet: wenn die Stelle erscheint, auf der der Preis einen starken Widerstand/Unterstützung hat, Sie können die Ihnen notwendigen Reaktionen und Market Swings finden, die auf älteren Timeframes nicht dargestellt werden, wenn Sie die kleineren vorübergehenden Intervalle verwenden.


4. DiNapoli/Fibonacci-Erweiterung

Das Netz der Erweiterungen der DiNapoli-Ebenen werden wir benötigen, um die Stellen für die Schließung der Positionen zu bestimmen. Als Grundlage ihres Aufbaus wird das Netz der Fibonacci-Erweiterungen dienen. Diesmal werden wir die Ebenen in 100 %, 161,8 % und 261,8 % verwenden, die für uns ein zweckbestimmter Punkt für die Setzung des Take-Profits sein werden.



Die Erweiterung der Fibonacci-Ebenen (DiNapoli)


Das Netz der Fibonacci-Erweiterungen wird auf dem Chart so gebaut:

  • Für den absteigenden Trend — vom Preisminimum und bis zur Spitze der Korrektion des Preises beginnend, der die Abbruch-Linie des Preises, von 38,2 % und höher gebildet hat.
  • Für den steigenden Trend — vom Preismaximum und bis zum Minimum der Korrektion des Preises beginnend, der die Ebene 38,2 % und höher überquert.



Das anschauliche Beispiel, wie auf dem Chart "Das Netz der Fibonacci-Erweiterungen" gesetzt werden soll


Im Buch "der Handel unter Verwendung der Ebenen DiNapoli" gibt der Autor viel Aufmerksamkeit auf solchen Begriffen wie "die zahlreichen Brennweitzahlen" und "Market Swing". Die gegebenen Modelle sind an der Arbeit für die Instrumente mit häufigen "Flets" charakteristisch, wenn es keinen klaren Trend gibt. An der Arbeit auf dem Chart und ihres Aufbaus sind solche Figuren komplizierter als einfache Market Swing. Das Hauptproblem besteht darin, die unnötigen Ebenen zu sortieren, die nicht mehr aktuell sind.

Ich werde kurz die Schlussfolgerungen aufzählen, die ich nach dem Lesen des Buches gemacht habe. Ihre zweifellosen Vorteile bestehen darin, dass sie kein einfacher Theoretiker geschrieben hat, sondern ein erfahrener Trader und Manager. Noch ein "unschlagbares" Argument zu ihrer Gunst — die Verwendung der Fibonacci-Ebenen, die die zeitlich Jahrhunderte Prüfung hinter sich hat, mathematisch präzis und geprüft. Außerdem die Beispiele, die im Buch gebracht sind, nicht nur die Waren- und Fondsmärkte beschreiben, sondern auch den Devisen-Future Handel, deren Prinzipien auch zum Markt Forex verwendet werden können.

Es ist besser, dieses Werk im Original zu lesen, da die Übersetzung den Kontext verzerren kann und das Verständnis der feinen Nuancen der Methodik erschweren. Eine Menge neuer eingeführten Begriffe DiNapolis fordert eine sorgfältige Forschung und ein allseitiges Verständnis.


5. Die Handelstechnik nach den Ebenen DiNapoli

Lassen Sie uns nun bitte direkt das Handelssystem nach den Ebenen DiNapoli betrachten. Kurz zusammengefasst, wenn man nur die Hauptideologie aus seinem Buch nimmt, kann man einige Taktiken des Handels mit den Ebenen "Aggressiv" und "Ruhig" aufbauen.

  • Die aggressiv Ebene hat 2 Weisen des Eintritts in den Markt: es sind die Strategien "Büsche" und "Bonsaj". Das Prinzip des Handels nach ihm ist ähnlich, der Unterschied besteht nur darin, wo die Stopp-Loss gesetzt werden müssen.
  • Die ruhige Ebene beschreibt auch 2 Weisen: "Pionier A" und "Pionier B".

Unter Verwendung der aggressiven Methode des Handels geht die Berechnung darauf, dass der Preis sich von der Ebene 38,2 % und schon vom bildenden Market Swing erwehren wird. Der Unterschied zwischen den Strategien "Büsche" und "Bonsaj" besteht nur darin, nach welcher Fibonacci-Ebene Stopp-Loss gesetzt wird.

Wir werden von der Weise des Handels "Büsche" beginnen.  Nach den Regeln dieser Methode müssen die Position zu jenem Moment geöffnet werden, wenn der Preis am gebauten Netz der Korrektionen die Ebene 38,2 % in die Richtung des aktuellen Trends überquert, und der Stopp-Loss wird weiter als die Ebene 50% gesetzt. Nach der Methodik "Bonsaj" treten wir in den Markt ebenso ein, wie nach der Methodik "Büsche", aber Stopp-Loss setzen wir bis zur Fibonacci-Ebene 50%.

Der Handel nach diesen Methoden heißt nicht einfach so aggressiv, da es das Risiko gibt, dass das Schlußsignal des Preises auf dem Chart nicht stattfinden kann. Denn es passiert sehr oft, dass die Korrektion letztendlich in einen neuen Trend umwandelt, oder der Preis bremst auf kurzer Zeit in Flat. Deshalb, wenn Sie sich für dieses Schema entscheiden, müssen Sie auf die vollwertige Bestätigung des Signals warten, um siecher zu sein.



Die Strategie "Büsche"


Im Buch wurden einige negative Besonderheiten beschrieben, die zur Strategie "Bonsaj" gehören. DiNapoli betont, dass es in diesem Fall auf der Börse eine ziemlich starke Gleitung während der Erfüllung des Stoppbefehls sein kann, da die Stütze auf eine starke Ebene fehlt, und es bedeutet, dass es auch keinen "Vorhandel" gibt, die Angabe der Orders. In diesem Zusammenhang wird die Auswahl vom Brokerunternehmen und der Handelsplattform abhängig sein. Andererseits, wenn man mit den hohe Liquidität-Instrumenten und mit einem kleinen Volumen auf dem Markt arbeitet, dann ist es sowas eher unwahrscheinlich.


6. Die Strategien "Pionier A" und "Pionier B"

Am ruhigsten und am wenigsten Riskanten Strategien — "Pionier A" und "Pionier B". Der Eintritt in den Markt über sie wird nach dem Schluss der Korrektion geplant, aber die Arbeit wird mit der Versicherung geführt.

  • Pionier A. Erstens warten wir, wenn die erste Korrektion zu Ende gehen wird (bisher öffnen wir keine Position), dann warten wir auf die Bildung der zweiten Korrektion. Erst dann öffnen wir Positionen. Der Stop-Loss setzen wir ebenso, wie wir es in der vorherigen Strategie gesetzt haben, d.h. nach der folgenden Fibonacci-Ebene.
  • Pionier B. Wir öffnen die Positionen nicht nach der zweiten bildenden Korrektion, sondern nur nach der dritten, vierten usw. Mit anderen Wörtern, wir treten in den Markt nur nach einer ernsten Bestätigung des Trends ein, was uns eine starke Versicherung von den falschen Signalen bestätigt.
Was haben wir infolge der vorliegenden Strategie? Wir bekommen die seltenen Eintritts in den Markt. Der Trend wird nicht immer so langfristig, um 3 und noch mehr nacheinander kommenden Bewegungen der Korrektion zu geben, die ja auch noch den Regeln des vorliegenden Handelssystems entsprechen (darüber, dass das Ende des Rücklaufes auf den Ebenen 38,2% — 61,8% sein soll). Andererseits sortieren wir so die falschen Signale ab, in den die Korrektion des Preises keine Fortsetzung des Trends sein wird.


Die Strategie "Pionier A"


Wenn Sie auf dem Markt auf einen ziemlich langwierigen Trend und eine Menge der Korrektionen gestoßen sind (der Reaktionen) und wenn Sie an allen Regeln der Analyse festhalten werden, so wird Ihr Chart stark von einer Menge der unbedeutenden Ebenen und der Linien gebaut. Wirklich, einen großen Teil von ihnen kann man einfach wie eine störende Information wegschmeißen, die nicht den Regeln des Handels nach den Ebenen DiNapoli entsprechen.

Stellen Sie sich vor, dass Sie auf dem Chart des Preises eine starke steigende Bewegung sehen, in der einige Reaktionen gibt. An einer Zeit bei Ihnen findet eine Korrektion auf alle Bewegungen des Preises nach oben statt, als dessen Ergebnis der Preis beginnt, die Minimums einiger Reaktionen abzuschreiben. Solche Reaktionen muss man aufheben, und ihre Minimums muss man nicht zur Arbeit hinzufügen.

7. Der Indikator der Ebenen DiNapoli

Speziell für die Trader, die keine Zeit für den manuellen Aufbau der Ebenen DiNapoli geben wollen, durch die Setzung der Fibonacci-Ebenen, wurde bereits der Indikator entwickelt, der diese Ebenen baut und sie auf dem Chart zeichnet. Den Indikator findet man im Abhang in den Dateien am Ende des Artikels. Er wurde in der Bibliothek der geöffneten Kodes dargestellt. Wir werden die Arbeit mit ihm ein wenig gründlicher betrachten. Der Name des Indikators wurde für die Bequemlichkeit der Leser geändert.

Die Setzung des Indikators findet traditionell statt, durch die Zuordnung der Datei in den Ordner des Root-Verzeichnises MetaTrader 5. Die Einstellungen darin sind nicht sehr viel, es werden hauptsächlich die Farben der Ebenen für die Darstellung eingestellt. Die Farben kann man willkürlich ändern, aber wenn Sie ein Neulinge sind, sollen Sie die Parameter nicht ändern, um Fehler der Darstellung und der Analyse des Marktes vom Indikator zu vermeiden.

Der Indikator für die automatische Darstellung der Ebenen DiNapoli hat auch den Indikator "Zigzag" mit der lautlichen Benachrichtigung über die Wende des Zickzackes. Der Indikator markiert mit der roten Linie auf dem Chart die Linie für die Setzung Stopp-Loss, mit der blauen Farbe — die Linie für den Anfang der Arbeit, die übrigen horizontalen Linien — sind zweckbestimmten für den Preis. Außerdem zeigt der Indikator die senkrechten Linien der Zeit-Markierung (sie können in den Einstellungen des Indikators abgeschaltet werden).


Eingabeparameter des Indikators



Die Darstellung des Indikators "DiNapoli Levels" auf dem Preischart des Terminals


Parameter:

  • Minimum points in a ray (standardmäßig = 400) — die Breiteänderung der vorübergehenden senkrechten Ebenen;
  • Show the vertical lines (standardmäßig = true) — Darstellung AN/Aus der vorübergehenden senkrechten Ebenen;
  • Number of history bars (standardmäßig = 5000) — die Anzahl der erfassten Bars in der History vom eingebauten Indikator "Zigzag";
  • Play sound (standardmäßig = true) — die lautliche Benachrichtigung über die Änderung der Richtung vom Indikator "Zigzag" einschalten;
  • Sound file (standardmäßig = "expert.wav") — die Auswahl der Datei für die lautliche Benachrichtigung;
  • Start Line color (standardmäßig = Blue) — die Farbe der horizontalen Anfangslinie;
  • Stop Line color (standardmäßig = Red) — ie Farbe der horizontalen Linie, für die Setzung des Stopp-Loss;
  • Target1 Line color (standardmäßig = Green) — die Farbe der horizontalen Linie für das Ziel №1;
  • Target2 Line color (standardmäßig = DarkOrange) — die Farbe der horizontalen Linie für das Ziel №2;
  • Target3 Line color (standardmäßig = DarkOrchid) — die Farbe der horizontalen Linie für das Ziel №3;
  • Target4 Line color (standardmäßig = DarkSlateBlue) — die Farbe der horizontalen Linie für das Ziel №4;
  • Time Target1 color (standardmäßig = DarkSlateGray) — die Farbe der horizontalen vorübergehenden Linie №1;
  • Time Target2 color (standardmäßig = SaddleBrown) — die Farbe der horizontalen vorübergehenden Linie №2;
  • Time Target3 color (standardmäßig = DarkSlateGray) — die Farbe der horizontalen vorübergehenden Linie №3;
  • Time Target4 color (standardmäßig = DarkSlateGray) — die Farbe der horizontalen vorübergehenden Linie №4;

Am Anfang fügen wir die grundlegenden Parameter des Indikators ein, auf den sein ganzer Code gebaut wird.

Die Anfangsparameter des Codes sehen so aus:

//------------------------------------------------------------------------------------
//                                                                 DiNapoli Levels.mq5
//                                                   The modified indicator FastZZ.mq5
//                                       Added DiNapoli Target Levels and Time Targets
//                                                         victorg, www.mql5.com, 2013
//------------------------------------------------------------------------------------
#property copyright   "Copyright 2012, Yurich"
#property link        "https://login.mql5.com/de/users/Yurich"
#property version     "3.00"
#property description "FastZZ plus DiNapoli Target Levels."
#property description "The modified indicator 'FastZZ.mq5'."
#property description "victorg, www.mql5.com, 2013."
//------------------------------------------------------------------------------------
#property indicator_chart_window // Zeigt den Indikator im Fenster des Charts
#property indicator_buffers 3    // Die Anzahl der Puffer für die Rechnung des Indikators
#property indicator_plots   1    // Die Anzahl der Fenster des Indikators
#property indicator_label1  "DiNapoli Levels" // Gibt das Zeichen der grafischen Serie ein
#property indicator_type1   DRAW_COLOR_ZIGZAG // Die Zeichenart des Indikators. N - Die Nummer der grafischen Serie
#property indicator_color1  clrTeal,clrOlive  // Die Nummer für die Darstellung der Linie N, wo N - Die Nummer der grafischen Serie ist
#property indicator_style1  STYLE_SOLID       // Der Linienstyle in der grafischen Serie
#property indicator_width1  1    // Die Linienbreite in der grafischen Serie
//------------------------------------------------------------------------------------
input int    iDepth=400;              // Die minimale Anzahl der Punkte im Strahl
input bool   VLine=true;              // Es zeigt die senkrechten Linien
input int    iNumBars=5000;           // Die Anzahl der Bars in der History
input bool   Sound=true;              // Die Einschaltung der lautlichen Benachrichtigungen
input string SoundFile="expert.wav";  // Die Sounds-Datei
input color  cStar=clrBlue;           // Die Farbe der Anfangslinie
input color  cStop=clrRed;            // die Farbe der Stopp-Linie
input color  cTar1=clrGreen;          // die Farbe der Linie des Ziels №1
input color  cTar2=clrDarkOrange;     // die Farbe der Linie des Ziels №2
input color  cTar3=clrDarkOrchid;     // die Farbe der Linie des Ziels №3
input color  cTar4=clrDarkSlateBlue;  // die Farbe der Linie des Ziels №4
input color  cTarT1=clrDarkSlateGray; // Die Farbe der vorübergehenden Linie №1
input color  cTarT2=clrDarkSlateGray; // Die Farbe der vorübergehenden Linie №2
input color  cTarT3=clrSaddleBrown;   // Die Farbe der vorübergehenden Linie №3
input color  cTarT4=clrDarkSlateGray; // Die Farbe der vorübergehenden Linie №4
input color  cTarT5=clrDarkSlateGray; // Die Farbe der vorübergehenden Linie №5

Wir werden Variabel in den Indikator einführen.

//Die Hauptvariablen
double   DiNapoliH[],DiNapoliL[],ColorBuffer[],Depth,A,B,C,Price[6];
int      Last,Direction,Refresh,NumBars;
datetime AT,BT,CT,Time[5];
color    Color[11];
string   Name[11]={"Start Line","Stop Line","Target1 Line","Target2 Line",
                   "Target3 Line","Target4 Line","Time Target1","Time Target2",
                   "Time Target3","Time Target4","Time Target5"};

Nach dem Schreiben der Hauptparameter und der Einfügung der Variabelen können wir mit dem Schreiben des Hauptteiles des Indikators anfangen.

Der Hauptteil:

// Wir beginnen die Initialization des Indikators
void OnInit()
  {
  int i;
  string sn,sn2;
  
// Wir stellen die Bedingung für die Punkte im Strahl
  if(iDepth<=0)Depth=500; 
  else Depth=iDepth;   
  
// Wir stellen die Bedingung für die Bars in der History     
  if(iNumBars<10)NumBars=10;
  else NumBars=iNumBars;
  
// Wir stellen die Darstellung der Indikatorpuffer ein  
  SetIndexBuffer(0,DiNapoliH,INDICATOR_DATA); 
  SetIndexBuffer(1,DiNapoliL,INDICATOR_DATA);
  SetIndexBuffer(2,ColorBuffer,INDICATOR_COLOR_INDEX);
  
//Wir werden die Genauigkeit der Darstellung der Werte des Indikators einstellen
  IndicatorSetInteger(INDICATOR_DIGITS,Digits()); 
  
// Wir stellen das Zeichen der Linien ein  
  PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0); 
  PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0); 
  
// Es wird ein Kurzname des Indikators eingestellt  
  sn="DiNapoli"; sn2=""; 
  for(i=1;i<100;i++)
    {
// Wir werden die Suche des Diagramms einstellen   
    if(ChartWindowFind(0,sn)<0){break;}
    sn2="_"+(string)i; sn+=sn2;
    }
    
// Wir stellen die Darstellung des Symbols ein    
  IndicatorSetString(INDICATOR_SHORTNAME,sn);
  for(i=0;i<11;i++) Name[i]+=sn2;
  
// wir initialisieren Puffer mit leeren Werten   
  ArrayInitialize(DiNapoliH,0); ArrayInitialize(DiNapoliL,0);

Und beginnen mit Gestaltung des Indikators:

// Wir stellen die farbigen Linien des Indikators ein
  Color[0]=cStar; Color[1]=cStop; Color[2]=cTar1; Color[3]=cTar2;
  Color[4]=cTar3; Color[5]=cTar4; Color[6]=cTarT1; Color[7]=cTarT2;
  Color[8]=cTarT3; Color[9]=cTarT4; Color[10]=cTarT5;
  Depth=Depth*_Point;
  Direction=1; Last=0; Refresh=1;
  for(i=0;i<6;i++)
    {
    if(ObjectFind(0,sn)!=0)
      {
      
// Wir stellen die horizontalen und senkrechten Linien ein
     
      ObjectCreate(0,Name[i],OBJ_HLINE,0,0,0);
      ObjectSetInteger(0,Name[i],OBJPROP_COLOR,Color[i]);
      ObjectSetInteger(0,Name[i],OBJPROP_WIDTH,1);
      ObjectSetInteger(0,Name[i],OBJPROP_STYLE,STYLE_DOT);
//    ObjectSetString(0,Name[i],OBJPROP_TEXT,Name[i]);// die Beschreibung des Objektes
      }
    }
  if(VLine==true)
    {
    for(i=6;i<11;i++)
      {
      if(ObjectFind(0,sn)!=0)
        {
        ObjectCreate(0,Name[i],OBJ_VLINE,0,0,0);
        ObjectSetInteger(0,Name[i],OBJPROP_COLOR,Color[i]);
        ObjectSetInteger(0,Name[i],OBJPROP_WIDTH,1);
        ObjectSetInteger(0,Name[i],OBJPROP_STYLE,STYLE_DOT);
//      ObjectSetString(0,Name[i],OBJPROP_TEXT,Name[i]);// die Beschreibung des Objektes
        }
      }
    }
  }
  
// Wir fügen die Funktion bei der Abnahme des Indikators vom Chart hinzu, dabei werden die graphischen Objekte vom Indikator entfernt
void OnDeinit(const int reason)
  {
  int i;
   
  for(i=0;i<11;i++) ObjectDelete(0,Name[i]);
  ChartRedraw();
  return;
  }

Jetzt werden wir die Puffer des Indikators rechnen:

// Die Funktion der Iteration des Indikators
int OnCalculate(const int total,        // Der Umfang der Eingangs-Timeserie
                const int calculated,   // Es wurden die Bars des Aufrufs bearbeitet 
                const datetime &time[], // Das Massiv mit den Werten der Zeit
                const double &open[],   // Das Massiv mit den Preisen der Eröffnung
                const double &high[],   // Das Massiv für das Kopieren der maximalen Preise 
                const double &low[],    // Das Massiv der minimalen Preise
                const double &close[],  // Das Massiv der Preise der Schließung
                const long &tick[],     // Der Parameter enthält die History des Ticks-Umfanges
                const long &real[],     // der reale Umfang
                const int &spread[])    // Das Massiv, das die Spread-History enthält                

  {
  int i,start;
  bool set;
  double a;

// Wir geben die Prüfung der Bars ein
  if(calculated<=0)
    {
    start=total-NumBars; if(start<0)start=0;
    
// wir initialisieren Puffer mit leeren Werten  
    Last=start; ArrayInitialize(ColorBuffer,0);
    ArrayInitialize(DiNapoliH,0); ArrayInitialize(DiNapoliL,0);
    }
    
// Обсчет нового бара    
  else start=calculated-1;
  for(i=start;i<total-1;i++)
    {
    set=false; DiNapoliL[i]=0; DiNapoliH[i]=0;
    if(Direction>0)
      {
      if(high[i]>DiNapoliH[Last])
        {
        DiNapoliH[Last]=0; DiNapoliH[i]=high[i];
        if(low[i]<high[Last]-Depth)
          {
          if(open[i]<close[i])
            {
            DiNapoliH[Last]=high[Last];
            A=C; B=high[Last]; C=low[i];
            AT=CT; BT=time[Last]; CT=time[i];
            Refresh=1;
            }
          else
            {
            Direction=-1;
            A=B; B=C; C=high[i];
            AT=BT; BT=CT; CT=time[i];
            Refresh=1;
            }
          DiNapoliL[i]=low[i];
          }
          
// Wir stellen die Farbe der Linien ein      
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        set=true;
        }
      if(low[i]<DiNapoliH[Last]-Depth&&(!set||open[i]>close[i]))
        {
        DiNapoliL[i]=low[i];
        if(high[i]>DiNapoliL[i]+Depth&&open[i]<close[i])
          {
          DiNapoliH[i]=high[i];
          A=C; B=high[Last]; C=low[i];
          AT=CT; BT=time[Last]; CT=time[i];
          Refresh=1;
          }
        else
          {
          if(Direction>0)
            {
            A=B; B=C; C=high[Last];
            AT=BT; BT=CT; CT=time[Last];
            Refresh=1;
            }
          Direction=-1;
          }
          
// Wir stellen die Farbe der Linien ein
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        }
      }
    else
      {
      if(low[i]<DiNapoliL[Last])
        {
        DiNapoliL[Last]=0; DiNapoliL[i]=low[i];
        if(high[i]>low[Last]+Depth)
          {
          if(open[i]>close[i])
            {
            DiNapoliL[Last]=low[Last];
            A=C; B=low[Last]; C=high[i];
            AT=CT; BT=time[Last]; CT=time[i];
            Refresh=1;
            }
          else
            {
            Direction=1;
            A=B; B=C; C=low[i];
            AT=BT; BT=CT; CT=time[i];
            Refresh=1;
            }
          DiNapoliH[i]=high[i];
          }
          
// Wir stellen die Farbe der Linien ein           
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        set=true;
        }
      if(high[i]>DiNapoliL[Last]+Depth&&(!set||open[i]<close[i]))
        {
        DiNapoliH[i]=high[i];
        if(low[i]<DiNapoliH[i]-Depth&&open[i]>close[i])
          {
          DiNapoliL[i]=low[i];
          A=C; B=low[Last]; C=high[i];
          AT=CT; BT=time[Last]; CT=time[i];
          Refresh=1;
          }
        else
          {
          if(Direction<0)
            {
            A=B; B=C; C=low[Last];
            AT=BT; BT=CT; CT=time[Last];
            Refresh=1;
            }
          Direction=1;
          }
// Wir stellen die Farbe der Linien ein            
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        }
      }
    DiNapoliH[total-1]=0; DiNapoliL[total-1]=0;
    }
//------------
  if(Refresh==1)
    {

Die Endeloop der Berechnung des Indikators:    

// Die Überprüfung der Anzahl der Bars , damit sie ausreichend für die Berechnung wären
    Refresh=0; a=B-A;
    Price[0]=NormalizeDouble(a*0.318+C,_Digits);           // Der Anfang;
    Price[1]=C;                                            // Stop
    Price[2]=NormalizeDouble(a*0.618+C,_Digits);           // Das Ziel №1
    Price[3]=a+C;                                          // Das Ziel №2;
    Price[4]=NormalizeDouble(a*1.618+C,_Digits);           // Das Ziel №3;
    Price[5]=NormalizeDouble(a*2.618+C,_Digits);           // Das Ziel №4;
    for(i=0;i<6;i++) ObjectMove(0,Name[i],0,time[total-1],Price[i]);
    if(VLine==true)
      {
 
// Wir liefern den abgerundeten Wert bis zur nächsten ganzen Zahl des angegebenen Wertes zurück      
      a=(double)(BT-AT);
      Time[0]=(datetime)MathRound(a*0.318)+CT;             // Das vorübergehende Ziel №1
      Time[1]=(datetime)MathRound(a*0.618)+CT;             // Das vorübergehende Ziel №2
      Time[2]=(datetime)MathRound(a)+CT;                   // Das vorübergehende Ziel №3
      Time[3]=(datetime)MathRound(a*1.618)+CT;             // Das vorübergehende Ziel №4
      Time[4]=(datetime)MathRound(a*2.618)+CT;             // Das vorübergehende Ziel №5
      for(i=6;i<11;i++) ObjectMove(0,Name[i],0,Time[i-6],open[total-1]);
      }
    ChartRedraw();
    
// Wenn die Richtung sich geändert hat, dann schalten wir die Wiedergabe des Lautes ein
    if(Sound==true&&calculated>0)PlaySound(SoundFile);
    }
  return(total);
  }
//------------------------------------------------------------------------------------

Der Indikator wurde am Ende des Artikels hinzugefügt.


8 dargestellt ist. Fazit

Ich hoffe darauf, dass diese grundlegenden Informationen Ihnen eine positive Vorstellung darüber ermittelt, was der Handel nach der Methode DiNapoli bedeutet. Diese Ebenen hätte man richtiger nennen sollen, "das Originelle Herangehen zur Arbeit mit den standarten Ebenen und der Erweiterungen Fibonacci". Das gründliche Prinzip der Arbeit mit den Ebenen bleibt genauso, DiNapoli hat einfach einige neue Regeln eingeführt, die in der richtigen Erfüllung die stabilen Ergebnisse auf dem Markt geben.

Die Programme, die im Artikel verwendet wurden:

 # Der Name
Typ
 Beschreibung
1 DiNapoli  Levels.mq5                 Indikator  Der Indikator für die automatische Berechnung und den Aufbau der Ebenen DiNapoli

9. Referenzen

  1. Joe DiNapoli D44 der Handel unter Verwendung der Ebenen DiNapoli. — M.: IK Analytik, 2001

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

Beigefügte Dateien |
DiNapoli_Levels.mq5 (22.35 KB)
Universeller Trend mit grafischem Interface Universeller Trend mit grafischem Interface

In diesem Artikel erstellen wir auf der Basis einer Reihe von Standardindikatoren einen universellen Trend. Ein zusätzliches grafisches Interface erlaubt das Auswählen des Indikatortyps mit seinen Parametern. Der Indikator erscheint in seinem eigene Fenster mit einer Reihe von farbigen Icons.

Das Handeln nach Donchians Kanälen Das Handeln nach Donchians Kanälen

Im Artikel werden einige Strategien aufgrund des Kanals Donchians unter Verwendung verschiedener Indikatorfilter getestet und entwickelt. Es wird die Forschung und die vergleichende Analyse ihrer Arbeit durchgeführt.

Grafische Interfaces X: Algorithmus für den Zeilenumbruch im mehrzeiligen Textfeld (build 12) Grafische Interfaces X: Algorithmus für den Zeilenumbruch im mehrzeiligen Textfeld (build 12)

Wir fahren fort mit der Entwicklung eines mehrzeiligen Textfeldes. Diesmal ist es unsere Aufgabe einen Algorithmus für den Fall, dass der Text die Breite des Textfeldes überschreitet, zu entwickeln oder, umgekehrt, einen Zeilenumbruch zu entfernen, wenn die möglich ist.

Die Rezepte MQL5 - die Handelssignale der Pivots Die Rezepte MQL5 - die Handelssignale der Pivots

Im Artikel wurde der Prozess der Entwicklung und der Realisierung des Klasse-Signalgebers auf der Grundlage der Pivots dargestellt — der Wendeebenen. Auf der Grundlage dieser Klasse wird die Strategie unter Verwendung der Standardbibliothek gebaut. Es werden die Möglichkeiten der Entwicklung der Pivots-Strategie durch das Hinzufügen der Filter betrachtet.