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

MatMul

La méthode MatMul, qui permet la multiplication de matrices et de vecteurs, comporte plusieurs surcharges.

Multiplication d'une matrice par une matrice : matrix[M][K] * matrix[K][N] = matrix[M][N]

matrix  matrix::MatMul(
  const matrix&  b      // deuxième matrice
   );

Multiplication d'un vecteur par une matrice : horizontal vector[K] * matrix[K][N] = horizontal vector[N]

vector  vector::MatMul(
  const matrix&  b      // matrice
   );

Multiplication d'une matrice par un vecteur : matrix[M][K] * vertical vector[K] = vertical vector[M]

vector  matrix::MatMul(
  const vector&  b      // vecteur
   );

Multiplication d'un vecteur par un scalaire : horizontal vector * vertical vector = dot value

scalar  vector::MatMul(
  const vector&  b      // deuxième vecteur
   );

Paramètres

[in] Matrice ou vecteur.

Valeur de Retour

Matrice, vecteur ou scalaire, selon la méthode utilisée.

Note

Les matrices doivent être compatibles pour la multiplication, c'est-à-dire que le nombre de colonnes dans la première matrice doit être égal au nombre de lignes dans la deuxième matrice. La multiplication matricielle est non commutative : le résultat de la multiplication de la première matrice par la seconde n'est pas égal au résultat de la multiplication de la seconde matrice par la première dans le cas général.

Le produit matriciel est constitué de toutes les combinaisons possibles de produits scalaires des vecteurs lignes de la première matrice et des vecteurs colonnes de la seconde matrice.

Dans la multiplication scalaire, les vecteurs doivent avoir la même longueur.

Lors de la multiplication d'un vecteur et d'une matrice, la longueur du vecteur doit correspondre exactement au nombre de colonnes de la matrice.

Algorithme naïf de multiplication matricielle en MQL5 :

matrix MatrixProduct(const matrix& matrix_a, const matrix& matrix_b)
  {
   matrix matrix_c;

   if(matrix_a.Cols()!=matrix_b.Rows())
      return(matrix_c);

   ulong M=matrix_a.Rows();
   ulong K=matrix_a.Cols();
   ulong N=matrix_b.Cols();
   matrix_c=matrix::Zeros(M,N);

   for(ulong m=0; m<M; m++)
      for(ulong k=0; k<K; k++)
         for(ulong n=0; n<N; n++)
            matrix_c[m][n]+=matrix_a[m][k]*matrix_b[k][n];

   return(matrix_c);
  }

Exemple de multiplication matricielle

   matrix a={{1, 0, 0},
             {0, 1, 0}};
   matrix b={{4, 1},
             {2, 2},
             {1, 3}};
   matrix c1=a.MatMul(b);
   matrix c2=b.MatMul(a);
   Print("c1 = \n", c1);
   Print("c2 = \n", c2);
/*
   c1 =
   [[4,1]
    [2,2]]
   c2 =
   [[4,1,0]
    [2,2,0]
    [1,3,0]]
*/

Un exemple de multiplication d'un vecteur horizontal par une matrice

//+------------------------------------------------------------------+
//| Fonction de démarrage du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- crée une matrice 3x5
   matrix m35;
   m35.Init(3, 5, Arange);
//---
   vector v3 = {1, 2, 3};
   Print("Produit du vecteur horizontal v et de la matrice m[3,5]");
   Print("Sur la gauche, vecteur v3 = ", v3);
   Print("Sur la droite, matrice m35 = \n", m35);
   Print("v3.MatMul(m35) = vecteur horizontal v[5] \n", v3.MatMul(m35));

  /* Résultat
    Produit du vecteur horizontal v3 et de la matrice m[3,5]
    Sur la gauche, vecteur v3 = [1,2,3]
    Sur la droite, matrice m35 =
    [[0,1,2,3,4]
     [5,6,7,8,9]
     [10,11,12,13,14]]
    v3.MatMul(m35) = vecteur horizontal v[5]
    [40,46,52,58,64]
   */
  }
//+------------------------------------------------------------------+
//|  Remplit la matrice avec des valeurs croissantes                 |
//+------------------------------------------------------------------+
void Arange(matrix & m, double start = 0, double step = 1)
  {
//---
   ulong cols = m.Cols();
   ulong rows = m.Rows();
   double value = start;
   for(ulong r = 0; r < rows; r++)
     {
      for(ulong c = 0; c < cols; c++)
        {
         m[r][c] = value;
         value += step;
        }
     }
//---
  }

Un exemple de comment multiplier une matrice par un vecteur vertical

//+------------------------------------------------------------------+
//| Fonction de démarrage du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- crée une matrice 3x5
   matrix m35;
   m35.Init(3, 5, Arange);
//---
   Print("Produit de la matrice m[3,5] et du vecteur vertical v[5]");
   vector v5 = {1,2,3,4,5};
   Print("Sur la gauche, m35 = \n",m35);
   Print("Sur la droite, v5 = ",v5);
   Print("m35.MatMul(v5) = vecteur vertical v[3] \n",m35.MatMul(v5));

  /* Résultat
   Produit de la matrice m[3,5] et du vecteur vertical v[5]
   Sur la gauche, m35 =
   [[0,1,2,3,4]
    [5,6,7,8,9]
    [10,11,12,13,14]]
   Sur la droite, v5 = [1,2,3,4,5]
   m35.MatMul(v5) = vecteur vertical v[3]
   [40,115,190]
   */
  }
//+------------------------------------------------------------------+
//|  Remplit la matrice avec des valeurs croissantes                 |
//+------------------------------------------------------------------+
void Arange(matrix & m, double start = 0, double step = 1)
  {
//---
   ulong cols = m.Cols();
   ulong rows = m.Rows();
   double value = start;
   for(ulong r = 0; r < rows; r++)
     {
      for(ulong c = 0; c < cols; c++)
        {
         m[r][c] = value;
         value += step;
        }
     }
//---
  }

Un exemple de produit scalaire (point) de vecteurs

void OnStart()
  {
//--- produit scalaire d'un vecteur horizontal et d'un vecteur vertical
   vector a= {1, 2, 3};  // vecteur horizontal
   vector b= {4, 5, 6};  // vecteur vertical
   Print("a = ", a);
   Print("b = ", b);
   Print("1) a.MatMul(b) = ", a.MatMul(b));
   //--- voyez que la méthode Dot génère le même résultat
   Print("2) a.Dot(b) = ", a.Dot(b));

  /* Résultat
   a = [1,2,3]
   b = [4,5,6]
   1) a.MatMul(b) = 32.0
   2) a.Dot(b) = 32.0
    */
  }

Voir aussi

Dot, GeMM

Products

GeMM