Diablo - pagina 12

Nuovo commento
 

Ho fatto un Expert Advisor, che piazza gli ordini come nella metodologia dell'autore, ma ci sono delle differenze. Colloca gli ordini secondo i livelli a seconda dell'ATR (se la metodologia è vincente, allora che differenza fa da quali livelli collocare). All'inizio di un nuovo giorno chiude e cancella tutti gli ordini (non so proprio come altro chiudere gli ordini che non hanno TP e SL e che non porteranno profitto).

Si può cercare di ottimizzare i parametri. Sono solo pigro, non credo in questa strategia.

 
khorosh:
Quando la critica è troppo pigra per essere ragionata, ma si vuole davvero dire qualcosa, è meglio stare in silenzio piuttosto che fare casino.
Non dimenticare di guardarti allo specchio.
 

Diablo v09.02.12 (versione immortale)

Gli ordini di due tipi sono piazzati a una certa distanza dal prezzo a intervalli uguali: ordini dritti (Buy Stop su dal prezzo e Sell Stop giù dal prezzo) e ordini invertiti (Sell Limit su dal prezzo e Buy Limit giù dal prezzo). Gli ordini Buy Stop e Sell Limit sono piazzati agli stessi livelli (a coppie), così come gli ordini Sell Stop e Buy Limit.

Tutti gli ordini hanno lo stesso volume e Stop Loss uguale al passo tra gli ordini.

Gli ordini diretti (Buy Stop e Sell Stop) non hanno Take Profit. Gli ordini invertiti (Sell Limit e Buy Limit) hanno il Take Profit aritmeticamente crescente: il primo ordine (il più vicino al prezzo) ha un passo tra gli ordini, il secondo ordine (un po' più lontano) ha tre passi, il terzo ordine ha cinque passi e così via.


Uno script per piazzare ordini:

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

Il sistema è completamente indistruttibile. Lasciato a se stesso, alla fine chiude sempre con un profitto o a zero.

Molto buona è la tendenza senza fallback sulla dimensione del passo - il profitto aumenta come una palla di neve, permettendo di raccogliere un movimento di prezzo più volte. Sul piatto il profitto è moderato o va a zero. La variante più lenta è il modello "drago", quando il prezzo si muove in una direzione, ma rotola indietro da ogni livello di un passo, poi va oltre. In questo caso ci vorrà solo un po' più di tempo per raggiungere il profitto o lo zero.

Calcolate quindi il passo tra i livelli per piazzare gli ordini in modo che il prezzo non tocchi i livelli già superati da mini-correzioni.

Lo schema può essere lasciato incustodito finché il prezzo non va oltre i livelli in cui gli ordini vengono piazzati. Un'altra variante è quella di seguire il Diablo e chiuderlo quando viene raggiunto un certo profitto (per esempio, la dimensione di un passo) con successiva riorganizzazione degli ordini di nuovo, o solo una volta chiudere con profitto.

 

Correzione nello script: c'era un offset sbagliato per lo spread negli ordini Sell Limit:

// 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 Step=0,Spread=0,Levels=0;
extern double Up=0,Vol=0.

Quali parametri devo mettere qui per farlo funzionare?

 
Perché non assegniamo la variabile UP ad asc, in modo che gli ordini vengano effettuati a partire dal prezzo corrente....
  
#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);
}
Ho aggiunto una pulizia allo script. Cioè se ci sono ordini aperti o pendenti, prima cancella tutto e poi imposta gli ordini pendenti secondo i parametri...
 
IronBird:

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

Quali parametri devono essere inseriti qui per farlo funzionare?

Step - passo tra gli ordini in punti (per esempio 20 per un ordine a quattro cifre o 200 per uno a cinque cifre);

Spread - spread in pip (es. 2 per quattro cifre o 20 per cinque cifre);

Livelli - il numero di livelli a cui saranno piazzati gli ordini (per esempio, 20);

Su - una linea sopra il prezzo, da cui il piazzamento degli ordini inizierà verso l'alto (gli ordini saranno piazzati automaticamente con un offset di Step da questa linea);

Vol - volume degli ordini (per esempio 0,1).

 
nikelodeon:
Perché non assegniamo la variabile UP a asc, così gli ordini saranno piazzati dal prezzo corrente....

Per due motivi:

1) Gli ordini non possono essere piazzati da un certo livello (resistenza, supporto, Fibonacci, Coniglio...)

2) Ci sono decine di ordini, e non vengono effettuati istantaneamente. Durante questo tempo Ask può spostarsi dal valore iniziale, il che sposta imprevedibilmente i luoghi di immissione degli ordini e i loro Take Profit e Stop Loss. Questo permetterà al centro dealing di aprire ordini a livelli non di coppia, ma di "tirare" ordini separati senza catturare il secondo ordine della coppia, e quindi di portarli in perdita, cosa che distruggerebbe l'intero sistema.

 
JonKatana:

Per due motivi:

1) Gli ordini non possono essere piazzati da un certo livello (resistenza, supporto, Fibonacci, Coniglio...)

2) Ci sono decine di ordini, e non vengono effettuati istantaneamente. Durante questo tempo Ask può spostarsi dal valore iniziale, il che sposta imprevedibilmente i luoghi di immissione degli ordini e i loro Take Profit e Stop Loss. Questo permetterà al centro dealing di aprire ordini a livelli non di coppia, ma di "tirare" ordini separati senza catturare il secondo ordine della coppia, e quindi di portarli in perdita, cosa che rovinerà l'intero sistema.

Puoi impostare i primi due ordini usando il prezzo corrente e calcolare i prezzi degli altri ordini rispetto ai prezzi del primo ordine. I primi due ordini possono essere ordini di mercato.
1...5678910111213141516171819...28
Nuovo commento
Motivazione: