Trading con medie mobili

Uno degli strumenti più utilizzati dai trader è l'indicatore Media Mobile.

La media Media Mobile è un indicatore costruito prendendo i prezzi più recenti di un periodo di riferimento prestabilito e calcolandone la media. Per esempio la Media Mobile a 20gg e la media degli ultimi 20 giorni; con il passare dei giorni, il prezzo più vecchio viene tolto dal calcolo e viene aggiunta l'ultima giornata finita.

L'indicatore graficamente compare come dalla figura di sotto, ovvero segue l'andamento dei prezzi smussando evetuali picchi e movimenti violenti dei prezzi

La Media Mobile può fornire segnali per comprare e vendere uno strumento finanziario.

Per esempio se il prezzo supera il valore della media mobile si compra, viceversa se scende, sta sotto, si vende.

Svantaggio nell''utilizzare le Media Mobile è che se questa è breve ( cioè si usa una serie storica breve) dà troppi segnali e molti sono falsi.

Per ovviare a questo inconveniente si preferisce utilizzare non l'incrocio della media mobile con i prezzi ma bensi l'incrocio tra due Media Mobili come evidenziato nella figura di sotto.

Come si vede in questo caso i segnali sono solo due.

Incrocio Medie Mobili

Creiamo un semplice Expert Advisor che mi fa comprare quando c'è un incrocio tra due medie mobili, precisamente nel caso che la media veloce tagli verso l'alto quella lenta compro, se invece ho comprato e la media mobile veloce taglia dal basso verso l'alto quella lenta chiudo. 

Prima di iniziare a scrivere il codice ci sono delle decisioni da prendere, tipo su che time frame operare o su che grafico cioè su che strumento.

Deciso questo possiamo iniziare a scrivere il codice.

//+------------------------------------------------------------------+
//|                                         Moving Average Cross.mq4 |
//|                                              Francesco Sgarbossa |
//|                                 http://appuntidimql.blogspot.it/ |
//+------------------------------------------------------------------+
#property copyright "Francesco Sgarbossa"
#property link      "http://appuntidimql.blogspot.it/"

// definisco delle costanti per la posizione
#define LONG 1
#define FLAT 2


//definisco delle costanti per il segnale delle medie mobili
#define neutro 1
#define acquistato 2
#define vendi 3

//definisco modificabili lotti e timeframe
extern double lotti =1;
extern int timeframe = PERIOD_H1;

//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {

     }
       
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
//----
    if(checkSignal()== neutro) return(0);  // se le medie mobili non si incrociano  
                                                             // non fare nulla

    if(checkSignal()== acquistato)           // media mobile velocie incrocia dal basso verso l'alto
                                                            // quella lenta, segnale di acquiso
        {
           if(checkPosition()== FLAT)      // se sono FLAT compro
            {
                compra();
                return(0);
             }
//---
   return(0);
         }

    if(checkSignal()==vendi)                  // media mobile veloce incrocia dall'alto verso il basso
                                                           // quella lenta

           {
                if(checkPosition()== FLAT)  return(0);   // se sono FLAT non faccio nulla
                if(checkPosition()== LONG)                // se ho una posizione aperta la chiudo
     
           {
            chiudi();
            return(0);
        }
     
        }
           
//----
   return(0);
  }
//+


int checkSignal()

{
   double MM7_old =iMA(0, timeframe,7,0,MODE_SMA,PRICE_CLOSE,1);
   double MM28_old =iMA(0, timeframe, 28,0, MODE_SMA, PRICE_CLOSE,1);
   double MM7_new =iMA(0, timeframe,7,0,MODE_SMA,PRICE_CLOSE,0);
   double MM28_new =iMA(0, timeframe, 28,0, MODE_SMA, PRICE_CLOSE,0);
 
   if (MM7_old < MM28_old)
   {
          if (MM7_new > MM28_new)
       
         {
            return (acquistato);
         }
   }
 
    if (MM28_old < MM7_old)
   {
        if ( MM28_new > MM7_new)
       
         {
       
            return(vendi);
        }
   }

 return(neutro);
  }

