Descargar MetaTrader 5

Scalping Agradable

24 noviembre 2015, 12:35
Eryomin Sergey
0
473

Introducción

Como decimos, este artículo describe un algoritmo de apertura de posiciones cuyo objetivo es hacer scalping de forma cómoda. Sin embargo, el algoritmo que definiremos aquí también es válido en otros muchos enfoques de trading. En realidad, describiremos un método para ayudar a los traders a ejecutar operaciones rápidas.

Generalmente se considera que el scalping es un tipo de trading muy nervioso. Hay que indicar el lote, así como los niveles de TakeProfit y StopLoss en cada momento, sin dejar de prestar atención al gráfico.

Este artículo es la continuación de "Betting Modeling as Means of Developing "Market Intuition"". Recomiendo leerlo antes de continuar leyendo este texto.

Antes de nada me gustaría recordar qué es el scalping. El scalping es un método de trading rápido. Generalmente aporta beneficios comprendidos entre 1 y 10 pips (puntos). Este sistema es conocido por su complejidad, por el nerviosismo que genera, y por la atención que exige al trader. Hay quien cree que no es un método serio, y otros piensan que dominar esta técnica es todo un arte. Personalmente no voy a entrar a valorar este tipo de trading; cada uno es libre de opinar como desee.


Concepto

Muy probablemente casi todos los traders habrán intentado aplicar alguna estrategia de scalping en algún momento de su carrera. Para algunos el scalping es lo más práctico, mientras que para otros es justo lo contrario. Hay quien cree que el scalping es interesante, pero otras opiniones afirman que es una pérdida de tiempo. Sin embargo todo el mundo está de acuerdo en que esta técnica exige prestar una atención superior, tanto al mercado como a las posiciones abiertas.

De hecho, muchos traders no hacen scalping porque requiere ciertamente mucho esfuerzo y porque pone nervioso. No obstante, existen métodos que pueden ayudan al scalper.

Supongamos que un trader hace scalping con un lote y un take profit fijos en cada transacción. En tal caso no hace falta indicar esos parámetros en cada operación. Porque requiere un tiempo extra y exige al trader prestar mucha atención.

Necesitamos pues una herramienta que abra posiciones con un lote fijo y unos niveles TP/SL determinados. Esta herramienta debe funcionar de la manera más sencilla posible; además, tiene que distraer lo justo al trader del gráfico.

Este programa se puede implementar fácilmente con MQL4.


Implementación

Tomemos el juego descrito en el artículo "Betting Modeling as Means of developing "Market Intuition"". Crearemos una herramienta para jugar a ese juego y haremos trading al mismo tiempo.

Breve descripción del juego. Se dibujan dos flechas en el gráfico: una hacia arriba y otra hacia abajo. El trader elimina una flecha innecesaria, tomando así una decisión que denota su opinión: si el activo subirá o bajará. Al principio de una nueva vela el EA comprueba si la previsión del trader es acertada. La exactitud de la predicción influye en la puntuación del juego. Además, el trader puede hacer su elección dentro de un período limitado de tiempo que puede cambiar (el trader decide si lo establece o no).

Dibujaremos dos flechas más, una barra a la izquierda de la barra actual. La barra actual se seguirá utilizando para las apuestas. Al borrar una flecha en la barra anterior se generará una señal para que el EA abra una posición en la dirección correspondiente. También se desactivará la limitación del plazo para elegir una dirección de trading. Los parámetros a configurar son: los niveles de TakeProfit y StopLoss, el lote, el slippage y el número mágico. Por otro lado, el trading se puede deshabilitar por medio de la variable booleana externa; por consiguiente el EA solo se utilizará para las apuestas.

En el momento de abrir una posición se dibuja en el gráfico una flecha de compra o de venta, dependiendo de la transacción. Esto evitará que el Asesor Experto abra nuevas posiciones en la vela. La flecha se dibujará a 300 puntos del precio de apertura de la barra, por lo que el usuario probablemente ni lo notará.

El EA se divide en dos bloques: el juego y la apertura de la posición. El lector puede observar el código correspondiente.

De modo que tenemos el siguiente programa:

//+------------------------------------------------------------------+
//|                                                       trener.mq4 |
//|                                       Copyright © 2008, FXRaider |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, FXRaider"
extern int gap=2;
extern bool Trading=true;
extern int TP=2;
extern int SL=20;
extern double Lots=0.02;
extern int slippage=1;
extern int MagicNumber=777;
extern int time_limit=30;
int start()
  {
//----
//#################################################################################
//####################################### JUEGO ###################################
//------------------------------
string solution="none"; 
int point, 
    point_neg, 
    point_pos;
//------------------------------    
//+---------------------------------------------------------------+
//|                      opción de búsqueda "arriba"              | 
 if(
    ObjectGet("up", OBJPROP_PRICE1)==Open[1]+gap*Point
    &&iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))==1
    &&ObjectFind("down") != 0
    &&ObjectFind("up") == 0
    )
    {
     solution="up";
    }
//|                      opción de búsqueda "arriba"              |  
//+---------------------------------------------------------------+
  
//+---------------------------------------------------------------+
//|                      opción de búsqueda "abajo"               |     
 if(
    ObjectGet("down", OBJPROP_PRICE1)==Open[1]-gap*Point
    &&iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))==1    
    &&ObjectFind("up") != 0
    &&ObjectFind("down") == 0
    )
    {
     solution="down";
    }
//|                      Opción de búsqueda "abajo"               |       
//+---------------------------------------------------------------+    
 
//+---------------------------------------------------------------+
//|             contar puntos en respuesta positiva               |
    if((solution=="up"&&Open[1]<Close[1])
      ||(solution=="down"&&Open[1]>Close[1]))
    {
     point=1;
     point_pos=1;
     point_neg=0;     
    }  
//|             contar puntos en respuesta positiva               |   
//+---------------------------------------------------------------+
 
//+---------------------------------------------------------------+
//|             contar puntos en respuesta negativa               |    
    if((solution=="up"&&Open[1]>Close[1])
      ||(solution=="down"&&Open[1]<Close[1]))
    {
     point=-1;
     point_pos=0;
     point_neg=1;     
    } 
//|             contar puntos en respuesta negativa               |
//+---------------------------------------------------------------+
 
//+----------------------------------------------------------------------------------+
//|                              trabajar con un archivo externo                     |       
      int handle; 
      double points,     //puntuación total
             points_pos, //puntuación de respuestas positivas
             points_neg; //puntuación de respuestas negativas 
       handle=FileOpen("trener_"+Symbol()+"_"+Period()+".csv",
                       FILE_CSV|FILE_WRITE|FILE_READ,";");
       if(handle>0) //si hay un archivo, leerlo
       { 
        points=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits); 
        points_pos=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits); 
        points_neg=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits);       
        FileClose(handle);
       } 
       
    if(solution!="none") //si se ha hecho una elección 
    {        
      handle=FileOpen("trener_"+Symbol()+"_"+Period()+".csv",
                      FILE_CSV|FILE_WRITE|FILE_READ,";");
      FileWrite(handle ,points+point);         //escribir la puntuación total
      FileWrite(handle ,points_pos+point_pos); //escribir la puntuación de respuestas positivas
      FileWrite(handle ,points_neg+point_neg); //escribir la puntuación de respuestas negativas                    
      FileClose(handle); 
    } 
//|                              trabajar con un archivo externo                     | 
//+----------------------------------------------------------------------------------+    
 
//+------------------------------------------------------------------------------------+
//|                                 trabajar con 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"); 
    } 
   
  int sec_lim;  
  if(!time_limit)
  {
   sec_lim=0; 
  }
  else
  {
   sec_lim=TimeCurrent()-time_limit;
  }
  if(sec_lim>ObjectGet("up",OBJPROP_TIME1)
     &&sec_lim>ObjectGet("down",OBJPROP_TIME1) 
     &&ObjectFind("down") == 0&&ObjectFind("up") == 0
     &&iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))==0
     &&iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))==0)            
    { 
     ObjectDelete("up"); 
     ObjectDelete("down");      
    } 
  
   if((ObjectFind("down") != 0&&ObjectFind("up") != 0) //si no hay objeto
      &&sec_lim<Time[0])
   {
     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, SYMBOL_ARROWDOWN);
     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, SYMBOL_ARROWUP);
     ObjectSet("up", OBJPROP_COLOR, Blue);
    }      
//|                                 trabajar con objetos                               |   
//+------------------------------------------------------------------------------------+
//####################################### JUEGO ###################################
//#################################################################################
 
 
//#################################################################################
//#################################### TRADING ####################################
//+------------------------------------------------------------------------------------+  
//|                                trabajar con objetos I                              | 
  if(iBarShift(NULL,0,ObjectGet("down_1",OBJPROP_TIME1))>1
  ||ObjectGet("down_1",OBJPROP_PRICE1)!=Open[0]-gap*Point
  ||!Trading)  
  {
   ObjectDelete("down_1"); 
  }  
  
  if(iBarShift(NULL,0,ObjectGet("up_1",OBJPROP_TIME1))>1
  ||ObjectGet("up_1",OBJPROP_PRICE1)!=Open[0]+gap*Point
  ||!Trading)  
  { 
   ObjectDelete("up_1"); 
  } 
  
  if(iBarShift(NULL,0,ObjectGet("sell",OBJPROP_TIME1))>0
  ||ObjectGet("sell",OBJPROP_PRICE1)!=Open[0]-300*Point
  ||!Trading) 
  {
   ObjectDelete("sell"); 
  }
  if(iBarShift(NULL,0,ObjectGet("buy",OBJPROP_TIME1))>0
  ||ObjectGet("buy",OBJPROP_PRICE1)!=Open[0]+300*Point 
  ||!Trading)
  
  {
   ObjectDelete("buy"); 
  } 
  
   if(ObjectFind("down_1") != 0&&ObjectFind("up_1") != 0 && Trading)
   {
     ObjectCreate("down_1", OBJ_ARROW, 0, Time[1], Open[0]-gap*Point);
     ObjectSet("down_1", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("down_1", OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
     ObjectSet("down_1", OBJPROP_COLOR, Red);
 
     ObjectCreate("up_1", OBJ_ARROW, 0, Time[1], Open[0]+gap*Point);
     ObjectSet("up_1", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("up_1", OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
     ObjectSet("up_1", OBJPROP_COLOR, Blue);
    }  
//|                                trabajar con objetos I                              |    
//+------------------------------------------------------------------------------------+     
 if(Trading)
 {
//+----------------------------------------------------------------------------------------------+
//|                              buscar órdenes de apertura de un valor                          |
    int pos_sell=0, bar_op_buy, bar_op_sell;
  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()
   &&(OrderType()==OP_SELLSTOP||OrderType()==OP_SELL)
   &&(OrderMagicNumber()==MagicNumber)
   &&iBarShift(NULL,0,OrderOpenTime())==0)
   {
    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()
   &&(OrderType()==OP_BUYSTOP||OrderType()==OP_BUY)
   &&(OrderMagicNumber()==MagicNumber)
   &&iBarShift(NULL,0,OrderOpenTime())==0)
   {
    pos_buy=1; break;   
   } 
  }    
//|                              buscar órdenes de apertura de un valor                            |
//+----------------------------------------------------------------------------------------------+ 
 
//+------------------------------------------------------------------------------------+  
//|                                trabajar con objetos II                             |   
 if(pos_buy==1)
 {   
      ObjectCreate("buy", OBJ_ARROW, 0, Time[0], Open[0]+300*Point);
      ObjectSet("buy", OBJPROP_STYLE, STYLE_DOT);
      ObjectSet("buy", OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
      ObjectSet("buy", OBJPROP_COLOR, Red);
 }
 
 if(pos_sell==1)
 {
      ObjectCreate("sell", OBJ_ARROW, 0, Time[0], Open[0]-300*Point);
      ObjectSet("sell", OBJPROP_STYLE, STYLE_DOT);
      ObjectSet("sell", OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
      ObjectSet("sell", OBJPROP_COLOR, Red);    
 }
//|                                trabajar con objetos II                             |   
//+------------------------------------------------------------------------------------+ 
  
//+------------------------------------------------------------------------------------+ 
//|                                   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;
 }
  if(
     ObjectGet("up_1", OBJPROP_PRICE1)==Open[0]+gap*Point
     &&iBarShift(NULL,0,ObjectGet("up_1",OBJPROP_TIME1))==1
     &&ObjectFind("down_1") != 0
     &&ObjectFind("up_1") == 0
     &&!pos_buy
     &&ObjectFind("buy") != 0    
     )
     {
      OrderSend(Symbol(),OP_BUY, Lots,Ask,slippage,sl_buy,Ask+TP*Point,"trener",MagicNumber,0,Blue);            
     }
  if(
     ObjectGet("down_1", OBJPROP_PRICE1)==Open[0]-gap*Point
     &&iBarShift(NULL,0,ObjectGet("down_1",OBJPROP_TIME1))==1
     &&ObjectFind("up_1") != 0
     &&ObjectFind("down_1") == 0
     &&!pos_sell
     &&ObjectFind("sell") != 0
     )
     {
      OrderSend(Symbol(),OP_SELL, Lots,Bid,slippage,sl_sell,Bid-TP*Point,"trener",MagicNumber,0,Red);  
     }
//|                                   apertura de posiciones                           |  
//+------------------------------------------------------------------------------------+   
 }
//#################################### TRADING ####################################
//#################################################################################
 
Comment("Score: ", points," (",points_pos,"/",points_neg,   //mostrar puntuación
        ") | Time: ", Hour(),":", Minute(),":", Seconds()); //mostrar la hora (por conveniencia)
     
   return(0);
  }
//+------------------------------------------------------------------+

El código incluye comentarios.

Tras colocar el Asesor Experto en el gráfico, obtendremos lo siguiente:


Las dos últimas flechas son para el juego, y las dos anteriores se utilizan para colocar órdenes.

La supresión de una flecha en la vela anterior ejecutará la función OrderSend(), abriéndose la orden correspondiente:



Esta es la pestaña para cambiar los parámetros de entrada:


La variable "gap" es la responsable del número de puntos iguales a la distancia entre una flecha y el precio de apertura de una vela. La variable "Trading" denota la función de trading, "TP" es el TakeProfit en puntos y "SL" es el StopLoss en puntos. La variable "Lots" es para el volumen de las posiciones abiertas; "slippage" indica el slippage, en puntos, que estamos dispuestos a aceptar. "MagicNumber" es el número mágico que el Asesor Experto utiliza para abrir posiciones (necesario para que el EA pueda hacer un seguimiento de sus propias órdenes). La variable "time_limit" establece el número de segundos en que el usuario debe hacer su elección. "0" indica que el tiempo no está limitado, es decir, se puede elegir durante todo el período de formación de la vela.


Conclusión

Como resultado tenemos un activo donde hacer trading resulta cómodo, con los parámetros estándar (TP, SL, Slippage, lot). Esta herramienta puede resultar de utilidad en cualquier tipo de trading. Sin embargo, es más eficiente cuando se abre un gran número de transacciones en un período corto de tiempo. For example, in scalping and scalping.

Con este programa el trader no tiene que ir definiendo en todo momento los parámetros de una orden nueva. La atención se concentra pues en un gráfico. Sin duda, esto hace que la eficacia del trading aumente.

Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/1509

Archivos adjuntos |
trener.mq4 (11.66 KB)
Utilizando MetaTrader 4 en el análisis de patrones temporales Utilizando MetaTrader 4 en el análisis de patrones temporales

El análisis de patrones basados en el tiempo sirve para determinar cuál es el mejor momento para entrar en el mercado, o para saber si una operación determinada debe evitarse a toda costa. En este artículo utilizamos MetaTrader 4 para analizar el historial de datos, y generamos unos resultados de optimización que pueden resultar útiles en los sistemas de trading automáticos.

Indicador de líneas de tendencia según el enfoque de T. Demark Indicador de líneas de tendencia según el enfoque de T. Demark

Este indicador muestra las líneas de tendencia junto con los acontecimientos recientes que suceden en el mercado. Se desarrolla de acuerdo a las recomendaciones de Thomas Demark en lo relativo al análisis técnico. El indicador muestra la dirección de la tendencia actual y la penúltima dirección opuesta de la misma.

A la caza de la tendencia A la caza de la tendencia

El presente artículo describe un algoritmo para aumentar el volumen de una operación ganadora. Se adjunta la implementación correspondiente en el lenguaje MQL4.

Asesores Expertos basados en sistemas populares de trading, y un poco de alquimia en la optimización de robots Asesores Expertos basados en sistemas populares de trading, y un poco de alquimia en la optimización de robots

Este artículo trata sobre la implementación de algoritmos de sistemas de trading sencillos. De modo que será de gran utilidad para los traders principiantes, así como para aquellas personas que se inician en la programación de EAs.