[Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 4. - pagina 99

Nuovo commento
 
kon12:

Capito... Se un altro modo con un ridisegno?
Mostra il codice e avrai una risposta immediata.
 
Lisi4ka330:


Per favore, aiutatemi con la funzione ArrayMo (restituisce il massimo della curva di densità). 

double ArrayMo(double& x[], int d=4) {
  double e, s=0;
  double m[][2];             // временный массив:
                             //  столбец 1 - количество значений
                             //  столбец 2 - значения
  int    i, k=ArraySize(x);
  int    n;                  // номер строки временного массива m
  int    r;                  // количество строк во временном массиве m

  if (k>0) {
    for (i=0; i<k; i++) {
      e=NormalizeDouble(x[i], d);
      n=ArraySearchDouble(m, e);
      if (n<0) {
        r=ArrayRange(m, 0);
        ArrayResize(m, r+1);
        m[r][0]++;
        m[r][1]=e;
      } else m[n][0]++;
    }
    ArraySort(m, WHOLE_ARRAY, 0, MODE_DESCEND);
    s=m[0][1];
  } else Print("ArrayMo(): Массив пуст!");

  return(s);
}

Sono sorte le seguenti domande:

1.Qual è lo scopo di creare un array temporaneo

m[][2]

2. Non è chiaro da cosa saranno presi i valori dell'array temporaneo, e quindi non è chiaro come questo array possa essere cercato:

n=ArraySearchDouble(m, e)

3. E poi generalmente per me la verità è profondamente nascosta))))) Una volta accertato che non c'è nessun valore, cominciamo a determinare la dimensione dell'array di "valori non chiari".

Sarei molto grato per un raggio di luce in questa storia))))


Non credo che la funzione sia scritta in modo corretto, dopo tutto. La ragione principale è che dopo l'annuncio. 

double m[][2];

è necessario

ArrayResize(m,0);

altrimenti(cito)

int ArrayResize( void array[], int new_size)
Imposta la nuova dimensione nella prima dimensione dell'array. Se ha successo, la funzione restituisce il numero di tutti gli elementi contenuti nell'array dopo il ridimensionamento, altrimenti restituisce -1 e l'array non viene ridimensionato.
!!!Nota: un array dichiarato localmente in qualsiasi funzione, che è stato ridimensionato, rimarrà invariato dopo l'esecuzione della funzione. Quando la funzione viene richiamata, tale array avrà una dimensione diversa da quella dichiarata!!!!

E quindi con più chiamate la funzione "cadrà nel passato")

Su come funziona l'algoritmo. L'array m[][2] stesso è una rappresentazione diretta della distribuzione empirica del numero di hit della variabile x[i] dai suoi diversi valori. Cioè, ogni elemento dell'array consiste di due numeri - il numero di riscontri su qualche valore (il primo campo) e il valore stesso. Il ciclo cerca lo stesso valore nell'array m per ogni x[i], e se lo trova, viene aggiunto il campo numerico, altrimenti viene creato un nuovo elemento usando ArrayResize() e il nostro x[i] viene scritto lì.

Poi, una volta che l'array è popolato, dobbiamo solo trovare l'elemento con il massimo numero di hit, cioè, per definizione, il modulo della distribuzione x.

Questo è fatto dalle stringhe

    ArraySort(m, WHOLE_ARRAY, 0, MODE_DESCEND);
    s=m[0][1];

