Grundsätze der Zeit-Transformation im Intraday-Trading

Einführung

Statistische Homogenität spielt immer eine wichtige Rolle bei der Analyse früherer Kursbewegungen. Wenn eine solche Homogenität erfolgt, ist es möglich die Prozesseigenschaften zur Offenlegung der Regelmäßigkeiten, die zum Aufbau eines Handelssystems beitragen, eingehend zu studieren. Es ist aber eine weit bekannte Tatsache, und es wird später nachgewiesen, dass auch bei der ersten Annäherung an den Prozess der Wechselkurs nicht homogen ist. Es gibt nämlich eine Heterogenität, verbunden mit der Aktivität von unterschiedlichem Handelszeiten: amerikanische, europäische, asiatische und wechseln zwischen ihnen.

Ich wage zu behaupten, dass wenige der neuen Systementwickler und nicht alle der "Erfahrenen" jemals denken, dass auch die einfachsten Indikatoren der Moving Avarage Sorte, gebunden an Zeit, tatsächlich unterschiedliche Einheiten an verschiedenen Zeiten des Tages sind. Ein typisches Beispiel - Syteme basierend auf Renko und Kagi Methoden, aber sie sind in der Minderheit. Ich wiederhole aber, die Mehrheit von ihnen ist an Zeit gebunden, in der Regel indirekt - über Indikatoren.

Alles oben bezieht sich offensichtlich nur auf Intraday-Systeme. Bei größeren Zeitrahmen, auch bei saisonalen Schwankungen, ist es nicht so offensichtlich. Und im Intraday-Handel ist es das und führt sehr oft zu der Tatsache, dass das System die unterschiedliche Rentabilität an verschiedenen Zeiten zeigt. Lassen Sie uns bei den Faktoren verweilen, die einen solchen Effekt verursachen, und den Wegen um sie zu überwinden.

Theorie

Aus der Sicht der zufälligen Prozess-Statistik, wird der Prozess der Kursänderung bei einer ersten Annäherung in der Regel als eine bestimmte Diffusionsart behandelt, d.h. Transfer einer Substanz oder Energie aus einem Bereich mit hoher Konzentration, in einen Bereich mit niedriger Konzentration. Es ist bekannt, dass die Zeit-Transformation kontinuierliche Martingales zu einer relativ leicht angelegten Brownschen Bewegung bringt.

Ohne bei der Frage zu verweilen, ob der Vorgang der Preisänderung eine Diffusion oder Martingale ist, lassen Sie uns anmerken, dass uns nicht daran hindert auf die gleiche Art von dem Prozess der Zeit-Transformation zu etwas geordnetem auf eine einfachere Art zu wechseln, nämlich zu einem statistisch in der Zeit homogenen Vorgang. Zu diesem Zweck wäre es natürlich Balken nicht mit einer Zeiteinteilung zu verwenden, sondern einfach mit einer festen Anzahl an Ticks., z.B. ein Balken enthält nicht 60 Minuten, sondern zum Beispiel 1.000 Ticks.

In der Theorie wird eine solche Zeit operativ genannt und ist natürlich für den Vorgang der Zeit-Transformation. In diesem Fall hat der Prozess eine statistisch konstante Abweichung, die es ermöglich die sich formende Marktatmosphäre klarer zu erkennen und effizient von zufälligen Marktschwankungen zu trennen. Und beachten Sie, dass die Verwendung gemeinsamer Indikatoren nicht nur möglich wäre, sondern auch viel homogener. Aber leider beinhaltet MetaTrader 4 eine solche Funktion bisher nicht. Also werden wie eine andere Methode verwenden - das System neu anordnen mit einem Ausgleich für die Zeit. Im Folgenden sind Beispiele geänderter Indikatoren. Lassen Sie uns aber zuerst die Heterogenität analysieren, über die wir sprechen.

Statistische Daten

Ein Chart von exotischen Währungspaaren zeigt anschaulich, dass die Aktivität auf dem Markt an bestimmten Teilen des Tages reduziert ist. Zum Beispiel:

Darüber hinaus werden die gleichen Effekte bei beliebten Währungspaaren beobachtet. Das weckt Interesse an einer eingehenderen Prüfung des Volumen und Volatilität-Verhaltens. Es ist klar, dass für ein besseres Verständnis der Volatilitätsschwankungen, das Verhalten des Volumen von entscheidender Bedeutung ist, z.B. Ticks in einem Balken. Aber wenn das Volumen selbst ein zufälliger Wert ist, müssen wir uns auf den historischen Durchschnitt beziehen. Solche Referenzen erscheinen nicht sehr gesetzmäßig, wenn statistisches "Rohmaterial" auf dem "falschen" Weg ist.

Lassen Sie uns einen einfachen Indikator zum Überprüfen dieser Hypothesen schreiben - ExpectedVolume, der die historische Durchschnittsmenge an Ticks pro Stunde finden wird, histSteps frühere Schritte, jeder Schritt ist span Tage lang. Typischer Wert dieser Parameter ist demnach 100 und 1. Das Testen wird durchgeführt in dem Zeitrahmen H1, bei anderen Intraday-Zeitrahmen sollten die Parameter geändert werden. Hier ist Ihr Indikator-Code:

//+------------------------------------------------------------------+
//|                                             Expected Volumes.mq4 |
//|                                     Copyright © 2007, Amir Aliev |
//|                                       http://finmat.blogspot.com/ |
//+------------------------------------------------------------------+
#property  copyright "Copyright © 2007, Amir Aliev"
#property  link      "http://finmat.blogspot.com/"
//---- 
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Blue
//---- input parameters
extern int hist_steps = 100;      // Number of observations
extern int span = 1;              // Days to step back each time 
//---- buffers
double ExtMapBuffer1[];
int sum;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   string short_name;
//---- indicators
   SetIndexStyle(0, DRAW_HISTOGRAM);
   SetIndexBuffer(0,ExtMapBuffer1);
//----
   short_name = "Expected volumes(" + hist_steps + ")";
   IndicatorShortName(short_name);
   SetIndexLabel(0, short_name);
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int counted_bars = IndicatorCounted();
   int rest = Bars - counted_bars;
   int j, k, u;
//----     
   while(rest >= 0)
     {
      if(Bars - rest < span * 23 * hist_steps) 
        {
         ExtMapBuffer1[rest] = 0;     
         rest--; 
         continue;                                   
        }
      sum = 0;
      j = 0;
      k = 0;
      u = 0;
      while(j < hist_steps && k < Bars) 
        {
         if(TimeHour(Time[rest+k]) == TimeHour(Time[rest]))
           {
            u++;
            if(u == span)
              {
               u = 0;
               j++;
               sum += Volume[rest + k]; 
              }
            k += 23;
           }
         k++;
        }
      ExtMapBuffer1[rest] = sum / hist_steps;     
      rest--;                                    
     }
//----
   return(0);
  }
//+------------------------------------------------------------------+

Zur Überprüfung der statistischen Homogenität sollten die Beobachtungen noch unabhängig sein - für Beispiele unterteilt in Wochentage. Zu diesem Zwecke geben sie span=5 an. Sie erhalten das Folgende:

Die benachbarten Höcker sind fast identisch. Das bedeutet, die Volatilität, bewertet in Ticks, ist statistisch homogen. Die Struktur dieser Volatilität ist klar von den Bildern unten (das linke - EURUSD, das rechte - USDJPY):

Sie zeigen anschaulich die Aktivität zu Handelszeiten - asiatische, europäische und amerikanische. Es sollte angemerkt werden, dass die Unterteilung genau in diese Handelszeiten nicht konventionell ist - Manchmal werden auch andere Handelszeiten hervorgehoben. Nun, wir können einige Besonderheiten feststellen, zum Beispiel den Aktivitätscharakter während der amerikanischen Handelszeit (wird in beiden Charts wederholt).

Ändern von Indikatoren

Wenn Indikatoren geändert werden ist es sehr wichtig zu verstehen, wie genau die Zeit in sie inbegriffen ist. Bei einfachen Indikatoren, wie den Moving Average, ist dies sehr einfach, während es sehr schwer ist, zum Beispiel, einen Alligator zu ändern.

Letztendlich wäre es rationaler einen "operativen" Zeitrahmen zu präsentieren. Aber lassen Sie uns versuchen einige einfache Indikatoren zu ändern. Der primitivste von ihnen ist korrigiertes Volumen - tatsächliche Volumina werden dividiert durch erwartete. Also reflektiert die Abweichung auf dieser oder jener Seite von 1 des Indikators die gestiegene/gefallene Aktivität am Markt. Der Code ist sehr einfach. Er ist in einer an diesen Artikel angehängten Datei enthalten.

Das nächste Beispiel ist Durchschnitt. Eigentlich müssen wir nur noch die Balkencharakteristik gewichten, danach wie der Durchschnitt aufgebaut ist (zum Beispiel Öffnen), durch die Menge an Ticks innerhalb des Balkens. Die endgültige Zahl ist nicht genau gleich der Summe von Preisen an allen Ticks. Für eine präzisere Einschätzung müssen wir nicht 'Öffnen' nehmen, sondern einen gewichteten Durchschnitt auf einem Balken. Der Indikator ist brachial gebaut, und deshalb benötigt die Berechnung erheblichen und eigentlich unnötigen Rechenaufwand. Deshalb wird ein weiterer Parameter hinzugefügt - die Menge an Balken aus der Vergangenheit, die ein Indikator zeichnen wird, ist standardmäßig 500. Darüber hinaus wird der Zeitraum des Durchschnitts nit im Balken eingestellt, sondern in der Menge der Ticks. Hier ist ein Code:

//+------------------------------------------------------------------+
//|                                                Corrected SMA.mq4 |
//|                                      Copyright © 2007, Amir Aliev |
//|                                    http://finmat.blogspot.com/   |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Amir Aliev"
#property link      "http://finmat.blogspot.com/"
//----
#property indicator_chart_window
#property indicator_color1 Red
//---- input parameters
extern int MA_Ticks = 10000;
extern int MA_Shift = 0;
extern int MA_Start = 500;
//---- indicator buffers
double ExtMapBuffer[];
double ExpVolBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//----
   SetIndexStyle(0, DRAW_LINE);
   SetIndexShift(0, MA_Shift);
   IndicatorBuffers(2);
//---- indicator buffers mapping
   SetIndexBuffer(0, ExtMapBuffer);
   SetIndexBuffer(1, ExpVolBuffer);
   SetIndexDrawBegin(0, 0);  
//---- initialization done
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int counted_bars = IndicatorCounted();
   int rest  = Bars - counted_bars;
   int restt = Bars - counted_bars;
   double sum;                               
   int ts;                                   
   int evol;                                 
   int volsum;
   int j;
//----
   while(restt >= 0)
     {
       volsum = 0;
       for(int k = 0; k < 30; k++) 
           volsum += iVolume(NULL, 0, restt + k*24); 
       ExpVolBuffer[restt] = volsum / 30;
       restt--;
     }
//----
   while(ExpVolBuffer[rest] == 0 && rest >= 0) 
       rest--;
   rest -= MA_Ticks / 200;
   if(rest > MA_Start) 
       rest = MA_Start;  
//----
   while(rest >= 0)
     {
       sum = 0;
       ts = 0;
       j = rest;
       while(ts < MA_Ticks)
         {
           evol = ExpVolBuffer[j];
           Print("Evol = ", evol);
           if(ts + evol < MA_Ticks)
             {
               sum += evol * Open[j];
               ts += evol;
             }
           else
             {
               sum += (MA_Ticks - ts) * Open[j];
               ts = MA_Ticks;
             }
           j++;
         }
       ExtMapBuffer[rest] = sum / MA_Ticks;
       rest--;
     }   
//----
   return(0);
  }
//+------------------------------------------------------------------+

Nachdem die einfachen Indikatoren geschrieben sind, wird es kein Problem mehr sein komplexere zu ändern. So sollte zum Beispiel im MACD ein angepasster gleitender Mittelwert verwendet werden, statt einem einfachen. Der entsprechende Code ist ebenfalls im Anhang angegeben.

Es sollte beachtet werden, dass für eine schnelle Berechnung des angepassten Durchschnitts, der empirische Durchschnitt an Ticks pro Stunde einmal berechnet werden sollte, und natürlich nicht auf die Schnelle, um Neuberechnungen zu vermeiden. Hier wurde darauf verzichtet, aber wenn wir ein vollumfassendes Testen/Optimieren auf einer Historie durchführen, rückt die Produktivität in den Vordergrund. Außerdem gibt es Liebhaber eines anderen Ansatzes zum Aufbau eines an Volumen angepassten Durchschnitt, der separat erläutert werden sollte.

Es wäre sinnlos für durchschnittliche Volumina der vorherigen Zeiträume: verfügbare Volumina als Koeffizienten zu verwenden ist ausreichend in der Durchschnittsberechnung. Hier ist ein Beispiel eines solchen Quellcodes. Dennoch sollte angemerkt werden, dass aus technischen Gründen ein solcher Durchschnitt am besten auf kurze Zeitrahmen angewendet wird, wie M1-M15.

//+------------------------------------------------------------------+
//|                                             Corrected SMA II.mq4 |
//|                                     Copyright © 2007, Amir Aliev |
//|                                       http://finmat.blogspot.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Amir Aliev"
#property link      "http://finmat.blogspot.com/"
 
#property indicator_chart_window
#property indicator_color1 Red
//---- input parameters
extern int MA_Ticks = 1000;
//---- indicator buffers
double sum = 0;                               
int ticks = 0;
bool collected = false;
bool started = false;
int fbar = 0;
double ExtMapBuffer[];
int oldRange = 0;
int lbarVol = 0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//----
   SetIndexStyle(0, DRAW_LINE);
//---- indicator buffers mapping
   SetIndexBuffer(0, ExtMapBuffer);
//---- initialization done
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int rest = Bars - IndicatorCounted();
   if(! rest) 
       return (0);
   Print("Ticks = ", ticks);
   Print("Rest = ", rest);
   Print("fbar = ", fbar);  
   rest--;
   fbar += rest;
   while(!collected && (rest >= 0))
     {
      if(ticks + Volume[rest] < MA_Ticks)
        {
         ticks += Volume[rest];
         sum += Volume[rest] * Open[rest];
         if(!started)
           {
            fbar = rest;
            started = true;
           }
         rest--;
         continue;
        } 
      collected = true;
     }
   if(! collected) 
       return (0);
 
   ticks += (Volume[rest] - lbarVol);
   sum += (Volume[rest] - lbarVol) * Open[rest];
   lbarVol = Volume[rest];
   while(ticks > MA_Ticks)
     {
       Print("fbar-- because bar ticks reaches 1000");
       ticks -= Volume[fbar];
       sum -= Volume[fbar] * Open[fbar];
       fbar--;
     }
   ExtMapBuffer[rest] = sum / ticks;
   rest--;
   while(rest >= 0)
     {
      ticks += Volume[rest];
      sum += Volume[rest] * Open[rest];
      lbarVol = Volume[rest];
      while(ticks > MA_Ticks)
        {
         Print("fbar-- because of new bar ");
         ticks -= Volume[fbar];
         sum -= Volume[fbar] * Open[fbar];
         fbar--;
        }
      ExtMapBuffer[rest] = sum / ticks;
      rest--;
     } 
//----
   return(0);
  }
//+------------------------------------------------------------------+

Allerdings meint der Autor, obwohl Verwenden dieses Indikators in manchen Fällen hilfreich sein kann, hat er im Allgemeinen eine andere Bedeutung als die in diesem Artikel beschriebene. Die Idee die Kurswerte zu berücksichtigen, wofür es einen großen "Kampf" am Markt gab, ist ziemlich künstlich, auch weil geringe Abweichungen aus technischen Gründen verursacht werden können. Außerdem scheint es nicht sinnvoll die Veränderung der Volatilität zu berücksichtigen (und das ist es, worüber wir sprechen).

Jeder dargestellte Indikator kann geändert werden um bestimmte Aufgaben zu erfüllen, z.B. Ändern eines Mittelwerts zur Berechnung der Summe der Werte innerhalb eines Balken, oder Ändern von Parametern einer Durchschnittsberechnung. Denken Sie daran, wir haben durch "Öffnen" berechnet, das visuell das Gefühl einer Verzögerung schafft - die Konzeption der Zeit-Transformation, entfernen flüchtiger Bestandteile, ermöglicht eine weite Auslegung, einschließlich der, die nicht in diesem Artikel besprochen werden, wie saisonale Volatilität.

Fazit

Es sei darauf hingewiesen, dass der Kursdurchschnitt ein sehr instabiler und schwer vorherzusagender Wert ist, die Volatilität ist, d.h. der der zweite Moment der Steigerung, aus der Sicht von Statistiken eher "angenehm" und hat eine Menge bekannter Eigenschaften, wie Clustereigenschaften, Hebeleffekt in Aktienmärkten und andere.

Deshalb ist die Konzeption der operativen Zeit selbst sehr nützlich und natürlich aus der Sicht der technischen Analyse. Natürlich, die Tatsache, dass einige Schlüsselnachrichten über die Wirtschaftssituation zu einer bestimmten Zeit veröffentlicht werden, unterbricht die Homogenität sehr sicher und ist schwer zu "verarbeiten". Aber in der Mehrzahl der Fälle ermöglicht die Verwendung der Zeit-Transformation stabilere Ergebnisse und steigende Rentabilität einer Handelsstrategie.