Manual de referencia de MQL5Métodos de matrices y vectoresProductosMatMul

MatMul

El método MatMul para realizar el producto de matrices y vectores tiene varias sobrecargas.

Multiplicación de una matriz por una matriz: matrix[M][K] * matrix[K][N] = matrix[M][N]

matrix  matrix::MatMul(
  const matrix&  b      // segunda matriz
   );

Multiplicación de un vector por una matriz: horizontal vector[K] * matrix[K][N] = horizontal vector[N]

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

Multiplicación de una matriz por un vector: matrix[M][K] * vertical vector[K] = vertical vector[M]

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

Multiplicación escalar de vectores: horizontal vector * vertical vector = dot value

scalar  vector::MatMul(
  const vector&  b      // segundo vector
   );

Parámetros

[in] Matriz o vector.

Valor retornado

Matriz, vector o escalar, dependiendo del método utilizado.

Observación

Las matrices a multiplicar deberán ser compatibles, el número de columnas de la primera matriz deberá ser igual al número de filas de la segunda matriz. La multiplicación de matrices es no conmutativa: la multiplicación de la primera matriz por la segunda matriz no es en general igual a la multiplicación de la segunda matriz por la primera.

El producto matricial consiste en todas las combinaciones posibles de los productos escalares de los vectores de fila de la primera matriz y los vectores de columna de la segunda matriz.

En la multiplicación escalar de vectores, sus longitudes deberán coincidir.

Al multiplicar un vector y una matriz, la longitud del vector deberá coincidir exactamente con el número de columnas de la matriz.

Algoritmo ingenuo de multiplicación de matrices 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);
  }

Ejemplo de multiplicación de matrices

   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]]
*/

Ejemplo de multiplicación de un vector horizontal por una matriz

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- creamos una matriz de 3x5
   matrix m35;
   m35.Init(3, 5, Arange);
//---
   vector v3 = {1, 2, 3};
   Print("Producto del vector horizontal v por la matriz m[3,5]");
   Print("A la izquierda vector v3 = ", v3);
   Print("A la derecha matriz m35 = \n", m35);
   Print("v3.MatMul(m35) = vector horizontal v[5] \n", v3.MatMul(m35));

  /* Resultado
    Producto del vector horizontal v3 por la matriz m[3,5]
    A la izquierda vector v3 = [1,2,3]
    A la derecha matriz m35 =
    [[0,1,2,3,4]
     [5,6,7,8,9]
     [10,11,12,13,14]]
    v3.MatMul(m35) = vector horizontal v[5]
    [40,46,52,58,64]
   */
  }
//+------------------------------------------------------------------+
//|  Rellenamos la matriz con valores incrementales                  |
//+------------------------------------------------------------------+
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;
        }
     }
//---
  }

Ejemplo de multiplicación de una matriz por un vector vertical

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- creamos una matriz de 3x5
   matrix m35;
   m35.Init(3, 5, Arange);
//---
   Print("Producto de la matriz m[3,5] por el vector vertical v[5]");
   vector v5 = {1,2,3,4,5};
   Print("A la izquierda m35 = \n",m35);
   Print("A la derecha v5 = ",v5);
   Print("m35.MatMul(v5) = vector vertical v[3] \n",m35.MatMul(v5));

  /* Resultado
   Producto de la matriz m[3,5] por el vector vertical v[5]
   A la izquierda m35 =
   [[0,1,2,3,4]
    [5,6,7,8,9]
    [10,11,12,13,14]]
   A la derecha v5 = [1,2,3,4,5]
   m35.MatMul(v5) = vector vertical v[3]
   [40,115,190]
   */
  }
//+------------------------------------------------------------------+
//|  Rellenamos la matriz con valores incrementales                  |
//+------------------------------------------------------------------+
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;
        }
     }
//---
  }

Ejemplo de multiplicación escalar de vectores

void OnStart()
  {
//--- multiplicación escalar de vectores horizontales y verticales
   vector a= {1, 2, 3};  // vector horizontal
   vector b= {4, 5, 6};  // vector vertical
   Print("a = ", a);
   Print("b = ", b);
   Print("1) a.MatMul(b) = ", a.MatMul(b));
   //--- mostramos que el método Dot da el mismo resultado
   Print("2) a.Dot(b) = ", a.Dot(b));

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

Ver también

Dot, GeMM

Productos

GeMM