Nachschlagewerk MQL5Matrizen und VektorenProdukteMatMul

MatMul

Die Methode MatMul, die die Multiplikation von Matrizen und Vektoren ermöglicht, hat mehrere Überladungen.

Multiplikation einer Matrix mit einer Matrix: Matrix[M][K] * Matrix[K][N] = Matrix[M][N]

matrix  matrix::MatMul(
  const matrix&  b      // zweite Matrix
   );

Multiplikation eines Vektors mit einem Vektor: horizontaler Vektor[K] * Matrix[K][N] = horizontaler Vektor[N]

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

Multiplikation einer Matrix mit einem Vektor: Matrix[M][K] * vertikaler Vektor[K] = vertikaler Vektor[M]

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

Skalare Vektormultiplikation: horizontaler Vektor * vertikaler Vektor = Dot- Wert

scalar  vector::MatMul(
  const vector&  b      // zweiter Vektor
   );

Parameter

[in] Matrix oder Vektor.

Rückgabewert

Matrix, Vektor oder Skalar, je nach der verwendeten Methode.

Hinweis

Die Matrizen sollten für die Multiplikation kompatibel sein, d. h. die Anzahl der Spalten in der ersten Matrix sollte gleich der Anzahl der Zeilen in der zweiten Matrix sein. Die Matrixmultiplikation ist nicht kommutativ: Das Ergebnis der Multiplikation der ersten Matrix mit der zweiten ist im allgemeinen Fall nicht gleich dem Ergebnis der Multiplikation der zweiten Matrix mit der ersten.

Das Matrixprodukt besteht aus allen möglichen Kombinationen von Skalarprodukten der Zeilenvektoren der ersten Matrix und der Spaltenvektoren der zweiten Matrix.

Bei der Skalarmultiplikation müssen die Vektoren die gleiche Länge haben.

Bei der Multiplikation eines Vektors mit einer Matrix muss die Länge des Vektors genau der Anzahl der Spalten der Matrix entsprechen.

Naiver Algorithmus zur Matrixmultiplikation 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);
  }

Beispiel einer Matrix-Multiplikation

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

Ein Beispiel für die Multiplikation eines horizontalen Vektors mit einer Matrix

//+------------------------------------------------------------------+
//| Skript Programm Start Funktion                                   |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- erstellen einer 3x5 Matrix
   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));

  /* Ergebnis
    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]
   */
  }
//+------------------------------------------------------------------+
//|  Füllen der Matrix mit ansteigenden Werten                       |
//+------------------------------------------------------------------+
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;
        }
     }
//---
  }

An example of how to multiply a matrix by a vertical vector

//+------------------------------------------------------------------+
//| Skript Programm Start Funktion                                   |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- erstellen einer 3x5 Matrix
   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));

  /* Ergebnis
   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]
   */
  }
//+------------------------------------------------------------------+
//|  Füllen der Matrix mit ansteigenden Werten                       |
//+------------------------------------------------------------------+
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;
        }
     }
//---
  }

Ein Beispiel für das Skalarprodukt (dot) von Vektoren

void OnStart()
  {
//--- Skalarprodukt eines horizontalen Vektors und eines vertikalen Vektors
   vector a= {1, 2, 3};  // horizontal vector
   vector b= {4, 5, 6};  // vertical vector
   Print("a = ", a);
   Print("b = ", b);
   Print("1) a.MatMul(b) = ", a.MatMul(b));
   //--- man sieht, dass die Methode Dot das gleiche Ergebnis liefert
   Print("2) a.Dot(b) = ", a.Dot(b));

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

Siehe auch

Dot, GeMM

Produkte

GeMM