Moving mini-max: un nuovo indicatore per l'analisi tecnica e la sua implementazione in MQL5

Introduzione

Esiste una scienza, chiamata Finanza Quantitativa, che permette di studiare i modelli di prezzo dei derivati finanziari utilizzando i metodi della fisica teorica e matematica.

Di recente mi sono imbattuto in un articolo che descrive un nuovo indicatore per l'analisi tecnica che combina le idee della fisica quantistica e le porta nell’ambito finanziario. Mi sono interessato e ho deciso che avrei insegnato come implementare gli indicatori basati sugli articoli scientifici in MQL5.

Il Moving Mini-Max originale [2] è scritto da Z.K. Silagadze, un fisico quantistico del Budker Institute of Nuclear Physics e della Novosibirsk State University. Il link al documento e il codice sorgente MQL5 sono disponibili alla fine dell'articolo.

Indicatore

Non mi sarei mai aspettato di dirlo, ma eccomi qui a spiegare il tunneling quantistico. Dal momento che presumo che la maggior parte dei lettori non siano fisici quantistici, lo descriverò in termini semplici, sperando di non offendervi. In un primo momento definiamo in una frase l'idea alla base dell'analisi tecnica delle serie temporali finanziarie. Stiamo cercando di trovare principalmente:

• livelli di prezzo di supporto e resistenza;
• direzione delle tendenze a breve e lungo termine;
• massimi e bassi delle tendenze.

L'idea originale dell'indicatore Moving Mini-Max è quella di trovare i massimi e i bottom sul grafico utilizzando l'analogo della particella alfa quantistica che cerca di sfuggire a un nucleo. Il problema è tratto dalla teoria del decadimento alfa di George Gamov [1].

Un'immagine vale mille parole, quindi incollerò un piccolo grafico qui sotto.

 

Figura 1. Pallina quantistica immaginaria sul grafico delle serie temporali

Immagina che una pallina venga lanciata dalla cima della collina o, nel nostro caso, da una cima recente sul grafico delle serie temporali. Nella meccanica classica, questa salterà gli ostacoli e potrebbe non avere la possibilità di fermarsi davanti all'ostacolo principale, poiché potrebbe bloccarsi da qualche parte sulla strada.

Ma secondo la meccanica quantistica e la teoria del decadimento alfa, una tale pallina può avere una probabilità molto piccola, ma diversa da zero, di scavare tunnel attraverso le barriere trovando la sua strada verso il potenziale fondo del pozzo e oscillare lì.

Questo è un modo analogo di trovare un minimo locale nel grafico dei prezzi. Il documento di Z.K. Silagadze [2] suggerisce che per ridurre le complessità di calcolo, anziché risolvere un vero problema quanto-meccanico ,è sufficiente imitare il comportamento quantistico. Introdurrò prima il background matematico che viene presentato nel documento originale e, successivamente, l'implementazione in MQL5.

Sia   una serie di prezzi per qualche finestra temporale. Il Moving Mini-Max è una trasformazione non lineare della serie di prezzi: 

dove  e per   è definito come segue:

 

Come puoi vedere questa è una relazione ricorrente, cioè l'i-esimo elemento dipende dall'elemento i-1. La serie moving mini-max soddisfa la condizione di normalizzazione, cioè somma di tutti gli elementi uguale a uno

 

Le probabilità di tunneling di una pallina quantistica sono chiamate probabilità di transizione perché modellano le probabilità di attraversare strette barriere di serie di prezzi, piccoli ostacoli immaginari in discesa:

con

 

Il parametro m è una larghezza della finestra di livellamento che imita la massa (inversa) della pallina quantistica e la sua capacità di passare attraverso piccoli ostacoli. In alternativa, il moving mini-max d(si) che enfatizza i massimi locali può essere costruito inserendo il segno meno nel parametro passato alla funzione exp(): 

 

Implementazione

Dopo aver letto riguardo alla matematica he sta dietro l'indicatore, possiamo implementarlo su MQL5. Per farlo, la cosa migliore è guardare dall'ultima equazione insù. Se si sposta l'attenzione sulle variabili m e n, vedrai che questo indicatore ha bisogno dell’elemento array n + 2m della serie di prezzi per una finestra mini-max e avrà una dimensione di ritardo di m barre.

