A la caza de la tendencia

Advertencia

La información contenida en este texto es solamente mi punto de vista particular. En ningún momento induzco a actuar de acuerdo el algoritmo que describo. Advierto que el uso de esta información puede incurrir en posibles pérdidas.

Introducción

A continuación vamos a exponer un método de trading basado en la acumulación del volumen de las operaciones ganadoras. Supongo que solo las transacciones ganadoras se pueden acumular. El artículo explica cómo implementar esta idea de manera óptima, y contiene el código de un EA que ayuda a ejecutar las operaciones correctamente.

Concepto del algoritmo

Acumular el volumen de una operación rentable permite obtener el beneficio máximo del movimiento del mercado. Pero el volumen se tiene que acumular para no incurrir en un aumento del riesgo. Este artículo describe un algoritmo de acumulación de volumen.

En primer lugar necesitamos un punto de referencia: la primera operación principal. El volumen de la operación principal tiene que ser mayor que el de todas y cada una de las operaciones auxiliares. Supongamos que el volumen de la transacción principal es de 0.2 lotes; el volumen de las operaciones auxiliares será de 0.1 lotes. Se utiliza un Trailing Stop Loss en todas las transacciones, por ejemplo de 50 puntos. Cuando el beneficio de la operación principal alcanza +100 puntos, el Stop Loss vale +50. En ese momento se abre una transacción de 0.1 lotes en la misma dirección, con un Stop Loss de -50 puntos. Si el precio retrocede, el Stop Loss cerrará ambas órdenes. El beneficio adquirido será igual a 50 puntos de 0.2 lotes, y la pérdida valdrá -50 puntos de 0.1 lotes. El beneficio total será pues de 50 puntos de 0.1 lotes. Así se consigue una pérdida de protección, mientras por otro lado aumenta el volumen de trading.

Si una transacción sigue el movimiento del mercado en la dirección necesaria, cuando el beneficio de la operación auxiliar alcanza +50 puntos, se habilita el Trailing Stop. Cuando la operación principal alcanza un beneficio de 200 puntos, y la auxiliar llega a los 100 puntos, se abre una operación auxiliar nueva. De nuevo, el SL vale -50. Y así sucesivamente.

Este método sencillo basado en la acumulación del lote permite obtener buenos resultados. Al mismo tiempo se minimiza el riesgo. En realidad, el riesgo aquí consiste en perder sólo una parte de la operación principal, esto es, el riesgo de que la primera operación auxiliar derive en pérdida. Sin embargo no supone un riesgo de pérdida en sí, sino no obtener el beneficio completo.

El Trailing Stop Loss estándar permite transacciones trailing solo si hay beneficio. Pero si se lleva a cabo en las transacciones auxiliares, antes de obtener la ganancia necesaria, se puede aumentar la rentabilidad de la técnica de acumulación de lotes. También se puede optimizar la apertura de órdenes auxiliares con la ayuda de MQL4.

Implementación

Hemos escrito un Asesor Experto con este objetivo en mente, basándonos en el EA expuesto en el artículo "Scalping agradable". El EA de dicho artículo tiene una naturaleza dual: desempeña el papel de un juego y el de una herramienta que coloca órdenes en el mercado. En esta operación se eliminó la función del juego. Así que el Asesor Experto dibuja dos flechas en el gráfico: una hacia arriba y otra hacia abajo. Borrar una de ellas se interpreta como una señal de apertura de operación en la dirección correspondiente. Por ejemplo, al borrar una flecha hacia abajo queda una flecha hacia arriba en el gráfico. Esto indica al EA que abra una orden de compra y coloque unas cuantas órdenes pendientes Buy Stop.

La orden principal es una orden de mercado. Las órdenes pendientes desempeñan la función de órdenes auxiliares, cuyo lote es más pequeño que el principal. Para el cálculo de la "frecuencia" de apertura de posiciones auxiliares, así como para su cantidad, se utilizan dos conceptos. El primero es el Take Profit, el objetivo final. Éste es igual en todas las órdenes (principales y auxiliares). El segundo concepto es el paso de apertura de órdenes pendientes. Dependiendo del objetivo final, el EA calcula cuántas órdenes puede colocar en el intervalo comprendido entre el precio actual y el nivel Take Profit.

Por ejemplo, si utilizamos un Take Profit de 400 puntos y el paso de apertura de posición es de 100 puntos (por defecto), se abrirán 4 órdenes Buy. La primera de ellas es un Buy de precio Ask, la transacción principal. La segunda orden es un Buy Stop auxiliar cuyo precio es Ask + 100 puntos. La tercera es un Buy Stop auxiliar de Ask + 200 puntos. La cuarta es un Buy Stop auxiliar a un precio de Ask + 300 puntos. El Take Profit será igual a Ask + 400 puntos; es decir, en la primera orden valdrá 400 puntos, en la segunda 300, en la tercera 200, y valdrá 100 puntos en la cuarta orden.

El Trailing Stop Loss de la operación principal solo funciona si se obtiene el beneficio necesario (50 puntos por defecto). En las operaciones auxiliares funciona desde el momento de la apertura (es decir, el Stop Loss se puede arrastrar a la zona de pérdida). El nivel Trailing Stop Loss es igual en todas las operaciones. Además del Trailing Stop Loss las operaciones auxiliares tienen un nivel Stop Loss.

Si se cierra la orden principal, las órdenes pendientes restantes se eliminan. Tras lo cual se vuelven a dibujar en el gráfico dos flechas. Esto indica que el EA está dispuesto a abrir nuevas posiciones.

Todo esto puede parecer extenso, pero se implementa fácilmente en la práctica. Analicemos el código del Asesor Experto.

//+------------------------------------------------------------------+
//|                                                   take_trend.mq4 |
//|                                       Copyright © 2008, FXRaider |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, FXRaider"
extern int gap=20;            //nivel donde se colocan las flechas 
extern int TP=400;            //nivel Take Profit
extern int SL=0;              //nivel Stop Loss
extern double Lots1=0.2;      //lote de la orden principal
extern double Lots2=0.1;      //lote de las órdenes auxiliares 
extern int slippage=2;        //nivel de recotización aceptable
extern int MagicNumber1=5345; //número mágico de la operación principal
extern int MagicNumber2=4365; //número mágico de las operaciones auxiliares
extern int Open_Step=100;     //paso de apertura de las operaciones auxiliares
 
extern bool UseTrailing = true; //activar/desactivar T-SL
extern int TrailingStop = 50;   //nivel Trailing Stop Loss
extern int TrailingStep = 1;    //paso Trailing Stop Loss
int start()
  {
//------------------------------       
//+----------------------------------------------------------------------------------------------+
//|                              búsqueda de órdenes abiertas de un par                          |
    int pos_sell=0;
  for (int i_op_sell=OrdersTotal()-1; i_op_sell>=0; i_op_sell--) 
  { 
   if (!OrderSelect(i_op_sell,SELECT_BY_POS,MODE_TRADES)) break; 
   if (Symbol()==OrderSymbol()
   &&OrderMagicNumber()==MagicNumber1   
   &&(OrderType()==OP_SELL))
   {
    pos_sell=1; break;   
   } 
  }
    
    int pos_buy=0;
  for (int i_op_buy=OrdersTotal()-1; i_op_buy>=0; i_op_buy--) 
  { 
   if (!OrderSelect(i_op_buy,SELECT_BY_POS,MODE_TRADES)) break; 
   if (Symbol()==OrderSymbol()
   &&OrderMagicNumber()==MagicNumber1
   &&(OrderType()==OP_BUY))
   {
    pos_buy=1; break;   
   } 
  }    
//|                              búsqueda de órdenes abiertas de un par                          |
//+----------------------------------------------------------------------------------------------+  
//+------------------------------------------------------------------------------------+
//|                                 trabajando con objetos                             |  
 
//+----------------------------------------------------------+
//|                    borrado de objetos                    | 
  if(iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))>0
     ||ObjectGet("down",OBJPROP_PRICE1)!=Open[0]-gap*Point) 
    {
     ObjectDelete("down"); 
    }  
  if(iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))>0
    ||ObjectGet("up",OBJPROP_PRICE1)!=Open[0]+gap*Point)            
    { 
     ObjectDelete("up"); 
    } 
//|                    borrado de objetos                    |   
//+----------------------------------------------------------+ 
 
//+----------------------------------------------------------+
//|                   dibujo de objetos                      |   
   if((ObjectFind("down") != 0&&ObjectFind("up") != 0) //si no hay objetos
   &&!pos_sell&&!pos_buy)                              //si no hay órdenes abiertas
   {
     ObjectCreate("down", OBJ_ARROW, 0, Time[0], Open[0]-gap*Point); //dibujar una flecha hacia abajo
     ObjectSet("down", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("down", OBJPROP_ARROWCODE, 234);
     ObjectSet("down", OBJPROP_COLOR, Red);
 
     ObjectCreate("up", OBJ_ARROW, 0, Time[0], Open[0]+gap*Point); //dibujar una flecha hacia arriba
     ObjectSet("up", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("up", OBJPROP_ARROWCODE, 233);
     ObjectSet("up", OBJPROP_COLOR, Blue);
   }    
//|                   dibujo de objetos                      |
//+----------------------------------------------------------+   
      
//|                                 trabajar con objetos                               |   
//+------------------------------------------------------------------------------------+
 
   
 
 
//+----------------------------------------------------------------------------------------------+ 
//|                                borrar órdenes innecesarias                                   | 
int cnt_del; 
if(pos_buy==0)
{               
  for (cnt_del=0; cnt_del<OrdersTotal(); cnt_del++) 
  {
    if (!(OrderSelect(cnt_del, SELECT_BY_POS, MODE_TRADES))) continue;     
    if(OrderSymbol()==Symbol())
    {
     if (OrderType()==OP_BUYSTOP && OrderMagicNumber()==MagicNumber2) OrderDelete(OrderTicket()); 
    }
  } 
 } 
 
if(pos_sell==0)
{               
  for (cnt_del=0; cnt_del<OrdersTotal(); cnt_del++) 
  {
    if (!(OrderSelect(cnt_del, SELECT_BY_POS, MODE_TRADES))) continue;     
    if(OrderSymbol()==Symbol())
    { 
    if (OrderType()==OP_SELLSTOP && OrderMagicNumber()==MagicNumber2) OrderDelete(OrderTicket()); 
    }
  } 
 }  
//|                                borrar órdenes innecesarias                                   |
//+----------------------------------------------------------------------------------------------+  
 
  
//+------------------------------------------------------------------------------------+ 
//|                                   apertura de posiciones                           |
double sl_buy, sl_sell;
 if(!SL)
 { 
  sl_buy=0;
  sl_sell=0;
 }
 else
 {
  sl_buy=Ask-SL*Point;
  sl_sell=Bid+SL*Point;
 }
 int stop_positions=MathFloor(TP/Open_Step-1);
 int i, open_step_2;
  if(
     ObjectGet("up", OBJPROP_PRICE1)==Open[0]+gap*Point
     &&iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))==0
     &&ObjectFind("down") != 0
     &&ObjectFind("up") == 0
     &&!pos_buy  
     )
     {
      OrderSend(Symbol(),OP_BUY, Lots1,Ask,slippage,sl_buy,Ask+TP*Point,"take_trend",MagicNumber1,0,Blue); 
      for(i=stop_positions;i>=0; i--) 
      {
       open_step_2=open_step_2+Open_Step;
       OrderSend(Symbol(),OP_BUYSTOP, Lots2,
       Ask+open_step_2*Point,slippage,
       0,Ask+TP*Point,"take_trend",MagicNumber2,0,Blue);
      }          
     }
  if(
     ObjectGet("down", OBJPROP_PRICE1)==Open[0]-gap*Point
     &&iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))==0
     &&ObjectFind("up") != 0
     &&ObjectFind("down") == 0
     &&!pos_sell
     )
     {
      OrderSend(Symbol(),OP_SELL, Lots1,Bid,slippage,sl_sell,Bid-TP*Point,"take_trend",MagicNumber1,0,Red);
      for(i=stop_positions;i>=0; i--) 
      {
       open_step_2=open_step_2+Open_Step;
       OrderSend(Symbol(),OP_SELLSTOP, Lots2,
       Bid-open_step_2*Point,slippage,
       0,Bid-TP*Point,"take_trend",MagicNumber2,0,Red);
      }        
     }
//|                                   apertura de posiciones                           |  
//+------------------------------------------------------------------------------------+   
 
 
//+-------------------------------------------------------------------------------------------------+ 
//|                                      trail de posiciones abiertas                               |
if (UseTrailing)
{ 
  for (int trall=0; trall<OrdersTotal(); trall++) {
    if (!(OrderSelect(trall, SELECT_BY_POS, MODE_TRADES))) continue;
    if (OrderSymbol() != Symbol()) continue;       
 
    if (OrderType() == OP_BUY ) {
      if (Bid-OrderOpenPrice() > TrailingStop*Point || OrderMagicNumber()==MagicNumber2) {
        if (OrderStopLoss() < Bid-(TrailingStop+TrailingStep-1)*Point || OrderStopLoss() == 0) {
          OrderModify(OrderTicket(), OrderOpenPrice(), Bid-TrailingStop*Point, OrderTakeProfit(), 0, Blue);
       }
      }
    }
 
    if (OrderType() == OP_SELL) {
     if (OrderOpenPrice()-Ask > TrailingStop*Point || OrderMagicNumber()==MagicNumber2) {
        if (OrderStopLoss() > Ask+(TrailingStop+TrailingStep-1)*Point || OrderStopLoss() == 0) {
          OrderModify(OrderTicket(), OrderOpenPrice(), Ask+TrailingStop*Point, OrderTakeProfit(), 0, Blue);
        }
     }
    }
  }
 }
//|                                      trail de posiciones abiertas                               |
//+-------------------------------------------------------------------------------------------------+
     
   return(0);
  }
//+------------------------------------------------------------------+

El código incluye comentarios.

Variables:

gap – nivel donde se colocan las flechas;
TP – nivel Take Profit;
SL – nivel Stop Loss;
Lots1 – lote de la operación principal;
Lots2 – lote de las operaciones auxiliares;
slippage – nivel de recotización aceptable;
MagicNumber1 – número mágico de la transacción principal;
MagicNumber2 – número mágico de las transacciones auxiliares;
Open_Step – paso de apertura de las órdenes auxiliares;


UseTrailing – activar/desactivar T-SL;
TrailingStop – nivel Trailing Stop Loss;
TrailingStep – paso Trailing Stop Loss.

Al adjuntar al gráfico el Asesor Experto se dibujan dos flechas:

La flecha restante permanecerá en el gráfico hasta la siguiente vela:

Justo después de borrar una de las flechas, el EA abre posiciones:

Como se puede ver, la flecha restante no se muestra en la imagen; tal y como se indicó anteriormente, se elimina en la siguiente vela, y las flechas aparecen cuando se cierran todas las operaciones. Cuando el beneficio de la primera orden alcanza el nivel necesario, el T-SL comienza a trabajar (siempre funciona en las transacciones auxiliares). En este ejemplo solo se cierra la primera operación. A continuación se borran todas las órdenes:

Conclusión

Para concluir, quisiera añadir que tanto los niveles de Trailing Stop Loss y Take Profit, como el nivel de apertura de las operaciones auxiliares, deben escogerse individualmente para cada par. Téngase también en cuenta que para un uso eficiente, el nivel de apertura de las operaciones auxiliares debe ser mayor que el nivel de T-SL. Se recomienda que el tamaño del lote de la operación principal sea superior al de las operaciones auxiliares.