Fragen von Anfängern MQL5 MT5 MetaTrader 5 - Seite 919

Neuer Kommentar
 
Artyom Trishkin:

Ihre Indikatorberechnung erfolgt von Anfang bis Ende (von den jüngsten historischen Daten bis zu den jüngsten aktuellen Daten). Dies ist ein Hinweis auf eine Indexierung wie bei Zeitreihen. Die Arrays müssen also entsprechend indiziert werden, was bei Ihnen der Fall ist.

Was ist daran falsch?

Es funktioniert alles das gleiche wie meine Portierung in MQL5 von MQL4, aber ich sehe, dass der Code wegenArraySetAsSeries() hässlich ist, das ist, warum ich fragte

hier sind beide Codes

Bringen Sie mir bei, wie man diesen Indikator für MT5 schreibt! - Mein Code ist nicht schön, Punkt! )))

ZSZ nicht erinnern, wie man Indikatoren für MT5 zu schreiben, setzte sich hin und schrieb es in 40 Minuten mit Hilfe, aber das Ergebnis ... imho, nicht so gut ((!

Dateien:
PTL.mq4  8 kb
PTL.mq5  13 kb
 
Igor Makanu:

Ja, alles funktioniert genau wie mein Port in MQL5 von MQL4, aber ich sehe, dass der Code wegenArraySetAsSeries() hässlich ist, so fragte ich

hier sind beide Codes

Bringen Sie mir bei, wie man diesen Indikator für MT5 schreibt! - Mein Code ist nicht schön, Punkt! )))

Wenn Sie die Schleife umkehren, müssen Sie unbedingt die Arrays Zeitreihen machen, da sonst die Indizierung der Puffer in der Schleife nicht mit der Indizierung der erforderlichen Daten übereinstimmt - der Schleifenindex im Array der Indikatorpuffer wird vom Anfang zum Ende gehen, während in open[], high[], low[], close[] und anderen - vom Ende zum Anfang. Oder Sie können die Schleife umkehren, um ihre Indizierung der Arrays open[], high[], low[], close[] und den Rest mit der Indizierung der Puffer abzugleichen, was komplizierter ist.

Wenn Sie eine Allegorie brauchen, um das zu verdeutlichen, hier ist eine Allegorie für Sie:

Du stehst an den Bahngleisen und siehst zwei Züge. Sie gehen entweder in eine Richtung - beide von links nach rechts (ArraySetAsSeries(array,true) - erster Zug und eine Schleife vom Grenzwert bis 0 - zweiter Zug),
Oder sie gehen aufeinander zu - (ArraySetAsSeries(array,false) - von rechts nach links - erster Zug, und die Schleife von Limit bis 0 - von links nach rechts - zweiter Zug)

Und, ja: Ich habe mir den Code nicht angesehen - ich möchte ihn nicht herunterladen, speichern (es gibt bereits eine Menge unnötigen Code aus dem Forum), miteinander vergleichen...

Es wäre einfacher, sie in Codes in die Nachricht zu packen - einen und einen zweiten - dann wäre sofort sichtbar, was zu was.

 
Artyom Trishkin:

Oder man dreht die Schleife um, damit sie mit der Indizierung der Arrays open[], high[], low[], close[] und dem Rest übereinstimmt, was schwieriger ist.

Ich habe es heute die ganze Nacht rückgängig gemacht, meine Geduld ist am Ende (((

Soweit ich das Problem verstehe:

- In MT5 werden die Arrays, die den Indikatorpuffern zugewiesen sind, standardmäßig von links nach rechts indiziert;

- in MT5 Zeitreihen werdenopen[], high[], low[], close[], die von OnCalculate() verfügbar sind, immer von rechts nach links indiziert übergeben

- d.h. auf der Grundlage der Schritte 1 und 2, um den Indikator vom Ende der Historie bis zum Null-Bar zu berechnen

a) oder die Indizierung der Puffer-Arrays neu zuordnen

b) oder eine Schleife zu bilden, in der die Elemente der Matrix von links nach rechts und in einer weiteren Schleife von rechts nach links neu berechnet werden:

for(i=limit;i>=0;i--)
     {
      BufBarsBuffer1[limit - i] = open[i];
      ...
      }


D.h.,es gibt keine schöne Lösung für meine Frage? Option a) - in meinen Quellen ist implementiert, Option b) - ich sehe keinen Sinn darin, zusätzliche Berechnungen durchzuführen

Quellen:

MT5:

