Fermeture des demi-lots. - page 16

Nouveau commentaire
 
Ok, j'ai fait un peu de progrès. Mais j'ai un problème. Si je place un ordre pour la première fois sur une paire donnée, il ne fermera PAS la moitié de l'ordre À MOINS que je n'aie une transaction à comparer dans l'historique... Dans ce cas, si la première transaction a été de 1:1, il ne fermera pas la moitié de la position car il n'y a rien à comparer dans l'historique... De même, je ne suis pas tout à fait sûr de ce que je fais mal, mais même lorsqu'il y a une transaction à comparer dans l'historique, (OrderOpenTime()), il la clôture toujours en continu au même prix ?

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. 
                  }
                      
     }
}  
Je sais que le problème me regarde droit dans les yeux, mais je ne le vois pas...
 
Voici les tirages du journal - certains tirages ne sont pas montrés ci-dessus - mais tous les tirages ci-dessus le sont.
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:

Le problème que j'ai cependant est que j'essaie de fermer partiellement le même "OP_BUY" ou "OP_SELL" jusqu'à 4 fois à des prix différents... Je pense que la question que je devrais poser est la suivante : puis-je obtenir un moyen par lequel j'ai une règle selon laquelle TOUTES les clôtures partielles (de n'importe quels lots et prix sur UNE transaction donnée) ne seront clôturées partiellement qu'UNE SEULE fois avec leurs paramètres prédéfinis "OrderClose()"...

La façon dont je cherche à le faire maintenant en comparant l'OrderOpenTime() ne fonctionnera essentiellement qu'une seule fois, et empêchera tout autre type de fonction OrderClose() de se produire du tout... Je veux trouver un moyen d'avoir une règle appliquée à 4 fonctions OrderClose()... (si cela a un sens ?)

Je sais que les gens suggèrent d'ouvrir 4 ordres, mais sans aller trop loin, c'est moins efficace pour moi de le faire de cette façon.

Pourquoi ne pas simplement avoir un tableau à deux dimensions qui stocke le numéro du ticket et le nombre de fermetures partielles disponibles restant à effectuer.

Schéma/Pseudocode :

1. définir un tableau statique à deux dimensions : cOrders[][2].

2. pour chaque nouvelle commande entrée : redimensionner la première dimension de cOrders à taille+1, mettre le numéro de ticket de la nouvelle commande dans [x][0] et le nombre de fermetures partielles restant à effectuer (dans ce cas, 4) dans [x][1].

3. à n'importe quel intervalle de temps (par exemple, chaque start()), boucle dans le tableau, sélectionne chaque ordre en utilisant le numéro de ticket stocké, et détermine si une fermeture partielle doit être effectuée.

4. Si une fermeture partielle doit être effectuée (voir étape 3), fermez partiellement la commande en utilisant OrderClose() et mettez à jour cOrders[x][0] pour refléter le nouveau numéro de ticket et réduisez cOrders[x][1] de 1.

5. supprimez de cOrders tous les ordres qui ont été fermés ou dont le nombre de fermetures partielles restant à effectuer est égal à 0.

Le seul problème est de savoir ce qu'il faut faire en cas de redémarrage de la plate-forme ou de l'ordinateur. Vous pourriez stocker ces informations dans un fichier et lire ce fichier dans init() lors du redémarrage de la plateforme.

 
Thirteen:

Pourquoi ne pas simplement avoir un tableau à deux dimensions qui stocke le numéro du ticket et le nombre de fermetures partielles disponibles restant à effectuer.

Schéma/Pseudocode :

1. définir un tableau statique à deux dimensions : cOrders[][2].

2. pour chaque nouvelle commande entrée : redimensionner la première dimension de cOrders à taille+1, mettre le numéro de ticket de la nouvelle commande dans [x][0] et le nombre de fermetures partielles restant à effectuer (dans ce cas, 4) dans [x][1].

3. à n'importe quel intervalle de temps (par exemple, chaque start()), boucle dans le tableau, sélectionne chaque ordre en utilisant le numéro de ticket stocké, et détermine si une fermeture partielle doit être effectuée.

4. Si une fermeture partielle doit être effectuée (voir étape 3), fermez partiellement la commande en utilisant OrderClose() et mettez à jour cOrders[x][0] pour refléter le nouveau numéro de ticket et réduisez cOrders[x][1] de 1.

5. supprimez de cOrders tous les ordres qui ont été fermés ou dont le nombre de fermetures partielles restant à effectuer est égal à 0.

Le seul problème est de savoir ce qu'il faut faire en cas de redémarrage de la plate-forme ou de l'ordinateur. Vous pourriez stocker ces informations dans un fichier et lire ce fichier dans init() lors du redémarrage de la plateforme.

Je pense que la façon la plus simple de le faire est d'utiliser des numéros magiques . . . utiliser des parties du numéro pour définir différents paramètres, par exemple : nombre de pièces, numéro de commande, jour, mois, numéro d'EA . . . toutes les pièces auraient le même numéro magique et pourraient être retrouvées facilement dans l'historique. Je suppose que la pièce fermée et la pièce ouverte ont toutes deux le même numéro magique...
 
Oui, je crois. Le nombre magique est toujours le même "1234" ?

Je n'ai pas la moindre idée de comment utiliser des parties du nombre magique pour définir différents paramètres? Je pense que l'utilisation de OrderOpenTime() ne va pas être un chemin logique... Je n'arrive pas à croire que ce fil de discussion soit si long. Lol.

Je jure devant Dieu que je vais faire un fil de discussion sur ce sujet une fois que je l'aurai résolu (avec beaucoup d'aide de tout le monde !).
 
RaptorUK:
Je pense que la façon la plus simple de faire cela est d'utiliser des numéros magiques... utiliser des parties du numéro pour définir différents paramètres, par exemple : nombre de pièces, numéro de commande, jour, mois, numéro d'EA... toutes les pièces auraient le même numéro magique et pourraient être retrouvées facilement dans l'historique. Je suppose que la pièce fermée et la pièce ouverte ont toutes deux le même numéro magique...

L'utilisation du nombre magique pour coder des éléments d'information est tout à fait possible, mais je vois quelques limitations possibles. Premièrement, le numéro magique est un nombre entier et comporte donc 10 chiffres, le chiffre le plus à gauche ne pouvant être qu'un 1 ou un 2 (et si le chiffre le plus à gauche est un 2, le deuxième chiffre le plus à gauche doit être égal ou inférieur à 7). Deuxièmement, cela pourrait prendre plus de temps par start() pour examiner tout l'historique afin de trouver toutes les parties de chaque ordre juste pour déterminer si l'ordre actuel doit (ou peut) être partiellement fermé. Je ne suis pas sûr que ce temps supplémentaire soit trivial ou non.

 

Attendez, je ne peux pas simplement avoir plusieurs MagicNumber ? En utiliser un pour le OrderSend() initial, un pour le OrderModify(), après que la moitié de la position soit fermée au premier objectif de 1:1, modifier l'ordre pour changer le MagicNumber ? Par conséquent, lorsque je cherche d'abord à fermer la moitié de la position à 1:1, il ne fermera que 1:1 tant que l'ouverture actuelle "OP_BUY" correspond au nombre magique que je lui ai d'abord donné ? Une fois qu'il aura partiellement fermé, il pourra modifier et changer ce nombre magique !

Lol ? N'est-ce pas très simple ? !

UPDATE : Je dois manifestement arrêter de regarder ça aujourd'hui - on ne peut pas modifier un MagicNumber - j'aimerais bien qu'on puisse le faire, putain... (facepalm) - Pourriez-vous imaginer combien tout cela serait plus facile...

 
DomGilberto:
Attendez, je ne peux pas avoir plusieurs numéros magiques ? Utiliser un pour l'OrderSend() initial, un pour l'OrderModify(), après que la moitié de la position soit fermée au premier objectif de 1:1, modifier l'ordre pour changer le MagicNumber ? Par conséquent, lorsque je cherche d'abord à fermer la moitié de la position à 1:1, il ne fermera que 1:1 tant que l'ouverture actuelle "OP_BUY" correspond au nombre magique que je lui ai d'abord donné ? Une fois qu'il aura partiellement fermé, je pourrai modifier et changer ce nombre magique !

Lol ? N'est-ce pas très simple ? !

Non. Premièrement, après l'envoi initial de l'ordre OrderSend(), vous ne pouvez pas ajouter/modifier le numéro magique en utilisant OrderModify(). Ensuite, lorsque vous procédez à une clôture partielle de l'ordre à l'aide de OrderClose(), le nouvel ordre (je suppose) obtient le même numéro magique que l'ancien.

 
Thirteen:

Non. Premièrement, après l'envoi initial de l'ordre OrderSend(), vous ne pouvez pas ajouter/modifier le numéro magique en utilisant OrderModify(). Deuxièmement, lorsque vous procédez à une clôture partielle de l'ordre à l'aide de OrderClose(), le nouvel ordre (je suppose) obtient le même numéro magique que l'ancien.


Oui, j'ai réalisé à quel point je suis attardé. Longue journée !

Oui, après la première clôture partielle, la position restante se voit toujours attribuer le même numéro magique qu'au départ.

C'est vraiment frustrant maintenant... Si seulement je pouvais modifier le magicnumber, ce serait trop facile ! ? Il doit y avoir un moyen logique de fermer partiellement une position UNE FOIS - et de le faire plusieurs fois à n'importe quel prix prédéfini spécifié dans l'OrderClose() - Il doit y avoir une mise à jour pour nous permettre de modifier le MagicNumber() !
 

Vous ne pensez pas du tout logiquement.

1. En quoi la modification du nombre magique vous aiderait-elle plus que la connaissance de l'OrderOpenTime() ? C'est exactement la même chose que de connaître l'identifiant de cet ordre.

2. pourquoi le convertissez-vous au format jour/heure/minutes avec timetostr ? OrderOpenTime() est déjà au format timestamp et ressemble à ceci : 1375356521 il représente l'heure exacte à la seconde près de l'ouverture de l'ordre.

Si vous pouviez changer le nombre magique, vous compareriez le nombre magique de l'ordre pour vous assurer qu'il n'a pas le nombre magique qui signifie qu'il a déjà été partiellement fermé, n'est-ce pas ?

Si vous pouviez faire cela, pourquoi ne pouvez-vous pas comparer l'OrderOpenTime de l'ordre avec l'horodatage qui, vous le savez, signifie qu'il s'agit d'un ordre déjà partiellement clôturé ?

static datetime alreadypartclosed ;

si l'ordre de fermeture partielle est réussi

alreadypartclosed = OrderOpenTime() ;

si l'ordre répond aux critères de fermeture partielle

if(OrderOpenTime() != alreadypartclosed )

Si vous gérez plusieurs ordres ouverts en même temps, utilisez un tableau[] pour contenir chaque horodatage des ordres partiellement fermés.

1...910111213141516171819
Nouveau commentaire