Matrixmultiplikation: Unterschied zwischen den Versionen

Aus DGL Wiki
Wechseln zu: Navigation, Suche
(Matrix Multiplikation mit Operator)
Zeile 1: Zeile 1:
 +
= Matrix Multiplikation =
 +
 
Zur Theorie der Matrixmultiplikation siehe den [[Matrix|Matrix Artikel]].
 
Zur Theorie der Matrixmultiplikation siehe den [[Matrix|Matrix Artikel]].
 +
== Dynamische Matrix Multiplikation ==
 +
Dies ist weniger für OpenGL geeignet. Für OpenGL verwendet man besser statische 4x4 oder 3x3 Array, siehe weiter unten.
  
 
Emre lieferte im Forum diesen kleinen Codeschnipsel für die Matrixmultiplikation ab:
 
Emre lieferte im Forum diesen kleinen Codeschnipsel für die Matrixmultiplikation ab:
Zeile 6: Zeile 10:
 
   TSMatrix = Array of Array of Single;
 
   TSMatrix = Array of Array of Single;
  
//sMatrix := sMatrix * Matrix
+
// sMatrix := sMatrix * Matrix
 
procedure pSMatrixMatrixProduct( var sMatrix: TSMatrix; const Matrix: TSMatrix );
 
procedure pSMatrixMatrixProduct( var sMatrix: TSMatrix; const Matrix: TSMatrix );
 
var
 
var
   m, n,
+
   m, n, o: Integer;
  o : Integer;
+
   Res   : TSMatrix;
   Res : TSMatrix;
 
 
begin
 
begin
   {Matrices can only be multiplicated, if the row count of the matrix#1 is the same
+
 
   as the column of the second matrix:}
+
   // Matrices can only be multiplicated, if the row count of the matrix#1 is the same
   if High(sMatrix[0]) <> High(Matrix) then
+
   // as the column of the second matrix:
    Exit;
+
   if High(sMatrix[0]) <> High(Matrix) then Exit;
   {if a k*l matrix is multiplicated by a m*n matrix,
+
 
  the result matrix will have a k*n dimension:}
+
   // if a k*l matrix is multiplicated by a m*n matrix,
   SetLength( Res, Length(sMatrix), Length(Matrix[0]) );
+
  // the result matrix will have a k*n dimension:
 +
   SetLength(Res, Length(sMatrix), Length(Matrix[0]));
 
   for m := 0 to High(Res) do
 
   for m := 0 to High(Res) do
 
     for n := 0 to High(Res[m]) do
 
     for n := 0 to High(Res[m]) do
 
       for o := 0 to High(Matrix) do
 
       for o := 0 to High(Matrix) do
         incS( Res[m,n], sMatrix[m,o]*Matrix[o,n] );
+
         incS(Res[m, n], sMatrix[m, o] * Matrix[o, n]);
 
   sMatrix := Res;
 
   sMatrix := Res;
 
end;  
 
end;  

Version vom 23. Juni 2018, 20:22 Uhr

Matrix Multiplikation

Zur Theorie der Matrixmultiplikation siehe den Matrix Artikel.

Dynamische Matrix Multiplikation

Dies ist weniger für OpenGL geeignet. Für OpenGL verwendet man besser statische 4x4 oder 3x3 Array, siehe weiter unten.

Emre lieferte im Forum diesen kleinen Codeschnipsel für die Matrixmultiplikation ab:

Type
  TSMatrix = Array of Array of Single;

// sMatrix := sMatrix * Matrix
procedure pSMatrixMatrixProduct( var sMatrix: TSMatrix; const Matrix: TSMatrix );
var
  m, n, o: Integer;
  Res    : TSMatrix;
begin

  // Matrices can only be multiplicated, if the row count of the matrix#1 is the same
  // as the column of the second matrix:
  if High(sMatrix[0]) <> High(Matrix) then Exit;

  // if a k*l matrix is multiplicated by a m*n matrix,
  // the result matrix will have a k*n dimension:
  SetLength(Res, Length(sMatrix), Length(Matrix[0]));
  for m := 0 to High(Res) do
    for n := 0 to High(Res[m]) do
      for o := 0 to High(Matrix) do
        incS(Res[m, n], sMatrix[m, o] * Matrix[o, n]);
  sMatrix := Res;
end;

Matrix Multiplikation mit Operator

Noch einfacher geht die Matrix Multiplikation, wen man es mit dem Operator "*" machen kann.
Diese Beispiel zeigt dies anhand der der OpenGL üblichen 4x4-Matrix.

type
  TVector4f = array[0..3] of GLfloat;
  Tmat4x4   = array[0..3] of TVector4f;


operator * (const m1, m2: Tmat4x4) Res: Tmat4x4;
var
  i, j, k: integer;
begin
  for i := 0 to 3 do begin
    for j := 0 to 3 do begin
      Res[i, j] := 0;
      for k := 0 to 3 do begin
        Res[i, j] := Res[i, j] + m2[i, k] * m1[k, j];
      end;
    end;
  end;
end;

Beispiel

var
  m, m0, m1: Tmat4x4;

begin
  m := m0 * m1; // Sieht sehr einfach aus.

Matrix / Vektor Multiplikation mit Operator

Dies funktioniert auch mit Vektoren.

type
  TVector4f = array[0..3] of GLfloat;
  Tmat4x4   = array[0..3] of TVector4f;


operator * (const m: Tmat4x4; v: TVector4f) Res: TVector4f;
var
  i: integer;
begin
  for i := 0 to 3 do begin
    Res[i] := m[0, i] * v[0] + m[1, i] * v[1] + m[2, i] * v[2]+ m[3, i] * v[3];
  end;
end;

Beispiel

var
  v    : TVector4f;
  m, m0: Tmat4x4;

begin
  m := m0 * v; // Sieht sehr einfach aus.