//+------------------------------------------------------------------+
//|                                          Perfect_Trend_Lines.mq5 |
//|                                                            IgorM |
//|                                                                  |
//+------------------------------------------------------------------+
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 9
#property indicator_plots   5
//--- plot BufBars
#property indicator_label1  "BufBars"
#property indicator_type1   DRAW_COLOR_BARS
#property indicator_color1  clrRed,clrAqua,clrNONE
#property indicator_style1  STYLE_SOLID
#property indicator_width1  3
//--- plot BufASELL
#property indicator_label2  "BufASELL"
#property indicator_type2   DRAW_ARROW
#property indicator_color2  clrBlue
#property indicator_style2  STYLE_SOLID
#property indicator_width2  5
//--- plot BufABUY
#property indicator_label3  "BufABUY"
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrRed
#property indicator_style3  STYLE_SOLID
#property indicator_width3  5
//--- plot BufLSELL
#property indicator_label4  "BufLSELL"
#property indicator_type4   DRAW_LINE
#property indicator_color4  clrBlue
#property indicator_style4  STYLE_SOLID
#property indicator_width4  2
//--- plot BufLBUY
#property indicator_label5  "BufLBUY"
#property indicator_type5   DRAW_LINE
#property indicator_color5  clrRed
#property indicator_style5  STYLE_SOLID
#property indicator_width5  2
//--- input parameters
input int SlowLength         = 7; //Slow length
input int SlowPipDisplace    = 0; //Slow pip displace
input int FastLength         = 3; //Fast length
input int FastPipDisplace    = 0; //Fast pip displace
//--- indicator buffers
double         BufBarsBuffer1[];
double         BufBarsBuffer2[];
double         BufBarsBuffer3[];
double         BufBarsBuffer4[];
double         BufBarsColors[];
double         BufASELLBuffer[];
double         BufABUYBuffer[];
double         BufLSELLBuffer[];
double         BufLBUYBuffer[];
static int trend=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,BufBarsBuffer1,INDICATOR_DATA);
   SetIndexBuffer(1,BufBarsBuffer2,INDICATOR_DATA);
   SetIndexBuffer(2,BufBarsBuffer3,INDICATOR_DATA);
   SetIndexBuffer(3,BufBarsBuffer4,INDICATOR_DATA);
   SetIndexBuffer(4,BufBarsColors,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(5,BufASELLBuffer,INDICATOR_DATA);
   SetIndexBuffer(6,BufABUYBuffer,INDICATOR_DATA);
   SetIndexBuffer(7,BufLSELLBuffer,INDICATOR_DATA);
   SetIndexBuffer(8,BufLBUYBuffer,INDICATOR_DATA);
   for(int i=0;i<9;i++)
     {
      PlotIndexSetInteger(i,PLOT_DRAW_BEGIN,FastLength+1);
      PlotIndexSetDouble(i,PLOT_EMPTY_VALUE,0.0);
     }
   ArraySetAsSeries(BufBarsBuffer1,true);
   ArraySetAsSeries(BufBarsBuffer2,true);
   ArraySetAsSeries(BufBarsBuffer3,true);
   ArraySetAsSeries(BufBarsBuffer4,true);
   ArraySetAsSeries(BufBarsColors,true);
   ArraySetAsSeries(BufABUYBuffer,true);
   ArraySetAsSeries(BufASELLBuffer,true);
   ArraySetAsSeries(BufLBUYBuffer,true);
   ArraySetAsSeries(BufLSELLBuffer,true);
//--- setting a code from the Wingdings charset as the property of PLOT_ARROW
   PlotIndexSetInteger(1,PLOT_ARROW,234);
   PlotIndexSetInteger(2,PLOT_ARROW,233);
   PlotIndexSetInteger(1,PLOT_ARROW_SHIFT,-20);
   PlotIndexSetInteger(2,PLOT_ARROW_SHIFT,20);
   trend=0;
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int i,limit;
   double thigh1,tlow1,thigh2,tlow2,trendUp,trendDn;
   ArraySetAsSeries(open,true); ArraySetAsSeries(high,true); ArraySetAsSeries(low,true); ArraySetAsSeries(close,true);
   if(prev_calculated==0)
     {
      limit=rates_total-1;
      BufLSELLBuffer[limit]=high[limit];
      BufLBUYBuffer[limit]=low[limit];
      limit--;
     }
   else limit=rates_total-prev_calculated+1;
   for(i=limit;i>=0;i--)
     {
      thigh1= high[iHighest(NULL,0,MODE_HIGH,SlowLength,i)]+SlowPipDisplace * _Point;
      tlow1 = low[iLowest(NULL,0,MODE_LOW,SlowLength,i)]-SlowPipDisplace * _Point;
      thigh2= high[iHighest(NULL,0,MODE_HIGH,FastLength,i)]+FastPipDisplace * _Point;
      tlow2 = low[iLowest(NULL,0,MODE_LOW,FastLength,i)]-FastPipDisplace * _Point;
      if(close[i]>BufLBUYBuffer[i+1])  trendUp=tlow1;  else trendUp=thigh1;
      if(close[i]>BufLSELLBuffer[i+1]) trendDn=tlow2;  else trendDn=thigh2;
      BufLSELLBuffer[i]= trendDn;
      BufLBUYBuffer[i] = trendUp;
      BufBarsBuffer1[i] = 0.0;
      BufBarsBuffer2[i] = 0.0;
      BufBarsBuffer3[i] = 0.0;
      BufBarsBuffer4[i] = 0.0;
      BufBarsColors[i]  = 2;
      if(close[i]<trendUp && close[i]<trendDn)
        {
         BufBarsBuffer1[i] = open[i];
         BufBarsBuffer2[i] = high[i];
         BufBarsBuffer3[i] = low[i];
         BufBarsBuffer4[i] = close[i];
         BufBarsColors[i]  = 0;
        }
      if(close[i]>trendUp && close[i]>trendDn)
        {
         BufBarsBuffer1[i] = open[i];
         BufBarsBuffer2[i] = high[i];
         BufBarsBuffer3[i] = low[i];
         BufBarsBuffer4[i] = close[i];
         BufBarsColors[i]  = 1;
        }
      if(close[i]>trendUp && close[i]>trendDn && trend!=1)
        {
         BufABUYBuffer[i]=trendDn;
         BufASELLBuffer[i]=0.0;
         trend=1;
        }
      if(close[i]<trendUp && close[i]<trendDn && trend!=2)
        {
         BufASELLBuffer[i]=trendUp;
         BufABUYBuffer[i]=0.0;
         trend=2;
        }
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

MT4:

//+------------------------------------------------------------------+
//|                                            PerfecTrend Lines.mq4 |
//|                 Copyright © 2005-2007, MetaQuotes Software Corp. |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, MetaQuotes Software Corp."

#property indicator_chart_window
#property indicator_buffers 6
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 Red
#property indicator_color4 Aqua
#property indicator_color5 Blue
#property indicator_color6 Red

extern int SlowLength         = 7; // Slow length
extern int SlowPipDisplace    = 0; // Slow pip displace
extern int FastLength         = 3; // Fast length
extern int FastPipDisplace    = 0; // Fast pip displace

double Buf_NTLine1[],Buf_NTLine2[],Buf_NTBar1[],Buf_NTBar2[],Buf_NTSig1[],Buf_NTSig2[];
static int trend=0;
//+------------------------------------------------------------------+
int init()
  {
   IndicatorBuffers(6);
   IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS));
   SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,2);
   SetIndexBuffer(0,Buf_NTLine1);
   SetIndexStyle(1,DRAW_LINE,STYLE_SOLID,2);
   SetIndexBuffer(1,Buf_NTLine2);
   SetIndexStyle(2,DRAW_HISTOGRAM,STYLE_SOLID,2);
   SetIndexBuffer(2,Buf_NTBar1);
   SetIndexStyle(3,DRAW_HISTOGRAM,STYLE_SOLID,2);
   SetIndexBuffer(3,Buf_NTBar2);
   SetIndexStyle(4,DRAW_ARROW,STYLE_DASH,3);
   SetIndexArrow(4,108);
   SetIndexBuffer(4,Buf_NTSig1);
   SetIndexStyle(5,DRAW_ARROW,STYLE_DASH,3);
   SetIndexArrow(5,108);
   SetIndexBuffer(5,Buf_NTSig2);
   IndicatorShortName("NeuroTrend");
   SetIndexLabel(0,"NTLine1");
   SetIndexLabel(1,"NTLine2");
   SetIndexLabel(2,"NTBar1");
   SetIndexLabel(3,"NTBar2");
   SetIndexLabel(4,"NTSig1");
   SetIndexLabel(5,"NTSig2");
   SetIndexDrawBegin(0,FastLength+1);
   SetIndexDrawBegin(1,FastLength+1);
   SetIndexDrawBegin(2,FastLength+1);
   SetIndexDrawBegin(3,FastLength+1);
   SetIndexDrawBegin(4,FastLength+1);
   SetIndexDrawBegin(5,FastLength+1);
   trend=0;
   return (0);
  }
