Diablo - página 12

[Alkor135]

Fiz um Expert Advisor, que faz pedidos como na metodologia do autor, mas há diferenças. Coloca os pedidos de acordo com os níveis dependendo da ATR (se a metodologia é vantajosa para todos, então que diferença faz de quais níveis colocar). No início de um novo dia fecha e remove todos os pedidos (eu simplesmente não sei como fechar pedidos que não têm TP e SL e que não trarão lucro).

Você pode tentar otimizar os parâmetros. Sou apenas preguiçoso, não acredito nesta estratégia.

[[Excluído]]

khorosh:
Quando a crítica é preguiçosa demais para ser raciocinada, mas você realmente quer dizer algo, é melhor ficar em silêncio do que em lama.

Não se esqueça de olhar para o espelho.

[JonKatana]

Diablo v09.02.12 (Versão Imortal)

As ordens de dois tipos são colocadas a uma certa distância do preço em intervalos iguais: ordens retas (Buy Stop up do preço e Sell Stop down do preço) e ordens invertidas (Sell Limit up do preço e Buy Limit down do preço). Os pedidos de Buy Stop e Sell Limit são colocados nos mesmos níveis (em pares), assim como os pedidos de Sell Stop e Buy Limit.

Todas as ordens têm o mesmo volume e Stop Loss igual ao passo entre as ordens.

Ordens diretas (Buy Stop e Sell Stop) não têm Take Profit. As ordens invertidas (Sell Limit e Buy Limit) têm o aumento aritmético Take Profit: a primeira ordem (a mais próxima do preço) tem um passo entre as ordens, a segunda ordem (um pouco mais distante) tem três passos, a terceira ordem tem cinco passos e assim por diante.

Um roteiro para fazer 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);}

O sistema é completamente indestrutível. Deixado a si mesmo, no final sempre se fecha com lucro ou a zero.

Muito boa é a tendência, sem recuar no tamanho do degrau - o lucro aumenta como uma bola de neve, permitindo coletar um movimento de preços várias vezes. No plano, o lucro é moderado ou vai a zero. A variante mais lenta é o padrão "dragão", quando o preço se move em uma direção, mas retrocede de cada nível em um passo, depois vai mais longe. Neste caso, levará apenas um pouco mais de tempo para atingir lucro ou zero.

Portanto, calcule a etapa entre os níveis de colocação de pedidos para que o preço não toque os níveis já passados por mini-correções.

O esquema pode ser deixado desacompanhado desde que o preço não vá além dos níveis em que as encomendas são feitas. Outra variante é seguir o Diablo e fechá-lo quando algum lucro (por exemplo, o tamanho de uma etapa) é alcançado com uma reorganização subseqüente dos pedidos novamente, ou apenas uma vez fechado com lucro.

[JonKatana]

Correção no roteiro: houve uma compensação errada para o spread nas ordens de Limite de Venda:

// 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);}

[Jeremy Falcon]

Externo int Etapa=0,Espalhamento=0,Níveis=0;
duploexterno Up=0,Vol=0.

Que parâmetros devo colocar aqui para que funcione?

[Mihail Marchukajtes]

Por que não atribuir a variável UP a asc, para que os pedidos sejam feitos a partir do preço atual....

[Mihail Marchukajtes]

#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);
}

Eu acrescentei uma limpeza ao roteiro. Isto é, se houver ordens abertas ou pendentes, primeiro apaga tudo e depois coloca as ordens pendentes de acordo com os parâmetros...

[JonKatana]

IronBird:

externo int Etapa=0,Spread=0,Níveis=0;
externo duplo Up=0,Vol=0

Que parâmetros devem ser inseridos aqui para que funcione?

Passo - passo entre pedidos em pontos (por exemplo, 20 para um pedido de quatro dígitos ou 200 para um pedido de cinco dígitos);

Spread - espalhar em pips (por exemplo, 2 para quatro dígitos ou 20 para cinco dígitos);

Níveis - o número de níveis em que as encomendas serão feitas (por exemplo, 20);

Para cima - uma linha acima do preço, a partir da qual a colocação de pedidos será iniciada para cima (os pedidos serão colocados automaticamente com uma compensação de Passo a partir desta linha);

Vol - volume de pedidos (por exemplo, 0,1).

[JonKatana]

nikelodeon:
Por que não atribuímos a variável UP a asc, para que os pedidos sejam feitos a partir do preço atual

Por duas razões:

1) As ordens não podem ser colocadas a partir de um certo nível (resistência, apoio, Fibonacci, Coelho...)

2) Há dezenas de pedidos, e eles não são feitos instantaneamente. Durante este tempo, Ask pode mudar do valor inicial, o que imprevisivelmente move os lugares de colocação de pedidos e seus Take Profit e Stop Loss. Isto permitirá ao centro de negociação abrir ordens em níveis não por um par, mas para "puxar" ordens separadas sem pegar a segunda ordem do par, e depois levá-las a perdas, o que destruiria todo o sistema.

[khorosh]

JonKatana:

Por duas razões:

1) As ordens não podem ser colocadas a partir de um certo nível (resistência, apoio, Fibonacci, Coelho...)

2) Há dezenas de pedidos, e eles não são feitos imediatamente. Durante este tempo, Ask pode mudar do valor inicial, o que imprevisivelmente move os lugares de colocação de pedidos e seus Take Profit e Stop Loss. Isto permitirá ao centro de negociação abrir ordens em níveis não por um par, mas para "puxar" ordens separadas, sem pegar a segunda ordem do par, e depois levá-las a perdas, o que arruinará todo o sistema.

Você pode definir os dois primeiros pedidos usando o preço atual e calcular os preços de outros pedidos em relação aos preços do primeiro pedido. As duas primeiras ordens podem ser ordens de mercado.