Référence MQL5Méthodes sur les Matrices et les VecteursInitialisation

Initialisation

Il existe plusieurs façons de déclarer et d'initialiser des matrices et des vecteurs.

Fonction	Action
Assign	Copie une matrice, un vecteur ou un tableau avec une distribution automatique
CopyIndicatorBuffer	Retourne la quantité spécifiée de données du buffer spécifié de l'indicateur vers un vecteur
CopyRates	Récupère la série historique de la structure MqlRates pour le symbole et la période spécifiés, avec le nombre spécifié d'éléments dans une matrice ou un vecteur
CopyTicks	Récupère les ticks d'une structure MqlTick dans une matrice ou un vecteur
CopyTicksRange	Récupère les ticks d'une structure MqlTick dans une matrice ou un vecteur dans la plage de dates spécifiée
Eye	Renvoie une matrice avec des 1 sur la diagonale et des 0 ailleurs
Identity	Crée une matrice d'identité de la taille spécifiée
Ones	Crée et renvoit une nouvelle matrice remplie de 1
Zeros	Crée et renvoit une nouvelle matrice remplie de 0
Full	Crée et retourne une nouvelle matrice remplie avec la valeur donnée
Tri	Construire une matrice avec des 1 sur la diagonale donnée et en dessous, et des 0 ailleurs
Init	Initialise une matrice ou un vecteur
Fill	Remplit une matrice ou un vecteur existant avec la valeur spécifiée

Déclaration sans préciser de taille (pas d'allocation mémoire pour les données) :

  matrix         matrix_a;   // matrice de types double
  matrix<double> matrix_a1;  // une autre façon de déclarer une matrice de types double; peut être utilisée dans les templates
  matrixf        matrix_a2;  // matrice de types float
  matrix<float>  matrix_a3;  // matrice de types float
  vector         vector_a;   // matrice de types double
  vector<double> vector_a1;
  vectorf        vector_a2;  // matrice de types float
  vector<float>  vector_a3;

Déclaration avec une taille spécifiée (avec allocation de mémoire pour les données, mais sans aucune initialisation) :

  matrix         matrix_a(128,128);           // les paramètres peuvent être soit constants
  matrix<double> matrix_a1(InpRows,InpCols);  // soit variables
  matrixf        matrix_a2(1,128);            // comme un vecteur horizontal
  matrix<float>  matrix_a3(InpRows,1);        // comme un vecteur vertical
  vector         vector_a(256);
  vector<double> vector_a1(InpSize);
  vectorf        vector_a2(SomeFunc());       // la fonction SomeFunc retourne une valeur de type ulong, utilisée pour définir la taille du vecteur
  vector<float>  vector_a3(InpSize+16);       // l'expression peut être utilisée comme paramètre

Déclaration avec initialisation (les tailles de matrice et de vecteur sont déterminées par la séquence d'initialisation) :

  matrix         matrix_a={{0.1,0.2,0.3},{0.4,0.5,0.6}};
  matrix<double> matrix_a1=matrix_a;                      // les matrices doivent être du même type
  matrixf        matrix_a2={{1,0,0},{0,1,0},{0,0,1}};
  matrix<float>  matrix_a3={{1,2},{3,4}};
  vector         vector_a={-5,-4,-3,-2,-1,0,1,2,3,4,5};
  vector<double> vector_a1={1,5,2.4,3.3};
  vectorf        vector_a2={0,1,2,3};
  vector<float>  vector_a3=vector_a2;                     // les vecteurs doivent être du même type

Déclaration avec initialisation :

template<typename T>
void MatrixArange(matrix<T> &mat,T value=0.0,T step=1.0)
  {
   for(ulong i=0; i<mat.Rows(); i++)
     {
      for(ulong j=0; j<mat.Cols(); j++,value+=step)
         mat[i][j]=value;
     }
  }
template<typename T>
void VectorArange(vector<T> &vec,T value=0.0,T step=1.0)
  {
   for(ulong i=0; i<vec.Size(); i++,value+=step)
      vec[i]=value;
  }
...

  matrix  matrix_a(size_m,size_k,MatrixArange,-M_PI,0.1); // une matrice non initialisée de taille size_m x size_k est d'abord créée, puis la fonction MatrixArange avec les paramètres spécifiés à l'initialisation est appelée
  matrixf matrix_a1(10,20,MatrixArange);                  // après avoir créé la matrice, la fonction MatrixArange avec les paramètres par défaut est appelée
  vector  vector_a(size,VectorArange,-10.0);              // après avoir le vecteurl la fonction VectorArange avec un paramètre est appelée, le deuxième paramètre prend la valeur par défaut
  vectorf vector_a1(128,VectorArange);

Veuillez noter que les dimensions de la matrice ou du vecteur peuvent être changés, car la mémoire allouée pour les données est toujours dynamique.

Méthodes statiques

Méthodes statiques pour créer des matrices et des vecteurs de la taille spécifiée, initialisés d'une certaine façon :

  matrix         matrix_a =matrix::Eye(4,5,1);
  matrix<double> matrix_a1=matrix::Full(3,4,M_PI);
  matrixf        matrix_a2=matrixf::Identity(5,5);
  matrixf<float> matrix_a3=matrixf::Ones(5,5);
  matrix         matrix_a4=matrix::Tri(4,5,-1);
  vector         vector_a =vector::Ones(256);
  vectorf        vector_a1=vector<float>::Zeros(16);
  vector<float>  vector_a2=vectorf::Full(128,float_value);

Méthodes pour initialiser des matrices et des vecteurs déjà créés :

  matrix  matrix_a;
  matrix_a.Init(size_m,size_k,MatrixArange,-M_PI,0.1);
  matrixf matrix_a1(3,4);
  matrix_a1.Init(10,20,MatrixArange);
  vector  vector_a;
  vector_a.Init(128,VectorArange);
  vectorf vector_a1(10);
  vector_a1.Init(vector_size,VectorArange,start_value,step);

  matrix_a.Fill(double_value);
  vector_a1.Fill(FLT_MIN);
  matrix_a1.Identity();

Enumerations

Assign