//+------------------------------------------------------------------+
int deinit()
  {
   return (0);
  }
//+------------------------------------------------------------------+
int start()
  {
   int i,limit;
   double thigh1,tlow1,thigh2,tlow2,trendA,trendB,trendUP,trendDN;
   if(Bars <= FastLength) return (0);
   if(IndicatorCounted()==0) limit=Bars-1;
   if(IndicatorCounted()>0) limit=Bars-IndicatorCounted()-1;
   for(i=limit;i>=0;i--)
     {
      thigh1= High[iHighest(NULL,0,MODE_HIGH,SlowLength,i)]+SlowPipDisplace * Point;
      tlow1 = Low[iLowest(NULL,0,MODE_LOW,SlowLength,i)]-SlowPipDisplace * Point;
      thigh2= High[iHighest(NULL,0,MODE_HIGH,FastLength,i)]+FastPipDisplace * Point;
      tlow2 = Low[iLowest(NULL,0,MODE_LOW,FastLength,i)]-FastPipDisplace * Point;
      if(Close[i] > Buf_NTLine1[i+1]) trendA = tlow1; else trendA = thigh1;
      if(Close[i] > Buf_NTLine2[i+1]) trendB = tlow2; else trendB = thigh2;
      Buf_NTLine1[i] = trendA;
      Buf_NTLine2[i] = trendB;

      trendUP = 0.0;
      trendDN = 0.0;
      if(Close[i] < trendA && Close[i] < trendB) { trendUP = High[i]; trendDN = Low[i]; }
      if(Close[i] > trendA && Close[i] > trendB) { trendUP = Low[i];  trendDN = High[i];}
      Buf_NTBar1[i] = trendUP;
      Buf_NTBar2[i] = trendDN;
      if(Close[i] > trendB && Close[i] > trendA && trend != 1) { Buf_NTSig1[i] = trendB; Buf_NTSig2[i] = EMPTY_VALUE; trend = 1; }
      if(Close[i] < trendB && Close[i] < trendA && trend != 2) { Buf_NTSig2[i] = trendB; Buf_NTSig1[i] = EMPTY_VALUE; trend = 2; }
     }
   return (0);
  }
