【MQL5】MatMul関数について

matrix  matrix::MatMul(
  const matrix&  b      // 2番目の行列
  );

vector  vector::MatMul(
  const matrix&  b      // 行列
  );

vector  matrix::MatMul(
  const vector&  b      // ベクトル
  );

scalar  vector::MatMul(
  const vector&  b      // 2番目のベクトル
  );

//+------------------------------------------------------------------+
//| スクリプトプログラム開始関数                                       |
//+------------------------------------------------------------------+
void OnStart()
{
   //--- 行列 a を定義（2x3の単位行列の一部を模した行列）
   //    この行列は2行3列で、以下の値を持ちます:
   //    1行目: [1, 0, 0]
   //    2行目: [0, 1, 0]
   matrix a = {
      {1, 0, 0},
      {0, 1, 0}
   };

   //--- 行列 b を定義（3x2の任意の値を持つ行列）
   //    この行列は3行2列で、以下の値を持ちます:
   //    1行目: [4, 1]
   //    2行目: [2, 2]
   //    3行目: [1, 3]
   matrix b = {
      {4, 1},
      {2, 2},
      {1, 3}
   };

   //--- 行列 a と b の乗算を行い、新しい行列 c1 に結果を格納
   //    ここで、a の行数と b の列数が結果行列 c1 のサイズを決定します。
   //    c1 のサイズは a の行数 (2) と b の列数 (2) になります。
   matrix c1 = a.MatMul(b);

   //--- 行列 b と a の順序を逆にして乗算を行い、新しい行列 c2 に結果を格納
   //    この場合、b の行数 (3) と a の列数 (3) が結果行列 c2 のサイズを決定します。
   //    c2 のサイズは b の行数 (3) と a の列数 (3) になります。
   matrix c2 = b.MatMul(a);

   //--- 乗算結果をエキスパートログに出力（結果行列 c1 と c2 を表示）
   //    c1 の結果: [[4,1], [2,2]]
   //    c2 の結果: [[4,1,0], [2,2,0], [1,3,0]]
   Print("c1 = \n", c1);
   Print("c2 = \n", c2);
}
//+------------------------------------------------------------------+

 1 0 0 0 1 0

 4 1 2 2 1 3

//+------------------------------------------------------------------+
//| スクリプトプログラム開始関数                                              |
//+------------------------------------------------------------------+
void OnStart()
{
   //--- 3行5列の行列を作成
   // matrix型の変数m35を宣言
   matrix m35;

   // 行列m35を初期化。サイズは3行5列で、値は関数Arangeによって埋められる
   // Arange関数は、行列を増加する値で埋める関数
   m35.Init(3, 5, Arange);

   //--- 水平ベクトルv3を作成
   // vector型の変数v3を宣言し、初期値として{1, 2, 3}を設定
   // これは3つの要素を持つ水平ベクトル（1行のベクトル）を表している
   vector v3 = {1, 2, 3};

   //--- 計算の概要をエキスパートログに出力
   // 水平ベクトルv3と行列m35の掛け算を説明する文を出力
   Print("Product of horizontal vector v and matrix m[3,5]");

   // 左側にあるベクトルv3の内容をエキスパートログに出力
   Print("On the left, vector v3 = ", v3);

   // 右側にある行列m35の内容をエキスパートログに出力
   Print("On the right, matrix m35 = \n", m35);

   //--- ベクトルv3と行列m35の掛け算を実行
   // MatMulメソッドを使用して、ベクトルv3を行列m35に掛け算
   // 結果は、5つの要素を持つ新しい水平ベクトルになる
   Print("v3.MatMul(m35) = horizontal vector v[5] \n", v3.MatMul(m35));

   /* 結果
      以下のような出力がエキスパートログに表示される：
      
      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]
      
      ベクトルv3が行列m35に掛けられ、結果として5要素のベクトル[40,46,52,58,64]が得られる。
   */
}

//+------------------------------------------------------------------+
//|  増加する値で行列を埋める                                              |
//+------------------------------------------------------------------+
void Arange(matrix & m, double start = 0, double step = 1)
{
   //--- 行列の列数を取得し、cols変数に格納
   ulong cols = m.Cols();

   //--- 行列の行数を取得し、rows変数に格納
   ulong rows = m.Rows();

   //--- 値の初期値を設定。start引数のデフォルト値は0
   double value = start;

   //--- 行列を埋めるための2重ループ
   for(ulong r = 0; r < rows; r++) // 行を順番に処理
   {
      for(ulong c = 0; c < cols; c++) // 各行の列を順番に処理
      {
         // 行列の指定位置に値を設定
         m[r][c] = value;

         // step分だけ値を増加
         value += step;
      }
   }
   //--- これにより、行列mは指定された増加量で値が埋められる
}

r=0, c=0 のとき、m[0][0] = 0
r=0, c=1 のとき、m[0][1] = 1
r=0, c=2 のとき、m[0][2] = 2
r=0, c=3 のとき、m[0][3] = 3
r=0, c=4 のとき、m[0][4] = 4
r=1, c=0 のとき、m[1][0] = 5
r=1, c=1 のとき、m[1][1] = 6
r=1, c=2 のとき、m[1][2] = 7
r=1, c=3 のとき、m[1][3] = 8
r=1, c=4 のとき、m[1][4] = 9
r=2, c=0 のとき、m[2][0] = 10
r=2, c=1 のとき、m[2][1] = 11
r=2, c=2 のとき、m[2][2] = 12
r=2, c=3 のとき、m[2][3] = 13
r=2, c=4 のとき、m[2][4] = 14

[[0,  1,  2,  3,  4 ],
 [5,  6,  7,  8,  9 ],
 [10, 11, 12, 13, 14]]

v3 = [1, 2, 3]

[40, 46, 52, 58, 64]

//+------------------------------------------------------------------+
//| スクリプトプログラム開始関数                                              |
//+------------------------------------------------------------------+
void OnStart()
{
   //--- 行列 m35 を作成
   // matrix 型の変数 m35 を宣言します。この変数は3行5列の行列を表します。
   matrix m35;

   // Init メソッドを使用して、行列 m35 を初期化します。
   // サイズは3行5列で、Arange 関数を使用して値を埋めます。
   m35.Init(3, 5, Arange);

   //--- 垂直ベクトル v5 を作成
   // vector 型の変数 v5 を宣言し、初期値として {1, 2, 3, 4, 5} を設定します。
   // これは5つの要素を持つ垂直方向のベクトルを表します。
   vector v5 = {1, 2, 3, 4, 5};

   //--- 行列 m35 とベクトル v5 の乗算についてエキスパートログに出力
   // 計算の説明をエキスパートログに出力します。
   Print("Product of matrix m[3,5] and vertical vector v[5]");

   // 行列 m35 の内容をエキスパートログに出力します。
   Print("On the left, m35 = \n", m35);

   // 垂直ベクトル v5 の内容をエキスパートログに出力します。
   Print("On the right v5 = ", v5);

   //--- 行列とベクトルの掛け算を実行
   // m35.MatMul(v5) を使用して、行列 m35 に垂直ベクトル v5 を掛けます。
   // 結果は新しい垂直ベクトルとなり、その内容をエキスパートログに出力します。
   Print("m35.MatMul(v5) = vertical vector v[3] \n", m35.MatMul(v5));

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

      行列 m35 とベクトル v5 の掛け算によって、新しい垂直ベクトル [40, 115, 190] が得られる。
   */
}

//+------------------------------------------------------------------+
//| 行列を増加する値で埋める関数                                           |
//+------------------------------------------------------------------+
void Arange(matrix & m, double start = 0, double step = 1)
{
   //--- 行列の列数を取得
   // 行列 m の列数を取得し、cols に格納します。
   ulong cols = m.Cols();

   //--- 行列の行数を取得
   // 行列 m の行数を取得し、rows に格納します。
   ulong rows = m.Rows();

   //--- 初期値を設定
   // 埋め込む値の初期値を start（デフォルトは0）に設定します。
   double value = start;

   //--- 行列を埋めるための二重ループ
   // 行を順番に処理する外側のループ
   for (ulong r = 0; r < rows; r++)
   {
      // 列を順番に処理する内側のループ
      for (ulong c = 0; c < cols; c++)
      {
         // 行列の各要素に値を設定
         m[r][c] = value;

         // 値を step（デフォルトは1）だけ増加
         value += step;
      }
   }
   //--- 結果として、行列 m は指定された増加量で埋められる。
}

[[ 0,  1,  2,  3,  4],
 [ 5,  6,  7,  8,  9],
 [10, 11, 12, 13, 14]]

r=0, c=0 のとき m[0][0] = 0
r=0, c=1 のとき m[0][1] = 1
r=0, c=2 のとき m[0][2] = 2
...
r=2, c=3 のとき m[2][3] = 13
r=2, c=4 のとき m[2][4] = 14

[[ 0,  1,  2,  3,  4],
 [ 5,  6,  7,  8,  9],
 [10, 11, 12, 13, 14]]

//+------------------------------------------------------------------+
//| スクリプトプログラム開始関数                                              |
//+------------------------------------------------------------------+
void OnStart()
{
   //--- 水平ベクトル a を作成
   // vector 型の変数 a を宣言し、初期値として {1, 2, 3} を設定します。
   // このベクトルは、水平方向（横向き）のベクトルを表しています。
   vector a = {1, 2, 3};

   //--- 垂直ベクトル b を作成
   // vector 型の変数 b を宣言し、初期値として {4, 5, 6} を設定します。
   // このベクトルは、垂直方向（縦向き）のベクトルを表しています。
   vector b = {4, 5, 6};

   //--- ベクトル a の内容をエキスパートログに出力
   // Print 関数を使用して、水平ベクトル a の内容を出力します。
   Print("a = ", a);

   //--- ベクトル b の内容をエキスパートログに出力
   // Print 関数を使用して、垂直ベクトル b の内容を出力します。
   Print("b = ", b);

   //--- スカラー積（内積）を計算して出力
   // MatMul メソッドを使用して、ベクトル a と b のスカラー積を計算します。
   // 計算結果をエキスパートログに出力します。
   // スカラー積の計算では、対応する成分を掛け合わせて合計します。
   Print("1) a.MatMul(b) = ", a.MatMul(b));

   //--- Dot メソッドを使って同じ計算を確認
   // Dot メソッドは、スカラー積を計算する別の方法です。
   // MatMul メソッドと同じ結果を生成することを確認するために使用します。
   Print("2) a.Dot(b) = ", a.Dot(b));

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

      ベクトル a と b のスカラー積は 32.0 です。
      これは、以下の計算によって得られます：
      (1×4) + (2×5) + (3×6) = 4 + 10 + 18 = 32
      MatMul メソッドと Dot メソッドは同じ結果を返します。
   */
}

1) a.MatMul(b) = 32.0
2) a.Dot(b) = 32.0