Nachschlagewerk MQL5Matrizen und VektorenProdukteGeMM

GeMM

Die Methode GeMM (General Matrix Multiply) implementiert die allgemeine Multiplikation von zwei Matrizen. Die Operation ist definiert als C ← α A B + β C, wobei die Matrizen A und B optional transponiert werden können. Bei einer normalen Multiplikation von Matrizen AB (MatMul) wird angenommen, dass der Skalar Alpha gleich 1 und Beta gleich Null ist.

Der Hauptunterschied zwischen GeMM und MatMul in Bezug auf die Effizienz besteht darin, dass MatMul immer ein neues Matrix-/Vektorobjekt erzeugt, während GeMM mit einem bestehenden Matrixobjekt arbeitet und es nicht neu erzeugt. Wenn Sie also GeMM verwenden und den Speicher für die entsprechende Matrix im Voraus zuweisen, müssen Sie bei der Arbeit mit denselben Matrixgrößen keinen Speicher neu zuweisen. Dies kann ein wichtiger Vorteil von GeMM für Massenberechnungen sein, z. B. bei der Durchführung von Optimierungen in einem Strategietester oder beim Training eines neuronalen Netzes.

Ähnlich wie MatMul hat auch GeMM 4 Überladungen. Die Semantik der vierten Überladung wurde jedoch geändert, um die Multiplikation eines vertikalen Vektors mit einem horizontalen Vektor zu ermöglichen.

Bei einem bestehenden Matrix-/Vektor-Objekt ist es nicht notwendig, den Speicher vorab zuzuweisen. Der Speicher wird beim ersten GeMM-Aufruf zugewiesen und mit Nullen gefüllt.

Multiplikation einer Matrix mit einer Matrix: Matrix C[M][N] = α * ( Matrix A[M][K] * Matrix B[K][N]) + β * matrix C[M][N]

bool  matrix::GeMM(
  const matrix &A,    // erste Matrix
  const matrix &B,    // zweite Matrix
  double alpha,       // der Multiplikator alpha für das Produkt AB
  double beta,        // der Multiplikator beta für die Matrix C
  uint   flags        // eine Kombination der Werte von ENUM_GEMM (bitwise OR), die bestimmen, ob die Matrizen A, B und C transponiert sind
   );

Multiplikation eines Vektors mit einer Matrix: Vektor C[N] = α * ( Vektor A[K] * Matrix B[K][N]) + β * Vektor C[N]

bool  vector::GeMM(
  const vector &A,    // horizontaler Vektor
  const matrix &B,    // Matrix
  double alpha,       // der Multiplikator alpha für das Produkt AB
  double beta,        // der Multiplikator beta für den Vektor C
  uint   flags        // Wert der Enumeration ENUM_GEMM, der bestimmt, ob die Matrix A transponiert ist
   );

Multiplikation einer Matrix mit einem Vektor: Vektor C[M] = α * ( Matrix A[M][K] * Vektor B[K] * ) + β * Vektor C[M]

bool  vector::GeMM(
  const matrix &A,    // Matrix
  const vector &B,    // vertikaler Vektor
  double alpha,       // der Multiplikator alpha für das Produkt AB
  double beta,        // der Multiplikator beta für den Vektor C
  uint   flags        // Wert der Enumeration ENUM_GEMM, der bestimmt, ob die Matrix B transponiert ist
   );

Multiplikation eines Vektors mit einem Vektor: Matrix C[M][N] = α * ( Vektor A[M] * Vektor B[N] * ) + β * matrix C[M][N]. Diese Überladung gibt eine Matrix zurück, im Gegensatz zu MatMul, die einen Skalar zurückgibt.

bool  matrix::GeMM(
  const vector &A,    // erster Vektor
  const vector &B,    // zweiter Vektor
  double alpha,       // der Multiplikator alpha für das Produkt AB
  double beta,        // beta für die Matrix C
  uint   flags        // Wert der Enumeration ENUM_GEMM, der bestimmt, ob die Matrix c transponiert ist
   );

Parameter

[in] Matrix oder Vektor.

alpha

[in] Der Multiplikator alpha für das Produkt AB.

beta

[in] Der Multiplikator beta für die Ergebnismatrix C.

flags

[in] Der Wert der Enumeration ENUM_GEMM, der bestimmt, ob Matrizen A, B und C transponiert sind.

Rückgabewert

Gibt true bei Erfolg zurück oder false andernfalls.

ENUM_GEMM

Die Enumeration er Flags der Methoden von GeMM.

ID	Beschreibung
TRANSP_A	Verwendung der transponierten Matrix A
TRANSP_B	Verwendung der transponierten Matrix B
TRANSP_C	Verwendung der transponierten Matrix

Hinweis

Als Parameter A und B können Matrizen und Vektoren vom Typ float, double und complex verwendet werden. Die Template-Varianten der GeMM-Methode sind wie folgt

bool matrix<T>::GeMM(const matrix<T> &A,const matrix<T> &B,T alpha,T beta,ulong flags);
bool matrix<T>::GeMM(const vector<T> &A,const vector<T> &B,T alpha,T beta,ulong flags);

bool vector<T>::GeMM(const vector<T> &A,const matrix<T> &B,T alpha,T beta,ulong flags);
bool vector<T>::GeMM(const matrix<T> &A,const vector<T> &B,T alpha,T beta,ulong flags);

Die allgemeine Matrixmultiplikationsfunktion wird im Wesentlichen wie folgt beschrieben:

C[m,n] = α *Sum(A[m,k]*B[k,n]) + β*C[m,n]

mit den folgenden Größen: Matrix A ist M x K, Matrix B ist K x N und Matrix C ist M x N.

Die Matrizen müssen also für die Multiplikation kompatibel sein, d. h. die Anzahl der Spalten der ersten Matrix muss gleich der Anzahl der Zeilen 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.

Beispiel:

void OnStart()
  {
   vector vector_a= {1, 2, 3, 4, 5};
   vector vector_b= {4, 3, 2, 1};
   matrix matrix_c;
//--- GeMM für zwei Vektoren berechnen
   matrix_c.GeMM(vector_a, vector_b, 1, 0);
   Print("matrix_c:\n ", matrix_c, "\n");
   /*
   matrix_c:
    [[4,3,2,1]
    [8,6,4,2]
    [12,9,6,3]
    [16,12,8,4]
    [20,15,10,5]]
   */
//--- Erstellen von Matrizen als Vektoren
   matrix matrix_a(5, 1);
   matrix matrix_b(1, 4);
   matrix_a.Col(vector_a, 0);
   matrix_b.Row(vector_b, 0);
   Print("matrix_a:\n ", matrix_a);
   Print("matrix_b:\n ", matrix_b);
   /*
   matrix_a:
   [[1]
   [2]
   [3]
   [4]
   [5]]
   matrix_b:
   [[4,3,2,1]]
   */
//-- GeMM für zwei Matrizen berechnen und das gleiche Ergebnis erhalten
   matrix_c.GeMM(matrix_a, matrix_b, 1, 0);
   Print("matrix_c:\n ", matrix_c);
   /*
   matrix_c:
    [[4,3,2,1]
    [8,6,4,2]
    [12,9,6,3]
    [16,12,8,4]
    [20,15,10,5]]
   */
  }

Siehe auch

MatMul

Power