MQL5 RiferimentoMetodi Matriciali e VettorialiProdottiMatMul

MatMul

Il metodo MatMul, che consente la moltiplicazione di matrici e vettori, ha diversi sovraccarichi.

Moltiplicare una matrice per una matrice: matrix[M][K] * matrix[K][N] = matrix[M][N]

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

Moltiplicare un vettore per una matrice: orizzontale vector[K] * matrix[K][N] = orizzontale vector[N]

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

Moltiplicare una matrice per un vettore: matrix[M][K] * verticale vector[K] = verticale vector[M]

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

Moltiplicazione vettoriale scalare: orizzontale vector * verticale vector = valore scalare

scalar  vector::MatMul(
  const vector&  b      // secondo vettore
   );

Parametri

[in] Matrice o vettore.

Valore Restituito

Matrice, vettore o scalare, a seconda del metodo utilizzato.

Note

Le matrici devono essere compatibili per la moltiplicazione, cioè il numero di colonne nella prima matrice deve essere uguale al numero di righe nella seconda matrice. La moltiplicazione di matrice non è commutativa: il risultato della moltiplicazione della prima matrice per la seconda non è uguale al risultato della moltiplicazione della seconda matrice per la prima nel caso generale.

Il prodotto della matrice è costituito da tutte le possibili combinazioni di prodotti scalari delle righe dei vettori della prima matrice e delle colonne dei vettori della seconda matrice.

Nella moltiplicazione scalare, i vettori devono avere la stessa lunghezza.

Quando si moltiplicano un vettore e una matrice, la lunghezza del vettore deve corrispondere esattamente al numero di colonne nella matrice.

Semplice algoritmo di moltiplicazione della matrice in 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);
  }

Esempio di moltiplicazione di matrice

   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 esempio di moltiplicazione di un vettore orizzontale per una matrice

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//-- creare una matrice 3x5
   matrix m35;
   m35.Init(3, 5, Arange);
//---
   vector v3 = {1, 2, 3};
   Print("Product of horizontal vector v and matrix m[3,5]");
   Print("On the left, vector v3 = ", v3);
   Print("On the right, matrix m35 = \n", m35);
   Print("v3.MatMul(m35) = horizontal vector v[5] \n", v3.MatMul(m35));

  /* Result
    Product of horizontal vector v3 and matrix m[3,5]
    On the left, vector v3 = [1,2,3]
    On the right, matrix m35 =
    [[0,1,2,3,4]
     [5,6,7,8,9]
     [10,11,12,13,14]]
    v3.MatMul(m35) = horizontal vector v[5]
    [40,46,52,58,64]
   */
  }
//+------------------------------------------------------------------+
// Riempire la matrice con valori crescenti                          |
//+------------------------------------------------------------------+
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 esempio di come moltiplicare una matrice per un vettore verticale

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//-- creare una matrice 3x5
   matrix m35;
   m35.Init(3, 5, Arange);
//---
   Print("Product of matrix m[3,5] and vertical vector v[5]");
   vector v5 = {1,2,3,4,5};
   Print("On the left, m35 = \n",m35);
   Print("On the right v5 = ",v5);
   Print("m35.MatMul(v5) = vertical vector v[3] \n",m35.MatMul(v5));

  /* Result
   Product of matrix m[3,5] and vertical vector v[5]
   On the left, m35 =
   [[0,1,2,3,4]
    [5,6,7,8,9]
    [10,11,12,13,14]]
   On the right, v5 = [1,2,3,4,5]
   m35.MatMul(v5) = vertical vector v[3]
   [40,115,190]
   */
  }
//+------------------------------------------------------------------+
// Riempire la matrice con valori crescenti                          |
//+------------------------------------------------------------------+
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 esempio di prodotto scalare (dot) dei vettori

void OnStart()
  {
//-- prodotto scalare di un vettore orizzontale e di un vettore verticale
   vector a= {1, 2, 3};  // vettore orizzontale
   vector b= {4, 5, 6};  // vettore verticale
   Print("a = ", a);
   Print("b = ", b);
   Print("1) a.MatMul(b) = ", a.MatMul(b));
   //--- notare che il metodo Dot genera lo stesso risultato
   Print("2) a.Dot(b) = ", a.Dot(b));

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

Vedere anche

Dot, GeMM

Prodotti

GeMM