Indikatoren: Pearson Korrelations Indikator - Seite 2

Neuer Kommentar
 
Hier in etwa so - https://www.mql5.com/de/code/183. Der Punkt ist, dass das Kopieren von Daten aus anderen Symbolen nicht auf einmal erfolgt, sondern ein Balken nach dem anderen. Beim Kopieren von anderen Symbolen wird der Balken genau zu dem Zeitpunkt kopiert, an dem der Indikator im Chart angezeigt wird. Wenn es keinen entsprechenden Balken gibt, dann von einem früheren Balken (wie die Funktion iBarShift() in MQL4). Bei diesem Indikator wird jeweils ein Balken kopiert, aber für die Korrelation kann es notwendig sein, die dem Korrelationszeitraum entsprechende Zahl zu kopieren. Sie können es auch anders machen: Kopieren Sie einen Balken nach dem anderen und legen Sie ihn in den Indikatorpuffer. Mit dem Puffer können Sie alles so schnell wie möglich erledigen (natürlich auf Kosten eines höheren Speicherverbrauchs). Man kann es auch ohne einen zusätzlichen Puffer machen, mit ein paar statischen Variablen.... Es ist lange zu erklären, es ist wahrscheinlich notwendig, einen Artikel zu schreiben:)
 
pusheax:

Okay, gestern haben wir uns ein wenig aufgeregt, ich nehme an, du hast auch den "Border Guard Day" gefeiert wie ich.

Kannst du mir einen Link zur korrekten Synchronisation der Takte geben, denn ich benutze auch diese Methode der Synchronisation durch den letzten Takt und das war's?

Ich werde Ihnen keinen Link geben (weil ich ihn noch nicht gefunden habe), aber ich werde die Methode beschreiben.

Die Methode betrifft die Synchronisierung verschiedener Instrumente, obwohl sie auch für die Synchronisierung verschiedener TFs verwendet werden kann.

Ich beschäftige mich schon lange mit diesem Problem, und SD hat sogar einen Bug-Fix für die von mir identifizierten Fehler dieser Methode gemacht.

Das Synchronisationsproblem hängt damit zusammen, dass verschiedene Instrumente eine unterschiedliche Anzahl von Balken haben. Ungefähr gleich ist ein falsches Kriterium, alles muss exakt sein. Takt zu Takt. Sonst geht der Sinn der Synchronisation verloren.

Der zweite Aspekt dieses Problems ist die Frage, wie man einen Balken anzeigt, wenn es auf dem aktuellen Instrument keinen Balken gibt.

Das Wesen der Methode ist also einfach: Die Daten des Instruments werden streng nach Zeiten abgefragt...

count=CopyRates(symbol,tf,time0,time1,rates); если нужно несколько баров
или
count=CopyRates(symbol,tf,time0,1,rates); если нужен один

und die Zeitprobe wird aus dem Standardpuffer des Indikators time[] entnommen. So können Sie immer sicher sein, dass Sie einen Balken vor sich haben, der synchron mit einem Balken eines anderen Instruments kam.

Auch hier gilt: Wenn es im aktuellen Instrument keinen solchen Balken gibt, werden Sie ihn nicht anfordern. Und wenn das angeforderte Instrument keinen solchen Balken als Beispiel hat, erhalten Sie eine Null in der Zählung und können diese Ausnahme normalerweise behandeln, je nach der Logik Ihres Programms.

 

Implementierung der Synchronisation (in MQL4) für eine beliebige Anzahl von FIs(ab hier):

double GetPrice( string Symb, int time )
{
  double Price;
 
  Price = iClose(Symb, Period(), iBarShift(Symb, Period(), time));
 
  return(Price);
}
 
int GetNextTime( int CurrTime )
{
  static int Pos[MAX_AMOUNTSYMBOLS];
  int i, MinTime, Tmp = -1;
 
  for (i = 0; i < AmountSymbols; i++)
  {
    Pos[i] = iBarShift(Symbols[i], Period(), CurrTime) - 1;
 
    if (Pos[i] >= 0)
      Tmp = i;
  }
 
  if (Tmp < 0)
    return(Time[0]);
 
  MinTime = iTime(Symbols[Tmp], Period(), Pos[Tmp]);
 
  i = Tmp - 1;
 
  while (i >= 0)
  {
    if (Pos[i] >= 0)
    {
      Tmp = iTime(Symbols[i], Period(), Pos[i]);
 
      if (Tmp < MinTime)
        MinTime = Tmp;
    }
 
    i--;
  }
 
  return(MinTime);
}
 
void GetBaseMatrix()
{
  int i, NextTime;
 
  NextTime = GetNextTime(CurrTime);
 
  while (NextTime < Time[0])
  {
    CurrTime = NextTime;
 
    for (i = 0; i < AmountSymbols; i++)
      BaseMatrix[i][MatrixRows] = 1000 * MathLog(GetPrice(Symbols[i], CurrTime));
 
    Times[MatrixRows] = CurrTime;
 
    MatrixRows++;
 
    NextTime = GetNextTime(CurrTime);
  }
 
  return;
}

In Analogie für zwei Symbole(ab hier):

double GetPrice( string Symb, int time )
{
  double Price;
 
  Price = iClose(Symb, Period(), iBarShift(Symb, Period(), time));
 
  return(Price);
}
 
int GetNextTime( int CurrTime )
{
  static int Pos[TWO_SYMBOLS];
  int i, MinTime, Tmp = -1;
 
  for (i = 0; i < TWO_SYMBOLS; i++)
  {
    Pos[i] = iBarShift(Symbols[i], Period(), CurrTime) - 1;
 
    if (Pos[i] >= 0)
      Tmp = i;
  }
 
  if (Tmp < 0)
    return(Time[0]);
 
  MinTime = iTime(Symbols[Tmp], Period(), Pos[Tmp]);
 
  i = Tmp - 1;
 
  while (i >= 0)
  {
    if (Pos[i] >= 0)
    {
      Tmp = iTime(Symbols[i], Period(), Pos[i]);
 
      if (Tmp < MinTime)
        MinTime = Tmp;
    }
 
    i--;
  }
 
  return(MinTime);
}
 
void GetBaseMatrix()
{
  int i, NextTime;
 
  NextTime = GetNextTime(CurrTime);
 
  while (NextTime < Time[0])
  {
    CurrTime = NextTime;
 
    for (i = 0; i < TWO_SYMBOLS; i++)
      BaseMatrix[i][MatrixRows + Shifts[i]] = MathLog(GetPrice(Symbols[i], CurrTime));
 
    Times[MatrixRows] = CurrTime;
 
    MatrixRows++;
 
    NextTime = GetNextTime(CurrTime);
  }
 
  return;
}
D.h. alles ist recht einfach. Eine andere Sache ist, dass die klassische barometrische (konstante Zeitdiskretisierung) Darstellung von Preis-GP nicht die einzige ist, und schon gar nicht immer richtig. Manchmal ist es äußerst nützlich, Preis-BP einer anderen Zeitdimension zu synchronisieren. Das heißt, durch die Einführung von Verzerrungen, die aus der Sicht der klassischen Zeit nicht linear sind. Dementsprechend zeigt die Korrelation dann nichtlineare Wechselbeziehungen zwischen zwei klassischen VR an.
 

Vielen Dank für Ihre Hilfe!

Ich gebe zu, dass ich mich geirrt habe. Ich hätte nicht gedacht, dass die Synchronisierung so kompliziert ist.

Ich werde versuchen, es herauszufinden und die Balken direkt mit diesem Indikator zu synchronisieren, da ich es sehr brauche.

 

Vielen Dank an alle für die Informationen!

Ich habe den Indikator ein wenig umgeschrieben. Jetzt sollte er angeblich schlechte Teile der Geschichte überspringen.

Da wir begonnen haben, überprüfen Sie bitte auf Fehler :)

Dateien:
Correlation.mq5  8 kb
 
Ich möchte mich noch einmal für die Notwendigkeit der algorithmischen Optimierung aller Indikatoren aussprechen. Und auch für den eingebauten Mechanismus der Berechnung von Indikatorwerten im Speicher (Datei), damit bei der Testeroptimierung der Indikator nicht das Gleiche berechnet, sondern fertige Werte von dort übernimmt.
 
hrenfx:
Ich möchte mich noch einmal für die Notwendigkeit der algorithmischen Optimierung aller Indikatoren aussprechen. Und auch für den eingebauten Mechanismus der Berechnung von Indikatorwerten im Speicher (Datei), damit bei der Testeroptimierung der Indikator nicht das Gleiche berechnet, sondern fertige Werte von dort übernimmt.
Könnten Sie mir ein Beispiel zeigen, wo dies bereits geschehen ist?
 

Die algorithmische Optimierung ist für jeden Indikator anders. Für verschiedene Arten der Nutzung der Korrelation habe ich zum Beispiel dies und dies getan .

Ich lese die Werte der Indikatoren, die ich im Voraus für die gesamte Geschichte berechnet habe, nur in meinem Taschenrechner ab. Das heißt, ich habe keinen universellen Mechanismus, denn ich verwende nur meine eigenen Lösungen, die keineswegs schön sind. Aber da ich für die Verbesserung von allem bin, wäre es toll, einen solchen universellen Mechanismus im Falle des Optimierers des MT5-Testers zu haben, weil er eine Beschleunigung um mehrere Größenordnungen bietet (Erfahrung bei der Verwendung in meinem Rechner), d.h. er übertrifft die Cloud in Bezug auf die Effizienz.

 

Hallo

Manchmal verbringe ich meine Zeit damit, die Codes anderer zu verfälschen, was in der Regel das Ergebnis eines unvollständigen oder unvollkommenen Programms ist, sowohl aus Zeitmangel als auch aus mangelndem Können.

Dieses Mal wollte ich diesen wunderbaren Indikator verfälschen und habe versucht, so etwas zu machen:

- Zeichnen Sie nur eine Linie, keine gepunktete Plotlinie



#property indicator_type1 DRAW_COLOR_LINE
#property indicator_width1 2

// #property indicator_type2 DRAW_COLOR_HISTOGRAM
// #Eigenschaft indicator_style2 STYLE_DOT
// #Eigenschaft indicator_width2 1

- Hinzufügen einer Menge von Symbolen wie

//--- Eingabe-Parameter
input string _SecondSymbol="EURGBP"; // Symbol

input string _ThirdSymbol="EURAUD"; // Symbol
input string _FourthSymbol="EURCAD"; // Symbol
input string _FifthSymbol="EURCHF"; // Symbol
input string _SixthSymbol="EURNZD"; // Symbol
input string _SeventhSymbol="EURHKD"; // Symbol
input string _EighthSymbol="EURTRY"; // Symbol

Dann 2 Varianten des Quellcodes zu erstellen:

- Visuelle Variante: eine farbige Linie für jedes der Währungspaare Korrelation 1 dicke Linie, die nur der Durchschnitt von 7 Linien ist ((A+B+C+D+E+F+G)/7)

- Keine visuelle Variante: Nur 1 Linie, die das Ergebnis der obigen Formel ist ((A+B+C+D+D+E+F+G)/7)

Fast wie die Addition von 7 (oder 8) ursprünglichen Korrelationsindikatoren, aber alle summiert, so dass nur Durchschnitte wie bei der Version, von denen eine 7 Linien + 1 (Durchschnitt) ist, und die andere Version mit 1 Linie (nur Durchschnitt).

etwas wie dies:

buf[i]= (
(v1/sqrt(v2*v3))+
(v4/sqrt(v2*v6))+
(v7/sqrt(v2*v9))+
(v10/sqrt(v2*v12))+
(v13/sqrt(v2*v15))+
(v16/sqrt(v2*v18))+
(v19/sqrt(v2*v21)) 
)/7; // einfacher Durchschnitt der Werte.


buf2[i]=buf[i];
c=getPlotColor(buf[i]);
colors1[i]=c;
colors2[i]=c;

Aus einer Reihe von Gründen tut der verstümmelte Code nicht das, was ich tun will, weil er völlig logische Fehler enthält.

Das Hauptproblem liegt bei den Puffern, der Synchronisierung und dem rekursiven Einrücken des Codes: 

if(bars1>bars2)
{
minBars=bars2;
bars2=bars1-bars2;
etc...

+ sowie andere logische Fehler.

wurden einige Print()-Funktionen hinzugefügt, um bei der Verfolgung von Variablenwerten zu helfen, und return 0-Anweisungen wurden auskommentiert, um herauszufinden, wo der Code logisch versagt.

 

Code und Datei

//+------------------------------------------------------------------+
//| Korrelation.mq5 |
//|| Copyright 2012, iC |
//| http://www.icreator.biz/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, iC"
#property link "http://www.icreator.biz/"
#property version "1.00"
//--- Indikatoreinstellungen
#property indicator_separate_window

#property indicator_minimum -1
#property indicator_maximum 1

#property indicator_buffers 25
#property indicator_plots 2

#property indicator_type1 DRAW_COLOR_LINE
#property indicator_width1 2

// #property indicator_type2 DRAW_COLOR_HISTOGRAM
// #Eigenschaft indicator_style2 STYLE_DOT
// #Eigenschaft indicator_width2 1

/*

#Eigenschaft indicator_type2 DRAW_COLOR_LINE
#Eigenschaft indicator_width2 2

#Eigenschaft indicator_type3 DRAW_COLOR_LINE
#Eigenschaft indicator_width3 2

#Eigenschaft indicator_type4 DRAW_COLOR_LINE
#Eigenschaft indicator_width4 2

#Eigenschaft indicator_type5 DRAW_COLOR_LINE
#Eigenschaftsindikator_Breite5 2

#Eigenschaftsindikator_type6 DRAW_COLOR_LINE
#Eigenschaftsindikator_Breite6 2

#Eigenschaftsindikator_type7 DRAW_COLOR_LINE
#Eigenschaftsindikator_Breite7 2

#Eigenschaftsindikator_type8 DRAW_COLOR_LINE
#Eigenschaftsindikator_Breite8 2

*/

//--- definiert
#define MAX_COL 64
//--- Strukturen
struct CRGB
{
int r;
int g;
int b;
};
//--- Eingabe-Parameter
input string _SecondSymbol="EURGBP"; // Symbol

input string _ThirdSymbol="EURAUD"; // Symbol
input string _FourthSymbol="EURCAD"; // Symbol
input string _FifthSymbol="EURCHF"; // Symbol
input string _SixthSymbol="EURNZD"; // Symbol
input string _SeventhSymbol="EURHKD"; // Symbol
input string _EighthSymbol="EURTRY"; // Symbol

input int _SettPeriod=100; // Zeitraum
input ENUM_APPLIED_PRICE _AppliedPrice=PRICE_CLOSE; // Preis
input color _Color1=clrLightGray; // Minimale Korrelation.
input color _Color2=clrLime; // Maximale Korrelation.

//--- Indikatorpuffer
double buf[],buf2[]
,buf3[],buf4[],buf5[],buf6[],buf7[],buf8[];

double arr1[],arr2[]
,arr3[],arr4[],arr5[],arr6[],arr7[],arr8[];

double colors1[],colors2[];

//--- MA Griffe
int h1,h2,
h3,h4,h5,h6,h7,h8;
//+------------------------------------------------------------------+
//| Benutzerdefinierte Initialisierungsfunktion für Indikatoren |
//+------------------------------------------------------------------+
int OnInit()
{
SetIndexBuffer(0,buf);
SetIndexBuffer(1,colors1,INDICATOR_COLOR_INDEX);

SetIndexBuffer(2,buf2);
SetIndexBuffer(3,colors2,INDICATOR_COLOR_INDEX);

SetIndexBuffer(4,arr1,INDICATOR_CALCULATIONS); // erstes Symbol
SetIndexBuffer(5,arr2,INDICATOR_CALCULATIONS); // zweites Symbol


SetIndexBuffer(6,arr3,INDICATOR_CALCULATIONS); //3.
SetIndexBuffer(7,arr4,INDICATOR_CALCULATIONS); //4.

SetIndexBuffer(8,arr5,INDICATOR_CALCULATIONS); //5.
SetIndexBuffer(9,arr6,INDICATOR_CALCULATIONS); //6.

SetIndexBuffer(10,arr7,INDICATOR_CALCULATIONS); //7.

SetIndexBuffer(11,arr8,INDICATOR_CALCULATIONS); //8.

/* 
SetIndexPuffer(12,arr9,INDICATOR_CALCULATIONS);
SetIndexPuffer(13,arr10,INDICATOR_CALCULATIONS);

SetIndexPuffer(14,arr11,INDICATOR_CALCULATIONS);
SetIndexPuffer(15,arr12,INDICATOR_CALCULATIONS);

SetIndexPuffer(16,buf3);
SetIndexPuffer(17,colours3,INDICATOR_COLOR_INDEX);

SetIndexPuffer(18,buf4);
SetIndexPuffer(19,Farben4,INDICATOR_COLOR_INDEX);

SetIndexPuffer(20,buf5);
SetIndexPuffer(21,Farben5,INDICATOR_COLOR_INDEX);

SetIndexPuffer(22,buf6);
SetIndexPuffer(23,farben6,INDICATOR_COLOR_INDEX);

SetIndexPuffer(24,buf7);
SetIndexPuffer(25,farben7,INDICATOR_COLOR_INDEX);

// usw...
*/

PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);
PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0);

PlotIndexSetInteger(0,PLOT_SHOW_DATA,0);
IndicatorSetInteger(INDICATOR_DIGITS,3); 

IndicatorSetString(INDICATOR_SHORTNAME,_Symbol+"/"+_SecondSymbol+", "+IntegerToString(_SettPeriod)+", "+EnumToString(_AppliedPrice)+","); // usw...

setPlotColor(0,_Color1,_Color2);
setPlotColor(1,_Color1,_Color2);

h1=iMA(_Symbol,0,1,0,MODE_EMA,_AppliedPrice);
h2=iMA(_SecondSymbol,0,1,0,MODE_EMA,_AppliedPrice);

// hinzugefügte Werte.
h3=iMA(_ThirdSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h4=iMA(_FourthSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h5=iMA(_FifthSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h6=iMA(_SixthSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h7=iMA(_SeventhSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h8=iMA(_EighthSymbol,0,1,0,MODE_EMA,_AppliedPrice);

return 0;
}
//+------------------------------------------------------------------+
//| Benutzerdefinierte Indikator-Iterationsfunktion |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const int begin,
const double &price[])
{
int i,j,c,limit,bars1,bars2
,bars3,bars4,bars5,bars6,bars7,bars8, 
minBars,toCopy;
double averX1=0,averX2=0
,averX3=0,averX4=0,averX5=0,averX6=0,averX7=0,averX8=0,
v1=0,v2=0,v3=0
,v4=0,v5=0,v6=0,v7=0,v8=0
,v9=0,v10=0,v11=0,v12=0
,v13=0,v14=0,v15=0,v16=0,v17=0
,v18=0,v19=0,v20=0,v21=0;
datetime t1[1],t2[1],
t3[1],t4[1],t5[1],t6[1],t7[1],t8[1];
//--- Synchronisationssymbole
if( 
(
CopyTime(_Symbol,0,0,1,t1)<1 || 
CopyTime(_SecondSymbol,0,0,1,t2)<1 || 

CopyTime(_ThirdSymbol,0,0,1,t3)<1 || 
CopyTime(_FourthSymbol,0,0,1,t4)<1 || 
CopyTime(_FifthSymbol,0,0,1,t5)<1 || 
CopyTime(_SixthSymbol,0,0,1,t6)<1 || 
CopyTime(_SeventhSymbol,0,0,1,t7)<1 || 
CopyTime(_EighthSymbol,0,0,1,t8)<1
) 
|| 

(
t1[0]!=t2[0]
|| t1[0]!=t3[0]
|| t1[0]!=t4[0]
|| t1[0]!=t5[0]
|| t1[0]!=t6[0]
|| t1[0]!=t7[0]
|| t1[0]!=t8[0]
)
) 
{
Print("Synchronization failed!");
// Rückgabe 0;
}
//--- Prüfung auf Daten

bars1=rates_total;
bars2=Bars(_SecondSymbol,0);

bars3=Bars(_ThirdSymbol,0);
bars4=Bars(_FourthSymbol,0);
bars5=Bars(_FifthSymbol,0);
bars6=Bars(_SixthSymbol,0);
bars7=Bars(_SeventhSymbol,0);
bars8=Bars(_EighthSymbol,0);

// einrücken, bis die minBars gefunden sind. // um zu prüfen, ob die Logik korrekt ist

if(bars1>bars2)
{
minBars=bars2;
bars2=bars1-bars2;
bars1=0;
Print("bars1>bars2; minBars(",minBars,"),=bars2(",bars2,")=bars1(",bars1,")-bars2(",bars2,");");
// }
//else 
if(bars1>bars3)
{
minBars=bars3;
bars3=bars1-bars3;
bars1=0;
Print("bars1>bars3; minBars(",minBars,"),=bars3(",bars3,")=bars1(",bars1,")-bars3(",bars3,");");
// } 
//else 
if(bars1>bars4)
{
minBars=bars4;
bars4=bars1-bars4;
bars1=0;
Print("bars1>bars4; minBars(",minBars,"),=bars4(",bars4,")=bars1(",bars1,")-bars4(",bars4,");");
// } 
//else 
if(bars1>bars5)
{
minBars=bars5;
bars5=bars1-bars5;
bars1=0;
Print("bars1>bars5; minBars(",minBars,"),=bars5(",bars5,")=bars1(",bars1,")-bars5(",bars5,");");
// } 
//else 
if(bars1>bars6)
{
minBars=bars6;
bars6=bars1-bars6;
bars1=0;
Print("bars1>bars6; minBars(",minBars,"),=bars6(",bars6,")=bars1(",bars1,")-bars6(",bars6,");");
// } 
//else 
if(bars1>bars7)
{
minBars=bars7;
bars7=bars1-bars7;
bars1=0;
Print("bars1>bars7; minBars(",minBars,"),=bars7(",bars7,")=bars1(",bars1,")-bars7(",bars7,");");
// } 
//else 
if(bars1>bars8)
{
minBars=bars8;
bars8=bars1-bars8;
bars1=0;
Print("bars1>bars8; minBars(",minBars,"),=bars8(",bars8,")=bars1(",bars1,")-bars8(",bars8,");");
} }}}}}} 

else
{
minBars=bars1;
bars1=bars2-bars1;
bars2=0;
Print("bars1!>bars2,3,4,5,6,7,8; minBars(",minBars,"),=bars1(",bars1,")=bars2(",bars2,")-bars1(",bars1,");");
}
if(minBars<_SettPeriod)
{
Print("Bars is not enough to calculate!");
// Rückgabe 0;
}
if(BarsCalculated(h1)<minBars)
{
Print("Not all data of MA1 is calculated. Error ",GetLastError());
// Rückgabe 0;
}
if(BarsCalculated(h2)<minBars)
{
Print("Not all data of MA2 is calculated. Error ",GetLastError());
// Rückgabe 0;
}
if(BarsCalculated(h3)<minBars)
{
Print("Not all data of MA3 is calculated. Error ",GetLastError());
// Rückgabe 0;
}
if(BarsCalculated(h4)<minBars)
{
Print("Not all data of MA4 is calculated. Error ",GetLastError());
// Rückgabe 0;
}
if(BarsCalculated(h5)<minBars)
{
Print("Not all data of MA5 is calculated. Error ",GetLastError());
// Rückgabe 0;
}
if(BarsCalculated(h6)<minBars)
{
Print("Not all data of MA6 is calculated. Error ",GetLastError());
// Rückgabe 0;
}
if(BarsCalculated(h7)<minBars)
{
Print("Not all data of MA7 is calculated. Error ",GetLastError());
// Rückgabe 0;
}
if(BarsCalculated(h8)<minBars)
{
Print("Not all data of MA8 is calculated. Error ",GetLastError());
// Rückgabe 0;
} 

//--- wir können nicht alle Daten kopieren
if(prev_calculated>rates_total || 
prev_calculated<=0)
toCopy=minBars;
else
toCopy=rates_total-prev_calculated+1;

if(CopyBuffer(h1,0,0,minBars,arr1)<minBars || 
CopyBuffer(h2,0,0,minBars,arr2)<minBars || 

CopyBuffer(h3,0,0,minBars,arr3)<minBars || 
CopyBuffer(h4,0,0,minBars,arr4)<minBars || 
CopyBuffer(h5,0,0,minBars,arr5)<minBars || 
CopyBuffer(h6,0,0,minBars,arr6)<minBars || 
CopyBuffer(h7,0,0,minBars,arr7)<minBars || 
CopyBuffer(h8,0,0,minBars,arr8)<minBars) 

{
Print("Getting MA buffer failed. Error ",GetLastError());
// Rückgabe 0;
}
if(prev_calculated>rates_total || 
prev_calculated<=0)
limit=bars1+bars2+_SettPeriod-1
+bars3+bars4+bars5+bars6+bars7+bars8;

else
limit=prev_calculated-1;
//--- 
for(i=limit;i<rates_total;i++)
{
averX1=0; averX2=0; 
averX3=0;averX4=0;averX5=0;averX6=0;averX7=0;averX8=0;
for(j=0;j<_SettPeriod;j++)
{
averX1+=arr1[i-j-bars1]/_SettPeriod;
averX2+=arr2[i-j-bars2]/_SettPeriod;

averX3+=arr3[i-j-bars3]/_SettPeriod;
averX4+=arr4[i-j-bars4]/_SettPeriod;
averX5+=arr5[i-j-bars5]/_SettPeriod;
averX6+=arr6[i-j-bars6]/_SettPeriod;
averX7+=arr7[i-j-bars7]/_SettPeriod;
averX8+=arr8[i-j-bars8]/_SettPeriod;
}

v1=0; v2=0; v3=0;
v4=0;v5=0;v6=0;v7=0;v8=0;
v9=0;v10=0;v11=0;v12=0;v13=0;
v14=0;v15=0;v16=0;v17=0;v18=0;
v19=0;v20=0;v21=0; 
for(j=0;j<_SettPeriod;j++)
{
v1+=(arr1[i-j-bars1]-averX1)*(arr2[i-j-bars2]-averX2);
v2+=pow((arr1[i-j-bars1]-averX1),2);
v3+=pow((arr2[i-j-bars2]-averX2),2);

v4+=(arr1[i-j-bars1]-averX2)*(arr3[i-j-bars3]-averX3);
// v5+=pow((arr1[i-j-bars1]-averX1),2);
v6+=pow((arr3[i-j-bars3]-averX3),2);

v7+=(arr1[i-j-bars1]-averX1)*(arr4[i-j-bars4]-averX4);
// v8+=pow((arr1[i-j-bars1]-averX1),2);
v9+=pow((arr4[i-j-bars4]-averX4),2);

v10+=(arr1[i-j-bars1]-averX1)*(arr5[i-j-bars5]-averX5);
// v11+=pow((arr1[i-j-bars1]-averX1),2);
v12+=pow((arr5[i-j-bars5]-averX5),2);

v13+=(arr1[i-j-bars1]-averX1)*(arr6[i-j-bars6]-averX6);
// v14+=pow((arr1[i-j-bars1]-averX1),2);
v15+=pow((arr6[i-j-bars6]-averX6),2);

v16+=(arr1[i-j-bars1]-averX1)*(arr7[i-j-bars7]-averX7);
// v17+=pow((arr1[i-j-bars1]-averX1),2);
v18+=pow((arr7[i-j-bars7]-averX7),2);

v19+=(arr1[i-j-bars1]-averX1)*(arr8[i-j-bars8]-averX8);
// v20+=pow((arr1[i-j-bars1]-averX1),2);
v21+=pow((arr8[i-j-bars8]-averX8),2);

}
buf[i]= (
(v1/sqrt(v2*v3))+
(v4/sqrt(v2*v6))+
(v7/sqrt(v2*v9))+
(v10/sqrt(v2*v12))+
(v13/sqrt(v2*v15))+
(v16/sqrt(v2*v18))+
(v19/sqrt(v2*v21)) 
)/7; // einfacher Durchschnitt der Werte.


buf2[i]=buf[i];
c=getPlotColor(buf[i]);
colors1[i]=c;
colors2[i]=c;
}
return rates_total;
}

//+------------------------------------------------------------------+
//| setPlotColour |
//+------------------------------------------------------------------+
void setPlotColor(int plot,color col1,color col2)
{
int i;
CRGB c1,c2;
double dr,dg,db;
string s;
//--- 
PlotIndexSetInteger(plot,PLOT_COLOR_INDEXES,MAX_COL);
ColorToRGB(col1,c1);
ColorToRGB(col2,c2);
dr=(double)(c2.r-c1.r)/MAX_COL;
dg=(double)(c2.g-c1.g)/MAX_COL;
db=(double)(c2.b-c1.b)/MAX_COL;
for(i=0;i<MAX_COL;i++)
{
s=StringFormat("%i,%i,%i",
c1.r+(int)NormalizeDouble(dr*(i+1),0),
c1.g+(int)NormalizeDouble(dg*(i+1),0),
c1.b+(int)NormalizeDouble(db*(i+1),0));
PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i,StringToColor(s));
}
}
//+------------------------------------------------------------------+
//| getPlotColor |
//+------------------------------------------------------------------+
int getPlotColor(double current)
{
return((int)NormalizeDouble((MAX_COL-1)*fabs(current),0));
}
//+------------------------------------------------------------------+
//| ColorToRGB |
//+------------------------------------------------------------------+
void ColorToRGB(color col,CRGB &res)
{
string s,s2;
int n;
//---
s=ColorToString(col);
n=StringFind(s,",");
s2=StringSubstr(s,0,n);
res.r=(int)StringToInteger(s2);
s=StringSubstr(s,n+1);
n=StringFind(s,",");
s2=StringSubstr(s,0,n);
res.g=(int)StringToInteger(s2);
s=StringSubstr(s,n+1);
s2=StringSubstr(s,0);
res.b=(int)StringToInteger(s2);
}
//+------------------------------------------------------------------+
Dateien:
Correlation_Var.mq5  16 kb
1234
Neuer Kommentar