[Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate. Non posso andare da nessuna parte senza di te. - pagina 622

Nuovo commento
 
Rossi:

c'è un modo per ordinare gli strumenti nelle schede nella parte inferiore dello schermo? perché 8 strumenti in 4 timeframes sono sparsi in un mess....

no
 
DDFedor:

prendere la scheda con il nome del grafico e trascinarla al posto giusto

AAAAAAAAAAAAAAAAAAAAAAAAAA grande risposta, grazie...
 
artmedia70:
:) Ora è apparso l'errore 130. La cosa più confusa è che con gli stop sbagliati (130) imposta ancora i decolli corretti (calcolati da ATR), ma i miei stop non erano impostati dall'inizio...
C'è un modo per capire questo?
Un errore di 130 potrebbe essere uno stoploss sbagliato o un takeprofit sbagliato.
 
ToLik_SRGV:


Ho aggiunto gli ordini limite (li ho dimenticati nel codice precedente :)) + l'elaborazione dell'errore #1 (prima della modifica il nuovo prezzo viene confrontato con quello attuale, se sono uguali, allora non succede niente):

Sembra che gli ordini modificati spostati dal trawl più vicino al mercato perdano la loro eredità TakeProfit... Essi, una volta innescati, si appendono al grafico in posizioni e consumano stupidamente il margine. Non chiudono in profitto o in perdita, e non c'è una linea TakeProfit... Anche se ho aggiunto di proposito il valore tp, calcolato con ATR, al codice per controllarlo:

void trailingOrder(int magic, int trailing){
   int index = 0, tp=TakeProfitATR (5);
   while(trailing > 0 && OrdersTotal() != 0 && OrderSelect(index, SELECT_BY_POS)){
      if(OrderMagicNumber() == magic){
         if(OrderType() == OP_BUYSTOP){
            if(OrderOpenPrice() - Ask > Point*trailing){
               if((Ask+Point*trailing) - Ask >= MarketInfo(Symbol(), MODE_STOPLEVEL)*Point &&
                 (Ask+Point*trailing) - Ask > MarketInfo(Symbol(), MODE_FREEZELEVEL)*Point &&
                 (Ask+Point*trailing) != OrderOpenPrice()){
                  if(!OrderModify(OrderTicket(),Ask+Point*trailing,OrderStopLoss(),
                  /*OrderTakeProfit()*/tp, 0, MediumSpringGreen))Print(">>> ERROR ", GetLastError());
               }else{
                  Print(">>> Слишком близко к рынку или передано неизмененное значение!");
               }
            }
            return;
         }
// ..... Далее по тексту функции также добавлены изменения...

Sia prima che dopo le mie modifiche l'ordine modificato non aveva una take line né prima né dopo la sua conversione in posizione...

Quale può essere la ragione?

 
artmedia70:

Sembra che gli ordini modificati spostati dal trawl più vicino al mercato perdano la loro eredità TakeProfit... Essi, una volta innescati, si appendono al grafico in posizioni e consumano stupidamente il margine. Non chiudono in profitto o in perdita, e non c'è una linea TakeProfit... Anche se ho aggiunto di proposito il valore tp, calcolato con ATR, al codice per controllarlo:

Sia prima che dopo l'aggiunta delle modifiche, l'ordine modificato non ha avuto una take line né prima né dopo la sua conversione in posizione...

Quale potrebbe essere la ragione?

Quando si modifica il prezzo di un ordine pendente, anche lo stoploss e il takeprofit dovrebbero essere modificati.
 
khorosh:
L'errore 130 può essere sia lo stoploss sbagliato che il takeprofit sbagliato.
Grazie. Lo sapevo già... Non era questo il punto. L'errore era causato dal trawl - l'ho disabilitato e tutto è ok. Non ho ancora il tempo di occuparmene.
 
khorosh:
Quando si modifica il prezzo dell'ordine pendente, è necessario modificare anche StopLoss e TakeProfit.

La funzione ATR Take Profit non lo fa? Lo chiamo prima di modificare un ordine, ottengo il valore attuale di take calcolato da TakeProfitATR() e lo incollo nella modifica dell'ordine... Questo è nel mio esempio sopra:

int index = 0, tp=TakeProfitATR (5); // Рассчёт нового тейка по значению ATR. Ф-ция возвращает размер тейка в пунктах

....

if(!OrderModify(OrderTicket(),Ask+Point*trailing,OrderStopLoss(),
   /*OrderTakeProfit()*/tp, 0, MediumSpringGreen))Print(">>> ERROR ", GetLastError()); // здесь вместо OrderTakeProfit() подставляю tp
Sembra che io abbia trovato un errore mentre scrivevo questo... La funzione TakeProfit di ATR restituisce il valore TakeProfit in pip, mentre il prezzo dovrebbe essere usato.
Ma allora non capisco perché l'ordine modificato perdeva il suo valore di takepoint prima di queste modifiche... Anche se, OrderTakeProfit() dovrebbe scrivere il valore del suo punto di presa nell'ordine che viene modificato...
E poi la domanda - perché dovrei modificarlo (prendere) ogni volta, se, diciamo, voglio solo spostare un ordine pendente più vicino al mercato senza cambiarlo, se il mercato si è allontanato da esso ed è pronto per un'inversione o correzione... ???
 
artmedia70:

La funzione ATR Take Profit non lo fa? Lo chiamo prima di modificare un ordine, ottengo il valore attuale di take calcolato da TakeProfitATR() e lo incollo nella modifica dell'ordine... Questo è nel mio esempio sopra:

....

Sembra che io abbia trovato il mio errore mentre scrivevo questo... La funzione TakeProfit di ATR restituisce il valore TakeProfit in pip, mentre il prezzo dovrebbe essere usato.
Ma allora non capisco perché l'ordine modificato perdeva ancora il suo valore di takepoint prima di questi cambiamenti... Anche se, OrderTakeProfit() dovrebbe scrivere il valore del suo punto di presa nell'ordine che viene modificato...
E poi la domanda - perché dovrei modificarlo (prendere) ogni volta, se, diciamo, voglio solo spostare un ordine pendente più vicino al mercato senza cambiarlo, se il mercato si è allontanato da esso ed è pronto per un'inversione o correzione... ???




Ho aggiunto stop e takeover automatici al mio metodo. Quando metti un ordine pendente devi solo impostare i limitatori e il metodo trascinerà tutto al posto giusto :))

//+------------------------------------------------------------------+
void trailingOrder(int magic, int trailing){
   int index = 0;
   double takeprofit, stoploss;
   while(trailing > 0 && OrdersTotal() != 0 && OrderSelect(index, SELECT_BY_POS)){
      if(OrderMagicNumber() == magic){
         if(OrderType() == OP_BUYSTOP){
            if(OrderOpenPrice() - Ask > Point*trailing){
               if((Ask+Point*trailing) - Ask >= MarketInfo(Symbol(), MODE_STOPLEVEL)*Point &&
                 (Ask+Point*trailing) - Ask > MarketInfo(Symbol(), MODE_FREEZELEVEL)*Point &&
                 (Ask+Point*trailing) != OrderOpenPrice()){
                  if(!OrderModify(OrderTicket(),Ask+Point*trailing, Ask+Point*trailing-(OrderOpenPrice()-OrderStopLoss()), Ask+Point*trailing+(OrderTakeProfit()-OrderOpenPrice()), 0))Print(">>> ERROR ", GetLastError());
               }else{
                  Print(">>> Слишком близко к рынку или передано неизмененное значение!");
               }
            }
            return;
         }
         if(OrderType() == OP_SELLSTOP){
            if(Bid - OrderOpenPrice() > Point*trailing){
               if(Bid - (Bid-Point*trailing) >= MarketInfo(Symbol(), MODE_STOPLEVEL)*Point &&
                 Bid - (Bid-Point*trailing) > MarketInfo(Symbol(), MODE_FREEZELEVEL)*Point &&
                 (Bid-Point*trailing) != OrderOpenPrice()){
                  if(!OrderModify(OrderTicket(),Bid-Point*trailing,Bid-Point*trailing+(OrderStopLoss()-OrderOpenPrice()),Bid-Point*trailing-(OrderOpenPrice()-OrderTakeProfit()), 0))Print(">>> ERROR ", GetLastError());
               }else{
                  Print(">>> Слишком близко к рынку или передано неизмененное значение!");
               }
            }
            return;
         }
         if(OrderType() == OP_SELLLIMIT){
            if(OrderOpenPrice() - Bid > Point*trailing){
               if((Bid+Point*trailing) - Bid >= MarketInfo(Symbol(), MODE_STOPLEVEL)*Point &&
                 (Bid+Point*trailing) - Bid > MarketInfo(Symbol(), MODE_FREEZELEVEL)*Point &&
                 (Bid+Point*trailing) != OrderOpenPrice()){
                  if(!OrderModify(OrderTicket(),Bid+Point*trailing,Bid+Point*trailing+(OrderStopLoss()-OrderOpenPrice()),Bid+Point*trailing-(OrderOpenPrice()-OrderTakeProfit()), 0))Print(">>> ERROR ", GetLastError());
               }else{
                  Print(">>> Слишком близко к рынку или передано неизмененное значение!");
               }
            }
            return;
         }
         if(OrderType() == OP_BUYLIMIT){
            if(Ask - OrderOpenPrice() > Point*trailing){
               if(Ask - (Ask-Point*trailing) >= MarketInfo(Symbol(), MODE_STOPLEVEL)*Point &&
                 Ask - (Ask-Point*trailing) > MarketInfo(Symbol(), MODE_FREEZELEVEL)*Point &&
                 (Ask-Point*trailing) != OrderOpenPrice()){
                  if(!OrderModify(OrderTicket(),Ask-Point*trailing,Ask-Point*trailing-(OrderOpenPrice()-OrderStopLoss()),Ask-Point*trailing+(OrderTakeProfit()-OrderOpenPrice()), 0))Print(">>> ERROR ", GetLastError());
               }else{
                  Print(">>> Слишком близко к рынку или передано неизмененное значение!");
               }
            }
            return;
         }
      }
      index++;
   }
}
//+------------------------------------------------------------------+
 
ToLik_SRGV:


Ho aggiunto al metodo lo stop automatico e i takeover. Quando imposto gli ordini pendenti, imposto i limitatori una volta e poi il metodo stesso trascina tutto al posto giusto :))

Molto molto utile! Ma non ottimale. Dovremmo cambiare dinamicamente la presa. Perché dobbiamo seguire il mercato? Se impostiamo un ordine pendente e il prezzo si è allontanato - una correzione, per esempio... Cosa facciamo? Aspettiamo il ritorno del prezzo? O cancellare l'ordine? Non sarebbe meglio fare così...

Immaginiamo una situazione in cui il mercato ha una bassa volatilità ma una tendenza costante al rialzo. Il prezzo si è lentamente allontanato dall'ordine SELLSTOP pendente verso l'alto. Una posizione BUY aperta è già stata elaborata e chiusa con profitto. Aspettiamo che la volatilità del mercato aumenti, e non appena supera una certa soglia, spostiamo un ordine limite sul prezzo. Così, si coglie la correzione che è iniziata e il limitatore funziona non come una posizione di blocco ma come una fonte aggiuntiva di reddito. Se non l'avessimo spostato, la correzione avrebbe potuto raggiungerlo, toccarlo e finire. In questo caso avremmo una posizione lota Sell in una tendenza al rialzo.

Una tale escursione in un safari di tendenza...

Se abbiamo dei TP dinamici, allora spostando un ordine pendente sul mercato e tenendo conto di una forte volatilità (qui sarà più grande che per una volatilità debole) abbiamo più probabilità di prendere più profitto da una correzione che in caso di TP statici. Comunque, se non abbiamo chiuso sulla presa, la rete a strascico farà il suo lavoro e perderemo solo il profitto mancato...

Ugh... Era da molto tempo che non cliccavo così tanto sulla tastiera...

Quindi, il suggerimento segue da solo. Per rendere in parametri di passaggio della funzione anche TimeFrame. E sulla base di questo calcolare il prelievo dai valori ATR.

Ho sperimentato per qualche tempo e le mie indagini per M5 TF hanno portato alla conclusione che il take profit ottimale secondo ATR è calcolato con ATR*45000, e l'ho fatto per i miei calcoli. A questi valori il mercato quasi sempre "cattura" la presa in tempo:

//+------------------------------------------------------------------+
//|                  Take from ATR                                   |
//+------------------------------------------------------------------+
double TakeProfitATR (int tf)
  {
   double   atr   =iATR(NULL,tf,14,0);
   double   mltp  =15000;
   if (tf==1) mltp=15000;
   if (tf==5) mltp=45000;
   double   tp    =MathRound(atr*mltp);
   return  (tp);
  }

Naturalmente, la funzione non è finita, ma è sufficiente per me per i test (sto testando M5 per ora)... A proposito, con il valore di input = 1 dà una distanza abbastanza buona per l'impostazione dell'ordine pendente.

Sarebbe bello vederlo nella vostra funzione... :)

Grazie comunque - è abbastanza soddisfacente considerando le mie modifiche solo per ottenere quanto sopra...
ZS... sarebbe bello aggiungere dei colori per le icone di modifica... (in realtà li ho già aggiunti)...

 

Ecco una domanda: come fa BC a gestire un gran numero di scambi? Il mio Expert Advisor apre posizioni ogni 29 minuti (solo una su cinque strategie). Poi, quando il patrimonio netto aumenta del cinque per cento, vengono chiusi tutti insieme. La cosa principale è che il saldo aumenta del cinque per cento ogni tre o cinque giorni.

Mi chiedo se BC ha qualche diritto a questo tipo di commercio.

1...615616617618619620621622623624625626627628629...1145
Nuovo commento
Motivazione: