Nachschlagewerk MQL5Matrizen und VektorenInitialisierung

Initialisierung

Es gibt mehrere Möglichkeiten, Matrizen und Vektoren zu deklarieren und zu initialisieren.

Funktion	Aktion
Assign	Kopiert eine Matrix, einen Vektor oder ein Array mit automatischer Typ-Umwandlung.
CopyIndicatorBuffer	Abrufen der Daten des spezifizierten Indikator-Puffers im angegebenen Umfang Menge in einen Vektor
CopyRates	Gibt die historischen Zeitreihendaten der Struktur MqlRates der angegebenen Symbolperiodenlänge in der angegebenen Menge in eine Matrix oder einen Vektor zurück.
CopyTicks	Weist die Ticks der Struktur MqlTick einer Matrix oder einem Vektor zu.
CopyTicksRange	Weist die Ticks des angegebenen Zeitintervalls aus der Struktur MqlTick einer Matrix oder einem Vektor zu.
Eye	Rückgabe einer Matrix mit Einsen auf der Diagonale und Nullen an anderer Stelle.
Identity	Erzeugt eine Identitätsmatrix mit der angegebenen Größe.
Ones	Erzeugen und Zurückgeben einer neuen Matrix aus Einsen.
Zeros	Erzeugt eine neue, mit Nullen gefüllte Matrix und gibt sie zurück.
Full	Erstellung und Rückgabe einer neuen Matrix, die mit dem angegebenen Wert gefüllt wurde.
Tri	Konstruktion einer Matrix mit Einsen auf und unterhalb der gegebenen Diagonalen und Nullen an anderen Stellen
Init	Initialisieren einer Matrix.
Fill	Füllen des angegebenen Wertes einer vorhandenen Matrix oder Vektors.

Deklaration ohne Angabe der Größe (keine Speicherzuweisung für die Daten):

  matrix         matrix_a;   // Matrix vom Typ double
  matrix<double> matrix_a1;  // Alternative, eine Matrix vom Typ double zu deklarieren; sie kann in Templates verwendet werden.
  matrixf        matrix_a2;  // float-Matrix
  matrix<float>  matrix_a3;  // float-Matrix
  vector         vector_a;   // double-Vektor
  vector<double> vector_a1;
  vectorf        vector_a2;  // float-Vektor
  vector<float>  vector_a3;

Deklaration mit der angegebenen Größe (mit Speicherzuweisung für die Daten, aber ohne jegliche Initialisierung):

  matrix         matrix_a(128,128);           // die Parameter können entweder Konstanten sein
  matrix<double> matrix_a1(InpRows,InpCols);  // oder Variablen
  matrixf        matrix_a2(1,128);            // analog bei einem horizontalen Vektor
  matrix<float>  matrix_a3(InpRows,1);        // analog bei einem vertikalen Vektor
  vector         vector_a(256);
  vector<double> vector_a1(InpSize);
  vectorf        vector_a2(SomeFunc());       // Die Funktion SomeFunc gibt eine Zahl vom Typ ulong zurück, mit der die Vektorgröße festgelegt wird.
  vector<float>  vector_a3(InpSize+16);       // Ausdruck kann als Parameter verwendet werden

Deklaration mit Initialisierung (Matrix- und Vektorgrößen werden durch die Initialisierungssequenz bestimmt):

  matrix         matrix_a={{0.1,0.2,0.3},{0.4,0.5,0.6}};
  matrix<double> matrix_a1=matrix_a;                      // es müssen Matrizen desselben Typs sein
  matrixf        matrix_a2={{1,0,0},{0,1,0},{0,0,1}};
  matrix<float>  matrix_a3={{1,2},{3,4}};
  vector         vector_a={-5,-4,-3,-2,-1,0,1,2,3,4,5};
  vector<double> vector_a1={1,5,2.4,3.3};
  vectorf        vector_a2={0,1,2,3};
  vector<float>  vector_a3=vector_a2;                     // es müssen Vektoren desselben Typs sein

Deklaration mit Initialisierung:

template<typename T>
void MatrixArange(matrix<T> &mat,T value=0.0,T step=1.0)
  {
   for(ulong i=0; i<mat.Rows(); i++)
     {
      for(ulong j=0; j<mat.Cols(); j++,value+=step)
         mat[i][j]=value;
     }
  }
template<typename T>
void VectorArange(vector<T> &vec,T value=0.0,T step=1.0)
  {
   for(ulong i=0; i<vec.Size(); i++,value+=step)
      vec[i]=value;
  }
...

  matrix  matrix_a(size_m,size_k,MatrixArange,-M_PI,0.1); // zunächst wird eine nicht initialisierte Matrix der Größe size_m x size_k erstellt, dann wird die Funktion MatrixArange mit den bei der Initialisierung angegebenen Parametern aufgerufen
  matrixf matrix_a1(10,20,MatrixArange);                  // nach der Erstellung der Matrix wird die Funktion MatrixArange mit Standardparametern aufgerufen
  vector  vector_a(size,VectorArange,-10.0);              // nach der Erstellung der Matrix wird die Funktion MatrixArange mit Standardparametern aufgerufen
  vectorf vector_a1(128,VectorArange);

Bitte beachten Sie, dass die Dimensionen der Matrix oder des Vektors geändert werden können, da der Speicher für die Daten immer dynamisch ist.

Statische Methoden

Statische Methoden zur Erzeugung von Matrizen und Vektoren der angegebenen Größe, die auf eine bestimmte Weise initialisiert werden:

  matrix         matrix_a =matrix::Eye(4,5,1);
  matrix<double> matrix_a1=matrix::Full(3,4,M_PI);
  matrixf        matrix_a2=matrixf::Identity(5,5);
  matrixf<float> matrix_a3=matrixf::Ones(5,5);
  matrix         matrix_a4=matrix::Tri(4,5,-1);
  vector         vector_a =vector::Ones(256);
  vectorf        vector_a1=vector<float>::Zeros(16);
  vector<float>  vector_a2=vectorf::Full(128,float_value);

Methoden zur Initialisierung bereits erstellter Matrizen und Vektoren:

  matrix  matrix_a;
  matrix_a.Init(size_m,size_k,MatrixArange,-M_PI,0.1);
  matrixf matrix_a1(3,4);
  matrix_a1.Init(10,20,MatrixArange);
  vector  vector_a;
  vector_a.Init(128,VectorArange);
  vectorf vector_a1(10);
  vector_a1.Init(vector_size,VectorArange,start_value,step);

  matrix_a.Fill(double_value);
  vector_a1.Fill(FLT_MIN);
  matrix_a1.Identity();

Enumerationen

Assign