Anche se mi sembra (non sono sicuro dell'array multidimensionale), si potrebbe avere solo

    s=m[ArrayMaximum(m)][1];

Tutto sommato posso dire (con tutto il rispetto per l'autore del codice) che anche quando si correggono tutti i difetti, questo algoritmo è estremamente inefficiente e spesso può dare risultati sbagliati. La ragione è che stiamo lavorando con il tipo double, il che significa che la probabilità che i valori di x[i] siano vicini ma ancora distinguibili è abbastanza alta. Questo potrebbe non essere così evidente quando la dimensione del campione è molto più grande (centinaia di volte o più) del numero totale di intervalli in cui x[i] è definito. Tuttavia, nei molti casi in cui questo vincolo non è rispettato, ci saranno molti calcoli sbagliati.

Il modo più corretto di calcolare il modo è questo: si costruisce una funzione di distribuzione empirica (da non confondere con la distribuzione di frequenza), poi la si interpola da piecewise linear a smooth, e infine si cerca il punto di massima derivazione. Un tale algoritmo è privo degli svantaggi elencati sopra e funziona abbastanza efficacemente anche con campioni di piccole dimensioni. Almeno, ho dovuto risolvere solo il compito di trovare una modalità per campioni di 50-100 elementi con un numero comparabile di intervalli usando MQL - e tutto era OK. L'unico svantaggio è che l'interpolazione di solito porta a un calo significativo della velocità di calcolo, se, naturalmente, vogliamo smussarla qualitativamente.

 
Ciao stimati membri del forum, con chi posso parlare per scrivere un EA. Un EA senza indicatori basato sul raddoppio su un movimento non nella nostra direzione.
 
Glazunov:
Ciao stimati membri del forum, con chi posso parlare per scrivere un EA. Un EA senza indicatori basato sul raddoppio su un movimento non nella nostra direzione.
qui: https://www.mql5.com/ru/job
 
ilunga:
qui: https://www.mql5.com/ru/job

Grazie. Forse ci sono più opzioni.
 
Glazunov:

Grazie. Forse ci sono più opzioni.
Provate a digitare "martingala" in una ricerca su un sito web - sarete sorpresi
 
YOUNGA:
Provate a digitare "martingala" in una ricerca su un sito web e sarete sorpresi

Già guardato! Ma quello che voglio non c'è (
 
Glazunov:
Ciao stimati membri del forum, con chi posso parlare per scrivere un EA. Un EA senza indicatori basato sul raddoppio su un movimento non nella nostra direzione.


Date un'occhiata qui

https://www.mql5.com/ru/forum/136747

 

Salve. Ho appena iniziato in MQL4.

Per favore, date un consiglio sulla funzione OrderModify. I manuali e gli esempi mostrano che questa funzione è usata per la pesca a strascico, cioè il cambiamento dello stop loss. Ho bisogno di cambiare solo il take profit su un ordine aperto. Lo stop loss non è impostato quando l'ordine è aperto e deve anche rimanere a 0 durante la modifica .

Come dovrebbe essere il calcolo e la selezione degli ordini?

L'obiettivo finale dovrebbe assomigliare a questo

if (OrderType()==OP_BUY && OrderOpenPrice()-Bid>kof*Point) // c'è un acquisto, ma è sceso di kof
{
OrderModify(OrderTicket(),OrderOpenPrice(),0,OrderOpenPrice()+tpnew*Point,0,CLR_NONE);// spostiamo TP più in basso di quello precedentemente piazzato

Lo stesso per la vendita.

Grazie per qualsiasi risposta.

 

Ciao di nuovo :)

Come pensavo, sono sorti dei problemi. Ecco il codice. Il punto è che gli ordini sul tester sono chiusi da TP, e per funzione TP viene rimosso quando l'ordine viene modificato durante il Trailing Stop.

double my_ord[31][2];                                           //ордера советника
                                                                //[][0] Ticket
                                                                //[][1] Вид операции 
//---------------------------------------------------------------------------------

void FindMyOrders()                                             //ищем свои ордера(от советника)
   {
    for (int a = 0;a<32;a++)                                    //во избежание ошибок заполняем все нулями
      {
       my_ord[a][0]=0;
       my_ord[a][1]=0;
      }
    int pos = 0;
    for(int i=0; i<32; i++)
      {
       if (Mas_Ord_New[i][8]==1)                                //есть ли комментарий
         {
          int num = Mas_Ord_New[i][4];
          OrderSelect(SELECT_BY_TICKET, num);
          string str = OrderComment();
          if (str == "AO Day Profiter Trade")                   //наш ли это комментарий
            {
             my_ord[pos][0] = num;
             my_ord[pos][1] = Mas_Ord_New[i][6];                //если наш, записываем Ticket и вид операции
             pos++;
            }
          else { }
         }
       else { }
      }
   }
//---------------------------------------------------------------
void TrailStop(int ticket, int TStop)                           //ф-ция трейлинг стопа, TStop-расстояние в пп
   {
    int minDist = MarketInfo(symb, MODE_STOPLEVEL);
    if (TStop<minDist)
      {
       TStop = minDist;
      }
    else { }
    if (TStop>0)
      {
       OrderSelect(ticket, SELECT_BY_TICKET);
       if(OrderType()==OP_BUY)
         {
          if(Bid - OrderOpenPrice()>Point*TStop)
            {
             if(OrderStopLoss()<Bid-Point*TStop)
               {
                OrderModify(OrderTicket(), OrderOpenPrice(), 
                Bid-Point*TStop, 0, 0, Blue);
                return;
               }
             else { }
            }
            else{ }
         }
       else if (OrderType()==OP_SELL)
         {
          if(OrderOpenPrice() - Ask>Point*TStop)
            {
             if(OrderStopLoss()>Ask + TStop*Point)
               {
                OrderModify(OrderTicket(), OrderOpenPrice(), 
                Ask+Point*TStop, 0, 0, Blue);                           //ordertakeprofit!!
                return;
               }
             else { }
            }
          else { }
         }
       else { }
      }
    else { }
    }
//-----------------------------------а это кусочек Start(), отвечающий за трейлинг стоп
   for (int i = 0; i<32; i++)                                   //трейлинг стоп для наших ордеров
      {
       if (my_ord[i][0]>0)
         {
          TrailStop(my_ord[i][0], TralingStop);
         }
       else {break;}
      }
Il che significa che il trailing stop non viene eseguito, e non ci sono stati errori con TP e SL sbagliati nel log del tester. Allora cosa c'è che non va?
1...9293949596979899100101102103104105106...631
Nuovo commento
Motivazione: