WebTerminal MetaTrader 5
Terminal
MQL5
class A { }; void OnStart(void) { const A *const arr[][2][3]={}; Print(typename(arr)); }Résultat :
"class A const * const [][2][3]"
Terminal
MQL5
Correction des erreurs rapportées dans les journaux de crash.
Nouvelle version du Terminal Web MetaTrader 5
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 :
Terminal
MQL5
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.bool vector::Assign(const matrix &mat);
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.//+------------------------------------------------------------------+
//| 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]]
*/
}
vector vector::LossGradient(const vector &expected,ENUM_LOSS_FUNCTION loss) const;
matrix matrix::LossGradient(const matrix &expected,ENUM_LOSS_FUNCTION loss) const;
CREATE TABLE artist(
artistid INTEGER PRIMARY KEY,
artistname TEXT
);
CREATE TABLE track(
trackid INTEGER,
trackname TEXT,
trackartist INTEGER,
FOREIGN KEY(trackartist) REFERENCES artist(artistid)
);
MetaEditor
MetaTester
Correction des erreurs rapportées dans les journaux de crash.
Terminal
MQL5
bool vector<TDst>::Assign(const vector<TSrc> &assign); bool matrix<TDst>::Assign(const matrix<TSrc> &assign);Exemple :
//--- copying matrices matrix b={}; matrix a=b; a.Assign(b); //--- copying an array to a matrix double arr[5][5]={{1,2},{3,4},{5,6}}; Print("array arr"); ArrayPrint(arr); b.Assign(arr); Print("matrix b \n",b); /* array arr [,0] [,1] [,2] [,3] [,4] [0,] 1.00000 2.00000 0.00000 0.00000 0.00000 [1,] 3.00000 4.00000 0.00000 0.00000 0.00000 [2,] 5.00000 6.00000 0.00000 0.00000 0.00000 [3,] 0.00000 0.00000 0.00000 0.00000 0.00000 [4,] 0.00000 0.00000 0.00000 0.00000 0.00000 matrix b [[1,2,0,0,0] [3,4,0,0,0] [5,6,0,0,0] [0,0,0,0,0] [0,0,0,0,0]] */
bool matrix::CopyRates(string symbol,ENUM_TIMEFRAMES period,ulong rates_mask,ulong from,ulong count); bool vector::CopyRates(string symbol,ENUM_TIMEFRAMES period,ulong rates_mask,ulong from,ulong count);Le type de données copiées est spécifié dans le paramètre rates_mask en utilisant l'énumération ENUM_COPY_RATES. Les valeurs suivantes sont disponibles :
Correction d'une erreur lors de la modification d'un paramètre constant transmis à une fonction en tant que référence de pointeur d'objet.
Le spécificateur const déclare une variable comme étant une constante pour éviter qu'elle ne soit modifiée pendant l'exécution du programme. Il ne permet qu'une seule initialisation de la variable lors de sa déclaration. Exemple de variables constantes dans la fonction OnCalculate:
int OnCalculate (const int rates_total, // price[] array size const int prev_calculated, // bars processed on previous call const int begin, // meaningful data starts at const double& price[] // array for calculation );
L'exemple ci-dessous contient une erreur de compilation qui a
permis un casting implicite de pointeur pour les paramètres de référence
:
class A {}; const A *a = new A; void foo( const A*& b ) { b = a; } void OnStart() { A *b; foo(b); // not allowed Print( a,":",b ); }Le compilateur détectera ces opérations illégales et renverra une erreur correspondante.
MetaEditor
Nouveau version du Terminal Web MetaTrader 5
Nous
avons publié une nouvelle version du Terminal Web MetaTrader 5 avec une
nouvelle interface et un noyau repensé. La nouvelle interface est
similaire à la version du terminal pour iPad :
Cette nouvelle version dispose également de nombreuses nouvelles fonctions :
Essayez dès maintenant le nouveau terminal Web sur www.mql5.com. Il sera bientôt disponible pour vos courtiers.
Terminal
MQL5
//--- matrix a= {{1, 4}, {9, 16}}; Print("matrix a=\n",a); a=MathSqrt(a); Print("MatrSqrt(a)=\n",a); /* matrix a= [[1,4] [9,16]] MatrSqrt(a)= [[1,2] [3,4]] */Pour MathMod et MathPow, le deuxième élément peut être soit un scalaire, soit une matrice/vecteur de la bonne taille.
//+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- Use the initializing function to populate the vector vector r(10, ArrayRandom); // Array of random numbers from 0 to 1 //--- Calculate the average value double avr=r.Mean(); // Array mean value vector d=r-avr; // Calculate an array of deviations from the mean Print("avr(r)=", avr); Print("r=", r); Print("d=", d); vector s2=MathPow(d, 2); // Array of squared deviations double sum=s2.Sum(); // Sum of squared deviations //--- Calculate standard deviation in two ways double std=MathSqrt(sum/r.Size()); Print(" std(r)=", std); Print("r.Std()=", r.Std()); } /* avr(r)=0.5300302133243813 r=[0.8346201971495713,0.8031556138798182,0.6696676534318063,0.05386516922513505,0.5491195410016175,0.8224433118686484,... d=[0.30458998382519,0.2731254005554369,0.1396374401074251,-0.4761650440992462,0.01908932767723626,0.2924130985442671, ... std(r)=0.2838269732183663 r.Std()=0.2838269732183663 */ //+------------------------------------------------------------------+ //| Fills the vector with random values | //+------------------------------------------------------------------+ void ArrayRandom(vector& v) { for(ulong i=0; i<v.Size(); i++) v[i]=double(MathRand())/32767.; }
Améliorations des fonctions mathématiques pour les opérations utilisant le type float.
La possibilité nouvellement implémentée d'appliquer des fonctions
mathématiques à des matrices et des vecteurs de ’float’ a permis une
amélioration des fonctions mathématiques appliquées aux scalaires de
type ’float’. Ces paramètres de fonction étaient auparavant
automatiquement transformés en type 'double'. L'implémentation
correspondante de la fonction mathématique était ensuite appelée et le
résultat était retransformé en type 'float'. Les opérations sont
désormais implémentées sans conversion de type supplémentaire.
L'exemple suivant montre la différence dans les calculs mathématiques du sinus :
//+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- Array of random numbers from 0 to 1 vector d(10, ArrayRandom); for(ulong i=0; i<d.Size(); i++) { double delta=MathSin(d[i])-MathSin((float)d[i]); Print(i,". delta=",delta); } } /* 0. delta=5.198186103783087e-09 1. delta=8.927621308885136e-09 2. delta=2.131878673594656e-09 3. delta=1.0228555918923021e-09 4. delta=2.0585739779477308e-09 5. delta=-4.199390279957527e-09 6. delta=-1.3221741035351897e-08 7. delta=-1.742922250969059e-09 8. delta=-8.770715820283215e-10 9. delta=-1.2543186267421902e-08 */ //+------------------------------------------------------------------+ //| Fills the vector with random values | //+------------------------------------------------------------------+ void ArrayRandom(vector& v) { for(ulong i=0; i<v.Size(); i++) v[i]=double(MathRand())/32767.; }
AF_ELU | Unité Linéaire Exponentielle |
AF_EXP | Exponentiel |
AF_GELU | Unité Linéaire d'Erreur Gaussienne |
AF_HARD_SIGMOID | Sigmoïde Dure |
AF_LINEAR | Linéaire |
AF_LRELU | Unité Linéaire Rectifiée Perméable |
AF_RELU | Unité Linéaire Rectifiée |
AF_SELU | Unité Linéaire Exponentielle Mise à l'Echelle |
AF_SIGMOID | Sigmoïde |
AF_SOFTMAX | Softmax |
AF_SOFTPLUS | Softplus |
AF_SOFTSIGN | Softsign |
AF_SWISH | Bruissement |
AF_TANH | Tangente Hyperbolique |
AF_TRELU | Unité Linéaire Rectifiée Avec Seuil |
LOSS_MSE | Erreur Quadratique Moyenne |
LOSS_MAE | Erreur Absolue Moyenne |
LOSS_CCE | Inter-entropie Catégorielle |
LOSS_BCE | Inter-entropie Binaire |
LOSS_MAPE | Erreur Moyenne en Pourcentage Absolu |
LOSS_MSLE | Erreur Logarithmique Quadratique Moyenne |
LOSS_KLD | Divergence Kullback-Leibler |
LOSS_COSINE | Similarité/Proximité Cosinus |
LOSS_POISSONS | Poisson |
LOSS_HINGE | Charnière |
LOSS_SQ_HINGE | Charnière Au carré |
LOSS_CAT_HINGE | Charnière Catégorielle |
LOSS_LOG_COSH | Logarithme du Cosinus Hyperbolique |
LOSS_HUBER | Huber |
int cl_ctx; //--- Initializing the OpenCL context if((cl_ctx=CLContextCreate(CL_USE_GPU_DOUBLE_ONLY))==INVALID_HANDLE) { Print("OpenCL not found"); return; }
CalendarValueLast(change, result, "", "EUR")
MetaEditor
'levels.bmp' as 'uint levels[18990]'
Terminal
MQL5
MetaTester
MetaEditor
Correction des erreurs signalées dans les journaux de plantage.
Terminal
MQL5
double vector.RegressionError(const enum lr_error); double matrix.RegressionError(const enum lr_error); vector matrix.RegressionError(const enum lr_error,const int axis);Les variables suivantes peuvent être utilisées comme métriques :
enum REGRESSION_ERROR { REGRESSION_MAE, // Erreur absolue moyenne REGRESSION_MSE, // Erreur quadratique moyenne REGRESSION_RMSE, // Erreur quadratique racine moyenne REGRESSION_R2, // R au carré REGRESSION_MAPE, // Erreur absolue moyenne en pourcentage REGRESSION_MSPE, // Erreur de pourcentage carré moyen REGRESSION_RMSLE // Erreur logarithmique quadratique moyenne };
MetaEditor
Testeur
Terminal
Terminal
Terminal
MQL5
void OnStart() { int arr[4][5]= { {22, 34, 11, 20, 1}, {10, 36, 2, 12, 5}, {33, 37, 25, 13, 4}, {14, 9, 26, 21, 59} }; ulong indexes[4][5]; //--- Trie le tableau arr.ArgSort(indexes,-1,0); Print("indexes"); ArrayPrint(indexes); } // Résultat : // indexes // [,0][,1][,2][,3][,4] // [0,] 4 2 3 0 1 // [1,] 2 4 0 3 1 // [2,] 4 3 2 0 1 // [3,] 1 0 3 2 4
void OnStart() { string test="some string"; PrintFormat("La longueur de la chaîne est %d",test.Length()); } // Résultat : // La longueur de la chaîne est 11
MQL5
double matrix::Flat(ulong index) const; // getter void matrix::Flat(ulong index,double value); // setter
Pseudocode pour calculer l'adresse d'un élément matriciel :
ulong row=index / mat.Cols(); ulong col=index % mat.Cols(); mat[row,col]
Par exemple, pour 'matrix mat(3,3)', l'accès aux éléments peut s'écrire comme suit :
Testeur
Terminal
Terminal
MQL5
VPS
MetaEditor
Testeur
>
Documentation mise à jour.
struct POINT { int x,y; }; int GetYFunc(y) { return(y * y); } void SomeFunction(int x1,int x2,int y) { POINT pt={ x1+x2, GetYFunc(y) }; ProcessPoint(pt); };
struct complex { double real; // Partie réelle double imag; // Partie imaginaire };Le type "complex" peut être passé par valeur comme paramètre pour les fonctions MQL5 (contrairement aux structures ordinaires, qui ne sont passées que par référence). Pour les fonctions importées à partir de DLL, le type "complex" doit être passé uniquement par référence.
complex square(complex c) { return(c*c); } void OnStart() { Print(square(1+2i)); // Une constante est passée en paramètre } // "(-3,4)" will be output, which is a string representation of the complex numberSeules les opérations simples sont actuellement disponibles pour les nombres complexes : =, +, -, *, /, +=, -=, *=, /=, ==, !=.
select count(*) as book_count, cast(avg(parent) as integer) as mean, cast(median(parent) as integer) as median, mode(parent) as mode, percentile_90(parent) as p90, percentile_95(parent) as p95, percentile_99(parent) as p99 from moz_bookmarks;
void func(int &arr[ ][ ][ ][ ]) { }