Un Esempio di Strategia di Trading Basata sulle Differenze di Fuso Orario nei Diversi Continenti

Introduzione

Ho avuto un po' di tempo libero ed era chiaro che questa volta avrei passato a studiare i mercati e a ricercare la divergenza dei cicli economici e degli indicatori tecnici. Puoi vedere i risultati della ricerca nel seguente articolo Creazione di un Indicatore con Opzioni di Controllo Grafico. Ma queste non erano solo scoperte! Ho trovato un fenomeno di una scala ancora più ampia, ma per capirlo, diamo un'occhiata al nostro mondo in termini di fusi orari (Fig. 1).

Figura 1. Fusi orari

Come possiamo vedere, la giornata inizia in modo diverso in ogni paese e continua con vari momenti, poiché vediamo il nostro grande vasto paese espanso attraverso quasi 10 fusi orari, mentre l'Oceano Atlantico si estende solo su 6 fusi orari.

Qual è il modello qui? Diamo un'occhiata all'ordine di apertura dei mercati nei seguenti paesi: Giappone, Australia, Cina, Russia. Quando gli impiegati russi arrivano per la prima volta nel loro ufficio e iniziano le operazioni commerciali, in Asia è già sera, e quando la sessione europea è aperta, sono già chiusi.

Qui è dove inizia il divertimento. Una volta aperto il mercato, i broker e i gestori di hedge fund europei mettono le loro attività sul mercato e intraprendono azioni speculative o concomitanti con gli interessi dei loro investitori. No, è troppo presto per la parte più interessante che inizia con l'alba a Chicago, in connessione con la minore estensione dell'Oceano Atlantico, arriva un momento in cui i gestori del mercato azionario di Chicago aprono i loro terminali di trading e iniziano a gestire il loro capitale.

Fermiamoci in questo momento, in relazione a una misura minore dell'Oceano Atlantico. La sessione europea non si è ancora conclusa (Fig. 1). Londra è separata da Chicago da 8 fusi orari, se ipotizziamo che la giornata lavorativa sia di 8 ore + 45 minuti per le pause fumo e un'ora per, il che prolunga il tempo per altre 1,30 - 2 ore (chi ha lavorato in un ufficio lo sa). 

Questo è il momento in cui otteniamo gli asset di mercato dei manager europei e americani. Ho paura di elencare tutti gli zeri delle attività a questo punto, i manager europei e americani stanno iniziando la loro lotta per il prezzo delle borse, e a questo punto è un fenomeno, come mostrato nella Figura 2. 

Figura 2. Impulso di mercato

Le battaglie finanziarie riempiono il mercato, le attività spostano i loro proprietari ogni secondo, ma questo non è ciò su cui finisce il mercato! Dopo che questo periodo è finito, inizia un movimento tranquillo e si muove nella direzione della tendenza attuale. A questo punto, la gamma espande i suoi confini, quindi li restringe ancora una volta e continua a muoversi nella direzione della tendenza principale.

Sono sicuro che hai notato che il prezzo di mercato può salire o scendere, ma si muove sempre verso destra.

2. Diagrammi di flusso come metodo principale per lo sviluppo di un algoritmo

Il primo blocco del programma "Start-Stop" è illustrato nella Figura 3:

Figura 3. Blocco "Start-Stop"

Questo blocco viene utilizzato per indicare l'inizio del programma, l'inizio e la fine di una funzione o di un'altra procedura, ad esempio un'inizializzazione e una reinizializzazione. Il prossimo blocco che esamineremo è etichettato "Dati" ed è illustrato nella Figura 4.

Figura 4. Blocco "Dati"

Il blocco "Dati" viene utilizzato per determinare i parametri specificati all'avvio del programma o le variabili di output nel caso MQL5. Questa unità serve anche la funzione di destinazione delle variabili globali.

Successivamente, consideriamo un blocco comunemente usato (il 99% dei programmi in MQL utilizza questo metodo) - è raffigurato in due parti, che segnano i confini di un ciclo. Considera la Fig. 5:

Figura 5. Blocchi del ciclo

Processi come l'attribuzione o la contabilità, di solito avvengono all'interno di questi cicli, i cui esempi sono illustrati nella Figura 6.

Figura 6. Azioni

E non dobbiamo dimenticare i blocchi logici - la Fig. 7 dimostra il blocco "soluzione".

Figura 7. Il blocco "Soluzione"

Il blocco "soluzione" può anche avere più di due uscite se si trova all'interno dell'operatore del tipo "interruttore che dipende dal numero di posizionamenti". Questa unità avrà un numero corrispondente di uscite.

Il blocco successivo induce funzioni predefinite, come iMACD o iRSA, così come funzioni personalizzate, definite altrove nel programma o nella libreria (Fig. 8).

Figura 8. Funzione

E gli ultimi due blocchi implementano esclusivamente funzioni di servizio, come i commenti e la violazione (Fig. 9).

Figura 9. Blocchi di servizio

Questi sono tutti i tipi di blocchi che possono essere utilizzati per descrivere qualsiasi programma scritto per una macchina; sono tutti chiari, semplici e facili da usare. Nella fase primaria dello sviluppo, rivelano anche i punti deboli del sistema e escogitano metodi per eliminarli.

Ora conosci questo metodo, tuttavia, non ti sto chiedendo di agire esattamente secondo questi schemi, ma semplicemente conoscendo il valore iniziale dei diagrammi di flusso, è abbastanza facile capire un qualche tipo di metodo di calcolo. Questo metodo mi aiuta a formulare rapidamente un'idea, che aveva rapidamente sparato nell'emisfero sinistro del mio cervello, pronta a fuggire dall'emisfero destro.

3. Costruzione dell'algoritmo

E così, passiamo alla preparazione dell'Expert Advisor in base alla strategia del diagramma di flusso.

Il primo blocco richiederà i parametri di input. Come abbiamo stabilito, è fondamentale attendere il momento delle principali battaglie, cioè 2 ore dopo la sessione di apertura degli Stati Uniti, quando i mercati europei si chiudono. Lo guarderemo sull'orologio globale, cioè sull'ora del terminale, e quindi calcoleremo noi stessi l'ora di apertura.

Quindi determiniamo la dimensione delle posizioni e i livelli di profitto e perdita che in futuro hanno il potenziale per ottimizzare. Particolare attenzione sarà prestata al parametro numero magico, in quanto verrà utilizzato dal nostro Expert Advisor per determinarne l'ordine e aprire le negoziazioni. Più avanti, faremo un trailing stop per limitare il rischio delle nostre posizioni, alle nostre osservazioni.

C'è un altro parametro interessante di cui avremo bisogno: un livello di sicurezza, in base al quale osserveremo la presenza di notizie economiche significative al momento, e se rappresentano o meno una minaccia, considerando che il panico principale sui mercati sorge entro queste due ore.

Figura 10. Parametri di Input

//--- input parameters
input int      America=16;
input double   Lots=0.1;
input int      TakeProfit=500;
input long     MagicNumber=665;
input int      Limited=600;
input int      TrailingStop=100;

Procediamo con la prossima parte della formazione della strategia.

Dobbiamo determinare se la sessione è stata un incrocio e se gli ordini sono stati stabiliti o sono in corso. (Fig. 11).

Figura 11. Tempo di fare trading

Come puoi vedere, l'algoritmo dato è un programma chiuso con parametri di input, calcoli completati e risultati di output. Tali mini-programmi sono chiamati funzioni e sono protetti dal programma principale mediante incapsulamento.

L'incapsulamento è una barriera tra i programmi o parti del programma, che è separata da metodi, come Get e Set (get e set) per impedire loro di attraversare il territorio di altri Get’ e Set’. L'essenza di questo processo sta nel fatto che i nomi delle variabili possono essere gli stessi all'interno delle funzioni e all'interno del programma principale, ma quando il metodo Get tenta di prendere da una cella con un nome della variabile, si troverà di fronte all'incapsulamento che gli darà accesso solo a un particolare settore di celle di memoria, allocato per questa funzione o programma.

Lo stesso vale per il metodo Set, ma a differenza di Get. Imposta il valore nella memoria della cella sul nome della variabile e se i nomi delle variabili all'interno del programma e all'interno della funzione coincidono, l'incapsulamento non consentirà al metodo Set di assegnare i valori delle variabili all'interno di un altro programma o funzione.

bool time2trade(int TradeHour,int Number)
  {
   MqlDateTime time2trade;
   TimeTradeServer(time2trade);
   if(time2trade.hour!=TradeHour) return(false);
   time2trade.hour= 0;
   time2trade.min = 0;
   time2trade.sec = 1;
   for(int ii=OrdersTotal()-1;ii>=0;ii--)
     {
      OrderGetTicket(ii);
      long ordmagic=OrderGetInteger(ORDER_MAGIC);
      if(Number==ordmagic) return(false);
     }
   HistorySelect(StructToTime(time2trade),TimeTradeServer());
   for(int ii=HistoryOrdersTotal()-1;ii>=0;ii--)
     {
      long HistMagic=HistoryOrderGetInteger(HistoryOrderGetTicket(ii),ORDER_MAGIC);
      if(Number==HistMagic) return(false);
     }
   return(true);
  }

Abbiamo identificato la sessione richiesta e determinato se abbiamo impostato o meno gli ordini. Consideriamo cosa dovrebbe essere fatto dopo.

In precedenza, abbiamo notato che le principali fluttuazioni si verificano 2 ore dopo la sessione di apertura degli Stati Uniti. Otteniamo 9 battute di quindici minuti dopo l'apertura della sessione americana. Troviamo l'intervallo massimo per questo periodo e lo consideriamo attentamente - se questa variazione è abbastanza grande, allora molto probabilmente, c'è un panico diffuso nel mercato e le tendenze future sono difficili da prevedere. Pertanto, avremo bisogno di alcune restrizioni qui.

Quando il mercato è calmo, la sessione aumenterà la loro volatilità. Questo ci darà l'opportunità di determinare la deviazione massima dalla tendenza principale e di posizionare le trappole dell'ordine a una distanza di sicurezza, che funzionerà perché la tendenza principale continuerà. Come abbiamo notato in precedenza, il prezzo può salire o scendere, ma si sposta sempre a destra. (Fig. 12).

Figura 12. Algoritmo del set di ordini

Modellando il codice del programma, prestare attenzione al fatto che il terminale di trading MetaTrader 5 non consente l'impostazione di un ordine vicino al prezzo dell'ultima transazione. Se in questo momento il prezzo attira un nuovo minimo o massimo, difenderemo la nostra posizione facendo un passo indietro a una distanza minima dall'ultimo prezzo della transazione, per una determinazione affidabile di un ordine. Inoltre, imposteremo il periodo di durata dei nostri ordini prima della fine della giornata, poiché in seguito non saranno più efficaci.

void OnTick()
  {
//---
   if(time2trade(America+2,MagicNumber))
     {
      int i;
      double Highest = 0;
      double Lowest = 0;
      MqlRates Range[];
      CopyRates(Symbol(),15,0,9,Range);
      Lowest=Range[1].low;
      for(i=0; i<9;i++)
        {
         if(Highest<Range[i].high) Highest=Range[i].high;//MathMax(,Highest);
         if(Lowest>Range[i].low)  Lowest=Range[i].low;
        }
      long StopLevel=SymbolInfoInteger(Symbol(),SYMBOL_TRADE_STOPS_LEVEL);
      Highest=Highest+StopLevel*Point();
      // add to the current prices parameters of the minimum distance possible for the setting of orders
      Lowest=Lowest-StopLevel*Point();
      // to ensure the maximum probability of the acceptance of our order 30>

      if((Higest-Lowest)/Point()<Limited)
        {
         MqlTradeRequest BigDogBuy;
         MqlTradeRequest BigDogSell;
         BigDogBuy.action=TRADE_ACTION_PENDING;
         // Set the pending order
         BigDogBuy.magic = MagicNumber;
         BigDogBuy.symbol=Symbol();
         BigDogBuy.price=Highest;
         //Price by which the order will be set
         BigDogBuy.volume=Lots;
         BigDogBuy.sl=Lowest;
         //if the stop loss is not set, then set by the strategy /s39>
         BigDogBuy.tp=Highest+TakeProfit*Point();
         //set the take profit/s41>
         BigDogBuy.deviation=dev;
         //minimum deviation from the requested price, 
         //in other words, by how much the executed price can differ from the specified price
         BigDogBuy.type=ORDER_TYPE_BUY_STOP;
         //order type, which is executed based on the specified price or by a higher than specified price
         //in this case the order is set to a higher or equal amount to the specified price 
         //if the order type was buy_limit, then it would be executed 
         //by the specified price, or prices lower than the specified price
         BigDogBuy.type_filling=ORDER_FILLING_AON;
         //the given parameter demonstrates how the order acts 
         //with partial execution of the scope 
         BigDogBuy.expiration=TimeTradeServer()+6*60*60;
         //by the strategy text the order life span only for the current work day
         //since it has been 2 hours since the opening of the American market, and the work day is 8 hours, we have 8-2 = 6
         BigDogSell.action=TRADE_ACTION_PENDING;

         // Set the pending order
         BigDogSell.magic = MagicNumber;
         BigDogSell.symbol=Symbol();
         BigDogSell.price=Lowest;
         //Price, by which the order will be set
         BigDogSell.volume=Lots;
         BigDogSell.sl=Highest;
         //Stop loss set by the strategy
         BigDogSell.tp=Lowest-TakeProfit*Point();
         //set the take profit
         BigDogSell.deviation=dev;
         //Minimum deviation from the requested price, 
         //in other words, by how much the executed price can differ from the specified price
         BigDogSell.type=ORDER_TYPE_SELL_STOP;
         //order type, which is executed based on the specified price or by a higher than specified price
         //in this case the order is set to a higher or equal amount to the specified price  
         //if the order type was buy_limit, then it would be executed
         //by the specified price, or prices lower than the specified price
         BigDogSell.type_filling=ORDER_FILLING_AON;
         //the given parameter demonstrates how the order acts 
         ///with partial execution of the scope  
         BigDogSell.expiration=TimeTradeServer()+6*60*60;
         //by the strategy text the order life span only for the current work day
         //since it has been 2 hours since the opening of the American market, and the work day is 8 hours, we have 8-2 = 6
         MqlTradeResult ResultBuy,ResultSell;
         OrderSend(BigDogBuy,ResultBuy);
         OrderSend(BigDogSell,ResultSell);
        }
     }

Gli ordini vengono effettuati, le trappole sono impostate - ora è il momento di occuparsi di ridurre i rischi delle nostre posizioni, applichiamo la tecnologia del trailing stop (trailing stop).

Per identificare la nostra posizione, useremo il numero Magico (MagicNumber) e sposteremo il livello di stop-loss, quando raggiunge un certo livello di profitto con variazioni di prezzo minime. (Figura 13).

Figura 13. Implementazione del trailing stop

Per le diverse strategie, il trailing stop viene implementato utilizzando il metodo più semplice, anche se in alcune strategie si raccomanda di non utilizzare un trailing stop, in modo da non impedire al prezzo di raggiungere il suo scopo o di utilizzare tale meccanismo solo per il trasferimento di posizioni a no-loss. Ma in questa strategia, applichiamo il meccanismo classico per spostare lo stop protettivo, in caso di spostamento dei prezzi, nella nostra direzione per un certo numero di variazioni minime di prezzo.

//--- trailing implementation
   int PosTotal=PositionsTotal();
   for(int i=PosTotal-1; i>=0; i--)
     {
      //--- go through open positions and see if there are positions created by this Expert Advisor.
      if(PositionGetSymbol(i)==Symbol())
        {
         if(MagicNumber==PositionGetInteger(POSITION_MAGIC))
           {
            MqlTick lasttick;
            SymbolInfoTick(Symbol(),lasttick);
            if(PositionGetInteger(POSITION_TYPE)==0)
              { //--- buy
               if(TrailingStop>0
                  &&(((lasttick.bid-PositionGetDouble(POSITION_PRICE_OPEN))/Point())>TrailingStop)
                  && ((lasttick.bid-PositionGetDouble(POSITION_SL))/Point())>TrailingStop)
                 {
                  MqlTradeRequest BigDogModif;
                  ZeroMemory(BigDogModif);
                  BigDogModif.action= TRADE_ACTION_SLTP;
                  BigDogModif.symbol= Symbol();
                  BigDogModif.sl = lasttick.bid - TrailingStop*Point();
                  BigDogModif.tp = PositionGetDouble(POSITION_TP);
                  BigDogModif.deviation=3;
                  MqlTradeResult BigDogModifResult;
                  ZeroMemory(BigDogModifResult);
                  OrderSend(BigDogModif,BigDogModifResult);
                 }
              }
            if(PositionGetInteger(POSITION_TYPE)==1)
              {//--- sell
               if(TrailingStop>0
                  && ((PositionGetDouble(POSITION_PRICE_OPEN)-lasttick.ask)/Point()>TrailingStop)
                  && (PositionGetDouble(POSITION_SL)==0
                  || (PositionGetDouble(POSITION_SL)-lasttick.ask)/Point()>TrailingStop))
                 {
                  MqlTradeRequest BigDogModif;
                  ZeroMemory(BigDogModif);
                  BigDogModif.action= TRADE_ACTION_SLTP;
                  BigDogModif.symbol= Symbol();
                  BigDogModif.sl = lasttick.ask + TrailingStop*Point();
                  BigDogModif.tp = PositionGetDouble(POSITION_TP);
                  BigDogModif.deviation=3;
                  MqlTradeResult BigDogModifResult;
                  ZeroMemory(BigDogModifResult);
                  OrderSend(BigDogModif,BigDogModifResult);
                 }
              }
           }
        }
     }
  }

Quindi, raccogli il nostro algoritmo (Fig. 14).

Fig. 14. Assemblaggio di un algoritmo

//+------------------------------------------------------------------+
//|                                          BigDog_By_CoreWinTT.mq5 |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
//--- input parameters
input int      America=16;
input double   Lots=0.1;
input int      TakeProfit=500;
input long     MagicNumber=665;
input int      Limited=600;
input int      TrailingStop=100;
int dev=30;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
bool time2trade(int TradeHour,int Number)
  {
   MqlDateTime time2trade;
   TimeTradeServer(time2trade);
   if(time2trade.hour!=TradeHour) return(false);
   time2trade.hour= 0;
   time2trade.min = 0;
   time2trade.sec = 1;
   for(int ii=OrdersTotal()-1;ii>=0;ii--)
     {
      OrderGetTicket(ii);
      long ordmagic=OrderGetInteger(ORDER_MAGIC);
      if(Number==ordmagic) return(false);
     }
   HistorySelect(StructToTime(time2trade),TimeTradeServer());
   for(int ii=HistoryOrdersTotal()-1;ii>=0;ii--)
     {
      long HistMagic=HistoryOrderGetInteger(HistoryOrderGetTicket(ii),ORDER_MAGIC);
      if(Number==HistMagic) return(false);
     }
   return(true);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   if(time2trade(America+2,int(MagicNumber)))
     {
      int i;
      double Highest= 0;
      double Lowest = 0;
      MqlRates Range[];
      CopyRates(Symbol(),15,0,9,Range);
      Lowest=Range[1].low;
      for(i=0; i<9;i++)
        {
         if(Highest<Range[i].high) Highest=Range[i].high;
         if(Lowest>Range[i].low) Lowest=Range[i].low;
        }
      long StopLevel=SymbolInfoInteger(Symbol(),SYMBOL_TRADE_STOPS_LEVEL);
      Highest=Highest+StopLevel*Point();
      //--- add to the current prices the parameters of a minimum possible distance for the order set.
      Lowest=Lowest-StopLevel*Point();
      //--- to ensure the maximum probability of the acceptance of our order.

      if((Highest-Lowest)/Point()<Limited)
        {
         MqlTradeRequest BigDogBuy;
         MqlTradeRequest BigDogSell;
         ZeroMemory(BigDogBuy);
         ZeroMemory(BigDogSell);
         BigDogBuy.action=TRADE_ACTION_PENDING;
         //--- set the pending order
         BigDogBuy.magic = MagicNumber;
         BigDogBuy.symbol=Symbol();
         BigDogBuy.price=Highest;
         //--- Price by which the order will be set
         BigDogBuy.volume=Lots;
         BigDogBuy.sl=Lowest;
         //--- if the stop loss is not established, then we set by the strategy
         BigDogBuy.tp=Highest+TakeProfit*Point();
         //--- set the take profit
         BigDogBuy.deviation=dev;
         //--- Minimum deviation from the requested price, 
         //--- in other words, by how much the executed price can differ from the specified price
         BigDogBuy.type=ORDER_TYPE_BUY_STOP;
         //--- order type, which is executed based on the specified price or by a higher than specified price
         //--- in this case the order is set to a higher or equal amount to the specified price 
         //--- if the order type was buy_limit, then it would be executed 
         //--- by the specified price, or prices lower than the specified price
         BigDogBuy.type_filling=ORDER_FILLING_FOK;
         //--- the given parameter demonstrates how the order acts  
         //--- with partial execution of the scope   
         BigDogBuy.expiration=TimeTradeServer()+6*60*60;
         //--- by the strategy text the order life span only for the current work day
         //--- since it has been 2 hours since the opening of the American market, 
         //--- and the work day is 8 hours, we have 8-2 = 6
         BigDogSell.action=TRADE_ACTION_PENDING;

         //-- Set the pending order
         BigDogSell.magic = MagicNumber;
         BigDogSell.symbol=Symbol();
         BigDogSell.price=Lowest;
         //--- Price by which the order will be set
         BigDogSell.volume=Lots;
         BigDogSell.sl=Highest;
         //-- Stop loss set by the strategy
         BigDogSell.tp=Lowest-TakeProfit*Point();
         //--- Set take profit
         BigDogSell.deviation=dev;
         //--- Minimum deviation from the requested price, 
         //--- in other words, by how much the executed price can differ from the specified price
         BigDogSell.type=ORDER_TYPE_SELL_STOP;
         //--- order type, which is executed based on the specified price or by a higher than specified price
         //--- in this case the order is set to a higher or equal amount to the specified price  
         //--- if the order type was buy_limit, then it would be executed
         //--- by the specified price, or prices lower than the specified price
         BigDogSell.type_filling=ORDER_FILLING_FOK;
         //--- the given parameter demonstrates how the order acts  
         //--- with partial execution of the scope 
         BigDogSell.expiration=TimeTradeServer()+6*60*60;
         //-- by the strategy text the order life span only for the current work day
         //--- since it has been 2 hours since the opening of the American market, 
         //--- and the work day is 8 hours, we have 8-2 = 6
         MqlTradeResult ResultBuy,ResultSell;
         ZeroMemory(ResultBuy);
         ZeroMemory(ResultSell);
         OrderSend(BigDogBuy,ResultBuy);
         OrderSend(BigDogSell,ResultSell);
        }
     }

//--- trailing implementation
   int PosTotal=PositionsTotal();
   for(int i=PosTotal-1; i>=0; i--)
     {
      //--- go through open positions and see if there are positions created by this Expert Advisor.
      if(PositionGetSymbol(i)==Symbol())
        {
         if(MagicNumber==PositionGetInteger(POSITION_MAGIC))
           {
            MqlTick lasttick;
            SymbolInfoTick(Symbol(),lasttick);
            if(PositionGetInteger(POSITION_TYPE)==0)
              { //--- buy
               if(TrailingStop>0
                  &&(((lasttick.bid-PositionGetDouble(POSITION_PRICE_OPEN))/Point())>TrailingStop)
                  && ((lasttick.bid-PositionGetDouble(POSITION_SL))/Point())>TrailingStop)
                 {
                  MqlTradeRequest BigDogModif;
                  ZeroMemory(BigDogModif);
                  BigDogModif.action= TRADE_ACTION_SLTP;
                  BigDogModif.symbol= Symbol();
                  BigDogModif.sl = lasttick.bid - TrailingStop*Point();
                  BigDogModif.tp = PositionGetDouble(POSITION_TP);
                  BigDogModif.deviation=3;
                  MqlTradeResult BigDogModifResult;
                  ZeroMemory(BigDogModifResult);
                  OrderSend(BigDogModif,BigDogModifResult);
                 }
              }
            if(PositionGetInteger(POSITION_TYPE)==1)
              {//--- sell
               if(TrailingStop>0
                  && ((PositionGetDouble(POSITION_PRICE_OPEN)-lasttick.ask)/Point()>TrailingStop)
                  && (PositionGetDouble(POSITION_SL)==0
                  || (PositionGetDouble(POSITION_SL)-lasttick.ask)/Point()>TrailingStop))
                 {
                  MqlTradeRequest BigDogModif;
                  ZeroMemory(BigDogModif);
                  BigDogModif.action= TRADE_ACTION_SLTP;
                  BigDogModif.symbol= Symbol();
                  BigDogModif.sl = lasttick.ask + TrailingStop*Point();
                  BigDogModif.tp = PositionGetDouble(POSITION_TP);
                  BigDogModif.deviation=3;
                  MqlTradeResult BigDogModifResult;
                  ZeroMemory(BigDogModifResult);
                  OrderSend(BigDogModif,BigDogModifResult);
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+

Conclusione

Ci sono molti fenomeni di mercato che si verificano periodicamente e regolarmente e se indagati possono garantirci qualche vantaggio. Inoltre, forse, i trader esperti hanno notato alcune sovrapposizioni con la ben nota strategia di "BigDog", l'articolo non lo menziona e l'ho fatto apposta - in modo che il lettore pensasse a come sono davvero preparati.

In Internet puoi familiarizzare con le diverse varianti di questa strategia, questo articolo si occupa solo del fenomeno su cui si basa questa strategia.