MetaTrader 5 herunterladen

Überlagerung und Interferenz bei Finanztiteln

29 März 2016, 14:34
Khristian Piligrim
0
206

"Genauso wie Sie nicht zweimal in dasselbe Wasser eines Flusses steigen können,
können Sie auch nicht zweimal den exakt gleichen Markt vorfinden.
Alles fließt und verändert sich, nichts bleibt gleich…
"

DAO Piligrimm



Einleitung

Aus Physikbüchern kennen wir das Prinzip der Interferenz von Licht. Interferenz ist die Verstärkung oder Abschwächung der Wellen gleicher Frequenz, die sich an einem Punkt treffen. Gemäß der Elektrostatik ist die Ladung eines Systemfelds gleich der Vektorsumme der Intensität der Felder, die separat von jeder einzelnen der Systemladungen produziert werden würde.

Mit diesen zwei Gesetzen als Basis, habe ich beschlossen, ihr Verhalten bei Finanztiteln des Forex-Markts zu überprüfen. Zu diesem Zweck habe ich folgendes als Axiom genommen: jedes Währungspaar zeigt zu jeder Zeit das Verhältnis einer Währung zur anderen; darüber hinaus verändert sich eine jede Landeswährung im Laufe der Zeit nicht nur relativ gegenüber einer anderen Währung, sondern auch relativ gegenüber sich selbst.

Die relative Veränderung einer Landeswährung im Laufe der Zeit gegenüber sich selbst wird von allen wirtschaftlichen Faktoren des Landes beeinflusst, zu dem die Währung gehört. Der daraus resultierende Kurs in einem Chart wird als eine Überlagerung von zwei Vektoren erhalten, die sich mit der Zeit ändert; die Vektoren ändern sich sowohl entsprechend der Phase als auch der Amplitude. Vektoren sind Ableitungen von Überlagerungen von allen wirtschaftlichen Faktoren in einem Land, zu dem die Währung gehört, als auch von internationalen Faktoren.

Lassen Sie uns als Beispiel das Währungspaar EURUSD hernehmen. Die resultierende Bewegung in einem Kurschart wird auf folgende Art und Weise unter Berücksichtigung der Landeswährungen EUR und USD mit dem Zeitablauf gebildet:

1). EURUSD steigt, wenn:

а). EUR – steigt und USD – fällt;

b). EUR – steigt und USD – sich nicht ändert;

c). EUR – sich nicht ändert und USD – fällt;

d). EUR – steigt und USD – steigt, aber langsamer als EUR;

2). EURUSD – fällt, wenn:

а). USD – steigt und EUR – fällt;

b). USD – steigt und EUR – sich nicht ändert;

c). USD – sich nicht ändert und EUR – fällt;

d). USD – steigt und EUR – steigt, aber langsamer als USD;

3). EURUSD – ändert sich nicht, wenn:

а). USD – sich nicht ändert und EUR – sich nicht ändert;

b). USD – steigt und EUR – steigt, aber mit gleicher Geschwindigkeit wie USD;

c). USD – fällt und EUR – fällt, aber mit gleicher Geschwindigkeit wie USD.

Je mehr Faktoren das Verhalten eines Währungspaares beeinflussen, desto schwieriger ist es, dessen Verhalten zu bewerten und zukünftige Prognosen zu bilden. Wenn wir also die Komponenten eines Währungspaares, Werte einer nationalen Währung, die sich mit der Zeit ändern, extrahieren könnten, könnten wir den möglichen Bewegungsraum einer nationalen Währung verglichen mit dem Währungspaar mit dieser Währung, sowie die Anzahl der Faktoren, die ihr Verhalten beeinflussen, stark eingrenzen. Als Ergebnis würden wir die Genauigkeit hinsichtlich des erwarteten Verhaltens sowie zukünftiger Prognosen erhöhen können. Wie können wir das machen?



Prinzip der Überlagerung und Interferenz bei Finanztiteln

Die Aufgabe wird also folgendermaßen definiert: wir haben ein Währungspaar, zum Beispiel EURUSD. Wir müssen dieses Währungspaar in seine Bestandteile zerlegen - EUR und USD. Um diese Aufgabe zu lösen, habe ich die verfügbaren Kurse für EUR und USD gegenüber anderen Währungen genommen: EURGBP, EURJPY, EURAUD, EURCHF, EURCAD, EURNOK, EURSEK, EURDKK, EURNZD, EURSGD, EURHKD, USDCHF, USDJPY, USDCAD, USDNOK, USDSEK, USDDKK, USDSGD, USDHKD, USDMXN, USDZAR, GBPUSD, AUDUSD, NZDUSD. Für USDMXN und USDZAR waren keine EUR-Kurse durch meinen Broker verfügbar, aber das leicht behoben werden: EURMXN = EURUSD * USDMXN; EURZAR = EURUSD * USDZAR.

Auf der ersten Etappe die Aufgabe zu lösen, sollten wir alle Währungen zu einer einzigen Skala bringen. Zu diesem Zweck wollen wir den Skalierungskoeffizienten für jedes Währungspaar berechnen, indem wir mit Hilfe der Stichprobenlänge LengthSample den Mittelwert aus den Schlusskursen des Währungspaares herausfinden. Nach dem Aufteilen der Kurswerte eines jeden Währungspaares entlang der gesamten Länge der Stichprobe durch den entsprechenden Skalierungskoeffizienten für dieses Währungspaar, erhalten wir die Währungspaare, die zu einer einzigen Skala gebracht wurden.

Auf der zweiten Etappe um EUR und USD zu erhalten, lassen Sie uns die Gesetze der Überlagerung und Interferenz an den Gruppen von Währungspaaren anwenden, die jeweils EUR und USD enthalten; und den Mittelwert aus der Anzahl der verwendeten Währungspaare bilden.


EUR = (EURUSD + EURGBP + EURJPY + EURAUD + EURCHF + EURCAD + EURNOK + EURSEK + EURDKK + EURNZD + EURSGD + EURHKD + EURMXN + EURZAR)/14;

USD = (USDCHF + USDJPY + USDCAD + USDNOK + USDSEK + USDDKK + USDSGD + USDHKD + USDMXN + USDZAR + 1/GBPUSD + 1/AUDUSD + 1/NZDUSD + 1/EURUSD)/14;

Dadurch, dass ein Währungspaar von zwei Vektoren der Landeswährungen gebildet wird und Phasenänderungen dieser Vektoren im Laufe der Zeit nicht synchron sind, aber vor allem unter dem Einfluss wirtschaftlicher Faktoren eines bestimmten Landes gebildet werden, können wir folgende Schlussfolgerung ziehen:

Bei der Überlagerung von Cross-Kursen von verschiedenen Währungen, verstärkt sich der Bestandteil eines Zählers gemäß dem Interferenz-Gesetz augrund der Koinzidenz der Phasen; Bestandteile eines Nenners werden zu einem großen Teil augrund der Nicht-Koinzidenz der Phasen gegenseitig kompensiert.

Abb. 1 zeigt Charts von EUR und USD Berechnungsergebnissen gemäß den oben angeführten Formeln. Die rosa Farbe zeigt EUR, blau - USD, hellblau - EURUSD.

Abb.1

Lassen Sie uns jetzt schätzen, was der Berechnungsfehler von EUR und USD ist, der sich aus der unvollständigen Kompensation der Nenner-Bestandteile in den obigen Formeln ergibt. Lassen Sie uns zu diesem Zweck Charts von EURUSD, hellblaue Linie in Abb. 2, und dem Verhältnis des berechneten EUR zum berechneten USD, rote Linie in Abb.2 bauen.

Abb.2

Aus den oben angeführten Charts ist klar ersichtlich, dass die Phasenverzerrungen von EUR und USD, die durch die Überlagerung und Interferenz der Cross-Kurse der Währung erhalten wurden, unbedeutend sind. Der Amplitudenfehler ist jedoch beträchtlich, was auf eine unvollständige Kompensation der Bestandteile der Landeswährungen hindeutet, die Teile der EUR und USD Cross-Kurse sind. Es kann jedoch angemerkt werden, dass der nicht-lineare Charakter des Fehlers von Balken zu Balken klein ist. Dadurch können wir die Kompensationskorrektur auf dem aktuellen Balken durchführen, indem wir den Kompensator des vorherigen Balkens in den obigen Formeln inkludieren.

Der Kompensationsfehler berechnet sich wie folgt:

  Och   = EURUSD * USD / EUR;


Durch das Inkludieren des erhaltenen Fehlerwerts in die EUR und USD Berechnungsformeln als Ausgleichselement vom vorherigen Balken bei der Berechnung des aktuellen Balkens, erhalten wir einen recht akzeptablen Berechnungsfehler für die meisten angewandten Probleme. Abb. 3 zeigt die Berechnungsergebnisse nach der Kompensation, Charts von EURUSD, hellblaue Linie in Abb. 3, sowie das Verhältnis des berechneten EUR zum berechneten USD, rote Linie in Abb. 3. Wie man aus den Charts erkennen kann, sind die erzielten Ergebnisse viel besser als vor der Kompensation.

Abb.3

Wie bereits gesagt wurde, sind die Phasenverzerrungen, die durch das angebotene Verfahren zur Extrahierung der Komponenten EUR und USD aus EURUSD entstehen unbedeutend, aber je weiter die analysierte Historie zum Erhalt der EUR und USD Werte vom Null-Balken entfernt ist, desto stärker wirkt sich der Effekt von Lücken in der Historie aus. Wenn Balken aufgrund von Lücken weggelassen werden, wird die Synchronisation der Cross-Kurse der verschiedenen Währungen gestört. Das Resultat ist das Auftreten von Phasenverzerrungen für die berechneten Werte von EUR und USD relativ zu EURUSD.

Je tiefer wir in die Historie eintauchen, oder je kleiner die Zeitrahmen sind, die wir für unsere Berechnungen verwenden, desto stärker wird die Auswirkung von Lücken in der Historie und desto größer werden die daraus resultierenden Phasenverzerrungen. Abb. 4 zeigt Charts, die die vorherige Aussage bestätigen. Diese Charts sind die Fortsetzung der Charts in der Abb. 3, jedoch mit einer tieferen Historie. Wegen des akkumulierten Fehlers, der mit dem Wegfall der separaten Historie-Balken der verschiedenen genutzen Instrumente verbunden ist, sehen wir erhebliche Phasenverzerrungen. Um dieses Problem zu lösen, sollten wir historische Daten von höherer Qualität oder spezielle Mittel zum Ausfüllen dieser Lücken in der Historie verwenden.

Abb.4

Nach der Berechnung von EUR und USD können wir jede andere Landeswährung berechnen.

GBP = (EUR / EURGBP + GBPUSD * USD) / 2;
JPY = (EUR / EURJPY + USD / USDJPY) / 2;
AUD = (EUR / EURAUD + AUDUSD * USD) / 2;
CHF = (EUR / EURCHF + USD / USDCHF) / 2;
CAD = (EUR / EURCAD + USD / USDCAD) / 2;
NOK = (EUR / EURNOK + USD / USDNOK) / 2;
SEK = (EUR / EURSEK + USD / USDSEK) / 2;
DKK = (EUR / EURDKK + USD / USDDKK) / 2;
NZD = (EUR / EURNZD + NZDUSD * USD) / 2;
SGD = (EUR / EURSGD + USD / USDSGD) / 2;
HKD = (EUR / EURHKD + USD / USDHKD) / 2;
MXN = (EUR / EURMXN + USD / USDMXN) / 2;
ZAR = (EUR / EURZAR + USD / USDZAR) / 2;

Abb. 5 zeigt eine Reihe der oben berechneten Währungen, dargestellt in einem Chart. EURUSD – hellblaue Farbe, EUR – rosa Farbe, USD – blaue Farbe, GBP – rote Farbe, JPY – braune Farbe, AUD – lila Farbe, CHF – gelbe Farbe, CAD – schwarze Farbe.

Abb.5

Der oben beschriebene Algorithmus zur Berechnung der Landeswährung, der das Prinzip der Überlagerung und Interferenz verwendet, ist in meinem Indikator SuperPosition implementiert, der dem Artikel angehängt ist.

//+------------------------------------------------------------------+
//|                                                SuperPosition.mq4 |
//|                                       Copyright © 2009,Piligrimm |
//|                                     mailto: piligrimm_fx@mail.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009,Piligrimm"
#property link      "mailto: piligrimm_fx@mail.ru"
#property indicator_separate_window   
#property indicator_buffers 3
#property indicator_color1 Magenta
#property indicator_color2 Blue
#property indicator_color3 Aqua
//---- input parameters
extern int LengthSample=1000;
int i,j;
double GL[][81],EURClose[],USDClose[],EURUSDClose[],EURHigh[],USDHigh[],EURUSDHigh[],EURLow[],USDLow[];
double GBPClose[],JPYClose[],AUDClose[],CHFClose[],CADClose[],NOKClose[],SEKClose[],EURUSDLow[],Kf[27];
double DKKClose[],NZDClose[],SGDClose[],HKDClose[],MXNClose[],ZARClose[],SGDLow[],HKDLow[],MXNLow[];
double GBPHigh[],JPYHigh[],AUDHigh[],CHFHigh[],CADHigh[],NOKHigh[],SEKHigh[],DKKLow[],NZDLow[];
double DKKHigh[],NZDHigh[],SGDHigh[],HKDHigh[],MXNHigh[],ZARHigh[],ZARLow[],CloseOch,HighOch,LowOch;
double GBPLow[],JPYLow[],AUDLow[],CHFLow[],CADLow[],NOKLow[],SEKLow[];
//---- buffers

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   
       SetIndexBuffer(0,EURClose);               // Assigning an array to a buffer
   //    SetIndexBuffer(0,EURHigh);              // Assigning an array to a buffer
   //    SetIndexBuffer(0,EURLow);               // Assigning an array to a buffer
       SetIndexStyle (0,DRAW_LINE,STYLE_SOLID,2);//   Line style
       SetIndexBuffer(1,USDClose);               // Assigning an array to a buffer
   //    SetIndexBuffer(1,USDHigh);              // Assigning an array to a buffer
   //    SetIndexBuffer(1,USDLow);               // Assigning an array to a buffer
       SetIndexStyle (1,DRAW_LINE,STYLE_SOLID,2);//   Line style
       SetIndexBuffer(2,EURUSDClose);            // Assigning an array to a buffer
   //    SetIndexBuffer(2,EURUSDHigh);           // Assigning an array to a buffer
   //    SetIndexBuffer(2,EURUSDLow);            // Assigning an array to a buffer
       SetIndexStyle (2,DRAW_LINE,STYLE_SOLID,2);//   Line style
       
       ArrayResize(GL, LengthSample+1);
       ArrayResize(EURClose, LengthSample);
       ArrayResize(USDClose, LengthSample);
       ArrayResize(GBPClose, LengthSample);
       ArrayResize(JPYClose, LengthSample);
       ArrayResize(AUDClose, LengthSample);
       ArrayResize(CHFClose, LengthSample);
       ArrayResize(CADClose, LengthSample);
       ArrayResize(NOKClose, LengthSample);
       ArrayResize(SEKClose, LengthSample);
       ArrayResize(DKKClose, LengthSample);
       ArrayResize(NZDClose, LengthSample);
       ArrayResize(SGDClose, LengthSample);
       ArrayResize(HKDClose, LengthSample);
       ArrayResize(MXNClose, LengthSample);
       ArrayResize(ZARClose, LengthSample);       
       ArrayResize(EURHigh, LengthSample);
       ArrayResize(USDHigh, LengthSample);       
       ArrayResize(GBPHigh, LengthSample);
       ArrayResize(JPYHigh, LengthSample);
       ArrayResize(AUDHigh, LengthSample);
       ArrayResize(CHFHigh, LengthSample);
       ArrayResize(CADHigh, LengthSample);
       ArrayResize(NOKHigh, LengthSample);
       ArrayResize(SEKHigh, LengthSample);
       ArrayResize(DKKHigh, LengthSample);
       ArrayResize(NZDHigh, LengthSample);
       ArrayResize(SGDHigh, LengthSample);
       ArrayResize(HKDHigh, LengthSample);
       ArrayResize(MXNHigh, LengthSample);
       ArrayResize(ZARHigh, LengthSample);
       ArrayResize(EURLow, LengthSample);
       ArrayResize(USDLow, LengthSample);
       ArrayResize(GBPLow, LengthSample);
       ArrayResize(JPYLow, LengthSample);
       ArrayResize(AUDLow, LengthSample);
       ArrayResize(CHFLow, LengthSample);
       ArrayResize(CADLow, LengthSample);
       ArrayResize(NOKLow, LengthSample);
       ArrayResize(SEKLow, LengthSample);
       ArrayResize(DKKLow, LengthSample);
       ArrayResize(NZDLow, LengthSample);
       ArrayResize(SGDLow, LengthSample);
       ArrayResize(HKDLow, LengthSample);
       ArrayResize(MXNLow, LengthSample);
       ArrayResize(ZARLow, LengthSample);
       ArrayResize(EURUSDClose, LengthSample); 
       ArrayResize(EURUSDHigh, LengthSample);      
       ArrayResize(EURUSDLow, LengthSample);
       

//----

   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 

//----
   return(0);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
//
int start()
    {//1

   for (i=0; i<=LengthSample; i++)                    
     {//2
       GL[i][0]=  iClose("EURUSD",0,i); 
       GL[i][1]=  iClose("EURGBP",0,i); 
       GL[i][2]=  iClose("EURJPY",0,i); 
       GL[i][3]=  iClose("EURAUD",0,i); 
       GL[i][4]=  iClose("EURCHF",0,i); 
       GL[i][5]=  iClose("EURCAD",0,i); 
       GL[i][6]=  iClose("EURNOK",0,i); 
       GL[i][7]=  iClose("EURSEK",0,i); 
       GL[i][8]=  iClose("EURDKK",0,i); 
       GL[i][9]=  iClose("EURNZD",0,i); 
       GL[i][10]= iClose("EURSGD",0,i); 
       GL[i][11]= iClose("EURHKD",0,i); 
       GL[i][12]= iClose("USDCHF",0,i); 
       GL[i][13]= iClose("USDJPY",0,i); 
       GL[i][14]= iClose("USDCAD",0,i); 
       GL[i][15]= iClose("USDNOK",0,i); 
       GL[i][16]= iClose("USDSEK",0,i); 
       GL[i][17]= iClose("USDDKK",0,i); 
       GL[i][18]= iClose("USDSGD",0,i); 
       GL[i][19]= iClose("USDHKD",0,i);
       GL[i][20]= iClose("USDMXN",0,i); 
       GL[i][21]= iClose("USDZAR",0,i); 
       GL[i][22]= iClose("GBPUSD",0,i); 
       GL[i][23]= iClose("AUDUSD",0,i); 
       GL[i][24]= iClose("NZDUSD",0,i); 
       GL[i][25]= GL[i][0]*GL[i][20];  //Close"EURMXN"
       GL[i][26]= GL[i][0]*GL[i][21];  //Close"EURZAR"
       GL[i][27]= iHigh ("EURUSD",0,i); 
       GL[i][28]= iHigh ("EURGBP",0,i); 
       GL[i][29]= iHigh ("EURJPY",0,i); 
       GL[i][30]= iHigh ("EURAUD",0,i); 
       GL[i][31]= iHigh ("EURCHF",0,i); 
       GL[i][32]= iHigh ("EURCAD",0,i); 
       GL[i][33]= iHigh ("EURNOK",0,i); 
       GL[i][34]= iHigh ("EURSEK",0,i); 
       GL[i][35]= iHigh ("EURDKK",0,i); 
       GL[i][36]= iHigh ("EURNZD",0,i); 
       GL[i][37]= iHigh ("EURSGD",0,i); 
       GL[i][38]= iHigh ("EURHKD",0,i); 
       GL[i][39]= iHigh ("USDCHF",0,i); 
       GL[i][40]= iHigh ("USDJPY",0,i); 
       GL[i][41]= iHigh ("USDCAD",0,i); 
       GL[i][42]= iHigh ("USDNOK",0,i); 
       GL[i][43]= iHigh ("USDSEK",0,i); 
       GL[i][44]= iHigh ("USDDKK",0,i); 
       GL[i][45]= iHigh ("USDSGD",0,i); 
       GL[i][46]= iHigh ("USDHKD",0,i);
       GL[i][47]= iHigh ("USDMXN",0,i); 
       GL[i][48]= iHigh ("USDZAR",0,i); 
       GL[i][49]= iHigh ("GBPUSD",0,i); 
       GL[i][50]= iHigh ("AUDUSD",0,i); 
       GL[i][51]= iHigh ("NZDUSD",0,i); 
       GL[i][52]= GL[i][27]*GL[i][47];  //High"EURMXN"
       GL[i][53]= GL[i][27]*GL[i][48];  //High"EURZAR"
       GL[i][54]= iLow  ("EURUSD",0,i); 
       GL[i][55]= iLow  ("EURGBP",0,i); 
       GL[i][56]= iLow  ("EURJPY",0,i); 
       GL[i][57]= iLow  ("EURAUD",0,i); 
       GL[i][58]= iLow  ("EURCHF",0,i); 
       GL[i][59]= iLow  ("EURCAD",0,i); 
       GL[i][60]= iLow  ("EURNOK",0,i); 
       GL[i][61]= iLow  ("EURSEK",0,i); 
       GL[i][62]= iLow  ("EURDKK",0,i); 
       GL[i][63]= iLow  ("EURNZD",0,i); 
       GL[i][64]= iLow  ("EURSGD",0,i); 
       GL[i][65]= iLow  ("EURHKD",0,i); 
       GL[i][66]= iLow  ("USDCHF",0,i); 
       GL[i][67]= iLow  ("USDJPY",0,i); 
       GL[i][68]= iLow  ("USDCAD",0,i); 
       GL[i][69]= iLow  ("USDNOK",0,i); 
       GL[i][70]= iLow  ("USDSEK",0,i); 
       GL[i][71]= iLow  ("USDDKK",0,i); 
       GL[i][72]= iLow  ("USDSGD",0,i); 
       GL[i][73]= iLow  ("USDHKD",0,i);
       GL[i][74]= iLow  ("USDMXN",0,i); 
       GL[i][75]= iLow  ("USDZAR",0,i); 
       GL[i][76]= iLow  ("GBPUSD",0,i); 
       GL[i][77]= iLow  ("AUDUSD",0,i); 
       GL[i][78]= iLow  ("NZDUSD",0,i); 
       GL[i][79]= GL[i][54]*GL[i][74];  //Low"EURMXN"
       GL[i][80]= GL[i][54]*GL[i][75];  //Low"EURZAR"                               
     }//2 

   for (j=0; j<27; j++)
     {//3
      Kf[j]=0;
    for (i=1; i<=LengthSample; i++)
      Kf[j]+=GL[i][j];
      Kf[j]/=LengthSample;
     }//3 
       
      CloseOch   = (GL[LengthSample][0]/Kf[0])*((Kf[0]/GL[LengthSample][0]+GL[LengthSample][12]/Kf[12]+GL[LengthSample][13]/Kf[13]
                   +GL[LengthSample][14]/Kf[14]+GL[LengthSample][15]/Kf[15]+GL[LengthSample][16]/Kf[16]+GL[LengthSample][17]/Kf[17]
                   +GL[LengthSample][18]/Kf[18]+GL[LengthSample][19]/Kf[19]+GL[LengthSample][20]/Kf[20]+GL[LengthSample][21]/Kf[21]
                   +Kf[22]/GL[LengthSample][22]+Kf[23]/GL[LengthSample][23]
                   +Kf[24]/GL[LengthSample][24])/14)/((GL[LengthSample][0]/Kf[0]
                   +GL[LengthSample][1]/Kf[1]+GL[LengthSample][2]/Kf[2]+GL[LengthSample][3]/Kf[3]+GL[LengthSample][4]/Kf[4]
                   +GL[LengthSample][5]/Kf[5]+GL[LengthSample][6]/Kf[6]+GL[LengthSample][7]/Kf[7]+GL[LengthSample][8]/Kf[8]
                   +GL[LengthSample][9]/Kf[9]+GL[LengthSample][10]/Kf[10]+GL[LengthSample][11]/Kf[11]+GL[LengthSample][25]/Kf[25]
                   +GL[LengthSample][26]/Kf[26])/14); 

      HighOch    = (GL[LengthSample][27]/Kf[0])*((Kf[0]/GL[LengthSample][27]+GL[LengthSample][39]/Kf[12]+GL[LengthSample][40]/Kf[13]
                   +GL[LengthSample][41]/Kf[14]+GL[LengthSample][42]/Kf[15]+GL[LengthSample][43]/Kf[16]+GL[LengthSample][44]/Kf[17]
                   +GL[LengthSample][45]/Kf[18]+GL[LengthSample][46]/Kf[19]+GL[LengthSample][47]/Kf[20]+GL[LengthSample][48]/Kf[21]
                   +Kf[22]/GL[LengthSample][49]+Kf[23]/GL[LengthSample][50]
                   +Kf[24]/GL[LengthSample][51])/14)/((GL[LengthSample][27]/Kf[0]
                   +GL[LengthSample][28]/Kf[1]+GL[LengthSample][29]/Kf[2]+GL[LengthSample][30]/Kf[3]+GL[LengthSample][31]/Kf[4]
                   +GL[LengthSample][32]/Kf[5]+GL[LengthSample][33]/Kf[6]+GL[LengthSample][34]/Kf[7]+GL[LengthSample][35]/Kf[8]
                   +GL[LengthSample][36]/Kf[9]+GL[LengthSample][37]/Kf[10]+GL[LengthSample][38]/Kf[11]+GL[LengthSample][52]/Kf[25]
                   +GL[LengthSample][53]/Kf[26])/14);
      
      LowOch     = (GL[LengthSample][54]/Kf[0])*((Kf[0]/GL[LengthSample][54]+GL[LengthSample][66]/Kf[12]+GL[LengthSample][67]/Kf[13]
                   +GL[LengthSample][68]/Kf[14]+GL[LengthSample][69]/Kf[15]+GL[LengthSample][70]/Kf[16]+GL[LengthSample][71]/Kf[17]
                   +GL[LengthSample][72]/Kf[18]+GL[LengthSample][73]/Kf[19]+GL[LengthSample][74]/Kf[20]+GL[LengthSample][75]/Kf[21]
                   +Kf[22]/GL[LengthSample][76]+Kf[23]/GL[LengthSample][77]+Kf[24]/GL[LengthSample][78])/14)/((GL[LengthSample][54]/Kf[0]
                   +GL[LengthSample][55]/Kf[1]+GL[LengthSample][56]/Kf[2]+GL[LengthSample][57]/Kf[3]+GL[LengthSample][58]/Kf[4]
                   +GL[LengthSample][59]/Kf[5]+GL[LengthSample][60]/Kf[6]+GL[LengthSample][61]/Kf[7]+GL[LengthSample][62]/Kf[8]
                   +GL[LengthSample][63]/Kf[9]+GL[LengthSample][64]/Kf[10]+GL[LengthSample][65]/Kf[11]+GL[LengthSample][79]/Kf[25]
                   +GL[LengthSample][80]/Kf[26])/14);
      
   for (i=LengthSample-1; i>=0; i--)
     {//4
      EURUSDClose[i]= GL[i][0]/Kf[0];

      EURClose[i]= (GL[i][0]/Kf[0]+GL[i][1]/Kf[1]+GL[i][2]/Kf[2]+GL[i][3]/Kf[3]+GL[i][4]/Kf[4]+GL[i][5]/Kf[5]+GL[i][6]/Kf[6]
                   +GL[i][7]/Kf[7]+GL[i][8]/Kf[8]+GL[i][9]/Kf[9]+GL[i][10]/Kf[10]+GL[i][11]/Kf[11]+GL[i][25]/Kf[25]
                   +GL[i][26]/Kf[26]+CloseOch)/14; 
                   
      USDClose[i]= (Kf[0]/GL[i][0]+GL[i][12]/Kf[12]+GL[i][13]/Kf[13]+GL[i][14]/Kf[14]+GL[i][15]/Kf[15]+GL[i][16]/Kf[16]
                   +GL[i][17]/Kf[17]+GL[i][18]/Kf[18]+GL[i][19]/Kf[19]+GL[i][20]/Kf[20]+GL[i][21]/Kf[21]+Kf[22]/GL[i][22]
                   +Kf[23]/GL[i][23]+Kf[24]/GL[i][24]+CloseOch)/14;
      
      CloseOch   = EURUSDClose[i]*USDClose[i]/EURClose[i];      
      GBPClose[i]= (Kf[1]*EURClose[i]/GL[i][1]+GL[i][22]*USDClose[i]/Kf[22])/2;                                                                 
      JPYClose[i]= (Kf[2]*EURClose[i]/GL[i][2]+Kf[13]*USDClose[i]/GL[i][13])/2;       
      AUDClose[i]= (Kf[3]*EURClose[i]/GL[i][3]+GL[i][23]*USDClose[i]/Kf[23])/2;       
      CHFClose[i]= (Kf[4]*EURClose[i]/GL[i][4]+Kf[12]*USDClose[i]/GL[i][12])/2;      
      CADClose[i]= (Kf[5]*EURClose[i]/GL[i][5]+Kf[14]*USDClose[i]/GL[i][14])/2;      
      NOKClose[i]= (Kf[6]*EURClose[i]/GL[i][6]+Kf[15]*USDClose[i]/GL[i][15])/2;      
      SEKClose[i]= (Kf[7]*EURClose[i]/GL[i][7]+Kf[16]*USDClose[i]/GL[i][16])/2;      
      DKKClose[i]= (Kf[8]*EURClose[i]/GL[i][8]+Kf[17]*USDClose[i]/GL[i][17])/2;      
      NZDClose[i]= (Kf[9]*EURClose[i]/GL[i][9]+GL[i][24]*USDClose[i]/Kf[24])/2;      
      SGDClose[i]= (Kf[10]*EURClose[i]/GL[i][10]+Kf[18]*USDClose[i]/GL[i][18])/2;      
      HKDClose[i]= (Kf[11]*EURClose[i]/GL[i][11]+Kf[19]*USDClose[i]/GL[i][19])/2;      
      MXNClose[i]= (Kf[25]*EURClose[i]/GL[i][25]+Kf[20]*USDClose[i]/GL[i][20])/2;      
      ZARClose[i]= (Kf[26]*EURClose[i]/GL[i][26]+Kf[21]*USDClose[i]/GL[i][21])/2;      
      EURUSDHigh[i] = GL[i][27]/Kf[0];                   
      EURHigh[i] = (GL[i][27]/Kf[0]+GL[i][28]/Kf[1]+GL[i][29]/Kf[2]+GL[i][30]/Kf[3]+GL[i][31]/Kf[4]+GL[i][32]/Kf[5]
                   +GL[i][33]/Kf[6]+GL[i][34]/Kf[7]+GL[i][35]/Kf[8]+GL[i][36]/Kf[9]+GL[i][37]/Kf[10]+GL[i][38]/Kf[11]
                   +GL[i][52]/Kf[25]+GL[i][53]/Kf[26]+HighOch)/14; 
                 
      USDHigh[i] = (Kf[0]/GL[i][27]+GL[i][39]/Kf[12]+GL[i][40]/Kf[13]+GL[i][41]/Kf[14]+GL[i][42]/Kf[15]+GL[i][43]/Kf[16]
                   +GL[i][44]/Kf[17]+GL[i][45]/Kf[18]+GL[i][46]/Kf[19]+GL[i][47]/Kf[20]+GL[i][48]/Kf[21]+Kf[22]/GL[i][49]
                   +Kf[23]/GL[i][50]+Kf[24]/GL[i][51]+HighOch)/14;             
      
      HighOch    = EURUSDHigh[i]*USDHigh[i]/EURHigh[i];      
      GBPHigh[i] = (Kf[1]*EURHigh[i]/GL[i][28]+GL[i][49]*USDHigh[i]/Kf[22])/2;                                                                 
      JPYHigh[i] = (Kf[2]*EURHigh[i]/GL[i][29]+Kf[13]*USDHigh[i]/GL[i][40])/2;       
      AUDHigh[i] = (Kf[3]*EURHigh[i]/GL[i][30]+GL[i][50]*USDHigh[i]/Kf[23])/2;       
      CHFHigh[i] = (Kf[4]*EURHigh[i]/GL[i][31]+Kf[12]*USDHigh[i]/GL[i][39])/2;      
      CADHigh[i] = (Kf[5]*EURHigh[i]/GL[i][32]+Kf[14]*USDHigh[i]/GL[i][41])/2;      
      NOKHigh[i] = (Kf[6]*EURHigh[i]/GL[i][33]+Kf[15]*USDHigh[i]/GL[i][42])/2;      
      SEKHigh[i] = (Kf[7]*EURHigh[i]/GL[i][34]+Kf[16]*USDHigh[i]/GL[i][43])/2;      
      DKKHigh[i] = (Kf[8]*EURHigh[i]/GL[i][35]+Kf[17]*USDHigh[i]/GL[i][44])/2;      
      NZDHigh[i] = (Kf[9]*EURHigh[i]/GL[i][36]+GL[i][51]*USDHigh[i]/Kf[24])/2;      
      SGDHigh[i] = (Kf[10]*EURHigh[i]/GL[i][37]+Kf[18]*USDHigh[i]/GL[i][45])/2;      
      HKDHigh[i] = (Kf[11]*EURHigh[i]/GL[i][38]+Kf[19]*USDHigh[i]/GL[i][46])/2;      
      MXNHigh[i] = (Kf[25]*EURHigh[i]/GL[i][52]+Kf[20]*USDHigh[i]/GL[i][47])/2;      
      ZARHigh[i] = (Kf[26]*EURHigh[i]/GL[i][53]+Kf[21]*USDHigh[i]/GL[i][48])/2;
            
      EURUSDLow[i]  = GL[i][54]/Kf[0];      
      EURLow[i]  = (GL[i][54]/Kf[0]+GL[i][55]/Kf[1]+GL[i][56]/Kf[2]+GL[i][57]/Kf[3]+GL[i][58]/Kf[4]+GL[i][59]/Kf[5]
                   +GL[i][60]/Kf[6]+GL[i][61]/Kf[7]+GL[i][62]/Kf[8]+GL[i][63]/Kf[9]+GL[i][64]/Kf[10]+GL[i][65]/Kf[11]
                   +GL[i][79]/Kf[25]+GL[i][80]/Kf[26]+LowOch)/14; 
                   
      USDLow[i]  = (Kf[0]/GL[i][54]+GL[i][66]/Kf[12]+GL[i][67]/Kf[13]+GL[i][68]/Kf[14]+GL[i][69]/Kf[15]+GL[i][70]/Kf[16]
                   +GL[i][71]/Kf[17]+GL[i][72]/Kf[18]+GL[i][73]/Kf[19]+GL[i][74]/Kf[20]+GL[i][75]/Kf[21]+Kf[22]/GL[i][76]
                   +Kf[23]/GL[i][77]+Kf[24]/GL[i][78]+LowOch)/14;
      
      LowOch     = EURUSDLow[i]*USDLow[i]/EURLow[i];      
      GBPLow[i]  = (Kf[1]*EURLow[i]/GL[i][55]+GL[i][76]*USDLow[i]/Kf[22])/2;                                                                 
      JPYLow[i]  = (Kf[2]*EURLow[i]/GL[i][56]+Kf[13]*USDLow[i]/GL[i][67])/2;       
      AUDLow[i]  = (Kf[3]*EURLow[i]/GL[i][57]+GL[i][77]*USDLow[i]/Kf[23])/2;       
      CHFLow[i]  = (Kf[4]*EURLow[i]/GL[i][58]+Kf[12]*USDLow[i]/GL[i][66])/2;      
      CADLow[i]  = (Kf[5]*EURLow[i]/GL[i][59]+Kf[14]*USDLow[i]/GL[i][68])/2;      
      NOKLow[i]  = (Kf[6]*EURLow[i]/GL[i][60]+Kf[15]*USDLow[i]/GL[i][69])/2;      
      SEKLow[i]  = (Kf[7]*EURLow[i]/GL[i][61]+Kf[16]*USDLow[i]/GL[i][70])/2;      
      DKKLow[i]  = (Kf[8]*EURLow[i]/GL[i][62]+Kf[17]*USDLow[i]/GL[i][71])/2;      
      NZDLow[i]  = (Kf[9]*EURLow[i]/GL[i][63]+GL[i][78]*USDLow[i]/Kf[24])/2;      
      SGDLow[i]  = (Kf[10]*EURLow[i]/GL[i][64]+Kf[18]*USDLow[i]/GL[i][72])/2;      
      HKDLow[i]  = (Kf[11]*EURLow[i]/GL[i][65]+Kf[19]*USDLow[i]/GL[i][73])/2;      
      MXNLow[i]  = (Kf[25]*EURLow[i]/GL[i][79]+Kf[20]*USDLow[i]/GL[i][74])/2;      
      ZARLow[i]  = (Kf[26]*EURLow[i]/GL[i][80]+Kf[21]*USDLow[i]/GL[i][75])/2;      
     }//4  

   return(0);

     }//1
//+------------------------------------------------------------------+

Für den korrekten Betrieb des Terminals, sollten alle darin verwendeten Währungspaare mit dem gleichen Zeitrahmen heruntergeladen werden.

In der Schleife, die durch "//2" begrenzt ist, werden die Daten von allen Währungspaaren heruntergeladen, die vom Indikator mit der Hilfe von drei Funktionen verwendet werden: iClose, iHigh, iLow. In der Schleife, die durch "//3" begrenzt ist, werden die Skalierungsverhältnisse für alle Symbole berechnet. Weitere Kompensationsfehler auf dem LengthSample Balken werden berechnet. In der Schleife, die durch "//4" begrenzt ist, werden alle Landeswährungen entsprechend dem obigen Algorithmus, sowie auch die Kompensationsfehler auf diesem Balken berechnet.

Sollte es notwendig sein, die berechneten Daten nicht in einem separaten Fenster, sondern im Hauptchartfenster anzuzeigen, dann sollten die Werte der berechneten Währung mit dem Skalierungsverhältnis, das von EURUSD erhalten wurde, multipliziert werden; außerdem sollte #property indicator_separate_window durch #property indicator_chart_window ersetzt werden. Abb. 6 zeigt das Ergebnis einer solchen Berechnung. EUR – rosa, USD – blau, GBP – rot, JPY – braun, AUD – lila, CHF – gelb, CAD – schwarz.

Abb.6



Fazit

Die dargestellte Methode zur Berechnung der nationalen Währungen ist universell und kann in ähnlicher Weise für andere Symbole verwendet werden. Außerdem ermöglicht sie Währungspaare zu synthetisieren, die nicht in Ihrem Brokerage-Unternehmen angeführt sind. Auch können Sie damit einige exotische Währungspaare erhalten, die gar nicht existieren. All dies, zusammen mit der Extraktion der nationalen Währungen aus Währungspaaren wird den informativen Charakter der Symbole erhöhen, die Sie verwenden. Dadurch können Sie die Marktbedingungen genauer einschätzen und verschiedene effiziente Handelsstrategien entwerfen.

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

Beigefügte Dateien |
SuperPosition.mq4 (17.57 KB)
Dateioperationen über WinAPI Dateioperationen über WinAPI

Die Umgebung MQL4 basiert auf der Konzeption der sicheren "Sandbox": Lesen und Speichern von Dateien mit der Sprache ist nur in einigen vo0rdefinierten Ordnern zulässig. Dies schützt den Benutzer von MetaTrader 4 vor der potentiellen Gefahr wichtige Daten auf der Festplatte zu beschädigen. Manchmal ist es jedoch notwendig diesen sicheren Bereich zu verlassen. Dieser Artikel widmet sich dem Problem, wie man es einfach und richtig macht.

Expert Advisors Basierend auf Beliebten Handelssystemen und Alchemie der Handelsroboter Optimierung (Forts.) Expert Advisors Basierend auf Beliebten Handelssystemen und Alchemie der Handelsroboter Optimierung (Forts.)

In diesem Artikel gibt der Autor ein Beispiel eines Expert Advisors, der den Anforderungen gemäß den Regeln der Automated Trading Championship 2008 entspricht

Baukasten des Händlers: Gestaltung der Indikatoren Baukasten des Händlers: Gestaltung der Indikatoren

In diesem Artikel finden Sie die wichtigsten Aufgaben, die es zu erledigen gilt, wenn es um die Gestaltung von Indikatoren geht, sowie auch Lösungen und Automatisierungen dafür.

Ein Muster Trailing Stop und Ausstieg aus dem Markt Ein Muster Trailing Stop und Ausstieg aus dem Markt

Entwickler von Order Modifizierung-/Schluss-Algorithmen leiden unter einem unvergänglichen Kummer - wie vergleicht man Ergebnisse, die man durch unterschiedliche Methoden erhalten hat? Der Mechanismus der Prüfung ist bekannt - es ist der Strategietester. Aber wie macht man einen EA zum gleichen Öffnen/Schließen von Ordern? Der Artikel beschreibt ein Werkzeug, das starke Wiederholung von Order-Öffnungen bietet, die es uns ermöglichen eine mathematisch korrekte Plattform zu pflegen, um verschiedene Algorithmen für Trailing Stops und für den Austritt aus dem Markt zu vergleichen.