int checkPosition()

  {

  if (OrdersTotal()>0)  return(LONG);

  else return(FLAT);

  }

int compra()
 {
   int ticket= OrderSend(Symbol(),OP_BUY,lotti,Ask,0,0,0,"",101,0,Red);

 }

void chiudi()
{

   int total = OrdersTotal();
   for(int pos=0; pos<total;pos++)
 
   {
 
      OrderSelect(pos, SELECT_BY_POS, MODE_TRADES);
      OrderClose(OrderTicket(),OrderLots(),Bid,0,Blue);
   
    }
 
 }

//--------------------

OrderSend()

La funzione OrderSend() è la funzione di trading predefinita per inviare un ordine a mercato, che può essere sia da eseguire subito sia pendente.

La funzione restituisce un numero intero che è il ticket che il broker assegna all'ordine.

la funzione prende come parametri una serie di argomenti:

Relative Strenght Index (RSI)

L'RSI è un indicatore utilizzato per indicare fasi di "ipercomprato" e "ipervenduto" ovvero fasi di mercato in cui i prezzi si sono mossi lungo una cerca direzione (alto o basso) con estrema velocità in un breve lasso di tempo. Misura quindi la velocità dei prezzi.

Questo indicatore può assumere valori che variano da 0 a 100.

La formula per il calcolo è semplice:

RSI = 100- 100/(1+BarrePositive/BarreNegative))

Introduzione ad Indicatori e Oscillatori

Gli indicatori e oscillatori sono dei valori o meglio una serie di valori costruiti attraverso diversi algoritmi matematici dalla serie dei valori dei prezzi dei strumenti finanziari.  

Sono strumenti di analisi e di trading, vengono utilizzati per analizzare l'andamento del mercato e predire i futuri movimenti.

Ne esistono moltissimi e molti vengono di continuo creati.

Media Mobile

In MQL si possono utilizzare diversi indicatori.

La media mobile è uno degli indicatori più diffusi e utilizzato in analisi tecnica.

Eistono diverse medie mobili in analisi tecnica.

La media mobile semplice, che non fa altro che dare la stessa importanza a tutta la serie storica dei dati dal più vecchio al più recente.

La media mobile esponenziale invece da maggior peso ai dati recenti rispetto a quelli passati.

Funzioni per il Trading

Per poter operare sul mercato MQL offre una serie di funzioni predefinite che permettono di inviare, cancellare e manipolare gli ordini.

Alcune funzioni sono dispositive , ovvero servono per inviare, cancellare e modificare gli ordini.

Altre funzioni sono informative cioè restituiscono le caratteristiche degli ordini inseriti sul mercato.

Come ottenere informazioni sul conto (seconda parte)

AccountCompany()

Questa funzione ritorna il nome del broker presso il quale si è aperto il conto.
String AccountCompay()

Ovviamente la funzione ritorna una stringa

AccountCurrency()

La funzione restituisce la valuta del conto
String AccountCurrency()

Come ottenere informazioni sul conto (prima parte)

Esistono in MQL delle funzioni che permettono di accedere alle informazioni sul conto.Si possono ottenere informazioni sul Saldo, sul margine impiegato, su quello libero, sulla leva impiegata, sul numero di conto e nome del broker.

Le funzioni sono:

Funzioni del tempo

Esiste in MQL la possibilità di leggere il tempo, manipolarlo e utilizzarlo nei nostri trading system.

Per tempo intendo ovviamente l'orario attuale.

E' importante notare che in realtà l'orario è rappresentato dal numero di secondi passati dalla data del 1 gennaio 1970.

CurTime

datetime CurTime()

questa funzione restituisce l'orario sul server del broker.

LocalTime

datetime LocalTime()

questa funzione restituice l'orario che compare sul Pc client.

Entrambe queste due funzioni mi restituiscono il numero di secondi che sono passati dalla data del 1 gennaio 1970.

Questo codice restituisce in secondi gli orari del broker e del server e ne calcola poi la differenza:

Minute

int Minute()

Questa funzione ritorna i minuti correnti

Hour

int Hour()

Questa funzione ritorna l'ora corrente

Seconds

int Seconds()

Questa funzione ritorna i secondi correnti

Tutti questi dati si riferiscono ai dati si riferiscono all'orario del broker.

Questa funzione restituisce l'ora del broker:

Matrici predefinite

Nel linguaggio MQL esistono delle matrici predefinite che aiutano ad ottenere informazione sui prezzi del grafico. 

Le matrici sono un insieme di elementi dello stesso tipo accessibili in lettura ed in scrittura tramite un indice.

Per quel che riguarda i prezzi dei grafici le matrici possono essere considerate come una serie storica dei prezzi.

La barra attuale ha indice di base 0., la barra con indice 1 è l'ultima barra che si sarà formata completamente. 

Array Predefiniti (seconda parte)

Altre istruzioni per gestire e manipolare i dati degli array:

iClose

double iClose(string Symbol, int timefrme, int shift)

Questa funziona ritorna il valore di chiusura della barra dall'argomento shift (0 è l'attuale, 1 è quello dell'ultima barra che si è formata, 2 penultima e così via).

Arrey Predefiniti (prima parte)

In MQL esistono degli arrey predefiniti che memorizzano automaticamente i valori storici degli strumenti finanziari.

I valori di questi arrey variano in funzione del diverso periodo temporale, ovvero del diverso time frame usato.

Se per esempio usiamo un time frame "largo" come per esempio un giorno, e lo confrontiamo con i valori di un time frame più breve per esempio l'ora, il valore massimo dell'ultimo giorno, differenzierà dal valore massimo dell'ultima ora.

Indicatori personalizzati - seconda parte

Nella prima parte di questo articolo abbiamo visto che il Wizard con i dati di input da noi inseriti ha creato per noi alcune direttive del preprocessore . 

#property indicator_buffers  definisce il numero di indicatori che verranno visualizzati (massimo 8).

#property indicator_colorn  definisce il colore dell'indicatore,  n è l'indice dell'indicatore, 1 sta per il primo e cosi via.

Indicatori personalizzati - prima parte

Gli indicatori di analisi tecnica nascono dalla fantasia ed ingegnosità degli analisti e dei trader.

Tutti i software di analisi tecnica offrono l'opportunità di creare e visualizzare nuovi indicatori.

Anche MetaTrader offre questa possibilità attraverso il MetaEditor.

MQL offre delle funzioni apposite per poter gestire e manipolare i dati di mercato con lo scopo di trarne un indicatore.

Per creare un indicatore è necessario creare un buffer di dati che conterrà i valori dell'indicatore che andremo a visualizzare sul grafico.

Si dovrà poi dire alla piattaforma come visualizzare l'indicatore: se all'interno della finestra del grafico o su una finestra a parte, e che stile grafico adottare per l'indicatore (lineare, a barre, trateggiato, ecc).

Preprocessore

In MQL esistono delle istruzioni che sono definite direttive del processore che servono a dichiarare costanti, includere file, inserire librerie.

Se il primo carattere nella linea di codice è #, significa che l'istruzione che segue è per il compilatore

Direttiva #define

Tipo Dati

I dati utilizzati per fare tutte le operazioni richeiste dai nostri programmi scritti in MQL vengono sempre salvati con dei nomi. Se è previsto che questi dati possano variare durante l'esecuzione del programa questi dati si dicono "variabili", se invece non devono cariare si diranno "costanti".

Poi quel che caratterizza questi valori è il tipo.

Il tipo è l'insieme di valori che il dato "variabile" o "costante" può assumere.

iHighest e iLowest

iHighest

Questa funzione permette di localizzare la posizione all'interno di un intervallo predefinito, dove un prezzo definito (come apertura, chiusura, minimo o massimo) è il maggiore.

int iHighest(string symbol, int timeframe, int type, int count=WHOLE_ARRAY,int start=0)

Manipolazione tipo dato

Potrebbe essere necessario convertire un tipo in un altro tipo durante la realizzazione di un trading system. Per esempio si dovrebbero confrontare valori di tipo diverso.

CharToStr
Trasforma un numero codificato (in codice ASCII) in un carattere

string ChartToStr(int char_code)

Programma che calcola la somma tra due numeri e li stampa

Scriviamo un semplice programma che calcola la somma di due numeri e li stampa.

Prima cosa apriamo MetaEditor e clicchiamo su New, si aprirà l'Expert Advisor Wizard, stiamo creando un programma non un trading system quindi scegliamo Script.

Operatori di assegnazione

In MQL ogni istruzione termina con un punto e virgola (;)

Se si vuole incrementare di 1 un valore basta usar il doppio più (++), s si vuol descrmentare di 1 basta un doppi meno(--)

Funzioni Speciali

Quando iniziamo un nuovo programma in MQL con il Wizard di MetaEditor vediamo che di default ci sono delle funzioni vuote nella pagina che viene creata in automatico. Sono delle funzioni speciali.

La funzione speciali denominata "init()" viene eseguita ogni volta che qualche parametro della piattaforma Metatrader cambia, per esempio ogni volta che viene associato il programma ad un particolare grafico, ogni volta che dalla piattaforma viene attivato o riattivato un Expert Advisor, ogni volta che si cambia grafico visualizzato o time frame temporale.

Valori massimi e minimi

Per trovare il valore massimo all'interno di un range di barre predefinito possiamo usare le funzioni iHighest e iHigh assieme:

Il risultato è:

SWITCH

L'istruzione if serve per far eseguire una operazione ad una funzione se si verifica una certa condizione.

Se le condizioni da verificare sono più di una si possono utilizzare degli if nidificati (cioè uno interno all'altro) tipo:

if (condizione 1)

       allora esegui istruzione 1

         else

                if( condizione 2)

                      allora esegui istruzione 2

e cosi a secondo di quante sono le condizioni da verificare

E' ovvio che se sono molti l'istruzione if non è la più efficace tra le varie ipotesi

A questo proposito si può utilizzare l'istruzione switch

switch (espressione)

{

case  1 : istruzione ; break ;

case  2 :  istruzione ; break ;

.....

default: istruzione ; break;

}

Il valore dell'espressione viene confortato con delle costanti se c'è uguaglianza viene eseguita istituzione corrispondente che potrebbe pure essere un blocco di istruzioni.

switch ( A)

{

case ' B' :
              print ( " A è uguale a:", B);
              break ;

case 'C' :

              print ( " A è uguale a:", C);
              break ;

[....]

}

Ciclo While

Il ciclo while a differenza del ciclo for viene utilizzato quando non si ha certezza del numero di iterazioni che si vuole far compiere al blocco di istruzioni.
La sintassi è la seguente:


while (condizione)

  

 {

       (blocco istruzioni);

  }

esempio

int a = 0;

while (a < 5)

  {

        

      Print(" il valore di "a " è:", a);

                 a++;

   

  }

Il risultato alla fine è il seguente:

I Cicli FOR e WHILE

Può capitare che necessitiamo di far avvenire un'istruzione o un blocco di istruzioni più volte fino al verificarsi di una certa condizione. In questo caso possiamo usare due istruzioni fondamentali di ciclo: l'istruzione for e l'istruzione While.

Istruzione for permette di far eseguire un'istruzione o il blocco di istruzioni almeno una o n volte.
Prevede l'utilizzo di una variabile intera di controllo che viene inizializzata all'inizio e che può essere incrementata o decrementata ogni volta che viene eseguita l'istruzione. Il ciclo si ferma solo quando la variabile di controllo assume un determinato valore specificato all'interno dell'istruzione for

for ([ variabile di controllo inizializzata];[condizione di stop ciclo]; 
           [incremento o decremento variabile di controllo])

         { blocco istruzioni};


Esempio:


for ( int a = 0; a<5; a++)

      { Print("Il valore di a =:", a); }


Il risultato sarà:

Condizione IF

Come tutti i normali linguaggi di programmazione esistono delle istruzioni condizionali, ovvero istruzioni che permettono di eseguire una singola istruzione o un blocco se è verificata una certa condizione.

La più comune istruzione condizionale è "IF" , spesso, ma non necessariamente, seguita dalla istruzione "ELSE" che comporta la esecuzione di una diversa operazione nel caso la condizione non sia verificata.

IF (condizione da verificare)

 {istruzione da eseguire se condizione IF vera}

ELSE

 {istruzione da eseguire se condizione IF false}

esempio:

[...]

IF (a>10)

    b= a+1;

ELSE

    b = a -1;

se a = 11 l'istruzione IF è vera e b = 12;

se a = 9 l'istruzione IF è falsa e b = 8.

 

Passaggio di parametri alle funzioni e ritorno di valore

Una funzione all'interno di un programma in MQL è un blocco di codice che può sia inizializzare delle variabili che verranno usate all'interno della funzione, sia accettare dei valori che vengono passati dall'esterno:

void  Addizione (int a, int b)

  {

         

          int C = A+B;

  }

In questo caso ne A ne B vengo inizializzati ma prendono i valori che vengono passati dell'esterno:

[...]

Addizione (3,5);

[...]

Le funzioni possono anche restituire un parametro che verra eventualmente utilizzato poi dal corpo del programma principale. 

In questo caso quando si chiama la funzione bisogna definire il tipo del parametro che si aspetta di ricevere.

int Addizione (3,5);

mettendo "int" di fronte al nome di funzione che richiama il blocco ci aspettiamo che la funzione ritorni un valore intero, se verrà restituito un valore diverso al momento della compilazione il compilatore darà errore.

int  Addizione (int a, int b)

  {

         

          int C = A+B;

         return (C);

  }

Ora la funzione presenta "int" di fronte al nome, significa che la funzione deve restituire un valore intero. Inoltre nel blocco della funzione c'è il comando return che ha come compito specificare quale valore verrà restituito.

Istruzioni e Funzioni

Un programma in MQL, come ogni codice di programmazione, è costituito da una successione di istruzioni. Un' istruzione può essere una assegnazione, una operazione logica o matematica, un confronto o un ciclo. Ogni istruzione esegue una operazione completa ed ogni istruzione termina con il punto e virgola (";")

int A = 5 ;  

Quella scritta sopra è una istruzione di dichiarazione e assegnazione: nella stessa istruzione viene dichiarata la variabile "A" di tipo intero (int) e a questa variabile viene assegnato il valore 5.

Spesso è necessario creare una serie di istruzioni che debbano essere eseguite in blocco tutte assieme e magari più volte dal programma. In questo caso questo blocco di istruzioni viene delimitato da parentesi graffe e viene chiamato Funzione

Void Addizione

  {
          int A = 5;
          int B = 2;
          int C = A+B;
 }


L'insieme di istruzioni contenute dentro la funzione, che qui viene chiamata Addizione,  hanno come scopo quello di fare una operazione di addizione tra due variabili.
Le variabili vengono prima dichiarate e poi inizializzate con i valori 5 e 2.
Poi le variabili vengono sommate tra loro e il risultato viene assegnato alla variabile C precedentemente dichiarata di tipo "int".

Come aprire il MetaEditor

Con il linguaggio MQL e la piattaforma Metatrader  è possibile non solo creare Trading System, che nel caso specifico vengono chiamata Expert Advisor, ma anche fare altro.

Si possono cerare Indicatori personalizzati (Custom Indicator), programmi che vengono eseguiti una volta sola (Script) e librerie.

Tutto ciò avviene tramite l’Editor di Metatrader.

L’editor, chiamato MetaEditor, è l’interfaccia che permette alla piattaforma di trasformare i comandi di MQL in linguaggio macchina e farli eseguire.

Per aprire l’interfaccia MetaEditor è sufficiente cliccare nel menù di Metatrader il piccolo rombo giallo con il punto esclamativo dentro che vedete nella figura.

Vi comparirà la schermata di cui sotto.

Per iniziare a scrivere il vostro programma dovete cliccare New dentro il menù file in alto a sinistra.

Il MetaEditor vi chiederà cosa vorrete creare, se un Expert Advisor, un indicatore ecc ecc.

Scegliete e cliccate su Next.

Ecco che ora l’editor è pronto per accettare il vostro codice e successivamente compilarlo.