Diablo - página 12

Nuevo comentario
 

Hice un Asesor Experto, que coloca órdenes como en la metodología del autor, pero hay diferencias. Coloca las órdenes según los niveles en función del ATR (si la metodología es ganar-ganar, entonces qué diferencia hay de qué niveles colocar). Al comienzo de un nuevo día cierra y borra todas las órdenes (es que no sé de qué otra manera cerrar las órdenes que no tienen TP y SL y que no van a aportar beneficios).

Puedes intentar optimizar los parámetros. Es que me da pereza, no creo en esta estrategia.

Archivos adjuntos:
duablo_28.09.10_v01.mq4  4 kb
 
khorosh:
Cuando la crítica es demasiado perezosa para ser razonada, pero realmente quieres decir algo, es mejor callar que fastidiar.
No olvides mirarte en el espejo.
 

Diablo v09.02.12 (Versión Inmortal)

Se colocan órdenes de dos tipos a cierta distancia del precio en intervalos iguales: órdenes rectas (Buy Stop arriba del precio y Sell Stop abajo del precio) y órdenes invertidas (Sell Limit arriba del precio y Buy Limit abajo del precio). Las órdenes Buy Stop y Sell Limit se colocan en los mismos niveles (en pares), así como las órdenes Sell Stop y Buy Limit.

Todas las órdenes tienen el mismo volumen y Stop Loss igual al paso entre las órdenes.

Las órdenes directas (Buy Stop y Sell Stop) no tienen Take Profit. Las órdenes invertidas (Sell Limit y Buy Limit) tienen el Take Profit aritméticamente creciente: la primera orden (la más cercana al precio) tiene un paso entre las órdenes, la segunda orden (un poco más lejana) tiene tres pasos, la tercera orden tiene cinco pasos y así sucesivamente.


Un script para hacer pedidos:

// Diablo v09.02.12
#property copyright "Jon Katana"
#property show_inputs
extern int Step=0,Spread=0,Levels=0;
extern double Up=0,Vol=0;
int start()
{for(int i=0;i<(Levels);i++)
{OrderSend(Symbol(),OP_BUYSTOP,Vol,Up+(i*Step+Spread)*Point,0,Up+(i-1)*Step*Point,0,0,0);
OrderSend(Symbol(),OP_SELLSTOP,Vol,Up-(i+1)*Step*Point,0,Up-(i*Step-Spread)*Point,0,0,0);
OrderSend(Symbol(),OP_SELLLIMIT,Vol,Up+i*Step*Point,0,Up+((i+1)*Step+Spread)*Point,Up-(Step*(i+1)+Spread)*Point,0,0);
OrderSend(Symbol(),OP_BUYLIMIT,Vol,Up-((i+1)*Step-Spread)*Point,0,Up-(i+2)*Step*Point,Up+i*Step*Point,0,0);}
return(0);}

El sistema es completamente indestructible. Si se deja, al final siempre se cierra con beneficio o a cero.

Muy buena es la tendencia sin retroceso en el tamaño del paso - el beneficio aumenta como una bola de nieve, lo que permite recoger un movimiento de precios varias veces. En el plano el beneficio es moderado o va a cero. La variante más lenta es el patrón "dragón", cuando el precio se mueve en una dirección, pero retrocede de cada nivel un paso, y luego va más allá. En este caso, sólo tardará un poco más en alcanzar el beneficio o el cero.

Por lo tanto, calcule el paso entre los niveles para colocar órdenes de manera que el precio no toque los niveles ya superados por las minicorrecciones.

El esquema puede dejarse sin control mientras el precio no supere los niveles en los que se colocan las órdenes. Otra variante es seguir el Diablo y cerrarlo cuando se alcance algún beneficio (por ejemplo, el tamaño de un paso) con la posterior reordenación de las órdenes de nuevo, o simplemente cerrar una sola vez con beneficio.

 

Corrección en el script: había una compensación errónea para el spread en las órdenes de Venta Limitada:

// Diablo v13.02.12
#property copyright "Jon Katana"
#property show_inputs
extern int Step=0,Spread=0,Levels=0;
extern double Up=0,Vol=0;
int start()
{for(int i=0;i<(Levels);i++)
{OrderSend(Symbol(),OP_BUYSTOP,Vol,Up+(i*Step+Spread)*Point,0,Up+(i-1)*Step*Point,0,0,0);
OrderSend(Symbol(),OP_SELLSTOP,Vol,Up-(i+1)*Step*Point,0,Up-(i*Step-Spread)*Point,0,0,0);
OrderSend(Symbol(),OP_SELLLIMIT,Vol,Up+i*Step*Point,0,Up+((i+1)*Step+Spread)*Point,Up-(Step*(i+1)-Spread)*Point,0,0);
OrderSend(Symbol(),OP_BUYLIMIT,Vol,Up-((i+1)*Step-Spread)*Point,0,Up-(i+2)*Step*Point,Up+i*Step*Point,0,0);}
return(0);}
 

