Referência MQL5Métodos matriciais e vetoriaisInicialização

Inicialização

Existem várias maneiras de declarar e inicializar matrizes e vetores.

Função	Ação
Assign	Copia uma matriz, vetor ou array com conversão automática
CopyIndicatorBuffer	Obtém no vetor dados do buffer especificado do indicador especificado com a quantidade indicada
CopyRates	Obtém em uma matriz ou vetor a série histórica da estrutura MqlRates do período-símbolo especificado na quantidade especificada
CopyTicks	Obtém na matriz ou vetor os ticks a partir da estrutura MqlTick
CopyTicksRange	Obtém na matriz ou vetor os ticks a partir da estrutura MqlTick dentro do intervalo de datas especificado
Eye	Retorna uma matriz com uns na diagonal principal e zeros em todas as outras posições.
Identity	Cria uma matriz de identidade do tamanho especificado
Ones	Cria e retorna uma nova matriz preenchida com uns
Zeros	Cria e retorna uma nova matriz preenchida com zeros
Full	Cria e retorna uma nova matriz preenchida com os valores fornecidos
Tri	Cria uma matriz com uns na diagonal indicada e abaixo e zeros em todas as outras posições
Init	Inicializa uma matriz ou vetor
Fill	Preenche uma matriz ou vetor existente com o valor fornecido
Random	Função estática. Cria e retorna uma nova matriz ou vetor preenchido com valores aleatórios. Os valores aleatórios são gerados uniformemente dentro do intervalo especificado.

Declaração sem especificar um tamanho (sem alocação de memória de dados):

  matrix         matrix_a;   // matriz do tipo double
  matrix<double> matrix_a1;  // outra forma de declarar uma matriz de tipo double, e é adequada para uso em modelos
  matrixf        matrix_a2;  // matriz do tipo float
  matrix<float>  matrix_a3;  // matriz do tipo float
  vector         vector_a;   // vetor do tipo double
  vector<double> vector_a1;
  vectorf        vector_a2;  // vetor do tipo float
  vector<float>  vector_a3;

Declaração de tamanho (com alocação de memória para dados, mas sem nenhuma inicialização):

  matrix         matrix_a(128,128);           // podem ser especificados como parâmetros quer seja constantes,
  matrix<double> matrix_a1(InpRows,InpCols);  // ou variáveis
  matrixf        matrix_a2(1,128);            // análogo de um vetor horizontal
  matrix<float>  matrix_a3(InpRows,1);        // análogo de um vetor vertical
  vector         vector_a(256);
  vector<double> vector_a1(InpSize);
  vectorf        vector_a2(SomeFunc());       // a função SomeFunc retorna um número de tipo ulong, que é usado para definir o tamanho do vetor
  vector<float>  vector_a3(InpSize+16);       // a expressão pode ser usada como um parâmetro

Declaração com inicialização (os tamanhos das matrizes e vetores neste caso são determinados pela sequência de inicialização):

  matrix         matrix_a={{0.1,0.2,0.3},{0.4,0.5,0.6}};
  matrix<double> matrix_a1=matrix_a;                      // devem ser matrizes do mesmo 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;                     // devem ser vetores do mesmo tipo

Declaração com inicialização:

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); // primeiro é criada uma matriz não inicializada de size_m x size_k, depois a função MatrixArange é chamada com os parâmetros listados durante a inicialização
  matrixf matrix_a1(10,20,MatrixArange);                  // após a criação da matriz, a função MatrixArange é chamada com os parâmetros padrão
  vector  vector_a(size,VectorArange,-10.0);              // Após a criação de um vetor, a VectorArange é chamada com um parâmetro, o segundo parâmetro é o padrão
  vectorf vector_a1(128,VectorArange);

É importante notar que as dimensões de uma matriz ou vetor podem ser alteradas, pois a memória de dados é sempre dinâmica.

Métodos estáticos

Métodos estáticos para criar matrizes e vetores do tamanho especificado, inicializados de uma determinada maneira:

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

Métodos para inicializar matrizes e vetores já criados:

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

Enumerações

Assign