[ARCHIVE !] Toute question de débutant, pour ne pas encombrer le forum. Professionnels, ne passez pas à côté. Nulle part sans toi - 4. - page 99

Nouveau commentaire
 
kon12:

Je l'ai... Si une autre voie avec un redraw ?
Montrez le code et vous obtiendrez une réponse immédiate.
 
Lisi4ka330:


Bonjour ! Veuillez m'aider avec la fonction ArrayMo (elle renvoie le maximum de la courbe de 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);
}

Les questions suivantes ont été soulevées :

Quel est l'objectif de la création d'un tableau temporaire ?

m[][2]

2) On ne sait pas très bien d'où proviendront les valeurs du tableau temporaire, et donc on ne sait pas très bien comment ce tableau peut être interrogé :

n=ArraySearchDouble(m, e)

3. Et puis généralement pour moi la vérité est profondément cachée))))). Une fois que nous avons établi qu'il n'y a pas de valeur, nous commençons à déterminer la taille du tableau des "valeurs incertaines".

Je serais très reconnaissant pour un rayon de lumière dans cette histoire)))).


Je ne pense pas que la fonction soit écrite correctement après tout. La raison principale est qu'après l'annonce. 

double m[][2];

il est nécessaire

ArrayResize(m,0);

autrement(je cite)

int ArrayResize( void array[], int new_size)
Si elle réussit, la fonction renvoie le nombre de tous les éléments contenus dans le tableau après le redimensionnement, sinon elle renvoie -1 et le tableau n'est pas redimensionné.
Note : un tableau déclaré localement dans une fonction, qui a été redimensionné, restera inchangé après l'exécution de la fonction. Lorsque la fonction est appelée à nouveau, un tel tableau aura une taille différente de celle déclarée!!!!.

Et donc avec des appels multiples la fonction va "tomber dans le passé").

Sur le fonctionnement de l'algorithme. Le tableau m[][2] lui-même est une représentation directe de la distribution empirique du nombre d'occurrences de la variable x[i] par ses différentes valeurs. En d'autres termes, chaque élément du tableau est constitué de deux nombres - le nombre d'occurrences d'une certaine valeur (le premier champ) et la valeur elle-même. La boucle cherche la même valeur dans le tableau m pour chaque x[i], et si elle est trouvée, le champ du numéro est ajouté, sinon un nouvel élément est créé en utilisant ArrayResize() et notre x[i] y est écrit.

Ensuite, une fois le tableau peuplé, il suffit de trouver l'élément ayant le nombre maximum d'occurrences, c'est-à-dire, par définition, le module de la distribution x.

Ceci est fait par des chaînes

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

Bien qu'il me semble (pas sûr pour le tableau multidimensionnel) que vous auriez pu simplement

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

Au final, je peux dire (avec tout le respect dû à l'auteur du code) que même en corrigeant tous les défauts, cet algorithme est extrêmement inefficace et peut souvent donner des résultats erronés. La raison en est que nous travaillons avec le type double, ce qui signifie que la probabilité que les valeurs de x[i] soient proches mais encore distinguables est assez élevée. Cela peut ne pas être si perceptible lorsque la taille de l'échantillon est beaucoup plus grande (des centaines de fois ou plus) que le nombre total d'intervalles dans lesquels x[i] est défini. Cependant, dans les nombreux cas où cette contrainte n'est pas respectée, il y aura beaucoup de calculs erronés.

La manière la plus correcte de calculer le mode est la suivante : on construit une fonction de distribution empirique (à ne pas confondre avec la distribution de fréquence), puis on l'interpole de linéaire par morceaux à lisse, et enfin on recherche le point de dérivation maximale. Un tel algorithme est exempt des inconvénients énumérés ci-dessus et fonctionne assez efficacement même avec des échantillons de petite taille. Au moins, j'ai dû résoudre la tâche consistant à rechercher des modes dans des échantillons de 50 à 100 éléments avec un nombre comparable d'intervalles en utilisant MQL - et tout était OK. Le seul inconvénient est que les interpolations entraînent généralement une baisse significative de la vitesse de calcul, bien sûr, si l'on souhaite effectuer un lissage qualitatif.

 
Bonjour chers membres du forum, à qui puis-je m'adresser pour écrire une EA? Un EA sans indicateurs basé sur le doublement sur un mouvement qui n'est pas dans notre direction.
 
Glazunov:
Bonjour chers membres du forum, à qui puis-je m'adresser pour écrire une EA ? Un EA sans indicateurs basé sur le doublement sur un mouvement qui n'est pas dans notre direction.
ici : https://www.mql5.com/ru/job
 
ilunga:
ici : https://www.mql5.com/ru/job

Merci. Il y a peut-être d'autres options.
 
Glazunov:

Merci. Il y a peut-être d'autres options.
Essayez de taper "martingale" dans une recherche sur un site web - vous serez surpris.
 
YOUNGA:
Essayez de taper "martingale" dans une recherche sur un site web et vous serez surpris.

Déjà regardé ! Mais ce que je veux est absent(
 
Glazunov:
Bonjour chers membres du forum, à qui puis-je m'adresser pour écrire une EA ? Un EA sans indicateurs basé sur le doublement sur un mouvement qui n'est pas dans notre direction.


Jetez un coup d'œil ici

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

 

Bonjour. Je viens de commencer dans MQL4.

Veuillez me conseiller sur la fonction OrderModify. Les manuels et les exemples montrent que cette fonction est utilisée pour le chalutage, c'est-à-dire la modification du stop loss. J'ai besoin de modifier uniquement le take profit sur un ordre ouvert. Le stop loss n'est pas fixé à l'ouverture de l'ordre et doit également rester à 0 pendant la modification .

Comment le calcul et la sélection des commandes doivent-ils se présenter ?

La cible finale devrait ressembler à quelque chose comme ceci

if (OrderType()==OP_BUY && OrderOpenPrice()-Bid>kof*Point) // il y a un achat, mais il a baissé de kof
{
OrderModify(OrderTicket(),OrderOpenPrice(),0,OrderOpenPrice()+tpnew*Point,0,CLR_NONE);// nous déplaçons le TP plus bas que celui précédemment placé

Il en va de même pour la vente.

Merci pour toute réponse.

 

Rebonjour :)

Comme je le pensais, des problèmes sont apparus. Voici le code. Le fait est que les ordres sur le testeur sont fermés par le TP, et par fonction le TP est supprimé lorsque l'ordre est modifié pendant le 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;}
      }
Ce qui signifie que le trailing stop n'est pas exécuté, et qu'il n'y a pas eu d'erreurs avec des TP et SL erronés dans le journal du testeur. Alors, qu'est-ce qui ne va pas ?
1...9293949596979899100101102103104105106...631
Nouveau commentaire