//+------------------------------------------------------------------+
 
Igor Makanu:

Ich habe heute die ganze Nacht geblättert, aber meine Geduld ist am Ende (((

soweit ich das Problem verstehe:

- In MT5 werden die Arrays, die den Indikatorpuffern zugewiesen sind, standardmäßig von links nach rechts indiziert;

- in MT5-Zeitreihen werdenopen[], high[], low[], close[], die von OnCalculate() verfügbar sind, immer von rechts nach links indiziert übergeben

- d.h. auf der Grundlage der Schritte 1 und 2, um den Indikator vom Ende der Historie bis zum Null-Bar zu berechnen

a) oder die Indizierung der Puffer-Arrays neu zuordnen

b) oder eine Schleife zu bilden, in der die Elemente der Matrix von links nach rechts und in einer weiteren Schleife von rechts nach links neu berechnet werden:


D.h., es gibtkeine schöne Lösung für meine Frage? Variante a) - in meinen Quellen ist implementiert, Variante b) - ich sehe keinen Sinn darin, zusätzliche Berechnungen durchzuführen

Alle Arrays werden von rechts nach links indiziert. Um die Schleife von links nach rechts vollständig einzuhalten (und zwar von links nach rechts - vom Limit bis 0), müssen Sie alle verwendeten Arrays auf die erforderliche Indizierung setzen : Puffer in OnInit(), verwendete Timeserver - in OnCalculate().

Oder Sie führen den Zyklus von 0 bis zum Limit durch, was bei der Portierung von mql4 auf mql5 nicht immer einfach ist.

Daher ist die Option ArraySetAsSeries() in diesem Fall besser geeignet.

 
Artyom Trishkin:

Alle Arrays werden von rechts nach links indiziert. Um die Schleife von links nach rechts vollständig einzuhalten (und zwar von links nach rechts von Limit bis 0), müssen Sie alle verwendeten Arrays auf die erforderliche Indizierung setzen : Puffer in OnInit(), verwendete Timeserver - in OnCalculate().

Oder man muss den Zyklus von 0 bis zum Grenzwert durchlaufen, was nicht immer einfach ist, wenn mql4 auf mql5 portiert wird.

Deshalb funktioniert in diesem Fall die Methode ArraySetAsSeries() besser.

Entfernen Sie alleArraySetAsSeries() aus Ihrem Code(am Anfang von Init() und OnCalculate() in den ersten Zeilen), und beheben Sie die Schleife:

for(i=0;i<limit;i++)

Theoretisch müsste alles zusammenpassen, aber nein, die Diagramme sind unterschiedlich ausgefallen - das ist es, was ich nicht begreifen kann!

Dateien:
1.jpg  747 kb
 
Igor Makanu:

Sehen Sie, ich habe alleArraySetAsSeries() aus meinem Code entfernt(oben in Init() und in OnCalculate() in den ersten Zeilen) und die Schleife behoben:

for(i=0;i<limit;i++)

Theoretisch sollte alles zusammenpassen, aber nein, die Karten sind unterschiedlich ausgefallen, und das ist es, was ich nicht begreifen kann!

Ich sage Ihnen, es ist viel komplizierter als das. Sie müssen die Logik ändern. Es reicht nicht aus, die Schleife zu invertieren.

Hier ein kleines Beispiel: Im Code gibt es 

Buf_NTLine1[i+1])

Wo wird der Index i+1 hingehen, wenn die Arrays unterschiedlich indiziert sind?

Und davon gibt es eine ganze Menge. IHighest() - Start und Nummer. Wo beginnt sie bei einer Indexierung und wo bei einer anderen?

Und so weiter ...

 
Artyom Trishkin:

und davon gibt es eine ganze Menge. IHighest() - Beginn und Anzahl der... Wo beginnt sie bei der einen Indizierung und wo bei der anderen?

oh mann! das ist richtig! gut gemacht!!! ja, das ist der schwierige teil!!!

Ja... eine Menge Unterschiede im MT5, eine Menge Kontrollen und alle möglichen Vorsichtsmaßnahmen für den Programmierer...

Als ich es vor nicht allzu langer Zeit sah, hatte ich eine Nachricht, dass in MT5 nicht immer alleskorrekt inInit() initialisiert wird, es sieht so aus, als obInit() auch dann beendet werden kann, wenn die Timeframes nicht bereit sind.

Ich sah einen Fehler gestern: wenn dieser Indikator in MT5 Zeitrahmen wechselt, manchmal Indikator Puffer kann nicht leer sein - es scheint, die alten Werte bleiben, wenn nicht einen bestimmten Wert für jedes Element in der Indikator-Array in OnCalculate() zuweisen, habe ich versucht, ArrayInitialize(arr, 0.0) inInit()- es funktioniert auch, dann nicht...

soweit ich es richtig verstanden habe:

- In MT5 werden bei der Initialisierung inInit() die Indikatorpuffer nicht automatisch initialisiert? (in MT4 kann ich mich nicht erinnern, dass etwas in den Puffern geblieben ist)

- in MT5 inInit() die Größen der Puffer-Arrays unbekannt sein können, wenn die Historie nicht geladen ist, weshalbArrayInitialize(arr, 0.0) die Puffer auch nicht immer korrekt initialisiert?

 
Igor Makanu:

Verdammt! Das ist richtig! Gut gemacht!!! Ja, so macht das Spaß!!!

Ja... Es gibt viele Unterschiede im MT5, der Programmierer hat eine Menge Kontrollen und alle Arten von Vorsichtsmaßnahmen...

Als ich diese Nachricht vor einiger Zeit sah, schien es, dass in MT5 nicht immer alleskorrekt inInit() initialisiert wird, es scheint, dassInit() auch dann beendet werden kann, wenn die Timeframes nicht bereit sind.

Ich sah einen Fehler gestern: wenn dieser Indikator in MT5 Zeitrahmen wechselt, manchmal Indikator Puffer kann nicht leer sein - es scheint, die alten Werte bleiben, wenn nicht einen bestimmten Wert für jedes Element in der Indikator-Array in OnCalculate() zuweisen, habe ich versucht, ArrayInitialize(arr, 0.0) inInit()- es funktioniert auch, dann nicht...

soweit ich es richtig verstanden habe:

- In MT5 werden bei der Initialisierung inInit() die Indikatorpuffer nicht automatisch initialisiert? (in MT4 kann ich mich nicht erinnern, dass etwas in den Puffern geblieben ist)

- in MT5 inInit() die Größen der Puffer-Arrays unbekannt sein können, wenn die Historie nicht geladen ist, weshalbArrayInitialize(arr, 0.0) die Puffer auch nicht immer korrekt initialisiert?

//+------------------------------------------------------------------+
//|                                            PerfecTrend Lines.mq5 |
//|                        Copyright 2018, MetaQuotes Software Corp. |
//|                             https://mql5.com/ru/users/artmedia70 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, MetaQuotes Software Corp."
#property link      "https://mql5.com/ru/users/artmedia70"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 9
#property indicator_plots   5
//--- plot Top
#property indicator_label1  "Top"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- plot Bottom
#property indicator_label2  "Bottom"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrBlue
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
//--- plot Candles
#property indicator_label3  "Open;High;Low;Close"
#property indicator_type3   DRAW_COLOR_CANDLES
#property indicator_color3  clrDodgerBlue,clrOrangeRed,clrDarkGray
#property indicator_style3  STYLE_SOLID
#property indicator_width3  1
//--- plot ArrowUP
#property indicator_label4  "ArrowUP"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrRed
#property indicator_style4  STYLE_SOLID
#property indicator_width4  1
//--- plot ArrowDN
#property indicator_label5  "ArrowDN"
#property indicator_type5   DRAW_ARROW
#property indicator_color5  clrBlue
#property indicator_style5  STYLE_SOLID
#property indicator_width5  1
//--- input parameters
input uint     InpPeriodSlow     =  7;    // Slow length
input uint     InpDistanceSlow   =  0;    // Slow pip displace
input uint     InpPeriodFast     =  3;    // Fast length
input uint     InpDistanceFast   =  0;    // Fast pip displace
//--- indicator buffers
double         BufferTop[];
double         BufferBottom[];
double         BufferCandlesOpen[];
double         BufferCandlesHigh[];
double         BufferCandlesLow[];
double         BufferCandlesClose[];
double         BufferColors[];
double         BufferArrowUP[];
double         BufferArrowDN[];
//--- global variables
int            period_slow;
int            period_fast;
int            period_max;
double         distance_slow;
double         distance_fast;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- set global variables
   period_fast=int(InpPeriodFast<1 ? 1 : InpPeriodFast);
   period_slow=int(InpPeriodSlow<1 ? 1 : InpPeriodSlow);
   period_max=fmax(period_fast,period_slow);
   distance_fast=InpDistanceFast*Point();
   distance_slow=InpDistanceSlow*Point();