extern int Paso=0,Dispersión=0,Niveles=0;
extern double Up=0,Vol=0.

¿Qué parámetros debo poner aquí para que funcione?

 
Por qué no asignamos la variable UP a asc, para que los pedidos se realicen a partir del precio actual....
  
#property copyright "Jon Katana"
#property show_inputs
extern int Step=50,Spread=2,Levels=5;
extern double Up=0,Vol=0.1;
int TotalOrders,i;
int start()
{Up=Ask;
        TotalOrders=OrdersTotal();
        for (i=0; i<=TotalOrders; i++){
                 if (OrderSelect(0,SELECT_BY_POS)==true){
                    if (OrderType()==OP_BUY) OrderClose(OrderTicket(),OrderLots(),Bid,5,Red);
                    if (OrderType()==OP_SELL) OrderClose(OrderTicket(),OrderLots(),Ask,5,Red);
                    if (OrderType()==OP_SELLSTOP) OrderDelete(OrderTicket(),Green);
                    if (OrderType()==OP_BUYSTOP) OrderDelete(OrderTicket(),Green);
                    if (OrderType()==OP_SELLLIMIT) OrderDelete(OrderTicket(),Green);
                    if (OrderType()==OP_BUYLIMIT) OrderDelete(OrderTicket(),Green);
                 
                 }
        }

for(int i=0;i<(Levels);i++)
{OrderSend(Symbol(),OP_BUYSTOP,Vol,Up+(i*Step+Spread)*Point,0,Up+(i-1)*Step*Point,0,0,0);
OrderSend(Symbol(),OP_SELLSTOP,Vol,Up-(i+1)*Step*Point,0,Up-(i*Step-Spread)*Point,0,0,0);
OrderSend(Symbol(),OP_SELLLIMIT,Vol,Up+i*Step*Point,0,Up+((i+1)*Step+Spread)*Point,Up-(Step*(i+1)-Spread)*Point,0,0);
OrderSend(Symbol(),OP_BUYLIMIT,Vol,Up-((i+1)*Step-Spread)*Point,0,Up-(i+2)*Step*Point,Up+i*Step*Point,0,0);}
return(0);
}
He añadido una limpieza al script. Es decir, si hay órdenes abiertas o pendientes, primero borra todo y luego pone las órdenes pendientes según los parámetros...
 
IronBird:

extern int Step=0,Spread=0,Levels=0;
extern double Up=0,Vol=0

¿Qué parámetros hay que introducir aquí para que funcione?

Paso - paso entre órdenes en puntos (por ejemplo, 20 para una orden de cuatro dígitos o 200 para una de cinco dígitos);

Spread - spread en pips (por ejemplo, 2 para cuatro dígitos o 20 para cinco dígitos);

Niveles - el número de niveles en los que se colocarán las órdenes (por ejemplo, 20);

Arriba - una línea por encima del precio, a partir de la cual se iniciará la colocación de órdenes hacia arriba (las órdenes se colocarán automáticamente con un desplazamiento de Paso desde esta línea);

Vol - volumen de pedidos (por ejemplo 0,1).

 
nikelodeon:
Por qué no asignamos la variable UP a asc, para que los pedidos se realicen a partir del precio actual....

Por dos razones:

1) No se pueden colocar órdenes a partir de un determinado nivel (resistencia, soporte, Fibonacci, Rabbit...)

2) Hay decenas de pedidos, y no se hacen al instante. Durante este tiempo el Ask puede desplazarse del valor inicial, lo que mueve imprevisiblemente los lugares de colocación de las órdenes y sus Take Profit y Stop Loss. Esto permitirá al centro de negociación abrir órdenes en niveles no por un par, pero "tirar" de órdenes separadas sin captar la segunda orden del par, y luego llevarlas a pérdidas, lo que destruiría todo el sistema.

 
JonKatana:

Por dos razones:

1) No se pueden colocar órdenes a partir de un determinado nivel (resistencia, soporte, Fibonacci, Rabbit...)

2) Hay decenas de pedidos, y no se hacen al instante. Durante este tiempo el Ask puede desplazarse del valor inicial, lo que mueve imprevisiblemente los lugares de colocación de las órdenes y sus Take Profit y Stop Loss. Esto permitirá al centro de negociación abrir órdenes en niveles no por un par, sino "tirar" de órdenes separadas, sin captar la segunda orden del par, y luego llevarlas a pérdidas, lo que arruinará todo el sistema.

Puede establecer las dos primeras órdenes utilizando el precio actual y calcular los precios de las demás órdenes en relación con los precios de la primera orden. Las dos primeras órdenes pueden ser órdenes de mercado.
1...5678910111213141516171819...28
Nuevo comentario