Referência MQL5Métodos matriciais e vetoriaisProdutosMatMul

MatMul

Método MatMul para determinar o produto de matrizes e vetores possui diversas sobrecargas.

Multiplicação de uma matriz por uma matriz: matrix[M][K] * matrix[K][N] = matrix[M][N]

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

Multiplicação de um vetor por uma matriz: horizontal vector[K] * matrix[K][N] = horizontal vector[N]

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

Multiplicação de uma matriz por um vetor: matrix[M][K] * vertical vector[K] = vertical vector[M]

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

Multiplicação escalar de vetores: horizontal vector * vertical vector = dot value

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

Parâmetros

[in] Matriz ou vetor.

Valor retornado

Matriz, vetor ou escalar, dependendo do método utilizado.

Observação

As matrizes multiplicadas devem ser compatíveis, o número de colunas da primeira matriz deve ser igual ao número de linhas da segunda matriz. A multiplicação de matrizes não é comutativa, a multiplicação da primeira matriz pela segunda não é igual à multiplicação da segunda matriz pela primeira.

O produto matricial consiste em todas as combinações possíveis de produtos escalares dos vetores linha da primeira matriz e dos vetores coluna da segunda matriz.

Com a multiplicação escalar, os vetores devem ter o mesmo comprimento.

Ao multiplicar um vetor e uma matriz, o comprimento do vetor deve corresponder exatamente ao número de colunas da matriz.

Algoritmo ingênuo de multiplicação de matrizes em 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);
  }

Exemplo de multiplicação de matrizes

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

Exemplo de multiplicação de um vetor horizontal por uma matriz

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- criamos uma matriz 3x5
   matrix m35;
   m35.Init(3, 5, Arange);
//---
   vector v3 = {1, 2, 3};
   Print("Produto do vetor horizontal v pela matriz m[3,5]");
   Print("Vetor à esquerda v3 = ", v3);
   Print("Matriz à direita m35 = \n", m35);
   Print("v3.MatMul(m35) = vetor horizontal v[5] \n", v3.MatMul(m35));

  /* Resultado
    Produto do vetor horizontal v3 pela matriz m[3,5]
    Vetor à esquerda v3 = [1,2,3]
    Matriz à direita m35 =
    [[0,1,2,3,4]
     [5,6,7,8,9]
     [10,11,12,13,14]]
    v3.MatMul(m35) = vetor horizontal v[5]
    [40,46,52,58,64]
   */
  }
//+------------------------------------------------------------------+
//|  Preenchimento da matriz com valores incrementais                |
//+------------------------------------------------------------------+
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;
        }
     }
//---
  }

Exemplo de multiplicação de uma matriz por um vetor vertical

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- criamos uma matriz 3x5
   matrix m35;
   m35.Init(3, 5, Arange);
//---
   Print("Produto da matriz m[3,5] pelo vetor vertical v[5]");
   vector v5 = {1,2,3,4,5};
   Print("À esquerda m35 = \n",m35);
   Print("À direita v5 = ",v5);
   Print("m35.MatMul(v5) = vetor vertical v[3] \n",m35.MatMul(v5));

  /* Resultado
   Produto da matriz m[3,5] pelo vetor vertical v[5]
   À esquerda m35 =
   [[0,1,2,3,4]
    [5,6,7,8,9]
    [10,11,12,13,14]]
   À direita v5 = [1,2,3,4,5]
   m35.MatMul(v5) = vetor vertical v[3]
   [40,115,190]
   */
  }
//+------------------------------------------------------------------+
//|  Preenchimento da matriz com valores incrementais                |
//+------------------------------------------------------------------+
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;
        }
     }
//---
  }

Exemplo de multiplicação escalar de vetores

void OnStart()
  {
//--- multiplicação escalar de vetores horizontais e verticais
   vector a= {1, 2, 3};  // vetor horizontal
   vector b= {4, 5, 6};  // vetor vertical
   Print("a = ", a);
   Print("b = ", b);
   Print("1) a.MatMul(b) = ", a.MatMul(b));
   //--- mostramos que o método Dot dá o mesmo 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 também

Dot, GeMM

Produtos

GeMM