MetaTrader 5 build 3490 : Version du terminal Web mobile et nouvelles méthodes matricielles dans MQL5

Version mobile de la plateforme web

Le nouveau terminal Web offre le support complet des appareils mobiles. L'interface s'adaptera automatiquement à la taille de l'écran, permettant des opérations plus efficaces depuis les téléphones et tablettes iOS et Android :

En outre, le Terminal Web comporte de nombreuses corrections et améliorations.

Le nouveau terminal Web MetaTrader 5 prend en charge l'ensemble des fonctions de trading. Il permet aux utilisateurs de :

• Travailler avec des comptes de démonstration et des comptes réels
• Recevoir les cotations de n’importe quel symbole financier
• Trader sur tous les marchés
• Analyser les cotations des symboles à l'aide de plus de 30 indicateurs et de 20 objets graphiques.
  
• Utiliser les données du Calendrier Economique pour l'analyse fondamentale

Terminal

1. Fonctions étendues du gestionnaire des tâches. La nouvelle version permet un suivi plus précis des ressources consommées.
   
   
   • Ajout de l’affichage de la taille de la pile des threads.
   • Ajout de l'affichage du nombre de changements de contexte.
   • Ajout de la reconnaissance des threads de DLL du système et de tiers.
   • Ajout de l'affichage du temps de fonctionnement en mode noyau. Une augmentation de cette mesure par rapport au temps passé par l’utilisateur peut indiquer des problèmes au niveau du système : problèmes de pilotes, erreurs matérielles ou matériel lent. Pour plus de détails, veuillez lire la documentation de Microsoft.
   • Ajout de l'affichage du temps de fonctionnement en mode utilisateur.
   
   

   
   
   
   

2. Nouvel onglet OpenCL dans les paramètres du terminal pour la gestion des périphériques disponibles. Le nouveau gestionnaire OpenCL permet de spécifier explicitement les périphériques à utiliser pour les calculs.
   
   

   

3. Ajout de l'indication des niveaux de Stop Loss et de Take Profit dans le Depth of Market pour les comptes fonctionnant en mode FIFO (le mode peut être activé du côté du courtier).
   
   Selon la règle FIFO, les positions de chaque instrument ne peuvent être clôturées que dans l'ordre dans lequel elles ont été ouvertes. Pour assurer une fermeture de position conforme au FIFO par des niveaux de stops, la logique suivante a été implémentée du côté du terminal client :
   
   Si plusieurs positions existent pour le même instrument, le placement des niveaux de stop pour l'une des positions entraîne le placement des mêmes niveaux pour toutes les autres positions également. Par conséquent, si un niveau se déclenche, toutes les positions seront fermées dans un ordre conforme au FIFO.
   
   Désormais, lorsque l'utilisateur ouvre le Depth of Market d'un instrument pour lequel des positions sont déjà ouvertes, les niveaux des positions existantes (le cas échéant) sont automatiquement spécifiés dans les champs Stop Loss et Take Profit.
   
   
4. Correction de la suppression des niveaux de Stop Loss et Take Profit à l'aide des boutons X dans la fenêtre Boîte à Outils\Trade. Une erreur pouvait se produire lorsque la fonction de trading rapide était désactivée. Un clic sur le bouton ouvre une boîte de dialogue de trading avec une valeur vide pour le niveau concerné.
   
   
5. Correction des légendes des graphiques et des calculs des commissions finales dans le rapport de trading. La section pouvait afficher des bénéfices incorrects dans les statistiques du rapport et des valeurs incorrectes dans les infobulles des graphiques Equity et Balance.
   
   

1. Ajout des méthodes CopyTicks et CopyTicksRange pour les vecteurs et pour les matrices. Elles permettent de copier facilement des tableaux de données de ticks en vecteurs et matrices.
   

   bool matrix::CopyTicks(string symbol,uint flags,ulong from_msc,uint count);
   bool vector::CopyTicks(string symbol,uint flags,ulong from_msc,uint count);
   
   bool matrix::CopyTicksRange(string symbol,uint flags,ulong from_msc,ulong to_msc);
   bool matrix::CopyTicksRange(string symbol,uint flags,ulong from_msc,ulong to_msc);

   Le type de données copié est spécifié dans le paramètre 'flags' à l'aide de l'énumération ENUM_COPY_TICKS. Les valeurs suivantes sont disponibles :
   

   COPY_TICKS_INFO    = 1,       // ticks résultant du changement des prix Bid et/ou Ask
   COPY_TICKS_TRADE   = 2,       // ticks résultant du changement des du prix Last et du Volume
   COPY_TICKS_ALL     = 3,       // tous les ticks ont changé
   COPY_TICKS_TIME_MS = 1<<8,    // heure en millisecondes
   COPY_TICKS_BID     = 1<<9,    // prix Bid
   COPY_TICKS_ASK     = 1<<10,   // prix Ask
   COPY_TICKS_LAST    = 1<<11,   // prix Last
   COPY_TICKS_VOLUME  = 1<<12,   // volume
   COPY_TICKS_FLAGS   = 1<<13,   // flags du tick

   Si plusieurs types de données sont sélectionnés (uniquement disponible pour les matrices), l'ordre des lignes dans la matrice correspondra à l'ordre des valeurs dans l'énumération.
   
   
2. Fonctionnalités des méthodes matrix::Assign et vector::Assign améliorées.
   
   On peut maintenant attribuer à la matrice un tableau ou un vecteur unidimensionnel :
   Le résultat sera une matrice de 1 ligne.
   
   De plus, une matrice peut maintenant être assignée à un vecteur (un lissage de la matrice sera effectué) :
   

   bool vector::Assign(const matrix &mat);

3. Ajout des méthodes Swap pour les vecteurs et les matrices.
   

   bool vector::Swap(vector &vec);
   bool vector::Swap(matrix &vec);
   bool vector::Swap(double &arr[]);
   bool matrix::Swap(vector &vec);
   bool matrix::Swap(matrix &vec);
   bool matrix::Swap(double &arr[]);

   Chaque tableau, vecteur ou matrice fait référence à un buffer mémoire contenant les éléments de cet objet. La méthode Swap échange en fait les pointeurs vers ces buffers sans écrire les éléments en mémoire. Par conséquent, une matrice reste une matrice, et un vecteur reste un vecteur. L'échange d'une matrice et d'un vecteur donnera une matrice à 1 rangée avec des éléments de vecteur et un vecteur avec des éléments de matrice dans une représentation plate (voir la méthode Flat).
   

   //+------------------------------------------------------------------+
   //| Fonction de démarrage du programme de script                     |
   //+------------------------------------------------------------------+
   void OnStart()
    {
   //---
     matrix a= {{1, 2, 3}, {4, 5, 6}};
     Print("a avant Swap: \n", a);
     matrix b= {{5, 10, 15, 20}, {25, 30, 35, 40}, {45, 50, 55, 60}};
     Print("b après Swap: \n", b);  
   //--- échange les pointeurs des matrices
     a.Swap(b);
     Print("a avant Swap: \n", a);
     Print("b après Swap: \n", b);
     /*
     a avant Swap:
     [[1,2,3]
     [4,5,6]]
     b avant Swap:
     [[5,10,15,20]
     [25,30,35,40]
     [45,50,55,60]]
     
     a après Swap:
     [[5,10,15,20]
     [25,30,35,40]
     [45,50,55,60]]
     b après Swap:
     [[1,2,3]
     [4,5,6]]
     */
     vector v=vector::Full(10, 7);
     Print("v avant Swap: \n", v);
     Print("b avant Swap: \n", b);
     v.Swap(b);
     Print("v après  Swap: \n", v);
     Print("b après  Swap: \n", b);
     /*
     v avant Swap:
     [7,7,7,7,7,7,7,7,7,7]
     b avant  Swap:
     [[1,2,3]
     [4,5,6]]
     
     v après Swap:
     [1,2,3,4,5,6]
     b après  Swap:
     [[7,7,7,7,7,7,7,7,7,7]]
     */
    }

   La méthode Swap() permet également d'effectuer des opérations avec des tableaux dynamiques (les tableaux de taille fixe ne peuvent pas être passés en paramètre). Le tableau peut être de n'importe quelle dimension mais d'une taille convenue, ce qui signifie que la taille totale d'une matrice ou d'un vecteur doit être un multiple de la dimension 0 du tableau. La dimension 0 du tableau est le nombre d'éléments contenus au 1er indice. Par exemple, pour un tableau dynamique à 3 dimensions "double array[][2][3]", la dimension 0 est le produit de la taille des 2ème et 3ème dimensions : 2 x 3 = 6. Ainsi, un tel tableau ne peut être utilisé dans la méthode Swap qu'avec des matrices et des vecteurs dont la taille totale est un multiple de 6 : 6, 12, 18, 24, etc.
   
   Prenons l'exemple suivant :
   

   //+------------------------------------------------------------------+
   //| Fonction de démarrage du script                                  |
   //+------------------------------------------------------------------+
   void OnStart()
    {
   //--- remplit la matrice 1x10 avec la valeur 7.0
     matrix m= matrix::Full(1, 10, 7.0);
     Print("matrix avant Swap :\n", m);
   //--- essaye d'échanger la matrice et le tableau
     double array_small[2][5]= {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
     Print("array_small avant Swap :");
     ArrayPrint(array_small);
     if(m.Swap(array_small))
      {
       Print("array_small après Swap :");
       ArrayPrint(array_small);
       Print("matrix après Swap : \n", m);
      }
     else // la taille de la matrice n'est pas un multiple de la première dimension du tableau
      {
       Print("Echec de m.Swap(array_small). Erreur ", GetLastError());
      }
     /*
     matrix avant Swap :
     [[7,7,7,7,7,7,7,7,7,7]]
     array_small avant Swap :
              [,0]     [,1]     [,2]     [,3]     [,4]
     [0,]  1.00000  2.00000  3.00000  4.00000  5.00000
     [1,]  6.00000  7.00000  8.00000  9.00000 10.00000
     Echec de m.Swap(array_small). Erreur 4006
     */
   //--- utilise une matrice plus grande et réessaye l'opération de swap
     double array_static[3][10]= {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
        {2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
        {3, 6, 9, 12, 15, 18, 21, 24, 27, 30}
      };
     Print("array_static avant Swap :");
     ArrayPrint(array_static);
     if(m.Swap(array_static))
      {
       Print("array_static après Swap :");
       ArrayPrint(array_static);
       Print("matrix après Swap : \n", m);
      }
     else // un tableau statique ne peut pas être utilisé pour permuter avec une matrice
      {
       Print("Echec de m.Swap(array_static). Erreur ", GetLastError());
      }
     /*
     array_static avant Swap:
            [,0]     [,1]     [,2]     [,3]     [,4]     [,5]     [,6]     [,7]     [,8]     [,9]
     [0,]  1.00000  2.00000  3.00000  4.00000  5.00000  6.00000  7.00000  8.00000  9.00000 10.00000
     [1,]  2.00000  4.00000  6.00000  8.00000 10.00000 12.00000 14.00000 16.00000 18.00000 20.00000
     [2,]  3.00000  6.00000  9.00000 12.00000 15.00000 18.00000 21.00000 24.00000 27.00000 30.00000
     Echec de m.Swap(array_static). Erreur 4006
     */
   //--- une autre tentative d'échanger un tableau et une matrice
     double array_dynamic[][10];    // tableau dynamique
     ArrayResize(array_dynamic, 3); // définit la taille de la première dimension
     ArrayCopy(array_dynamic, array_static);
   //--- utilise maintenant un tableau dynamique pour le swap
     if(m.Swap(array_dynamic))
      {
       Print("array_dynamic après Swap :");
       ArrayPrint(array_dynamic);
       Print("matrix après Swap : \n", m);
      }
     else //  aucune erreur
      {
       Print("Echec de m.Swap(array_dynamic). Erreur ", GetLastError());
      }
     /*
     array_dynamic après Swap :
           [,0]    [,1]    [,2]    [,3]    [,4]    [,5]    [,6]    [,7]    [,8]    [,9]
     [0,] 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000
     matrix après Swap :
     [[1,2,3,4,5,6,7,8,9,10,2,4,6,8,10,12,14,16,18,20,3,6,9,12,15,18,21,24,27,30]]
     */
    }

4. Ajout de la méthode LossGradient pour les vecteurs et les matrices. Cette méthode calcule un vecteur ou une matrice de dérivées partielles de la fonction de perte sur les valeurs prédites. En algèbre linéaire, un tel vecteur est appelé gradient et est utilisé dans l'apprentissage automatique.
   

   vector vector::LossGradient(const vector &expected,ENUM_LOSS_FUNCTION loss) const;
   matrix matrix::LossGradient(const matrix &expected,ENUM_LOSS_FUNCTION loss) const;

5. Permet l'utilisation de FOREIGN KEYS dans SQLite pour renforcer les relations entre les tables dans les requêtes SQL.   Exemple :
   

   CREATE TABLE artist(
     artistid    INTEGER PRIMARY KEY, 
     artistname  TEXT
   );
   
   CREATE TABLE track(
     trackid     INTEGER, 
     trackname   TEXT, 
     trackartist INTEGER,
     FOREIGN KEY(trackartist) REFERENCES artist(artistid)
   );

   
   
6. Sélection fixe de la méthode de classe appropriée en fonction de la constance de la méthode et de l'objet.

MetaEditor

1. Augmentation de la longueur autorisée des commentaires dans commits du Dépôt MQL5. Des commentaires détaillés lors de la validation des changements dans le référentiel sont considérés comme une bonne pratique lorsque l'on travaille sur de grands projets, mais auparavant la longueur des commentaires était limitée à 128 caractères. La longueur autorisée est désormais de 260 caractères maximum.

1. Sensibilité accrue du sélecteur de vitesse de test en mode visuel.

Correction des erreurs rapportées dans les journaux de crash.