Ho bisogno di aiuto per individuare qualche piccolo errore. - pagina 4

 
Se è così allora ho ragione anche nel mio 1° codice, chiamo OrderSelect() subito dopo il 1° ciclo for ..... Il problema ora è che il trailing stop loss non funziona correttamente e non ho ancora idea di dove sia il problema.
 
juniorlcq: usa il ciclo di conto alla rovescia ma con x-- . Non capisco perché suggerisci --x però.
  1. x++ legge il valore, salva una copia, incrementa il valore, memorizza il nuovo valore in x, erecupera la copia per un uso successivo.
  2. ++x legge il valore, incrementa il valore, memorizza il nuovo valore in x
  3. Per gli interi fa poca differenza. Su alcune piattaforme quest'ultimo è una singola istruzione che lo rende diverse volte più veloce.
  4. Per le classi (come gli iteratori) si ha una chiamata extra al costruttore e al distruttore, rendendolo molto più veloce.
    Prefisso operatore++
    Operatore postfisso++
    RaRev* RaRev::operator++(void){         // prefix
       ++mPos;
       return GetPointer(this); // Allow (++It).Get()
    }
    
    RaRev RaRev::operator++(int){               // postfix
       RaRev  orig(this); // Make a copy to return.
       ++this;            // Increment myself.
       return orig;       // Return the original position.
    }
    
    Nella maggior parte delle implementazioni STL vedrete spesso "iteratore last=end; --end;" piuttosto che "iteratore last=end--".

 

Diciamo che il prezzo sale di 600 punti da OrderOpenprice(), = StartTraillingStop (200) + 8(xai)*50

il codice è qui:

  if ( xai >= 8 ) 
    {
    if ( ( ( OrderClosePrice() - OrderOpenPrice() ) / Figure ) >= ( StartTrailingStop + ( CummulativeValue * xai ) ) )
        {
        if ( OrderStopLoss() == ( OrderOpenPrice() + ( ( TrailingStop + ( CummulativeValue * ( xai - 1 ) ) ) * Figure ) ) )
           {
            Result = OrderModify ( OrderTicket() , OrderOpenPrice() , ( OrderOpenPrice() + ( ( TrailingStop + ( CummulativeValue * xai ) ) * Figure ) ) , OrderTakeProfit() , 0 , Color ) ;
       }
    }

ma il codice farà tutte le xai da 0 a 8, diciamo che il codice è a xai = 4; questa condizione è vera?

if ( ( ( OrderClosePrice() - OrderOpenPrice() ) / Figure ) >= ( StartTrailingStop + ( CummulativeValue * xai ) ) )

sì, allora lo SL sarà impostato a : StartTraillinStop (200) + 4(xai)*50 (scendendo dal precedente)

poi xai 5, lo SL sarà impostato a : StartTraillinStop (200) + 5(xai)*50

e così via, quindi non è possibile mettere una pausa una volta che lo SL è impostato;

 

juniorlcq Il tuo codice è molto più facile da leggere ora che l'hai riformattato. L'ho riformattato un po' di più per renderlo più piccolo da postare, ho evidenziato i possibili problemi. Sto pensando che potresti avere un problema di "doppio == doppio calcolato" che sta impedendo al tuo codice di eseguire alcuni dei percorsi. Hai mai letto il thread su can price != price ?

Sono più sospettoso del 2° e 4° perché sono calcoli più complicati.

Mettete le istruzioni Print() dopo questi calcoli per vedere se fanno davvero == o no.

L'errore noto come errore di virgola mobile potrebbe renderli != anche quando sembra che dovrebbero essere ==.

== è davvero sicuro al 100% da usare con i numeri interi, quindi potresti cambiare il == in <= o >= come test.

  void ProcessTrailingStop()
 {
  bool Result;
  for(int x=(OrdersTotal()-1); x>=0; x--)
  {if(OrderSelect(x,SELECT_BY_POS,MODE_TRADES)==True)
   {PointsDetection();
    if(OrderType()==OP_BUY)
    {for(int xai=0; xai<NumberOfTrail; xai++)
     {if(xai==0)
      {if(((OrderClosePrice()-OrderOpenPrice())/Figure)>=StartTrailingStop)
       {if(( OrderStopLoss()==0) || (OrderStopLoss()<(OrderOpenPrice()+(TrailingStop*Figure))))
        {Result=OrderModify(OrderTicket(),OrderOpenPrice(),(OrderOpenPrice()+(TrailingStop*Figure)),OrderTakeProfit(),0,Color);
      }}}
      if(xai==1)
      {if(((OrderClosePrice()-OrderOpenPrice())/Figure)>=(StartTrailingStop+CummulativeValue))
       {if(OrderStopLoss()==(OrderOpenPrice()+(TrailingStop*Figure)))
        {Result=OrderModify(OrderTicket(),OrderOpenPrice(),(OrderOpenPrice()+((TrailingStop+CummulativeValue)*Figure)),OrderTakeProfit(),0,Color);
      }}}
      if(xai>=2)
      {if(((OrderClosePrice()-OrderOpenPrice())/Figure)>=(StartTrailingStop+(CummulativeValue*xai)))
       {if(OrderStopLoss()==(OrderOpenPrice()+(( TrailingStop+(CummulativeValue *(xai-1)))*Figure)))
        {Result=OrderModify(OrderTicket(),OrderOpenPrice(),(OrderOpenPrice()+(( TrailingStop+(CummulativeValue*xai))*Figure)),OrderTakeProfit(),0,Color);
    }}}}}else
    {if(OrderType()==OP_SELL)
     {for(int xaii=0; xaii<NumberOfTrail; xaii++)
      {if(xaii==0)
       {if(((OrderOpenPrice()-OrderClosePrice())/Figure)>=StartTrailingStop)
        {if(( OrderStopLoss()==0) || (OrderStopLoss()>(OrderOpenPrice() -(TrailingStop*Figure))))
         {Result=OrderModify(OrderTicket(),OrderOpenPrice(),(OrderOpenPrice() -(TrailingStop*Figure)),OrderTakeProfit(),0,Color);
       }}}
       if(xaii==1)
       {if(((OrderOpenPrice()-OrderClosePrice())/Figure)>=(StartTrailingStop+CummulativeValue))
        {if(OrderStopLoss()==(OrderOpenPrice() -(TrailingStop*Figure)))
         {Result=OrderModify(OrderTicket(),OrderOpenPrice(),(OrderOpenPrice() -(( TrailingStop+CummulativeValue)*Figure)),OrderTakeProfit(),0,Color);
       }}}
       if(xaii>=2)
       {if(((OrderOpenPrice()-OrderClosePrice())/Figure)>=(StartTrailingStop+(CummulativeValue*xaii)))
        {if(OrderStopLoss()==(OrderOpenPrice() -(( TrailingStop+(CummulativeValue *(xaii-1)))*Figure)))
         {Result=OrderModify(OrderTicket(),OrderOpenPrice(),(OrderOpenPrice() -(( TrailingStop+(CummulativeValue*xaii))*Figure)),OrderTakeProfit(),0,Color);
 }}}}}}}}}


Inoltre, come nota a margine: il tuo codice sarebbe molto più efficiente se tu chiamassi OrderOpenPrice(), OrderStopLoss(), OrderClosePrice() una volta all'inizio del tuo ciclo OrderSelect() e assegnassi i loro valori a vars locali da utilizzare nel resto del codice. Le vars locali hanno un accesso molto più veloce delle chiamate di funzione, quindi dovreste evitare di fare ripetute chiamate di funzione per lo stesso risultato... Come regola generale, più scrittura rosa hai nel tuo codice e più lenta sarà la performance dell'EA.

 

Capisco, non riesco a farlo funzionare, questo può funzionare con ordine di acquisto, SL sono gioing down come spiegato:

   extern double CummulativeValue = 50.0 ;
   extern int    NumberOfTrail = 100 ;



  void ProcessTrailingStop()
   {
       double Figure = Point;
    color Color = Yellow;
  
    bool Result ;
         for ( int x =  OrdersTotal(); x >= 0 ; x-- )
         {
         if ( OrderSelect ( x , SELECT_BY_POS , MODE_TRADES ) == false) continue;
        if ( OrderType() == OP_BUY )
           {
                 for ( int xai = 0 ; xai < NumberOfTrail ; xai++ )
                     {
                        if ( xai == 0 )
                        {
                           if ( ( ( OrderClosePrice() - OrderOpenPrice() ) / Figure ) >= StartTrailingStop )
                           {
                              if ( OrderStopLoss() == 0 ) 
                              {
                               Result = OrderModify ( OrderTicket() , OrderOpenPrice() , ( OrderOpenPrice() + ( TrailingStop * Figure ) ) , OrderTakeProfit() , 0 , Color ) ;
                          } } }                        
                  
                        if ( xai == 1 )
                           {
                           if ( ( ( OrderClosePrice() - OrderOpenPrice() ) / Figure ) >= ( StartTrailingStop + CummulativeValue ) )
                           {
                           Result = OrderModify ( OrderTicket() , OrderOpenPrice() , ( OrderOpenPrice() + ( ( TrailingStop + CummulativeValue ) * Figure ) ) , OrderTakeProfit() , 0 , Color ) ;
                          } }                         
                        
                        if ( xai >= 2 )
                           {
                          if ( ( ( OrderClosePrice() - OrderOpenPrice() ) / Figure ) >= ( StartTrailingStop + ( CummulativeValue * xai ) ) )
                           {
                           Result = OrderModify ( OrderTicket() , OrderOpenPrice() , ( OrderOpenPrice() + ( ( TrailingStop + ( CummulativeValue * xai ) ) * Figure ) ) , OrderTakeProfit() , 0 , Color ) ;
                        } }                         
                     }
                  }
                  
       }}           
 
WHRoeder:
  1. x++ legge il valore, salva una copia, incrementa il valore, memorizza il nuovo valore in x, erecupera la copia per un uso successivo.
  2. ++x legge il valore, incrementa il valore, memorizza il nuovo valore in x
  3. Per gli interi fa poca differenza. Su alcune piattaforme quest'ultima è una singola istruzione che la rende diverse volte più veloce.
  4. Per le classi (come gli iteratori) si ha una chiamata extra al costruttore e al distruttore, rendendolo molto più veloce.
    Operatore prefisso++
    Postfix operator++
    Nella maggior parte delle implementazioni STL vedrete spesso "iteratore last=end; --end;" piuttosto che "iteratore last=end--".


Ohhhhhhh non sapevo di questo. Grazie WHRoeder :) .

Quindi significa che ,

diciamo che OrdersTotal() == 3 , con il ciclo for count down for ( int x = ( OrdersTotal() - 1 ) ; x >= 0 ; x-- ) , x salverà il 1° valore come 2 , poi continuerà il ciclo for da 2 in poi senza passare di nuovo per OrdersTotal() ??

 
SDC:

juniorlcq Il tuo codice è molto più facile da leggere ora che l'hai riformattato. L'ho riformattato un po' di più per renderlo più piccolo da postare, ho evidenziato possibili problemi. Sto pensando che potresti avere un problema di "doppio == doppio calcolato" che sta impedendo al tuo codice di eseguire alcuni dei percorsi. Hai mai letto il thread su can price != price ?

Sono più sospettoso del 2 ° e 4 ° in quanto sono calcoli più complicati.

Metti le dichiarazioni Print() dopo quei calcoli per vedere se fanno davvero == o no.

L'errore noto come errore di virgola mobile potrebbe renderli != anche quando sembra che dovrebbero essere ==.

== è veramente sicuro al 100% da usare con i numeri interi quindi potreste cambiare il == in <= o >= come test.



No, non ho letto quel thread prima. L'ho solo fatto.

Quello che hai suggerito sembra logico. Ripensandoci, a volte disegnare linee su MT4 sulle proprietà del prezzo non mostra davvero 5 cifre di prezzo, invece a volte mostra qualcosa di più di quello.

Ma ecco uno dei miei trade fluttuanti su quello del conto precedente, l'ho stampato per vedere com'era il doppio con una semplice codifica di stampa. Strano MQL4 credo @.@ ?

Sto ancora pensando a come modificare la parte double == double .....

DSC:


Inoltre, come nota a margine: il tuo codice sarebbe molto più efficiente se tu chiamassi OrderOpenPrice(), OrderStopLoss(), OrderClosePrice() una volta all'inizio del tuo ciclo OrderSelect() e assegnassi i loro valori a vars locali da utilizzare nel resto del codice. Le vars locali hanno un accesso molto più veloce delle chiamate di funzione, quindi dovreste evitare di fare ripetute chiamate di funzione per lo stesso risultato... Come regola generale, più scrittura rosa hai nel tuo codice e più lenta sarà la performance dell'EA.

Ohhh non sapevo che ci sarebbe stata un'enorme differenza nella velocità di esecuzione, grazie per la guida SDC. Sarà modificato secondo la tua guida dopo la fermata sentiero iniziato a lavorare.

 

Prova a sostituire l'ultimo blocco di codice con questa versione di debug. Controllate il mio codice che non ho compilato.

       if(xaii>=2)
       {if(((OrderOpenPrice()-OrderClosePrice())/Figure)>=(StartTrailingStop+(CummulativeValue*xaii)))
        {Print("debug2.1: first condition true");
         if(OrderStopLoss()==(OrderOpenPrice() -(( TrailingStop+(CummulativeValue *(xaii-1)))*Figure)))
         {Print("debug2.2: second condition true");
          Result=OrderModify(OrderTicket(),OrderOpenPrice(),(OrderOpenPrice() -(( TrailingStop+(CummulativeValue*xaii))*Figure)),OrderTakeProfit(),0,Color);
         }else
         {Print("debug2.2: second condition false");
          Print("debug2.2: val1=",OrderStopLoss()," val2=",OrderOpenPrice() -(( TrailingStop+(CummulativeValue *(xaii-1)))*Figure));
 }}}}}}}}}

Questo potrebbe rivelare qualcosa, potreste fare qualcosa di simile anche con le altre condizioni ==.

 
SDC:

Prova a sostituire l'ultimo blocco di codice con questa versione di debug. Potresti fare qualcosa di simile con la xa

Questo potrebbe rivelare qualcosa, potresti fare qualcosa di simile anche con le altre condizioni ==.


Sì, il problema salta fuori, è il "problema doppio == doppio calcolato". Grazie per aver sottolineato il problema SDC.

Grazie ffoorr per avermi fatto notare lo stesso problema prima, ma non l'ho modificato nel modo corretto e ho pensato che non fosse il problema.

Ho una domanda, ma ho bisogno di qualche suggerimento, per il 2° e 3° if nel 2° ciclo for, è meglio mettere una dichiarazione "between"? Tipo OrderStopLoss() >= x + 1 && x - 1? O dovrei semplicemente usare >= o <= ?

 

Spero che WHR non legga questo, si arrabbierebbe, ma ti dirò di provare NormalizeDouble() .... dovrebbe rendere queste condizioni uguali quando dovrebbero essere uguali. Non dovrebbe essere necessario farlo anche sul lato OrderStopLoss(), ma se ancora non viene uguale quando dovrebbe, potresti provare a farlo su entrambi i lati della condizione....

       if(xaii>=2)
       {if(((OrderOpenPrice()-OrderClosePrice())/Figure)>=(StartTrailingStop+(CummulativeValue*xaii)))
        {Print("debug2.0: condition true");
         if(OrderStopLoss()==NormalizeDouble((OrderOpenPrice() -(( TrailingStop+(CummulativeValue *(xaii-1)))*Figure)),Digits));
         {Print("debug2.1: condition true");
          Result=OrderModify(OrderTicket(),OrderOpenPrice(),(OrderOpenPrice() -(( TrailingStop+(CummulativeValue*xaii))*Figure)),OrderTakeProfit(),0,Color);
         }else
         {Print("debug2.1: condition false");
          Print("debug2.1: val1=",OrderStopLoss()," val2=",OrderOpenPrice() -(( TrailingStop+(CummulativeValue *(xaii-1)))*Figure));
 }}}}}}}}}
Motivazione: