Show Must Go On, oder WIeder Einmal über ZigZagl

Einführung

Eine riesige Menge an ZigZag Versionen beweist die Existenz eines konstanten und anhaltenden Interesse an diesem Indikator. Dies ist vielleicht der einzige Indikator, der direkt die Emotionen von Tradern beeinflusst, mit seine hellen grafisch anschaulichen Darstellung der wichtigen Marktbewegungen zu sofortigem Handeln zwingt. Dies kann offenbar die einzige Erklärung des Phänomens sein, mit dem eingehenden Verständnis der Mehrheit, nicht für die Erzeugung direkter Handelssignale gedacht ist, sie dennoch kontinuierlich versuchen ihn maximal der aktuellen Marktsituation anzunähern. Die Beobachtung des endlos neu gezeichneten voraussagenden letzten Bruchs ist ein zweifelhafter Vorteil, insbesondere wenn er wahrgenommen wird.

Machen wir einen kleinen Diskurs. Glauben Sie es oder nicht, aber dies ist der Anfang von allem.

Lyrics

Alle von uns, die gekommen und GEBLIEBEN sind, verstehen fürher oder später, dass es nicht so einfach ist, wie wir es am Anfang dachten. Sobald wir das begreifen, beginnen wir zu lesen (diejenigen, die es können, natürlich). Aber, irgendwie erkennen wir was wir lesen sehr eigenartig. Kurz gesagt, wir wählen die einfachsten Dinge, nicht die richtigen. Entsprechend fügen wir unserem Waffenarsenal nur Dinge hinzu, die oberflächlich liegen, die offenkundig für das Verständnis sind und einfach (schnell) in eine Algorithmus-Sprache übersetzt werden können. Davon gibt es viele Beispiele. Hier ist eins von ihnen, vielleicht nicht das beste, aber nehmen wir es wie es ist.

Jeder kennt und erinnert sich an die grundlegende TA These, die bis jetzt nicht widerlegt wurde, aber noch nicht streng bewiesen ist, dennoch:

Der Kurs ist Alles fr uns!

Nehmen wir dies buchstäblich und direkt, beginnen wir nicht nach den Kontrollpunkten des Marktes zu suchen, sondern mit allen Mitteln sondern nach seinen maximal und minimal Werten - das ist einfacher und klarer. Wir zeichnen Support/Resistance Ebenen mit einem Lineal, zählen Fibo-Ebenen von ihnen, zählen die Zyklen in Balken, usw. Von schlecht zu schlechter - wir fangen an aus jemandes Handelssystem nur die Dinge herauszupicken, die für unser Verständnis zugänglich sind, ohne Warnungen oder für welchen Markt es ist und den Zeitpunkt seiner Erstellung zu beachten... Was noch schlimmer ist...Vereinfachung von Gann (!!!), der, wie ich denke, die Lösung des Kurs/Zeit Problems gefunden hat (oder sehr nah dran war)...Delirium...wie ist es möglich etwas zu vereinfachen, das bisher von niemanden vollständig verstanden wurde?

Und dann, wenn wir erkennen, dass alles irgendwie falsch funktioniert, ein wenig besser als fünfzig-fünfzig, beginnen wir laut auszusprechen, dass die Gurus lügen, deren Methoden nicht funktionieren, Bücher nur zum Geldverdienen geschrieben wurden, der Goldene Schnitt nicht existiert...usw. Und dies ist das Ergebnis unseres Vergessens, dass es nicht das Minimax Synonym ist, wenn wir nach einem Extremum suchen, sondern die wirklich ein Maximum oder Minimum sind, einfach eine weitere Zurschaustellung seines inneren Wesens, das wir noch erreichen müssen. Also, auf der Grundlage dieser flachen Sicht, versuchen wir die Zukunft vorherzusagen, aber versuchen nicht auch zu analysieren, was diesen Punkt zu dem richtigen an dieser Stelle und genau zu dieser Zeit macht.

So sehr wir Geld verdienen möchten, trifft es uns nicht hart, dass wir manchmal stoppen müssen und ein wenig nachdenken. Es ist nützlicher Stoff, Sie wissen es. Sie beginnen deutlich die Richtigkeit davon wahrzunehmen, dass "der Mensch das einzige Lebewesen ist, das die gleiche Sache immer wieder macht und immer andere Ergebnisse erwartet". Wir hacken kein Holz, oder? :)

Ich mich habe von dem Enthusiasmus mitreißen lassen. Vielleicht, weil es auch über mich geht. Es ist Zeit abzurunden. Verstehen wir einfach, dass nicht alle Gurus auch Gurus sind, und diejenigen die es sind, werden niemals alles erzählen...zumal sie wissen, dass ein gefütterter Löffel nicht schmeckt und auch nicht viel hilft.

Zurück zum Thema.

Multiframe Fractal ZigZag

Ich brauchte einen Indikator, der nicht nur Minima und Maxima darstellt, sondern die Markt-Extrempunkte logisch begründet durch Kursbewegungen (LREP - kann diese Abkürzung vielleicht eingebürgert werden?) und, wenn möglich, bestätigt. Das Problem einen Signal-Generator aus ihm zu machen war zunächst nicht gestellt. Zuerst begann ich mit dem Standard (nicht den in MT4 eingebetteten, sondern "Standard" in einem allgemeinen Sinn) ZigZag zu spielen, aber da war etwas, das mich in Alarmbereitschaft versetzte und zwang dieser Idee abzuschwören:

• die Gleichförmigkeit aller Algorithmen, trotz eine Fülle an Diskussionen im Internet und der großen Vielfalt an Versionen (übrigens, vielleicht ist das in meinen Augen so, aber ich habe den Algorithmus noch nie irgendwo deutlich entschlüsselt angetroffen),
• das Fehlen eines einzelnen Konzepts darüber "wie" es aussehen sollte,
• widerlich häufig und, was am schlimmsten ist, schlecht vorhersehbare Neufestlegung,
• direkte Abhängigkeit von dem Zeitrahmen und/oder vorher festgelegten Kursausbrüchen.

Soweit es mich persönlich betrifft, ist das letzte am wenigsten akzeptabel. Nichts privates.

Ich erinnere mich an Demark mit seinen TD Punkten und Williams mit seinen "Fractals" (ich weiß nicht wer bei wem geborgt hat, aber sie sind wie zwei Erbsen im Topf). Es schien "der eine" zu sein - er war zumindest mit den vorherigen und den nachfolgenden Kursbewegungen begründet. Vielleicht wird nicht jeder diese Art der Annäherung an die Auswahl der Punkte mögen. Allerdings hat bis jetzt niemand etwas genaueres und richtigeres für deren anfängliche Identifizierung erfunden, ausgenommen Begriffe wie "wertvolles Extremum", "lokales Maximum", usw., natürlich.

Die eigenen Dinge sind vielleicht nicht die besseren, aber sicher die mehr "blutsverwandten". Aus diesem Grund habe ich nicht nach einem geliehenen Code gesucht und meinen eigenen einfachen Fractal Indikator geschrieben, um genauer zu sein, einen ähnlichen: die Regel der Punkt-Auswahl unterscheidet sich leicht von den standardmäßigen. Ich habe versucht ihn mit verschiedenen Zeitrahmen mit iCustom aufzurufen, habe aber dann verstanden, dass es vernünftiger wäre alles auf dem aktuellen (arbeitenden) Zeitrahmen (TF) zu berechnen. Des Weiteren, die Programmierlogik hat alles selbst abgefragt: und über die Modulkonstruktion, die sich in der Zukunft von selbst vorschlägt, und über den unzulänglichen TF. Hier ist das Ergebnis, das dabei herausgekommen ist.

Die Bilder zeigen sein Aussehen mit den Parametern 1440, 360, 60. Das H1 Chart wurde gewählt wegen seiner Betontheit Sie erkennen zu lassen, dass die schwarze Linie (60) nicht alle Fractals nimmt und einige von ihnen ablehnt. Das erste Bild ist zum Zeigen der Spitze, und das zweite wurde einfach aus der Mitte des Charts entnommen.

Das Farbschema ist hier nicht das beste, das angehangene Bild zeigt meine Ansicht davon.

Code

Schauen wir uns an wie es umgesetzt ist - sollten wir nicht wie in einer dummen Show handeln? ;)
Der Indikator bildet auf dem aktuell arbeitenden Zeitrahmen (TF) eine Abfolge von ZigZag Knoten, die auf den drei größeren emulierten TFs berechnet werden. Es funktioniert auf allen mit allen TFs, einschließlich unzulängliche mit den folgenden im Code umgesetzten Einschränkungen:
- der größere TF muss durch den arbeitenden teilbar sein, ist das nicht so, werden die nächstgelegenen richtigen Werte erzwungen gesetzt,
- der arbeitende TF ist nicht größer als der a wenigsten größere TF,
- die Perioden in den Parametern werden in Minuten festgelegt und müssen in abnehmender Reihenfolge eingestellt werden,
- die Periode des größten TF überscheitet 43200 (ein Monat) nicht - dies ist nicht die Grenze, ein größerer ist möglich,
Das Feature ist, das nur ein Puffer für jeden TF verwendet wird. Es ist nicht nötig zwei von ihnen zu verwenden, weil bei der sinnvollen Kombination von TFs die Wahrscheinlichkeit des Auftretens von zwei unterschiedlich gerichteten Extremums auf einem einzelnen Balken des arbeitenden TF zu klein ist.

Hier ist das Fragment:

//-----------------------------------------------------------------------
// MF_Fractal_ZZ_3in1.mq4
//-----------------------------------------------------------------------
#property copyright "Copyright © 2008, BiViSi Corp."
#property link      "[e-mail]"
#property link      "ICQ 499949112"

#property indicator_chart_window    
#property indicator_buffers 3
//---- style of the indicator line
#property indicator_color1 Blue 
#property indicator_color2 Red
#property indicator_color3 Yellow        
#property indicator_style1 0
#property indicator_style2 0
#property indicator_style3 0
#property indicator_width1 5
#property indicator_width2 3
#property indicator_width3 1
//---- INOUT PARAMETERS OF THE INDICATOR
extern int VolExt=50; // VolExt+1" calculation of the last control points
extern int TFLarge=1440;
extern int TFMidle=240;
extern int TFSmall=60;
//---- Variables 
double Large[],Midle[],Small[];  // control points (indicator bufers)
datetime PrevTimePer[4];         // the time of the last calculation of every TF
datetime PrevTimeCalc=0; 
double P60,CP60;
int CurPeriod, ErrorTF=0, NumberExt, Per,  largelast=0, midlelast=0, smalllast=0;
//-----------------------------------------------------------------------
int init() 
{
   // initialization
   IndicatorBuffers(3); // for perspective" entry :)
   SetIndexBuffer(0,Large); SetIndexStyle(0,DRAW_SECTION);
   SetIndexEmptyValue(0,0.0);
   SetIndexBuffer(1,Midle); SetIndexStyle(1,DRAW_SECTION);
   SetIndexEmptyValue(1,0.0); 
   SetIndexBuffer(2,Small); SetIndexStyle(2,DRAW_SECTION);
   SetIndexEmptyValue(2,0.0);
   ArrayInitialize(PrevTimePer,0);
   CurPeriod=Period(); CP60=CurPeriod*60;
   // restrictions:
   // control of TF and inputted parameters
   if (MathCeil(TFSmall/CurPeriod) != TFSmall/CurPeriod) 
      TFSmall=MathCeil(TFSmall/CurPeriod)*CurPeriod;
   if (MathCeil(TFMidle/CurPeriod) != TFMidle/CurPeriod)
      TFMidle=MathCeil(TFMidle/CurPeriod)*CurPeriod;
   if (MathCeil(TFLarge/CurPeriod) != TFLarge/CurPeriod)
       TFLarge=MathCeil(TFLarge/CurPeriod)*CurPeriod;
   if (CurPeriod > TFSmall) 
      {Alert ("The chart period must be less than or equal to", TFSmall," min.");
       ErrorTF=1;return;}
   if (TFSmall >= TFMidle || TFMidle >= TFLarge || TFLarge>43200)
      {Alert ("Incorrect choice of timeframes for calulation!!!"); ErrorTF=1;return;}
   return;              
}
//--------------------------------------------------------------------

Der nächste Block ist verantwortlich für die Steuerung der Punkt-Suche, ZigZag Knoten und diese in die Puffer Arrays des Indikators zu schreiben.
Die Ablehnung der Verwendung der Konstruktion des int IC=IndicatorCounted(); Typ und so weiter, ist abhängig von dem Berechnungsalgorithmus selbst, der die ausreichende Geschwindigkeit ohne sie bereitstellt (siehe Force #1-3 im Code), sie kann auch erhöht werden auf diesem Weg, ein wenig eher über es.

//--------------------------------------------------------------------
int start()
{
   if ( ErrorTF==1 ) return; // incorrect timeframe
   FractalCalc(); 
   return;
}
//======================================================================
// Searching of the 5 bar fractals and zigzag nodes claculation
// on the emulation of the larger TF, deleting of the odd ones and representation on the current TF
//======================================================================
void FractalCalc ()
{   
   // Force  №1 - caculation only on the fully formed bar of the working TF
   if (PrevTimeCalc == Time[0]) return; else PrevTimeCalc=Time[0];
   int y, x, k, i, j, extr=0; 
   // the time of the last bar of the current TF, that closes bar №1-5 of the larger TF
   int t1, t2, t3, t4, t5;                     
   // the number of the last bar of the cur. TF, that closes bar №1-5 of the larger TF
   int limit1, limit2, limit3, limit4, limit5; 
   // the numver of bars of the cur. TF with the peaks and bases that correspond with the bars 1-5 of the larger TF
   int up1,up2,up3,up4,up5,dn1,dn2,dn3,dn4,dn5;
      
   for (y=1; y<=3; y++) // cycle of the calculated TF
      {
      if (y==1) Per=TFLarge; if (y==2) Per=TFMidle; if (y==3) Per=TFSmall;
      P60=Per*60;
      // Force №2 - calculate the fissures only with the forming of the bar of the larger TF
      if (PrevTimePer[y] !=0)
         { 
         if (Per<43200 && (Time[0] - PrevTimePer[y])<P60 )continue;
         if (Per==43200 && Month()==TimeMonth(PrevTimePer[y]))continue;
         }
      // Processing of bars absence
      // If linearly PrevTimePer[y]=Time[0], then in case of bar absence
      // the shift of whole calculation chain by the absence size will take place on the working TF
      PrevTimePer[y]=MathCeil(Time[0]/Per/60)*P60; 
      
      NumberExt=0;  extr=0;
      k=Per/CurPeriod;
      // limitation of cycle depending on currently calculated TF
      // and on the last fractal
      i=MathCeil(Bars/k)-5;
      // Force #3 - calculation starting with the last fissure
      if(y==1 && largelast !=0) i=largelast+k;
      if(y==2 && midlelast !=0) i=midlelast+k;
      if(y==3 && smalllast !=0) i=smalllast+k;
      for (x=1; x<=i; x++) 
         {
         // find peaks and bases
         // the time of the beginning of the las bar of the cur. TF, that closes bar №1 of the larger TF
         if (PrevTimePer[y] !=0) t1=PrevTimePer[y]-x*P60+(k-1)*CP60;
         else t1=MathCeil(Time[0]/Per/60)*P60-x*P60+(k-1)*CP60;
         t2=t1-P60; t3=t2-P60; t4=t3-P60; t5=t4-P60;
         limit1=iBarShift(NULL,0,t1, false); limit2=iBarShift(NULL,0,t2, false);
         limit3=iBarShift(NULL,0,t3, false); limit4=iBarShift(NULL,0,t4, false);
         limit5=iBarShift(NULL,0,t5, false);         
         up1=iHighest(NULL,0,MODE_HIGH,k,limit1); up2=iHighest(NULL,0,MODE_HIGH,k,limit2);
         up3=iHighest(NULL,0,MODE_HIGH,k,limit3); up4=iHighest(NULL,0,MODE_HIGH,k,limit4);
         up5=iHighest(NULL,0,MODE_HIGH,k,limit5);
         dn1=iLowest(NULL,0,MODE_LOW,k,limit1); dn2=iLowest(NULL,0,MODE_LOW,k,limit2);
         dn3=iLowest(NULL,0,MODE_LOW,k,limit3); dn4=iLowest(NULL,0,MODE_LOW,k,limit4);
         dn5=iLowest(NULL,0,MODE_LOW,k,limit5);

         // searching for control points
         if(High[up3]>High[up2] && High[up3]>High[up1] && High[up3]>=High[up4] && High[up3]>=High[up5])
            {
            if (y==1){Large[up3]=High[up3];largelast=up3;}
            if (y==2){Midle[up3]=High[up3];midlelast=up3;}
            if (y==3){Small[up3]=High[up3];smalllast=up3;}
            NumberExt++;  extr++;
            }
         if(Low[dn3]<Low[dn2] && Low[dn3]<Low[dn1] && Low[dn3]<=Low[dn4] && Low[dn3]<=Low[dn5])
            {
            if (y==1){Large[dn3]=Low[dn3];largelast=dn3;}
            if (y==2){Midle[dn3]=Low[dn3];midlelast=dn3;}
            if (y==3){Small[dn3]=Low[dn3];smalllast=dn3;}
            NumberExt++; extr++;
            }
         if (NumberExt>VolExt) break;   
         } 
      }

Wie Sie sehen, dient der meiste Code der Optimierung der Berechnungen und dem Schutz gegen unerwartete Situationen - unterbrochene Serververbindung und verlorene Balken in der Historie.

Der nächste Block führt eine Art "Jäten" durch: das Löschen von ungeraden Extremums (wenn mehrere Basen zwischen zwei Spitzen erscheinen, und umgekehrt) um einen korrekten ZigZag zu bilden; die Maximums/Minimums werden aus zwei oder mehr nacheinander kommenden Spitzen/Basen gewählt und, im Falle der Gleichheit, wird derjenige mit der geringsten Zahl gewählt... die ungeraden werden auf Null gesetzt. Der Algortihmus bietet Raum zur Diskussion, natürlich, und Alternativen sind möglich, aber ich entschied es für den Moment so zu machen.
Der Code enthält kommentierte Einträge, die es ermöglichen in Spitzen/Basen auftretende Unstimmigkeiten auf verschiedenen TFs zu beseitigen, aber es ist notwendig ihm einen anderen Anstrich zu geben, er arbeitet in der gegenwärtigen Form nicht korrekt. Ich habe diese Idee vorübergehend ausgesetzt, aber Sie können es selber machen, wenn Sie daran interessiert sind.
Das gleiche Fragment hat eine andere Möglichkeit seine Arbeit zu beschleunigen, wenn die Konstruktion if (NumberExt>VolExt) break; der vorherberechneten Verschiebung verwendet wird, aber ich habe es auch für den Moment ausgesetzt.
Und, wenn wir einmal begonnen haben über Geschwindigkeit zu reden, die offensichtlichste und einfachste Methode ist, den VolExt in den Indikator-Eingaben zu verringern, kaum jemand benötigt mehr als 10-15 zum Trading, nicht für die Analyse, mit Ausnahme echter Gourmets :).

   if (extr==0) return;
   for (y=1; y<=3; y++)
      {
      if (y==1) j=ArraySize(Large);if (y==2)j=ArraySize(Midle);
      if (y==3)j=ArraySize(Small);      
      int min=0, max=0, extmin=0, extmax=0;
      NumberExt=0;      
      for (x=1;x<=j;x++)
         {
         if (y==1)
            {
            if (Large[x] == 0.0 ) continue;
            if (Large[x] == High[x])
               {
               NumberExt++; extmax++; extmin=0;
               if (extmax==2)
                  {
                  if (Large[max]>=Large[x])Large[x]=0.0;
                  else {Large[max]=0.0;max=x;}
                  extmax--;  
                  }
               else max=x;
               }
            if (Large[x] == Low[x])
               {
               NumberExt++; extmax=0; extmin++;
               if (extmin==2)
                  {
                  if (Large[min]<=Large[x])Large[x]=0.0;
                  else {Large[min]=0.0;min=x;}
                  extmin--;  
                  }
               else min=x;
               }
            }         
         if (y==2)
            {
            if (Midle[x] == 0.0 ) continue;
            if (Midle[x] == High[x])
               {
               NumberExt++; extmax++; extmin=0;
               if (extmax==2)
                  {
                  if (Midle[max]>=Midle[x])Midle[x]=0.0;
                  else {Midle[max]=0.0;max=x;}
                  extmax--;  
                  // it can be easier as the above one, but.... remove disagreements
                  /*
                  if (Midle[max]>Midle[x])Midle[x]=0.0; 
                  if (Midle[max]==Midle[x])
                     {
                     if (Large[x] == High[x]) {Midle[max]=0.0;max=x;}
                     else Midle[x]=0.0; 
                     }
                  if (Midle[max]<Midle[x]){Midle[max]=0.0;max=x;}
                  */
                  }
               else max=x;
               }
            if (Midle[x] == Low[x])
               {
               NumberExt++; extmax=0; extmin++;
               if (extmin==2)
                  {
                  if (Midle[min]<=Midle[x])Midle[x]=0.0;
                  else {Midle[min]=0.0;min=x;}
                  extmin--;  
                  // it can be easier as the above one, but.... remove disagreements
                  /*
                  if (Midle[min]<Midle[x])Midle[x]=0.0; 
                  if (Midle[min]==Midle[x])
                     {
                     if (Large[x] == Low[x]) {Midle[min]=0.0;min=x;}
                     else Midle[x]=0.0; 
                     }
                  if (Midle[min]>Midle[x]){Midle[min]=0.0;min=x;}
                  */
                  }
               else min=x;
               }
            }         
         if (y==3)
            {
            if (Small[x] == 0.0 ) continue;
            if (Small[x] == High[x])
               {
               NumberExt++; extmax++; extmin=0;
               if (extmax==2)
                  {
                  if (Small[max]>=Small[x])Small[x]=0.0;
                  else {Small[max]=0.0;max=x;}
                  extmax--;  
                  // it can be easier as the above one, but.... remove disagreements
                  /*
                  if (Small[max]>Small[x])Small[x]=0.0; 
                  if (Small[max]==Small[x])
                     {
                     if (Midle[x] == High[x]) {Small[max]=0.0;max=x;}
                     else Small[x]=0.0; 
                     }
                  if (Small[max]<Small[x]){Small[max]=0.0;max=x;}
                  */
                  }
               else max=x;
               }
            if (Small[x] == Low[x])
               {
               NumberExt++; extmax=0; extmin++;
               if (extmin==2)
                  {
                  if (Small[min]<=Small[x])Small[x]=0.0;
                  else {Small[min]=0.0;min=x;}
                  extmin--;  
                  // it can be easier as the above one, but.... remove diagreements
                  /*
                  if (Small[min]<Small[x])Small[x]=0.0; 
                  if (Small[min]==Small[x])
                     {
                     if (Midle[x] == Low[x]) {Small[min]=0.0;min=x;}
                     else Small[x]=0.0; 
                     }
                  if (Small[min]>Small[x]){Small[min]=0.0;max=x;}
                  */
                  }
               else min=x;
               }
            }         
         if (NumberExt>VolExt) break;
         }
      }         

}