//--- indicator buffers mapping
   SetIndexBuffer(0,BufferTop,INDICATOR_DATA);
   SetIndexBuffer(1,BufferBottom,INDICATOR_DATA);
   SetIndexBuffer(2,BufferCandlesOpen,INDICATOR_DATA);
   SetIndexBuffer(3,BufferCandlesHigh,INDICATOR_DATA);
   SetIndexBuffer(4,BufferCandlesLow,INDICATOR_DATA);
   SetIndexBuffer(5,BufferCandlesClose,INDICATOR_DATA);
   SetIndexBuffer(6,BufferColors,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(7,BufferArrowUP,INDICATOR_DATA);
   SetIndexBuffer(8,BufferArrowDN,INDICATOR_DATA);
//--- setting a code from the Wingdings charset as the property of PLOT_ARROW
   PlotIndexSetInteger(3,PLOT_ARROW,108);
   PlotIndexSetInteger(4,PLOT_ARROW,108);
//--- setting indicator parameters
   IndicatorSetString(INDICATOR_SHORTNAME,"NeuroTrend");
   IndicatorSetInteger(INDICATOR_DIGITS,Digits());
//--- setting buffer arrays as timeseries
   ArraySetAsSeries(BufferTop,true);
   ArraySetAsSeries(BufferBottom,true);
   ArraySetAsSeries(BufferCandlesOpen,true);
   ArraySetAsSeries(BufferCandlesHigh,true);
   ArraySetAsSeries(BufferCandlesLow,true);
   ArraySetAsSeries(BufferCandlesClose,true);
   ArraySetAsSeries(BufferColors,true);
   ArraySetAsSeries(BufferArrowUP,true);
   ArraySetAsSeries(BufferArrowDN,true);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- Установка массивов буферов как таймсерий
   ArraySetAsSeries(open,true);
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   ArraySetAsSeries(close,true);
//--- Проверка и расчёт количества просчитываемых баров
   if(rates_total<fmax(period_max,4)) return 0;
   int limit=rates_total-prev_calculated;
   if(limit>1)
     {
      limit=rates_total-period_max-1;
      ArrayInitialize(BufferTop,EMPTY_VALUE);
      ArrayInitialize(BufferBottom,EMPTY_VALUE);
      ArrayInitialize(BufferCandlesOpen,EMPTY_VALUE);
      ArrayInitialize(BufferCandlesHigh,EMPTY_VALUE);
      ArrayInitialize(BufferCandlesLow,EMPTY_VALUE);
      ArrayInitialize(BufferCandlesClose,EMPTY_VALUE);
      ArrayInitialize(BufferArrowUP,EMPTY_VALUE);
      ArrayInitialize(BufferArrowDN,EMPTY_VALUE);
     }
//---
   for(int i=limit; i>=0 && !IsStopped(); i--)
     {
      int bhs=Highest(period_slow,i);
      int bls=Lowest(period_slow,i);
      int bhf=Highest(period_fast,i);
      int blf=Lowest(period_fast,i);
      if(bhs==WRONG_VALUE || bls==WRONG_VALUE || bhf==WRONG_VALUE || blf==WRONG_VALUE)
         continue;
      double thigh1=high[bhs]+distance_slow;
      double tlow1=low[bls]-distance_slow;
      double thigh2=high[bhf]+distance_fast;
      double tlow2=low[blf]-distance_fast;
      
      double trendA=(close[i]>BufferTop[i+1] ? tlow1 : thigh1);
      double trendB=(close[i]>BufferBottom[i+1] ? tlow2 : thigh2);
      BufferTop[i]=trendA;
      BufferBottom[i]=trendB;

      double trendUP=0;
      double trendDN=0;
      
      BufferCandlesOpen[i]=open[i];
      BufferCandlesHigh[i]=high[i];
      BufferCandlesLow[i]=low[i];
      BufferCandlesClose[i]=close[i];
      BufferColors[i]=2;
      if(close[i]<trendA && close[i]<trendB)
        {
         BufferColors[i]=1;
         trendUP=high[i];
         trendDN=low[i];
        }
      else if(close[i]>trendA && close[i]>trendB)
        {
         BufferColors[i]=0;
         trendUP=low[i];
         trendDN=high[i];
        }
      else
        {
         BufferCandlesOpen[i]=EMPTY_VALUE;
         BufferCandlesHigh[i]=EMPTY_VALUE;
         BufferCandlesLow[i]=EMPTY_VALUE;
         BufferCandlesClose[i]=EMPTY_VALUE;
        }
      static int trend=0;
      BufferArrowUP[i]=BufferArrowDN[i]=EMPTY_VALUE;
      if(close[i]>trendB && close[i]>trendA && trend!=1)
        {
         BufferArrowDN[i]=trendB;
         BufferArrowUP[i]=EMPTY_VALUE;
         trend=1;
        }
      if(close[i]<trendB && close[i]<trendA && trend!=2)
        {
         BufferArrowUP[i]=trendB;
         BufferArrowDN[i]=EMPTY_VALUE;
         trend=2;
        }
     }
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Возвращает индекс максимального значения таймсерии High          |
//+------------------------------------------------------------------+
int Highest(const int count,const int start,const bool as_series=true)
  {
   double array[];
   ArraySetAsSeries(array,as_series);
   return(CopyHigh(NULL,PERIOD_CURRENT,start,count,array)==count ? ArrayMaximum(array)+start : WRONG_VALUE);
  }
//+------------------------------------------------------------------+
//| Возвращает индекс минимального значения таймсерии Low            |
//+------------------------------------------------------------------+
int Lowest(const int count,const int start,const bool as_series=true)
  {
   double array[];
   ArraySetAsSeries(array,as_series);
   return(CopyLow(NULL,PERIOD_CURRENT,start,count,array)==count ? ArrayMinimum(array)+start : WRONG_VALUE);
  }
//+------------------------------------------------------------------+

Ich bin nicht wirklich in die Logik des Ganzen eingestiegen.

 
Artyom Trishkin:

Ich bin nicht wirklich in die Logik des Ganzen eingestiegen.

Das ist der richtige Weg: Setzen Sie die Einstiegspunkte nicht auf den Höchst- oder Mindestpreis, sondern besser auf den Eröffnungskurs.

//+------------------------------------------------------------------+
//|                                            PerfecTrend Lines.mq5 |
//|                        Copyright 2018, MetaQuotes Software Corp. |
//|                             https://mql5.com/ru/users/artmedia70 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, MetaQuotes Software Corp."
#property link      "https://mql5.com/ru/users/artmedia70"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 9
#property indicator_plots   5
//--- plot Top
#property indicator_label1  "Top"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- plot Bottom
#property indicator_label2  "Bottom"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrBlue
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
//--- plot Candles
#property indicator_label3  "Open;High;Low;Close"
#property indicator_type3   DRAW_COLOR_CANDLES
#property indicator_color3  clrDodgerBlue,clrOrangeRed,clrDarkGray
#property indicator_style3  STYLE_SOLID
#property indicator_width3  1
//--- plot ArrowUP
#property indicator_label4  "ArrowUP"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrRed
#property indicator_style4  STYLE_SOLID
#property indicator_width4  1
//--- plot ArrowDN
#property indicator_label5  "ArrowDN"
#property indicator_type5   DRAW_ARROW
#property indicator_color5  clrBlue
#property indicator_style5  STYLE_SOLID
#property indicator_width5  1
//--- input parameters
input uint     InpPeriodSlow     =  7;    // Slow length
input uint     InpDistanceSlow   =  0;    // Slow pip displace
input uint     InpPeriodFast     =  3;    // Fast length
input uint     InpDistanceFast   =  0;    // Fast pip displace
//--- indicator buffers
double         BufferTop[];
double         BufferBottom[];
double         BufferCandlesOpen[];
double         BufferCandlesHigh[];
double         BufferCandlesLow[];
double         BufferCandlesClose[];
double         BufferColors[];
double         BufferArrowUP[];
double         BufferArrowDN[];
//--- global variables
int            period_slow;
int            period_fast;
int            period_max;
double         distance_slow;
double         distance_fast;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- set global variables
   period_fast=int(InpPeriodFast<1 ? 1 : InpPeriodFast);
   period_slow=int(InpPeriodSlow<1 ? 1 : InpPeriodSlow);
   period_max=fmax(period_fast,period_slow);
   distance_fast=InpDistanceFast*Point();
   distance_slow=InpDistanceSlow*Point();
//--- indicator buffers mapping
   SetIndexBuffer(0,BufferTop,INDICATOR_DATA);
   SetIndexBuffer(1,BufferBottom,INDICATOR_DATA);
   SetIndexBuffer(2,BufferCandlesOpen,INDICATOR_DATA);
   SetIndexBuffer(3,BufferCandlesHigh,INDICATOR_DATA);
   SetIndexBuffer(4,BufferCandlesLow,INDICATOR_DATA);
   SetIndexBuffer(5,BufferCandlesClose,INDICATOR_DATA);
   SetIndexBuffer(6,BufferColors,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(7,BufferArrowUP,INDICATOR_DATA);
   SetIndexBuffer(8,BufferArrowDN,INDICATOR_DATA);
//--- setting a code from the Wingdings charset as the property of PLOT_ARROW
   PlotIndexSetInteger(3,PLOT_ARROW,108);
   PlotIndexSetInteger(4,PLOT_ARROW,108);
//--- setting indicator parameters
   IndicatorSetString(INDICATOR_SHORTNAME,"NeuroTrend");
   IndicatorSetInteger(INDICATOR_DIGITS,Digits());
//--- setting buffer arrays as timeseries
   ArraySetAsSeries(BufferTop,true);
   ArraySetAsSeries(BufferBottom,true);
   ArraySetAsSeries(BufferCandlesOpen,true);
   ArraySetAsSeries(BufferCandlesHigh,true);
   ArraySetAsSeries(BufferCandlesLow,true);
   ArraySetAsSeries(BufferCandlesClose,true);
   ArraySetAsSeries(BufferColors,true);
   ArraySetAsSeries(BufferArrowUP,true);
   ArraySetAsSeries(BufferArrowDN,true);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- Установка массивов буферов как таймсерий
   ArraySetAsSeries(open,true);
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   ArraySetAsSeries(close,true);
//--- Проверка и расчёт количества просчитываемых баров
   if(rates_total<fmax(period_max,4)) return 0;
   int limit=rates_total-prev_calculated;
   if(limit>1)
     {
      limit=rates_total-period_max-1;
      ArrayInitialize(BufferTop,EMPTY_VALUE);
      ArrayInitialize(BufferBottom,EMPTY_VALUE);
      ArrayInitialize(BufferCandlesOpen,EMPTY_VALUE);
      ArrayInitialize(BufferCandlesHigh,EMPTY_VALUE);
      ArrayInitialize(BufferCandlesLow,EMPTY_VALUE);
      ArrayInitialize(BufferCandlesClose,EMPTY_VALUE);
      ArrayInitialize(BufferArrowUP,EMPTY_VALUE);
      ArrayInitialize(BufferArrowDN,EMPTY_VALUE);
     }
//---
   for(int i=limit; i>=0 && !IsStopped(); i--)
     {
      int bhs=Highest(period_slow,i);
      int bls=Lowest(period_slow,i);
      int bhf=Highest(period_fast,i);
      int blf=Lowest(period_fast,i);
      if(bhs==WRONG_VALUE || bls==WRONG_VALUE || bhf==WRONG_VALUE || blf==WRONG_VALUE)
         continue;
      double thigh1=high[bhs]+distance_slow;
      double tlow1=low[bls]-distance_slow;
      double thigh2=high[bhf]+distance_fast;
      double tlow2=low[blf]-distance_fast;
      
      double trendA=(close[i]>BufferTop[i+1] ? tlow1 : thigh1);
      double trendB=(close[i]>BufferBottom[i+1] ? tlow2 : thigh2);
      BufferTop[i]=trendA;
      BufferBottom[i]=trendB;
      
      BufferCandlesOpen[i]=open[i];
      BufferCandlesHigh[i]=high[i];
      BufferCandlesLow[i]=low[i];
      BufferCandlesClose[i]=close[i];
      BufferColors[i]=2;
      if(close[i]<trendA && close[i]<trendB)
         BufferColors[i]=1;
      else if(close[i]>trendA && close[i]>trendB)
         BufferColors[i]=0;
      else
        {
         BufferCandlesOpen[i]=EMPTY_VALUE;
         BufferCandlesHigh[i]=EMPTY_VALUE;
         BufferCandlesLow[i]=EMPTY_VALUE;
         BufferCandlesClose[i]=EMPTY_VALUE;
        }
      static int trend=0;
      BufferArrowUP[i]=BufferArrowDN[i]=EMPTY_VALUE;
      if(close[i]>trendB && close[i]>trendA && trend!=1)
        {
         BufferArrowDN[i]=open[i];
         BufferArrowUP[i]=EMPTY_VALUE;
         trend=1;
        }
      if(close[i]<trendB && close[i]<trendA && trend!=2)
        {
         BufferArrowUP[i]=open[i];
         BufferArrowDN[i]=EMPTY_VALUE;
         trend=2;
        }
     }
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Возвращает индекс максимального значения таймсерии High          |
//+------------------------------------------------------------------+
int Highest(const int count,const int start,const bool as_series=true)
  {
   double array[];
   ArraySetAsSeries(array,as_series);
   return(CopyHigh(NULL,PERIOD_CURRENT,start,count,array)==count ? ArrayMaximum(array)+start : WRONG_VALUE);
  }
//+------------------------------------------------------------------+
//| Возвращает индекс минимального значения таймсерии Low            |
//+------------------------------------------------------------------+
int Lowest(const int count,const int start,const bool as_series=true)
  {
   double array[];
   ArraySetAsSeries(array,as_series);
   return(CopyLow(NULL,PERIOD_CURRENT,start,count,array)==count ? ArrayMinimum(array)+start : WRONG_VALUE);
  }
//+------------------------------------------------------------------+

Und die Linien sollten entfernt werden - wozu sind sie auf dem Diagramm? Und sei es nur, um ihnen das Handwerk zu legen?

 

Deklaration ohne Typ

Wenn ich eine Include-Datei kompiliere, tritt kein Fehler auf. Wenn ich die Hauptprogrammdatei kompiliere, in die ich diese Include-Datei einfüge, gibt es eine Deklaration ohne Typfehler. Es sieht das in der Include-Datei deklarierte Objekt nicht protected CSomeClass *object. Die Include-Datei enthält die Anweisung #include "SomeClass.mqh". Und in der Hauptdatei wird ein Objekt der Klasse der eingeschlossenen Datei erstellt und eine der Methoden aufgerufen.
1...912913914915916917918919920921922923924925926...1504
Neuer Kommentar
Grund der Beschwerde: