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

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

  matrix         matrix_a;   // matriz do tipo double
  matrix<doublematrix_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<doublevector_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<doublematrix_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<doublevector_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<doublematrix_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<doublevector_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=0i<mat.Rows(); i++)
     {
      for(ulong j=0j<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=0i<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<doublematrix_a1=matrix::Full(3,4,M_PI);
  matrixf        matrix_a2=matrixf::Identity(5,5);
  matrixf<floatmatrix_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();