Chiusura di mezzi lotti. - pagina 16

Nuovo commento
 
Ok, ho fatto un po' di progressi. Ho però un problema. Se piazzo un ordine per la prima volta su una data coppia, non chiuderà la metà dell'ordine a meno che non abbia un trade con cui confrontarlo nella cronologia... In tal caso, se il primo trade è andato 1:1, non chiuderà la metà della posizione perché non ha nulla con cui confrontarsi nello storico... Allo stesso modo, non sono del tutto sicuro di cosa sto sbagliando, ma anche quando c'è un'operazione nella cronologia con cui confrontarla (OrderOpenTime()), la chiude continuamente allo stesso prezzo?

int start()
{
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
if(OrderSelect(OrderTicket(),SELECT_BY_TICKET, MODE_TRADES)==True)
{  
   OrderEntryTime            = OrderOpenTime();
   datetime OrderEntryClosed = OrderCloseTime(); 
    CurrentSymbol            = OrderSymbol();
     if(OrderType() <= OP_SELL && CurrentSymbol == Symbol())
         {   
         Print(" The Selected Order ", CurrentSymbol, " matches this pair: ", Symbol());
         Print(" The Open Time of this order was: ", TimeToStr(OrderEntryTime, TIME_MINUTES | TIME_DATE));  
         }
         
  if(OpenOrdersThisPair(Symbol())>0 && CurrentSymbol==Symbol())
     {
      // Need a for loop to compare historically closed trades that match with Symbol() and the "datetime OrderEntryTime = OrderOpenTime();" above.
     CheckHistoricalTrades(); 
     }
   }
}
}  
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  

void CheckHistoricalTrades()
{
for(int Pos=OrdersHistoryTotal()-1; Pos >= 0; Pos--) 
    {
     if (OrderSelect(Pos, SELECT_BY_POS, MODE_HISTORY)  
        &&  OrderMagicNumber()  == MagicNumber            
        &&  CurrentSymbol       == Symbol()            
        &&  OrderType()         <= OP_SELL
        &&  OrderEntryTime    >  OrderOpenTime() && OrderType()==OP_BUY)
          {
          Print(" Last Order Open Time: ", TimeToStr(OrderOpenTime(), TIME_MINUTES | TIME_DATE), 
                  " Was not the same as current order: ", TimeToStr(OrderEntryTime, TIME_MINUTES | TIME_DATE));
          CloseHalfOrder();
          }
                if(OrderEntryTime > OrderOpenTime() && OrderType()==OP_SELL)
                  {
                  Print("Last Order Open Time: ", TimeToStr(OrderOpenTime(), TIME_MINUTES | TIME_DATE), 
                     " Was not the same as current order: ", TimeToStr(OrderEntryTime, TIME_MINUTES | TIME_DATE));
                  CloseHalfOrder1(); // This just closes half of the position at 1:1 - then if OrderStopLoss > OrderOpenPrice() = MoveToBreakEven() void kicks in. 
                  }
                      
     }
}  
So che il problema è davanti ai miei occhi, ma non riesco a vederlo...
 
Queste sono le stampe del diario - alcune stampe non sono mostrate sopra - ma tutte quelle sopra lo sono.
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1: Last Order Open Time: 2010.02.04 09:22 Was not the same as current order: 2010.02.25 01:16 //>>> "Last Order Open time" here doesn't make sense?
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1: SELL First Target Closed: 0.03 OP_SELL First Closed - Open Time: 2010.02.05 15:07 //>>> This is the same as "The Last Order Open Time"?
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1: close #16 sell 0.03 GBPJPY at 138.270 sl: 138.240 tp: 135.082 at price 136.637  //>>> Therefore, it closed it here.
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1: Ask >= FirstTarget_Sell - Current Ask: 136.637 FirstTarget_Sell: 136.676     //>>> The ask is at the OrderClose() price.
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1: FirstTarget_Sell: 136.676
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1: Order Ticker Number = 10
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1: The Lots to close is: 0.030
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1: Last Order Open Time: 2010.02.05 15:07 Was not the same as current order: 2010.02.25 01:16
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1:  The Open Time of this order was: 2010.02.25 01:16
2013.08.09 13:56:20     2010.02.25 09:16  Trend Fishing 3 Exits GBPJPY,H1:  The Selected Order GBPJPY matches this pair: GBPJPY
 
DomGilberto:

Il problema che ho però; sto cercando di chiudere parzialmente lo stesso "OP_BUY" o "OP_SELL" fino a 4 volte a prezzi diversi... Penso che la domanda che dovrei fare è: posso ottenere un modo in cui ho una regola che TUTTE le chiusure parziali (di qualsiasi lotto e prezzo su una data operazione) si chiuderanno solo parzialmente una volta ai loro parametri predefiniti "OrderClose()" impostati...

Il modo in cui sto cercando di farlo ora con il confronto di OrderOpenTime() funzionerà essenzialmente solo una volta, e limiterà qualsiasi altro tipo di funzione OrderClose() dall'accadere... Voglio trovare un modo in cui posso avere una regola applicata a 4 funzioni OrderClose()... (se questo ha senso?)

So che la gente suggerisce di aprire 4 ordini, ma senza andare troppo in profondità, è meno efficiente per me farlo in quel modo.

Perché non avere semplicemente un array bidimensionale che memorizza il numero del biglietto e il numero di chiusure parziali disponibili rimaste da eseguire.

Schema/Pseudocodice:

1. definire un array statico bidimensionale: cOrders[][2].

2. per ogni nuovo ordine inserito: ridimensiona la prima dimensione di cOrders a size+1, metti il numero di ticket del nuovo ordine in [x][0] e il numero di chiusure parziali rimaste da eseguire (in questo caso, 4) in [x][1].

3. in qualsiasi intervallo di tempo (ad esempio, ogni start()), eseguire il loop attraverso l'array, selezionare ogni ordine utilizzando il numero di ticket memorizzato, e determinare se è necessario eseguire una chiusura parziale.

4. se deve essere eseguita una chiusura parziale (vedi passo 3), chiudere parzialmente l'ordine usando OrderClose() e aggiornare cOrders[x][0] per riflettere il nuovo numero di biglietto e ridurre cOrders[x][1] di 1.

5. rimuovere da cOrders tutti gli ordini che sono stati chiusi o che il loro numero di chiusure parziali rimaste da eseguire è 0.

L'unico problema è cosa fare al riavvio della piattaforma/computer. Potresti memorizzare queste informazioni in un file e leggere il file in init() al riavvio della piattaforma.

 
Thirteen:

Perché non avere semplicemente un array bidimensionale che memorizza il numero del biglietto e il numero di chiusure parziali disponibili rimaste da eseguire.

Schema/Pseudocodice:

1. definire un array statico bidimensionale: cOrders[][2].

2. per ogni nuovo ordine inserito: ridimensiona la prima dimensione di cOrders a size+1, metti il numero di ticket del nuovo ordine in [x][0] e il numero di chiusure parziali rimaste da eseguire (in questo caso, 4) in [x][1].

3. in qualsiasi intervallo di tempo (ad esempio, ogni start()), eseguire il loop attraverso l'array, selezionare ogni ordine utilizzando il numero di ticket memorizzato, e determinare se è necessario eseguire una chiusura parziale.

4. se deve essere eseguita una chiusura parziale (vedi passo 3), chiudere parzialmente l'ordine usando OrderClose() e aggiornare cOrders[x][0] per riflettere il nuovo numero di biglietto e ridurre cOrders[x][1] di 1.

5. rimuovere da cOrders tutti gli ordini che sono stati chiusi o che il loro numero di chiusure parziali rimaste da eseguire è 0.

L'unico problema è cosa fare al riavvio della piattaforma/computer. Potresti memorizzare queste informazioni in un file e leggere il file in init() al riavvio della piattaforma.

Penso che il modo più semplice di farlo sia con i Magic Number . . . utilizzare parti del numero per definire diversi parametri, per esempio: numero di pezzi, numero d'ordine, giorno, mese, numero EA . . . tutti i pezzi avrebbero lo stesso Magic Number e potrebbero essere rintracciati facilmente nella Storia. Presumo che la parte chiusa e la parte aperta a sinistra abbiano entrambe lo stesso Magic Number . . .
 
Sì, penso di sì. Il numero magico è sempre lo stesso "1234"?

Non ho idea di come utilizzare parti del numero magico per definire diversi parametri? Penso che usare OrderOpenTime() non sia un percorso logico... Non posso credere quanto sia lungo questo thread. Lol.

Giuro su Dio che farò un thread su questo una volta che io (con un sacco di aiuto da tutti gli altri!) l'avrò risolto.
 
RaptorUK:
Penso che il modo più semplice per farlo sia con i Magic Number . . . usare parti del numero per definire diversi parametri, per esempio: numero di parti, numero d'ordine, giorno, mese, numero EA . . . tutte le parti avrebbero lo stesso Magic Number e potrebbero essere tracciate facilmente nella Storia. Presumo che la parte chiusa e la parte aperta a sinistra abbiano entrambe lo stesso Magic Number . . .

L'uso del Magic Number per codificare pezzi di informazione è abbastanza possibile, ma vedo un paio di possibili limitazioni. Primo, il Magic Number è un int e quindi è lungo 10 cifre dove la cifra più a sinistra può essere solo un 1 o un 2 (e se la cifra più a sinistra è un 2, la seconda cifra più a sinistra deve essere 7 o meno). In secondo luogo, potrebbe essere necessario più tempo per start() per rivedere tutta la storia per trovare tutte le parti di ogni ordine solo per determinare se l'ordine corrente deve (o può essere) parzialmente chiuso. Non sono sicuro se questo tempo in più sarebbe banale o no.

 

Aspetta, non posso avere diversi MagicNumber? Usarne uno per l'iniziale OrderSend(), uno per l'OrderModify(), dopo che metà della posizione è chiusa al primo target di 1:1, modificare l'ordine per cambiare il MagicNumber? Quindi, quando sto cercando di chiudere la metà a 1:1, chiuderà solo 1:1 finché l'attuale apertura "OP_BUY" corrisponde al numero magico che gli ho dato per primo? Dopo che si è chiuso parzialmente, modificare e cambiare quel numero magico?!

Lol? Non è molto semplice?!

AGGIORNAMENTO: Ovviamente devo smettere di guardare questo oggi - non puoi modificare un MagicNumber - vorrei che tu potessi, cazzo... (facepalm) - Potresti immaginare quanto sarebbe più facile tutto questo...

 
DomGilberto:
Aspetta, non posso avere diversi magicnumbers? Usarne uno per l'iniziale OrderSend(), uno per OrderModify(), dopo che metà della posizione è chiusa al primo target di 1:1, modificare l'ordine per cambiare il MagicNumber? Quindi, quando sto cercando di chiudere la metà a 1:1, chiuderà solo 1:1 finché l'attuale apertura "OP_BUY" corrisponde al numero magico che gli ho dato per primo? Dopo che si è chiuso parzialmente, modificare e cambiare quel numero magico?!

Lol? Non è molto semplice?!

No. Innanzitutto, dopo l'iniziale OrderSend(), non puoi aggiungere/modificare il Magic Number usando OrderModify(). Secondo, quando fai una chiusura parziale dell'ordine usando OrderClose(), il nuovo ordine (presumo) ottiene lo stesso Magic Number del vecchio ordine.

 
Thirteen:

No. Innanzitutto, dopo l'iniziale OrderSend(), non puoi aggiungere/modificare il Magic Number usando OrderModify(). Secondo, quando fai una chiusura parziale dell'ordine usando OrderClose(), il nuovo ordine (presumo) ottiene lo stesso Magic Number del vecchio ordine.


Sì, ho capito quanto sono ritardato. Giornata lunga!

Sì, dopo la prima chiusura parziale, alla posizione rimanente viene ancora assegnato lo stesso numero magico con cui è iniziata.

Ora mi sta davvero frustrando... Se solo potessi modificare il magicnumber, sarebbe troppo facile! Ci deve essere un modo logico per chiudere parzialmente una posizione UNA VOLTA - e farlo più volte a qualsiasi prezzo predefinito specificato all'interno di OrderClose() - Ci deve essere un aggiornamento per permetterci di modificare il MagicNumber()!
 

Non stai pensando affatto in modo logico.

1. In che modo modificare il numero magico ti aiuterebbe più che conoscere l'OrderOpenTime()? Si tratta esattamente della stessa cosa di un identificatore di quell'ordine.

2. perché lo stai convertendo nel formato giorno/ora/minuti con timetostr? OrderOpenTime() è già nel formato timestamp che si presenta così: 1375356521 che rappresenta l'ora esatta al secondo in cui l'ordine è stato aperto.

Se si potesse cambiare il numero magico si dovrebbe confrontare il numero magico dell'ordine per assicurarsi che non abbia il numero magico che significa che è già stato chiuso in parte, giusto?

Se puoi farlo, perché non puoi confrontare l'OrderOpenTime dell'ordine con il timestamp che sai che significa che è uno che è già stato parzialmente chiuso?

static datetime alreadypartclosed;

se la chiusura parziale dell'ordine ha successo

alreadypartclosed = OrderOpenTime();

quando l'ordine soddisfa i criteri per la chiusura parziale

if(OrderOpenTime() != alreadypartclosed )

Se stai gestendo più ordini aperti allo stesso tempo, usa un array[] per contenere ogni timestamp degli ordini chiusi.

1...910111213141516171819
Nuovo commento