MQL5 RiferimentoMetodi Matriciali e VettorialiInitialization

Initialization

Ci sono diversi modi per dichiarare e inizializzare matrici e vettori.

Funzione	Azione
Assign	Copia una matrice, vettore o array con auto cast
CopyIndicatorBuffer	Ottiene i dati del buffer dell'indicatore specificato nella quantità specificata in un vettore
CopyRates	Ottiene la serie storica della struttura MqlRates del periodo-simbolo specificato nella quantità specificata in una matrice o un vettore
CopyTicks	Ottiene i tick dalla struttura MqlTick in una matrice o vettore.
CopyTicksRange	Ottiene i tick dalla struttura MqlTick in una matrice o vettore all'interno dell'intervallo di date specificato.
Eye	Restituisce una matrice con tutti uno sulla diagonale e zeri altrove
Identity	Crea una matrice di identità della dimensione specificata
Ones	Crea e restituisce una nuova matrice riempita con tutti uno
Zeros	Crea e restituisce una nuova matrice riempita con zeri
Full	Crea e restituisce una nuova matrice riempita con un determinato valore
Tri	Costruisce una matrice con tutti uno sulla diagonale data e sotto di essa e zeri altrove
Init	Inizializza una matrice o un vettore
Fill	Riempie una matrice o un vettore esistente con il valore specificato

Dichiarazione senza specificare la dimensione (nessuna allocazione di memoria per i dati):

  matrix         matrix_a;   // matrice di tipo double
  matrix<double> matrix_a1;  // un altro modo per dichiarare una matrice double; può essere utilizzata nei modelli
  matrixf        matrix_a2;  // matrice float
  matrix<float>  matrix_a3;  // matrice float
  vector         vector_a;   // vettore double
  vector<double> vector_a1;
  vectorf        vector_a2;  // vettore float
  vector<float>  vector_a3;

Dichiarazione con la dimensione specificata (con allocazione della memoria per i dati, ma senza inizializzazione):

  matrix         matrix_a(128,128);           // i parametri possono essere sia costanti
  matrix<double> matrix_a1(InpRows,InpCols);  // o variabili
  matrixf        matrix_a2(1,128);            // analogo ad un vettore orizzontale
  matrix<float>  matrix_a3(InpRows,1);        // analogo ad un vettore verticale
  vector         vector_a(256);
  vector<double> vector_a1(InpSize);
  vectorf        vector_a2(SomeFunc());       // la funzione SomeFunc restituisce un numero di tipo ulong, che viene utilizzato per impostare la dimensione del vettore
  vector<float>  vector_a3(InpSize+16);       // l'espressione può essere usata come parametro

Dichiarazione con inizializzazione (le dimensioni della matrice e del vettore sono determinate dalla sequenza di inizializzazione):

  matrix         matrix_a={{0.1,0.2,0.3},{0.4,0.5,0.6}};
  matrix<double> matrix_a1=matrix_a;                      // devono essere matrici dello stesso tipo
  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;                     // devono essere vettori dello stesso tipo

Dichiarazione con inizializzazione:

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); //prima viene creata una matrice non inizializzata di dimensioni size_m x size_k, quindi viene chiamata la funzione MatrixArange con i parametri specificati per l'inizializzazione
  matrixf matrix_a1(10,20,MatrixArange);                  // dopo aver creato la matrice, viene chiamata la funzione MatrixArange con i parametri di default
  vector  vector_a(size,VectorArange,-10.0);              // dopo aver creato il vettore, viene chiamata la funzione VectorArange con un parametro mentre il secondo parametro è predefinito
  vectorf vector_a1(128,VectorArange);

Notare che le dimensioni della matrice o del vettore possono essere modificate, poiché la memoria per i dati è sempre dinamica.

Metodi statici

Metodi statici per la creazione di matrici e vettori della dimensione specificata, inizializzati in un certo modo:

  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);

Metodi per l'inizializzazione di matrici e vettori già creati:

  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();

Enumerazioni

Assign