Ciò è dovuto agli indici S i+k e S i-k nel calcolo delle variabili Q. La variabile i  è incrementata da 1 a n e k è incrementata da 1 a m, quindi avremo bisogno di un buffer n+2m da cui partire. Ciò si può ottenere chiamando:

double S[];
ArrayResize(S,n+2*m);
CopyClose(Symbol(),0,0,n+2*m,S);

Questo dichiarerà l’array dei doppi, lo ridimensiona a n + 2m e copierà i valori di chiusura delle ultime barre n+2m dal grafico dei simboli corrente a partire dall'ultima barra.

Il prossimo passo è calcolare i valori Q. Se leggi attentamente la definizione vedrai che per l'i-esimo elemento della serie di prezzi analizzati dobbiamo sommare m risultati della funzione exp() con variabili di valori di prezzo. Quindi dobbiamo fare un ciclo da 1 a n che conterà tutti i valori Q:

void calcQii()
  {
   int i,k;

   for(i=0; i<n; i++)
     {
      double sqiip1=0;
      double sqiim1=0;
      double dqiip1=0;
      double dqiim1=0;

      for(k=0; k<m; k++)
        {
         sqiip1 += MathExp(2*(S[m-1+i+k]-S[i])/(S[m-1+i+k]+S[i]));
         sqiim1 += MathExp(2*(S[m-1+i-k]-S[i])/(S[m-1+i-k]+S[i]));

         dqiip1 += MathExp(-2*(S[m-1+i+k]-S[i])/(S[m-1+i+k]+S[i]));
         dqiim1 += MathExp(-2*(S[m-1+i-k]-S[i])/(S[m-1+i-k]+S[i]));       
        }
      sQiip1[i] = sqiip1;
      sQiim1[i] = sqiim1;
      dQiip1[i] = dqiip1;
      dQiim1[i] = dqiim1;

     }
  }

Come si può osservare, la funzione calcQii calcola l’i-esimo Q e i valori Q` per la finestra di prezzo osservata di dimensione n. L'array S contiene i valori di prezzo e gli sQiip1, sQiim1, dQiip1, dQiim1 sono utilizzati come variabili di calcolo intermedie di Q e Q'.

Le probabilità sono calcolate in base alle variabili Q e Q`, quindi possiamo creare un'altra funzione che va in loop da 1 a n attraverso gli array sQii e dQii:

void calcPii()
  {
   int i;

   for(i=0; i<n; i++)
     {
      sPiip1[i] = sQiip1[i] / (sQiip1[i] + sQiim1[i]);
      sPiim1[i] = sQiim1[i] / (sQiip1[i] + sQiim1[i]);
      dPiip1[i] = dQiip1[i] / (dQiip1[i] + dQiim1[i]);
      dPiim1[i] = dQiim1[i] / (dQiip1[i] + dQiim1[i]);
     }
  }

Ciò che resta è calcolare gli elementi uSi e successivamente dSi e inserire i risultati nell’array uSi e dSi 

void calcui()
  {
   int i;

   sui[0] = 1;
   dui[0] = 1;

   for(i=1; i<n; i++) 
     {
      sui[i] = (sPiim1[i]/sPiip1[i])*sui[i-1];
      dui[i] = (dPiim1[i]/dPiip1[i])*dui[i-1];
     }

   double uSum = 0;
   double dSum = 0;

   ArrayInitialize(uSi, 0.0);
   ArrayInitialize(dSi, 0.0);
   
   for(i=0; i<n; i++) { uSum+=sui[i]; dSum+=dui[i]; }
   for(i=0; i<n; i++) { uSi[n-1-i] = sui[i] / uSum; dSi[n-1-i] = dui[i] / dSum; }
 
  }

Per verificare se la condizione di normalizzazione è valida, è possibile aggiungere le seguenti righe:

   double result=0;
   for(i=0; i<n; i++) { /* Print("i = "+i+" uSi = "+uSi[i]); */ result+=uSi[i]; }

   Print("Result = "+ DoubleToString(result));

Dopo aver effettuato tutti i calcoli, dobbiamo visualizzarlo all'interno della finestra dell'indicatore. Per fare ciò, è necessario dichiarare almeno due buffer di indicatori, uno per uSi e il secondo per l'array dSi e definire il tipo di indicatore come DRAW_LINE. 

    #property indicator_separate_window

    #property indicator_buffers 2
    #property indicator_plots 2
    #property indicator_type1 DRAW_LINE
    #property indicator_type2 DRAW_LINE
    #property indicator_color1 SeaGreen
    #property indicator_color2 BlueViolet

Quindi, chiamando la funzione SetIndexBuffer(), assegniamo gli array uSi e dSi da visualizzare come INDICATOR_DATA:

   SetIndexBuffer(0,uSi,INDICATOR_DATA);
   SetIndexBuffer(1,dSi,INDICATOR_DATA);

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

   PlotIndexSetInteger(0,PLOT_SHIFT,-(m-1));
   PlotIndexSetInteger(1,PLOT_SHIFT,-(m-1));

 Figura 2. L'indicatore Moving Mini-Max implementato 

Le possibili applicazioni dell'indicatore descritto nell'articolo sono l'identificazione delle linee di supporto e resistenza e l'identificazione dei modelli grafici mediante il livellamento intrinseco dell'indicatore. Per quanto riguarda le linee di supporto e resistenza, si formano incrociando il moving mini-max delle serie di prezzi e il moving mini-max della sua media mobile.

Se il prezzo passa attraverso il massimo locale e attraversa una media mobile, abbiamo una resistenza. Dopo averlo implementato, ho visto che il metodo è soggetto ad alcuni falsi segnali. Sto quindi incollando un codice sorgente come riferimento su come inserire le linee in MQL5 usando la libreria ChartObjectsLines.mqh: 

void SR()
{
   // if price goes through local maximum and crosses a moving average draw resistance
   int i, cnt=0;
   int rCnt=CopyClose(Symbol(),0,0,n+2*m,S);
      
   for (i=n-2; i>=0; i--)
      if (uSi[i]<uSi_MA[i] && uSi[i+1]>=uSi_MA[i+1]) 
      {
      Print("Resistance at " + i);
      CChartObjectHLine *line=new CChartObjectHLine();
      line.Create(0, "MiniMaxResistanceLine:"+IntegerToString(cnt), 0, S[i]);
      line.Color(LightSkyBlue);
      line.Width(1);
      line.Background(true);
      line.Selectable(false);
      cnt++;
      }
   // if price goes through local minimum and crosses a moving average draw support

   for (i=n-2; i>=0; i--)
      if (dSi[i]<dSi_MA[i] && dSi[i+1]>=dSi_MA[i+1]) 
      {
      Print("Support at " + i);
      CChartObjectHLine *line=new CChartObjectHLine();
      line.Create(0, "MiniMaxSupportLine:"+IntegerToString(cnt), 0, S[i]);
      line.Color(Tomato);
      line.Width(1);
      line.Background(true);
      line.Selectable(false);
      cnt++;
      }
}

Il fatto interessante dell'indicatore però è che ho visto che riconosce abbastanza bene i minimi e i massimi locali di breve tendenza per una determinata finestra temporale. È sufficiente filtrare lo spread tra le letture più alte e più basse dei moving mini-max e contrassegnarli come l'inizio di una tendenza rialzista o ribassista a breve termine.

Potremmo sfruttare questo comportamento in conformità con altri indicatori e gestione del denaro per rendere redditizio un Expert Advisor.

Per contrassegnare le letture più alte sulla finestra temporale corrente, possiamo utilizzare buffer di indicatori aggiuntivi per visualizzare frecce rivolte verso l’alto e verso il basso ogni volta che lo spread è più grande. Inoltre, per rendere l'indicatore più accattivante ho deciso di utilizzare la nuova funzionalità di MQL5: un istogramma a colori. La tendenza al ribasso e la tendenza al rialzo sono di diversi colori e il cambiamento di tendenza è segnalato da una barra gialla. 

Per utilizzare l'istogramma del colore tra due buffer dobbiamo utilizzare 2 buffer di dati e un buffer per gli indici di colore. Osserva come vanno definite le trame. Ci sono 5 buffer indicatori in totale e tre colori definiti per l'istogramma del colore.

//+------------------------------------------------------------------+
//|                                                MovingMiniMax.mq5 |
//|                                      Copyright 2011, Investeo.pl |
//|                                               http://Investeo.pl |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2011, Investeo.pl"
#property link        "http://Investeo.pl"

#property description "Moving Mini-Max indicator"
#property description "proposed by Z.K. Silagadze"
#property description "from Budker Institute of Nuclear Physics"
#property description "and Novosibirsk State University"
#property description "Original paper can be downloaded from:"
#property description "http://arxiv.org/abs/0802.0984"

#property version     "0.6"
#property indicator_separate_window

#property indicator_buffers 5
#property indicator_plots 3

#property indicator_type1 DRAW_COLOR_HISTOGRAM2
#property indicator_type2 DRAW_ARROW
#property indicator_type3 DRAW_ARROW

#property indicator_color1 Chartreuse, OrangeRed, Yellow
#property indicator_color2 RoyalBlue
#property indicator_color3 RoyalBlue

#property indicator_width1 5
#property indicator_width2 4
#property indicator_width3 4

Da notare che l'istogramma prende due buffer di tipo INDICATOR_DATA e un buffer INDICATOR_COLOR_INDEX. I buffer devono essere impostati esattamente nell'ordine seguente: i buffer di dati vengono prima, dopo di che viene definito un buffer dell'indice di colore.

   SetIndexBuffer(0,uSi,INDICATOR_DATA);
   SetIndexBuffer(1,dSi,INDICATOR_DATA);
   SetIndexBuffer(2,trend,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(3,upArrows,INDICATOR_DATA);
   SetIndexBuffer(4,dnArrows,INDICATOR_DATA);
   
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(2,PLOT_EMPTY_VALUE,0.0);
   
   PlotIndexSetInteger(1,PLOT_ARROW,234);
   PlotIndexSetInteger(2,PLOT_ARROW,233); 

I buffer 0,1,2 sono per l'istogramma a colori, i buffer 3 e 4 sono per la visualizzazione delle frecce.

L'algoritmo di colorazione è il seguente:

   if (upind<dnind) 
    { 
      for (i=0; i<upind; i++) trend[i]=0;
      for (i=upind; i<dnind; i++) trend[i]=1;
      for (i=dnind; i<n; i++) trend[i]=0 ;
    } else
    {
      for (i=0; i<dnind; i++) trend[i]=1;
      for (i=dnind; i<upind; i++) trend[i]=0;
      for (i=upind; i<n; i++) trend[i]=1;
   }
   
   trend[upind] = 2;
   trend[dnind] = 2;

 Sto incollando lo screenshot del risultato finale:

Figura 3. Versione finale dell'indicatore Moving Mini-Max

Bisogna ricordare che i valori per il downtrend e l’uptrend sono calcolati per una data finestra temporale ogni volta che arriva una nuova barra. Questo è il motivo per cui chiamiamo l'indicatore moving mini-max.

Sebbene sia in ritardo di m barre, offre una panoramica sorprendentemente buona per la tendenza nell'attuale finestra temporale e l'interpretazione su come il mercato "respiri".

Sono convinto che questo indicatore possa essere redditizio.

 

Conclusione

Ho parlato della matematica che sta dietro a un nuovo indicatore per l'analisi tecnica e della sua implementazione in MQL5.

Il documento originale di Z.K. Silagadze è disponibile su http://arxiv.org/abs/0802.0984. Il codice sorgente allegato è disponibile per il download.

Spero in futuro di introdurre altri indicatori tecnici più interessanti e la loro implementazione MQL5.

 

Fonti:

1. G.Gamov, Theory of alpha decay.
2. Z.K. Silagadze, Moving Mini-Max - a new indicator for technical analysis.