Fazit

Als Ergebnis haben wir einen Indikator mit einem Algorithmus erhalten, der vielleicht offensichtlich ist, aber vorher von niemandem verwendet wurde, geliefert aus den Nachteilen des Standard ZigZg und mit den folgenden Vorteilen:

• Knoten sind relativ weniger häufig, die Neu-Zeichnungen sind sinnvoll für den Swing und vorherige Kursbewegung. Gleichzeitig, wenn sie mit verschiedenen TFs übereinstimmen, ist es zu 90-95% wahrscheinlich, das kein Neu-Zeichnen auftritt,

• die Möglichkeit auf einem einzigen Chart alles zu beobachten, was auf drei größeren Zeitrahmen passiert, und, als Ergebnis, die Möglichkeit den Haupttrend ohne zusätzliche Konstruktionen und Werkzeuge zu erkennen,
• Verwendung für ZigZag Berechnungen aller atypischen TFs (von M5 bis MN1) erfüllt jeden Geschmack und Bedarf;
• effiziente, hohe Geschwindigkeit von Berechnungen, klarer Algorithmus und Code, der einfach berichtigt und verbessert werden kann.

Sie können mich fragen, warum ich die Korrektur nicht selber mache und auf einmal. Es ist genug für mich, was ich für den Moment bekommen habe... genug FÜR DEN MOMENT. :)
Und ich weiss, dass ein fertiger effiziente Code endlos überarbeitet werden kann. es ist wie das Spitzen eines Bleistifts... du kannst vergessen, dass du mit ihm zeichnen wolltest. Ich möchte mit dem Zeichnen beginnen. Ich will es so sehr! :)

Was wird das nächste sein, und was sollten wir damit machen? Es gibt keine vorgefertigte Lösung. Dies ist nur ein Werkzeug, und was sollte mit seiner Verwendung gemacht werden, ein Pinicchio oder ein Hocker, jeder Geppetto wird für sich selbst entscheiden.
Ich kann nur sagen, dass der trockene Rest enthält 5 freie Indikator-Puffer, die Möglichkeit zu einfachen Hinzufügen einiger neuer Module, und eine sehr angemessene Reaktion zum Aufruf durch iCustom().... Fantasieren Sie!

Die schönste übrige Sache ist ANERKENNUNG für:

ANG3110 - für die wichtigste Sache - die Idee die, richtig, mich dazu brachte diesen Indikator zu schreiben,
Korey - für seine Unterstützung und Hilfe in der Diagnose von TimeCurrent und Optimierung von Berechnungen,
Plattform-Teilnehmer, die wohl oder übel, bewusst oder nicht, aber manchmal ihre Ideen zum Ausdruck bringen, über die ich nachdenken möchte.