Manual de referencia de MQL5Métodos de matrices y vectoresInicialización

Inicialización

Existen varias formas de declarar e inicializar matrices y vectores.

Función	Acción
Assign	Copia una matriz, vector o array con transformación automática
CopyIndicatorBuffer	Obtiene en un vector los datos del búfer indicado del indicador especificado en la cantidad especificada
CopyRates	Obtiene las series históricas de la estructura MqlRates en una matriz o vector del símbolo-periodo especificado en la cantidad especificada.
CopyTicks	Obtiene en una matriz o vector los ticks de la estructura MqlTick
CopyTicksRange	Obtiene en una matriz o vector los ticks de la estructura MqlTick en el intervalo de fechas indicado
Eye	Retorna una matriz con unidades a lo largo de la diagonal y ceros en el resto
Identity	Crea una matriz unitaria con el tamaño especificado
Ones	Crea y retorna una nueva matriz rellenada con unidades
Zeros	Crea y retorna una nueva matriz rellenada con ceros
Full	Crea y retorna una nueva matriz rellenada con los valores dados
Tri	Crea una matriz con unidades en la diagonal indicada y por debajo de la misma, y ceros en el resto.
Init	Inicializa una matriz o vector
Fill	Rellena una matriz o vector existente con el valor dado

Declaración de tamaño no especificado (sin asignación de memoria para los datos):

  matrix         matrix_a;   // matriz del tipo double
  matrix<double> matrix_a1;  // otra forma de declarar una matriz double, resulta adecuada para usar en plantillas
  matrixf        matrix_a2;  // matriz de tipo float
  matrix<float>  matrix_a3;  // matriz de tipo float
  vector         vector_a;   // vecto de tipo double
  vector<double> vector_a1;
  vectorf        vector_a2;  // vecto de tipo float
  vector<float>  vector_a3;

Declaración con declaración del tamaño (con asignación de memoria para datos, pero sin ninguna inicialización):

  matrix         matrix_a(128,128);           // como constantes se pueden especificar tanto parámetros,
  matrix<double> matrix_a1(InpRows,InpCols);  // como variables
  matrixf        matrix_a2(1,128);            // análogo del vector horizontal
  matrix<float>  matrix_a3(InpRows,1);        // análogo del vector vertical
  vector         vector_a(256);
  vector<double> vector_a1(InpSize);
  vectorf        vector_a2(SomeFunc());       // la función SomeFunc retorna un número de tipo ulong que se utilizará para establecer el tamaño del vector
  vector<float>  vector_a3(InpSize+16);       // como parámetro se puede utilizar una expresión

Declaración con inicialización (los tamaños de las matrices y vectores en este caso estarán determinados por la secuencia de inicialización):

  matrix         matrix_a={{0.1,0.2,0.3},{0.4,0.5,0.6}};
  matrix<double> matrix_a1=matrix_a;                      // las matrices deberán ser del mismo 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;                     // los vectores deberán ser del mismo tipo

Declaración con inicialización:

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); // primero, se crea una matriz no inicializada del tamaño size_m x size_k, luego se llama a la función MatrixArange con los parámetros enumerados durante la inicialización
  matrixf matrix_a1(10,20,MatrixArange);                  // después de crear la matriz, se llamará a la función MatrixArange con los parámetros predeterminados
  vector  vector_a(size,VectorArange,-10.0);              // una vez creado el vector, VectorArange se llamará con un parámetro, el segundo parámetro será el parámetro por defecto
  vectorf vector_a1(128,VectorArange);

Debemos tener en cuenta que las dimensiones de la matriz o vector se pueden cambiar, ya que la memoria de datos siempre es dinámica.

Métodos estáticos

Métodos estáticos para crear matrices y vectores del tamaño especificado, inicializados de cierta manera:

  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 las matrices y vectores ya creados:

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

Enumeraciones

Assign