Introducción a MQL5 (Parte 6): Guía para principiantes sobre las funciones de matriz en MQL5

Introducción

Bienvenidos a la sexta parte de nuestro viaje MQL5. Una fascinante continuación de nuestra serie te espera mientras nos adentramos en los detalles de la programación MQL5, equipándote con el conocimiento y las habilidades necesarias para navegar con éxito en el dinámico mundo del trading automatizado. Este capítulo nos llevará más lejos en el tema de las funciones de matriz. En la Parte 5 anterior sentamos las bases introduciendo algunas funciones de array.

Ahora, exploraremos las funciones de array restantes en la Parte 6, lo que garantizará que conozcas a fondo estas útiles herramientas. Nuestro objetivo sigue siendo cubrir las ideas básicas necesarias para automatizar estrategias de trading, independientemente de su nivel de experiencia como desarrollador o nivel de familiaridad con el trading algorítmico. Nuestro objetivo al profundizar en los matices de estas funciones es promover una comprensión exhaustiva para que cada lector pueda atravesar de forma competente el terreno siempre cambiante de la programación MQL5.

En este artículo, trataremos las siguientes funciones de array:

• ArrayPrint
  
• ArrayInsert
  
• ArraySize
  
• ArrayRange
  
• ArrarRemove
  
• ArraySwap
  
• ArrayReverse
  
• ArraySort

1. ArrayPrint

En MQL5, puedes imprimir los elementos de un array usando la función predefinida "ArrayPrint()". Esta función se utiliza frecuentemente para depuración, ya que ofrece una forma rápida y práctica de ver los valores guardados en un array mientras se ejecuta un algoritmo o script. Para ayudar a los operadores y desarrolladores a rastrear y validar los datos en varios puntos de su código, la función envía los elementos de la matriz a la consola o al diario.

Analogía

Supongamos que tiene una estantería exclusiva para guardar sus libros. Es posible que de vez en cuando olvide qué libros están en cada estantería. Ahora considere "ArrayPrint()" como la frase secreta a utilizar para ver todos los títulos de libros de su estantería sin visitar físicamente cada uno de ellos. Diga "ArrayPrint()" para ver una lista ordenada de todos los títulos de los libros de su estantería única cada vez que pregunte qué libros posee. Es como echar un vistazo rápido a tu estantería para asegurarte de que están todos tus títulos favoritos.

Sin embargo, esta herramienta no se limita a la impresión estándar; considere "ArrayPrint()" como el comando mágico que le da a su estantería inteligente cuando quiere poder ver los títulos así como organizarlos específicamente. Puede utilizar este comando para especificar cuánta información desea para cada libro, como el autor y la fecha de publicación, o si prefiere ver sólo los títulos. Incluso el orden en que aparecen los títulos es personalizable. "ArrayPrint()" es capaz de mucho más, de lo que hablaremos más adelante. No se limita a mostrar los títulos de sus libros. ¡Espere la magia con impaciencia!

Sintaxis:

ArrayPrint(array[], digit , Separator, Start, Count, Flags);

Parámetros:

• array[]: Esta es la matriz que se imprimirá. Puede ser un array de diferentes tipos de datos o un array de una estructura simple.
  
• Digits: El número de decimales a mostrar para cada número de la matriz se establece mediante este parámetro.
  
• Separator: Este parámetro especifica el espacio que debe haber entre cada elemento de la matriz cuando se imprime.
  
• Start: Especifica el índice del elemento desde el que debe comenzar la impresión.
  
• Count: Especifica el número de elementos a imprimir.
  
• Flags: Se utiliza para modificar la salida. Esto es opcional porque está activado por defecto. ARRAYPRINT_HEADER (esta bandera imprime las cabeceras de la matriz de estructuras), ARRAYPRINT_INDEX (imprime el índice en el lado izquierdo), y ARRAYPRINT_LIMIT (imprime sólo los 100 primeros y los 100 últimos elementos del array). ARRAYPRINT_ALIGN (esta bandera permite la alineación de los valores impresos) y ARRAYPRINT_DATE (imprime la fecha en el día, mes y año).
  

Ejemplo:

void OnStart()
  {

// Define an array of doubles
   double ThisArray[] = { 1.46647, 2.76628, 3.83367, 4.36636, 5.9393};

// Print the entire array using ArrayPrint with 2 decimal places and a single spacing between array elements
   ArrayPrint(Array,2," ",0,WHOLE_ARRAY);

  }

Explicación:

En este fragmento de código, trabajamos con una matriz de valores dobles con un nombre determinado. La matriz se define con cinco elementos, cada uno de los cuales contiene un número decimal. La línea siguiente utiliza la función "ArrayPrint()" para mostrar todo el contenido del array.

Vamos a desglosar los parámetros utilizados en la función "ArrayPrint()":

• "ThisArray": Este es el array que queremos imprimir.
  
• "2": Especifica el número de decimales a mostrar para cada elemento de la matriz.
  
• " ": Establece un único espacio como separador entre los elementos de la matriz.
  
• "0": Especifica que la impresión comience desde el principio de la matriz.
  
• “WHOLE_ARRAY”: Especifica que debe imprimirse toda la matriz.
  

Salida:

Esto ilustra directamente la función de doble valor "ArrayPrint()" en acción. Veamos ahora más ejemplos que utilizan estructuras. A medida que exploramos las posibilidades de utilizar "ArrayPrint()" para organizar y mostrar datos estructurados, prepárate para un poco más de complejidad.

Ejemplo:

void OnStart()
  {

// Define a structure for storing information about students
   struct StudentsDetails
     {
      string         name;
      int            age;
      string         address;
      datetime       time; // Add a time field
     };

// Create an array of Students structures
   StudentsDetails Students[3];

// Fill in details for each person
   Students[0].name = "Abioye";
   Students[0].age = 25;
   Students[0].address = "123 MQL5 St";
   Students[0].time = TimeCurrent();

   Students[1].name = "Israel";
   Students[1].age = 26;
   Students[1].address = "456 MQL4 St";
   Students[1].time = TimeCurrent();

   Students[2].name = "Pelumi";
   Students[2].age = 27;
   Students[2].address = "789 MetaQuotes St";
   Students[2].time = TimeCurrent();

// Print the details of each person using ArrayPrint
   ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY);

  }

Explicación:

struct StudentsDetails
{
   string         name;
   int            age;
   string         address;
   datetime       time; // Add a time field
};

• Para almacenar los datos de los estudiantes, se define una estructura denominada "StudentsDetails".
  
• El nombre, la edad, la dirección y la fecha y hora del día actual se añaden como miembros de la estructura.
  

StudentsDetails Students[3];

• Se crea un array llamado Students de tipo "StudentsDetails" con un tamaño de 3, permitiendo el almacenamiento de tres estudiantes.
  

Students[0].name = "Abioye";
Students[0].age = 25;
Students[0].address = "123 MQL5 St";
Students[0].time = TimeCurrent();

Students[1].name = "Israel";
Students[1].age = 26;
Students[1].address = "456 MQL4 St";
Students[1].time = TimeCurrent();

Students[2].name = "Pelumi";
Students[2].age = 27;
Students[2].address = "789 MetaQuotes St";
Students[2].time = TimeCurrent();

• Se completan los datos de cada estudiante. Por ejemplo, a los campos nombre, edad, dirección y hora se les asignan valores, y "Students[0]" representa al primer alumno.
  

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY);

• Para mostrar toda la información del alumno en el array, se utiliza la función "ArrayPrint()". La matriz se imprime, con el separador de campos establecido en " | ".
  

Salida:

Utilizamos la función "ArrayPrint()" para mostrar la información del estudiante después de introducir todos los detalles necesarios para cada estudiante. La imagen de arriba muestra la salida por defecto, que muestra cómo se muestran los detalles sin ninguna bandera de formato adicional. Utilizando el separador designado "|", se presentan limpiamente el nombre, la edad, la dirección y la hora y fecha actuales de cada alumno. Esta es la primera representación; veremos cómo añadir más opciones de formato para personalizar aún más la salida.  

Es crucial saber que añadir un indicador de formato específico a una función "ArrayPrint()" indica al ordenador que aplique ese indicador de formato e ignore los demás. Para ilustrar cómo afecta la bandera "ARRAYPRINT_HEADER" al resultado, la incluiremos en el ejemplo.

Ejemplo:

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY,ARRAYPRINT_HEADER);

Salida:

Para facilitar la identificación de cada campo, la bandera indica a la función que incluya cabeceras ([nombre] [edad] [dirección] [hora]) para la matriz de estructuras. "ARRAYPRINT_INDEX" se encuentra entre las otras banderas que se omiten a propósito en este caso para resaltar cómo funciona cada bandera por sí misma.

En las imágenes comparativas, observe que la segunda salida difiere de la primera, ya que hemos introducido la bandera "ARRAYPRINT_HEADER". Esta bandera indica a la función "ArrayPrint" que incluya cabeceras para cada campo, proporcionando etiquetas claras para la información mostrada. En particular, la información de indexación está ausente en la segunda salida. Esto enfatiza el punto de que cada bandera de formato funciona de manera independiente, y al incluir una bandera específica, se modifica la salida en consecuencia. Para demostrar la versatilidad de ajustar la salida según tus preferencias, también experimentaremos con varias combinaciones de banderas.

Es importante señalar que, cuando se trabaja con datos temporales, la función "ArrayPrint" ofrece aún más versatilidad. Banderas como “ARRAYPRINT_MINUTES” y “ARRAYPRINT_SECONDS” se pueden usar para ajustar el formato de la hora. Estas banderas le dan la posibilidad de ajustar el nivel de detalle en la información horaria que se muestra, ofreciéndole una visualización personalizada según sus gustos. Si opta por el indicador "ARRAYPRINT_MINUTES", la función mostrará sólo la hora y los minutos actuales, omitiendo la fecha y los segundos. Por otra parte, el uso de la bandera "ARRAYPRINT_SECONDS" refina aún más la salida, mostrando sólo la hora, los minutos y los segundos. Estas banderas proporcionan un nivel granular de control sobre la representación del tiempo, asegurando que su salida coincide exactamente con sus requisitos sin incluir detalles innecesarios.

Ejemplo:

ArrayPrint(Students, 0, " | ", 0, WHOLE_ARRAY,ARRAYPRINT_MINUTES);

Salida:

Estas banderas no se excluyen mutuamente. Puede combinar varias banderas para adaptar la salida de forma aún más precisa. Por ejemplo, si aplica conjuntamente los indicadores ARRAYPRINT_HEADER y ARRAYPRINT_MINUTES, la función incluirá los encabezados de columna y presentará la hora en un formato que sólo muestra la hora y los minutos actuales.

Ejemplo:

ArrayPrint(Students,0," | ",0,WHOLE_ARRAY,ARRAYPRINT_HEADER | ARRAYPRINT_MINUTES);

Salida:

Esto muestra cómo las banderas trabajan juntas a la perfección para proporcionar un resultado personalizado e informativo.

2. ArrayInsert

Un método útil para insertar elementos de una matriz en otra es utilizar la función "ArrayInsert()". Organizar elementos de la matriz fuente en una ubicación designada te permite aumentar el tamaño de la matriz de destino. Imagíneselo como la integración de una nueva pieza en un puzle ya existente sin causar ningún trastorno en el diseño general del rompecabezas.

Diferencia entre ArrayInsert y ArrayCopy:

La principal diferencia entre "ArrayInsert()" y "ArrayCopy()" es cómo manejan los elementos que ya existen. "ArrayCopy()" puede modificar la matriz original sustituyendo los elementos de otra matriz por los de una posición determinada. Por otro lado, "ArrayInsert()" preserva la estructura y secuencia del array moviendo los elementos actuales para hacer sitio a los nuevos. Esencialmente, "ArrayInsert()" proporciona un método versátil para manipular arrays en MQL5, similar a añadir un nuevo elemento a una secuencia sin causar que ninguna otra pieza se mueva. Comprender esta distinción le permitirá manipular con precisión las operaciones con matrices en sus actividades de programación.

Tenga en cuenta que para matrices estáticas, si el número de elementos a insertar es igual o superior al tamaño de la matriz, "ArrayInsert()" no añadirá elementos de la matriz de origen a la matriz de destino. En tales circunstancias, la inserción sólo puede tener lugar si comienza en el índice 0 de la matriz de destino. En estos casos, la matriz de destino se sustituye completamente por la matriz de origen.

Analogía

Imagina que tienes dos conjuntos de bloques de construcción (matrices), cada uno con su propia disposición. Supongamos que quieres combinar estos conjuntos sin alterar las estructuras existentes. "ArrayInsert()" es como una herramienta mágica que te permite insertar sin problemas nuevos bloques de un conjunto en un punto específico del otro conjunto, ampliando la colección total.

Ahora, comparando "ArrayInsert()" con "ArrayCopy()": Cuando usas "ArrayCopy()", es un poco como reordenar el conjunto original sustituyendo algunos bloques por otros nuevos de otro conjunto. Por otro lado, "ArrayInsert()" es más delicado. Asegura que el orden existente se mantenga intacto desplazando los bloques para hacer sitio a los recién llegados. Es como tener un asistente meticuloso que sabe exactamente dónde colocar cada bloque, manteniendo el diseño original del conjunto.

Para los conjuntos estáticos (arrays), hay una regla importante. Si el número de nuevos bloques es demasiado para que el conjunto lo maneje, "ArrayInsert()" no los forzará a entrar. Sin embargo, si inicia el proceso de inserción desde el principio del conjunto (índice 0), puede sustituir efectivamente todo el conjunto por los nuevos bloques. La comprensión de estos conceptos le ayudará a convertirse en un maestro en el mundo de la programación MQL5.

Sintaxis:

ArrayInsert(DestinationArray[],SourceArray[],DestinationIndexStart,SourceIndexStart,count);

Parámetros:

• DestinationArray[]: La matriz que recibirá elementos de la matriz de origen y se insertará en ella.
  
• SourceArray[]: La matriz que se va a insertar en la matriz de destino se denomina matriz de origen.
  
• DestinationIndexStart: El índice donde comienza la inserción en el array de destino.
  
• SourceIndexStart: El índice dentro de la matriz de origen que se utilizará para copiar elementos para su inserción.
  
• Count: El número de elementos que deben insertarse de la matriz de origen en la matriz de destino.
  

Ejemplo:

void OnStart()
  {

// Declare two dynamic arrays
   int SourceArray[];
   int DestinationArray[];

// Resizing the dynamic arrays to have 5 elements each
   ArrayResize(SourceArray, 5);
   ArrayResize(DestinationArray, 5);

// Assigning values to dynamic array elements
   SourceArray[0] = 1;
   SourceArray[1] = 3;
   SourceArray[2] = 5;
   SourceArray[3] = 7;
   SourceArray[4] = 9;

// Assigning different values to DestinationArray
   DestinationArray[0] = 15;
   DestinationArray[1] = 20;
   DestinationArray[2] = 25;
   DestinationArray[3] = 30;
   DestinationArray[4] = 35;

// Print the elements of SourceArray before ArrayInsert/ArrayCopy
   Print("Elements of SourceArray before ArrayInsert/ArrayCopy: ");
   ArrayPrint(SourceArray, 2, " ", 0, WHOLE_ARRAY);

// Print the elements of DestinationArray before ArrayInsert/ArrayCopy
   Print("Elements of DestinationArray before ArrayInsert/ArrayCopy: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

// Using ArrayInsert to insert SourceArray into DestinationArray at index 2
   ArrayInsert(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

// Print the modified DestinationArray after ArrayInsert
   Print("Elements of DestinationArray after using ArrayInsert: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

// Reset DestinationArray to demonstrate ArrayCopy
   ArrayFree(DestinationArray);
   ArrayResize(DestinationArray, 5);

   DestinationArray[0] = 15;
   DestinationArray[1] = 20;
   DestinationArray[2] = 25;
   DestinationArray[3] = 30;
   DestinationArray[4] = 35;

// Using ArrayCopy to copy elements from SourceArray to DestinationArray
   ArrayCopy(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

// Print the modified DestinationArray after ArrayCopy
   Print("Elements of DestinationArray after using ArrayCopy: ");
   ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

  }

Explicación:

int SourceArray[];
int DestinationArray[];

• Aquí se declaran "SourceArray" y "DestinationArray", dos matrices dinámicas. En estas matrices se guardarán valores enteros.
  

ArrayResize(SourceArray, 5);
ArrayResize(DestinationArray, 5);

• Las matrices dinámicas se redimensionan para contener cinco elementos cada una mediante estas líneas. Para ello, se emplea la función "ArrayResize()".
  

SourceArray[0] = 1;
SourceArray[1] = 3;
SourceArray[2] = 5;
SourceArray[3] = 7;
SourceArray[4] = 9;

• Los elementos "SourceArray" reciben valores.
  

DestinationArray[0] = 15;
DestinationArray[1] = 20;
DestinationArray[2] = 25;
DestinationArray[3] = 30;
DestinationArray[4] = 35;

• Los elementos "DestinationArray" reciben valores.
  

Print("Elements of SourceArray before ArrayInsert/ArrayCopy: ");
ArrayPrint(SourceArray, 2, " ", 0, WHOLE_ARRAY);

• Esta línea utiliza la función "ArrayPrint()" para imprimir los elementos de "SourceArray" después de imprimir un mensaje en la consola. Se utiliza un espacio como separador y se muestran dos decimales en el formato.
  

Print("Elements of DestinationArray before ArrayInsert/ArrayCopy: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Similar a la línea anterior, esta imprime un mensaje y luego los elementos de "DestinationArray".
  

ArrayInsert(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

• Esta línea inserta los elementos de "SourceArray" en "DestinationArray" comenzando en el índice 2 utilizando la función "ArrayInsert()".
  

Print("Elements of DestinationArray after using ArrayInsert: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Tras la operación "ArrayInsert()", se imprime un mensaje seguido de los elementos modificados de "DestinationArray".
  

ArrayFree(DestinationArray);
ArrayResize(DestinationArray, 5);

• Estas líneas redimensionan "DestinationArray" para que vuelva a contener cinco elementos después de liberar memoria.
  

DestinationArray[0] = 15;
DestinationArray[1] = 20;
DestinationArray[2] = 25;
DestinationArray[3] = 30;
DestinationArray[4] = 35;

• Se vuelven a dar valores a los elementos "DestinationArray".
  

ArrayCopy(DestinationArray, SourceArray, 2, 0, WHOLE_ARRAY);

• Esta línea utiliza la función ArrayCopy para copiar elementos de SourceArray en DestinationArray a partir del índice 2.
  

Print("Elements of DestinationArray after using ArrayCopy: ");
ArrayPrint(DestinationArray, 2, " ", 0, WHOLE_ARRAY);

• Esto imprime un mensaje y luego los elementos modificados de "DestinationArray" después de la operación "ArrayCopy()".

Salida:

El objetivo de este ejemplo de código es demostrar las diferencias entre las funciones "ArrayInsert()" y "ArrayCopy()" de MQL5. Aunque la manipulación de elementos de una matriz es un uso común para ambas funciones, sus funciones son distintas. En este ejemplo se utilizan dos matrices dinámicas: "SourceArray" y "DestinationArray". Antes de realizar cualquier operación, el script muestra los elementos contenidos en estas matrices. A continuación, para insertar elementos de "SourceArray" en las ubicaciones designadas dentro de "DestinationArray()", se utiliza ArrayInsert. A continuación, se restablecen las matrices y los elementos de - "SourceArray" se copian en "DestinationArray()" mediante "ArrayCopy()". Sus acciones son donde más divergen: Al insertar elementos en una posición específica en la matriz de destino, "ArrayInsert()" desplaza los elementos existentes para hacer sitio a los nuevos elementos. Es útil para colocar elementos en el índice deseado. Con "ArrayCopy()", los elementos de la matriz de origen se copian y sustituyen por cualquier elemento existente en la matriz de destino. Eficaz para copiar elementos entre matrices sin afectar a los valores ya establecidos.

3. ArraySize

La función MQL5 "ArraySize()" sirve para saber cuantos elementos contiene un array unidimensional. Al devolver un número entero que representa el recuento total de elementos dentro de la matriz especificada, se simplifica el proceso de determinar el tamaño de una matriz.

Analogía

Supongamos que tienes una estantería llena de libros diferentes, cada uno de los cuales es una representación de un elemento de un array. Como un bibliotecario, la función "ArraySize()" le indica el número exacto de libros de su estantería. Del mismo modo, puede gestionar y organizar sus datos de forma más eficaz utilizando "ArraySize()", que, cuando se aplica a una matriz, le indica el número total de elementos que contiene. Los programadores pueden utilizarla como herramienta útil para comprender el tamaño de sus matrices y asegurarse de que disponen del número adecuado de "libros" para sus tareas de codificación.

Sintaxis:

ArraySize( array[]);

Parámetro:

• array[]: Este parámetro indica la matriz cuyo tamaño se desea averiguar.
  

Ejemplo:

void OnStart()
  {

// Declare an array
   int array[5];

// Get the size of the array using ArraySize
   int arraySize = ArraySize(array);

// Print the array size
   Print("The size of array is: ", arraySize); // Output will be 5

  }

Explicación:

“int array[5];”

• En esta línea se declara un array de enteros con el nombre "array" y un tamaño de "5".
  

“int arraySize = ArraySize(array);”

• Esta línea crea una nueva variable entera llamada "arraySize" y establece su valor al resultado de "ArraySize" (array) utilizando el operador de asignación "=". Dado que el tamaño de una matriz es siempre un número entero, se utiliza el tipo "int". La función que proporciona MQL5 para determinar el tamaño de un array se llama "ArraySize" (en mayúsculas), y la variable que hemos declarado para almacenar el resultado se llama "arraySize" (en minúsculas). Hay que tener en cuenta que los lenguajes de programación distinguen entre mayúsculas y minúsculas. ArraySize en mayúsculas denota el array incorporado, mientras que arraySize en minúsculas denota nuestra variable particular.
  

“Print("The size of array is: ", arraySize);”:

• Esta línea utiliza la función "Print" para imprimir un mensaje en la consola. Muestra el tamaño del array, que se deriva de la variable "arraySize".
  

Debes tomarte tu tiempo y aprender las complejidades de cada función que nos encontremos a medida que exploramos más profundamente en el increíble mundo de la programación MQL5. Es similar a aprender a utilizar las herramientas en el taller de un artesano para comprender funciones como ArraySize, ArrayInsert y ArrayPrint; cada una tiene un uso específico. Tómese su tiempo para aprender y comprender las sutilezas; no se precipite en el proceso. Las ideas más complejas que trataremos en artículos posteriores tendrán estas funciones como base.

4. ArrayRange

La función "ArrayRange()" en la programación MQL5 es esencial para averiguar el número de elementos en una dimensión especificada de un array multidimensional. Es una herramienta útil para los desarrolladores que trabajan con matrices complejas, ya que les proporciona información precisa sobre cuántos elementos hay en un determinado nivel o dimensión de una matriz multidimensional. Sin tener que lidiar con la complejidad de averiguar cuántos elementos hay en total en todas las dimensiones, la concentración de esta función en una dimensión específica ofrece una visión en profundidad.

Diferencia entre ArrayRange y ArraySize

Distingamos ahora entre "ArraySize()" y "ArrayRange()". Aunque ambas proporcionan información sobre las dimensiones de las matrices, los ámbitos respectivos de las funciones son diferentes. El número total de elementos de una matriz unidimensional se puede encontrar utilizando "ArraySize()".  

Las matrices unidimensionales y multidimensionales difieren entre sí por la forma en que organizan los datos y se estructuran. Una lista simple con elementos dispuestos en una sola línea es análoga a una matriz unidimensional. Se puede acceder a los elementos haciendo referencia al lugar que ocupan en esta estructura lineal.

Sin embargo, las matrices multidimensionales añaden más niveles de estructura. Con sus componentes dispuestos en filas y columnas, se asemejan a matrices o tablas. Los índices de fila y columna deben especificarse para acceder a los elementos de una matriz multidimensional, lo que ofrece un método más estructurado de organización y recuperación de datos. Las matrices unidimensionales son, en esencia, secuencias lineales simples, mientras que las multidimensionales añaden complejidad al organizar los elementos de forma más parecida a una cuadrícula.

Analogía

Imagina que tienes una gran estantería que representa una matriz multidimensional, donde cada estantería tiene una dimensión diferente. La función "ArrayRange()" en MQL5 es como una lupa mágica que le permite centrarse en un estante específico, revelando el número exacto de libros (elementos) en ese estante. Esta herramienta es increíblemente útil cuando se trata de una biblioteca compleja de información.

Contrastemos ahora "ArraySize()" y "ArrayRange()". Si los libros están organizados linealmente, como una matriz unidimensional, entonces "ArraySize()" indica el número total de libros de toda la estantería. También puede utilizar "ArrayRange()" para ampliar una sección concreta de la estantería y obtener un recuento preciso del número de libros que hay en ella.

Sintaxis:

ArrayRange(array[], dimensionIndex);

Parámetros:

• array[]: La matriz cuyo rango desea verificar.
• dimensionIndex: El índice de dimensión, empezando por 0, para el que hay que determinar el rango.

Ejemplo:

void OnStart()
  {

// Declare a three-dimensional array
   double my3DArray[][2][4];

// Get the range of the first dimension (index 0)
   int dimension1Index = ArrayRange(my3DArray, 0);

// Get the range of the second dimension (index 1)
   int dimension2Index = ArrayRange(my3DArray, 1);

// Get the range of the third dimension (index 2)
   int dimension3Index = ArrayRange(my3DArray, 2);

   Print("Number of elements in dimension 1: ", dimension1Index);
   Print("Number of elements in dimension 2: ", dimension2Index);
   Print("Number of elements in dimension 3: ", dimension3Index);

  }

Explicación:

double my3DArray[][2][4];

• En esta línea se declara un array tridimensional llamado "my3DArray".

int dimension1Index = ArrayRange(my3DArray, 0);

• En este caso, el rango (número de elementos) en la primera dimensión (índice 0) de my3DArray se determina utilizando la función "ArrayRange()". La variable "dimension1Index" contiene el resultado.
  

int dimension2Index = ArrayRange(my3DArray, 1);

• Del mismo modo, esta línea obtiene y almacena en la variable "dimension2Index" el rango de la segunda dimensión (índice 1) de "my3DArray".
  

int dimension3Index = ArrayRange(my3DArray, 2);

• Esta línea asigna el valor de la variable "dimension3Index" al rango de la tercera dimensión (índice 2) de "my3DArray".
  

Print("Number of elements in dimension 1: ", dimension1Index);
Print("Number of elements in dimension 2: ", dimension2Index);
Print("Number of elements in dimension 3: ", dimension3Index);

• Por último, mostramos los resultados y el número de elementos de cada dimensión mediante la función Imprimir. Las dimensiones primera, segunda y tercera de la matriz tridimensional se incluyen en la información impresa.
  

Salida:

5. ArrayRemove

La función "ArrayRemove()" es una herramienta eficaz que permite a los programadores eliminar determinados elementos de una matriz. El tamaño y la estructura de la matriz se ajustan automáticamente para dar cabida a la eliminación, lo que garantiza un proceso de eliminación sin problemas. Los desarrolladores tienen flexibilidad a la hora de manipular matrices porque pueden especificar el índice inicial y el número de elementos que desean eliminar.< Esta función resulta especialmente útil cuando se trabaja con matrices que deben modificarse dinámicamente en respuesta a condiciones cambiantes del programa.

Pero cuando se trata de "ArrayRemove()", su comportamiento varía dependiendo de si se utilizan arrays estáticos o dinámicos. En el caso de las matrices dinámicas, la función garantiza un proceso de eliminación racionalizado mediante la eliminación efectiva del elemento o elementos especificados y el ajuste suave del tamaño de la matriz. Por otro lado, "ArrayRemove()" elimina los elementos especificados y mantiene el tamaño original del array cuando se trabaja con arrays estáticos. Pero para superar la naturaleza fija de las matrices estáticas, la función duplica los elementos que vienen después del final de la matriz para rellenar los espacios vacíos. Este método permite eliminar elementos manteniendo el tamaño fijo, lo que proporciona a "ArrayRemove()" una comprensión más matizada de varios escenarios de matrices. A medida que avancemos en esta sección, más ejemplos e ideas nos ayudarán a comprender mejor "ArrayRemove()" y cómo funciona en diferentes escenarios de array.

Analogía

Considere nuestra matriz como una estantería, con libros individuales que representan bits de información. Ahora, MQL5 nos proporciona una herramienta única similar a un organizador de estanterías llamada "ArrayRemove()". Con este organizador podemos retirar determinados libros de nuestra estantería y colocar ordenadamente los restantes para rellenar huecos.

Imagina que tienes una estantería dinámica en la que puedes añadir o quitar libros fácilmente. En este caso, el organizador ajusta suavemente la estantería después de retirar los libros sin ningún problema. Sin embargo, si su estantería es más como una pantalla de tamaño fijo, donde no se puede cambiar su tamaño (una matriz estática), cuando se trabaja con matrices estáticas, "ArrayRemove()" no puede cambiar el tamaño de la estantería, por lo que inteligentemente duplica el libro al final de la matriz para llenar la ranura vacía. Es como hacer una copia de los últimos libros de la estantería y colocarla en el hueco dejado por el libro retirado. De este modo, la estantería de tamaño fijo mantiene su integridad y no se desperdicia espacio.

Así, si quitas un libro de en medio de tu estantería, "ArrayRemove()" se asegura de que el final de la estantería se copia para rellenar el hueco, preservando la estructura de la matriz. Esto puede ser especialmente útil cuando se tiene un número específico de ranuras (elementos) que mantener, proporcionando un método para ordenar su estantería sin cambiar su tamaño.

 

Sintaxis:

ArrayRemove(array[],start_index,count);

Parámetros:

• array[]:Esta es la matriz que tendrá sus elementos eliminados. El área de almacenamiento, o estantería, es donde quieres hacer cambios.
  
• start_index: Indica el punto inicial de la eliminación dentro del array. Para eliminar los libros que empiezan en el tercer estante, por ejemplo, se pondría el índice a 3.
  
• count: El número de elementos a eliminar del array. Si quieres eliminar tres libros, debes establecer el conteo en 3.
  

Ejemplo:

void OnStart()
  {

// Declare fixed-size array
   int fixedSizeArray[5] = {11, 13, 17, 21, 42};

// Declare dynamic array
   int dynamicArray[];
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 11;
   dynamicArray[1] = 13;
   dynamicArray[2] = 17;
   dynamicArray[3] = 21;
   dynamicArray[4] = 42;

// Print initial arrays
   Print("Initial fixedSizeArray: ");
   ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamicArray: ");
   ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

// Remove two elements at index 2 from both arrays
   ArrayRemove(fixedSizeArray, 2, 2);
   ArrayRemove(dynamicArray, 2, 2);

// Print arrays after removal
   Print("After removing 3 elements at index 2 - fixedSizeArray: ");
   ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

   Print("After removing 3 elements at index 2 - dynamicArray: ");
   ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

  }

Explicación:

// Declare fixed-size array
   int fixedSizeArray[5] = {11, 13, 17, 21, 42};

// Declare dynamic array
   int dynamicArray[];
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 11;
   dynamicArray[1] = 13;
   dynamicArray[2] = 17;
   dynamicArray[3] = 21;
   dynamicArray[4] = 42;

• Declara que un array estático de enteros con un tamaño fijo de 5 se llama "fixedSizeArray". Utiliza los valores 11, 13, 17, 21 y 42 para inicializar el array.
  
• Declara un array dinámico entero llamado "dynamicArray" sin especificar un tamaño inicial. Redimensiona "dynamicArray" para que tenga un tamaño de 5 usando "ArrayResize".
  

Print("Initial fixedSizeArray: ");
ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

Print("Initial dynamicArray: ");
ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

• Imprime los elementos iniciales de "fixedSizeArray" y "dynamicArray" utilizando "ArrayPrint".
  

ArrayRemove(fixedSizeArray, 2, 2);
ArrayRemove(dynamicArray, 2, 2);

• Usando "ArrayRemove", se eliminan dos elementos de "fixedSizeArray" y "dynamicArray", empezando por el índice 2.
  

Print("After removing 3 elements at index 2 - fixedSizeArray: ");
ArrayPrint(fixedSizeArray, 0, " ", 0, WHOLE_ARRAY);

Print("After removing 3 elements at index 2 - dynamicArray: ");
ArrayPrint(dynamicArray, 0, " ", 0, WHOLE_ARRAY);

• Después del proceso de eliminación, utilice "ArrayPrint" para imprimir los elementos de "fixedSizeArray" y "dynamicArray".
  

Salida:

 

La salida del código dado se muestra en la imagen de arriba, que muestra cómo la función "ArrayRemove()" se comporta tanto con arrays estáticos como dinámicos. Cuando se trata de la matriz dinámica, el procedimiento es muy sencillo: sólo consiste en borrar los elementos que se especifican en el índice designado. Para rellenar los espacios vacíos creados por la eliminación, la función para la matriz estática duplica los elementos que aparecen después del final de la matriz. Este sutil comportamiento demuestra la forma en que "ArrayRemove()" se ajusta a varios tipos de matrices.

Los conceptos de "ArrayRemove()" se irán aclarando a medida que avancemos en estos artículos y nos adentremos en ejemplos del mundo real. No dude en hacer más preguntas; juntos, seguiremos explorando y comprendiendo estos conceptos.

6. ArraySwap

El propósito de la función "ArraySwap()" en la programación MQL5 es intercambiar todo el contenido de dos arrays dinámicos. Todos los elementos entre dos matrices pueden intercambiarse más fácilmente con la ayuda de esta función. Ofrece una forma sencilla de cambiar todo el conjunto de datos entre matrices, lo que agiliza el proceso MQL5 de reordenar el contenido de las matrices.

Analogía

Supongamos que tienes dos estanterías llenas de libros. La función "ArraySwap()" permite intercambiar todos los libros de una estantería por todos los demás, como si se tratara de un hechizo de brujo. Para hacer que todos los libros de la "Estantería A" se muevan a la "Estantería B" y todos los libros de la "Estantería B" se muevan a la "Estantería A", puedes usar el hechizo "ArraySwap()" si tienes la "Estantería A" llena con algunos libros y la "Estantería B" llena con otros libros. Es una forma fácil de cambiar todos los libros de dos estanterías sin tener que preocuparse por ningún libro en concreto.

Sintaxis:

ArraySwap(dynamic_array1, dynamic_array2);

Parámetros:

Supongamos que tienes dos estanterías llenas de libros. La función "ArraySwap()" permite intercambiar todos los libros de una estantería por todos los demás, como si se tratara de un hechizo de brujo. Para hacer que todos los libros de la "Estantería A" se muevan a la "Estantería B" y todos los libros de la "Estantería B" se muevan a la "Estantería A", puedes usar el hechizo "ArraySwap()" si tienes la "Estantería A" llena con algunos libros y la "Estantería B" llena con otros libros. Es una forma fácil de cambiar todos los libros de dos estanterías sin tener que preocuparse por ningún libro en concreto.

Ejemplo:

void OnStart()
  {

// Declare dynamic arrays
   int dynamic_array1[];
   int dynamic_array2[];

// Resize dynamic arrays to have 5 elements each
   ArrayResize(dynamic_array1, 5);
   ArrayResize(dynamic_array2, 5);

// Assign values to dynamic arrays
   dynamic_array1[0] = 1;
   dynamic_array1[1] = 3;
   dynamic_array1[2] = 5;
   dynamic_array1[3] = 7;
   dynamic_array1[4] = 9;

   dynamic_array2[0] = 11;
   dynamic_array2[1] = 13;
   dynamic_array2[2] = 15;
   dynamic_array2[3] = 17;
   dynamic_array2[4] = 19;

// Print initial dynamic arrays
   Print("Initial dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

// Swap the contents of dynamic_array1 and dynamic_array2
   ArraySwap(dynamic_array1, dynamic_array2);

// Print dynamic arrays after swapping
   Print("After swapping - dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("After swapping - dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);
  }

Explicación:

// Declare dynamic arrays
   int dynamic_array1[];
   int dynamic_array2[];

// Resize dynamic arrays to have 5 elements each
   ArrayResize(dynamic_array1, 5);
   ArrayResize(dynamic_array2, 5);

• En estas líneas se declaran las matrices dinámicas de enteros "dynamic_array1" y "dynamic_array2". El tamaño de cada matriz dinámica se establece en 5 mediante la función "ArrayResize".
  

// Assign values to dynamic arrays
   dynamic_array1[0] = 1;
   dynamic_array1[1] = 3;
   dynamic_array1[2] = 5;
   dynamic_array1[3] = 7;
   dynamic_array1[4] = 9;

   dynamic_array2[0] = 11;
   dynamic_array2[1] = 13;
   dynamic_array2[2] = 15;
   dynamic_array2[3] = 17;
   dynamic_array2[4] = 19;

• Estas líneas dan a cada elemento de "dynamic_array1" y "dynamic_array2" un valor específico.
  

// Print initial dynamic arrays
   Print("Initial dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("Initial dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

• Estas líneas imprimen los valores iniciales de "dynamic_array1" y "dynamic_array2" en la consola.
  

// Swap the contents of dynamic_array1 and dynamic_array2
   ArraySwap(dynamic_array1, dynamic_array2);

• Para sustituir todo el contenido de "dynamic_array1" por "dynamic_array2", utilice la función "ArraySwap()".
  

// Print dynamic arrays after swapping
   Print("After swapping - dynamic_array1: ");
   ArrayPrint(dynamic_array1, 0, " ", 0, WHOLE_ARRAY);

   Print("After swapping - dynamic_array2: ");
   ArrayPrint(dynamic_array2, 0, " ", 0, WHOLE_ARRAY);

• Tras el proceso de intercambio, estas líneas imprimen los valores actualizados de "dynamic_array1" y "dynamic_array2" en la consola.
  

Salida:

7. ArrayReverse

Los elementos de una matriz pueden reordenarse o invertirse utilizando la función "ArrayReverse()". Con la ayuda de esta función, los desarrolladores pueden dar la vuelta rápidamente a los elementos de la secuencia, convirtiendo el último elemento en el primero y viceversa. Esta operación ofrece una forma flexible y eficaz de cambiar la disposición de los elementos dentro de matrices que contienen diversos tipos de datos. Cuando es necesario invertir el orden de un elemento en programación, "ArrayReverse()" facilita el proceso y da como resultado un código más conciso y legible.

Analogía

Imagine una estantería con una fila de libros, cada uno con un número. Es como si esos libros se hubieran reordenado mágicamente con la función "ArrayReverse()", con el libro del extremo derecho ahora en el extremo izquierdo, y viceversa. Es un método sencillo para cambiar el orden de los libros de tu estantería. No sólo eso, sino que funciona de forma similar en programación, donde puede utilizar "ArrayReverse()" para invertir el orden de los elementos de una lista o matriz, empezando por el último y subiendo hasta el primero. Es como lanzar un hechizo hacia atrás en tu matriz, dándole la vuelta sin esfuerzo.

Sintaxis:

ArrayReverse(array[], start, count);

Parámetros: 

• array[]: La matriz que desea invertir está representada por este parámetro.
• start: El índice dentro del array en el que quieres que comience la inversión.
• count: El número de elementos que deben invertirse en la matriz.

Ejemplos:

void OnStart()
  {

// Declare and initialize a 10-element array
   int array[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

// Print the original array
   Print("Original Array: ");
   ArrayPrint(array, 0, " ", 0, WHOLE_ARRAY);

// Reverse the array starting from index 4
   ArrayReverse(array, 4, WHOLE_ARRAY);

// Print the array after reversal
   Print("Array after reversal from index 4: ");
   ArrayPrint(array, 0, " ", 0, WHOLE_ARRAY);

  }

Este código inicializa la matriz con los elementos especificados, imprime la matriz original, la invierte empezando por el índice 4, y luego imprime el resultado.

Salida:

8. ArraySort

Para ordenar los elementos de una matriz en orden ascendente, la función "ArraySort()" es una herramienta útil. Esta función permite ordenar rápidamente los elementos de una matriz de forma secuencial, empezando por el valor más pequeño y subiendo hasta el más grande. Esta función resulta especialmente útil cuando se trabaja con matrices que contienen valores numéricos.

Analogía

Imagina que quieres ordenar una colección de números mezclados del menor al mayor. Puedes ordenar rápidamente estos números en el orden adecuado con la ayuda de la función "ArraySort()", que funciona como un hechizo mágico. De este modo, puede identificar fácilmente los números más pequeños y los más grandes de su lista utilizando un único y sencillo comando para ordenar los números de forma ordenada. Gracias a la magia de la función "ArraySort()", puedes ver los números de forma comprensible y estructurada.

Sintaxis:

ArraySort(array[]); // array[] is the array you want to sort in ascending order

Ejemplo:

void OnStart()
  {

// Declare an array of numbers
   double array[5] = {9.5, 2.1, 7.8, 1.3, 5.6};

// Print the array before sorting
   Print("Array before sorting: ");
   ArrayPrint(array, 1, " ", 0, WHOLE_ARRAY);

// Use ArraySort to arrange the array in ascending order
   ArraySort(array);

// Print the array after sorting
   Print("Array after sorting: ");
   ArrayPrint(array, 1, " ", 0, WHOLE_ARRAY);

  }

Salida:

Conclusión

Ya hemos cubierto muchas de las ideas clave para la gestión de arrays en MQL5, incluyendo ArrayPrint, ArrayInsert, ArraySize, ArrayRange, ArrarRemove, ArraySwap, ArrayReverse, y ArraySort. El objetivo es abarcar una amplia gama de ideas esenciales que sirvan de base para la automatización de estrategias de negociación a medida que avanzamos en esta serie. Es fundamental comprender estas funciones de matriz, sobre todo cuando se trabaja con datos históricos para crear asesores expertos. Independientemente del nivel de experiencia, me comprometo a asegurar que cada lector domine estos conceptos fundamentales, sentando las bases para un viaje gratificante en la programación MQL5 y el trading algorítmico. 

Como conclusión de este artículo, insto a todos a abordar cada idea con paciencia y curiosidad, porque estos elementos básicos serán importantes en futuros artículos y harán que el desarrollo de sistemas fiables de trading automatizado sea gratificante y accesible. Tu comprensión es mi máxima prioridad, así que no dudes en preguntar si necesitas ayuda o aclaraciones sobre cualquier parte de este artículo. En el próximo artículo, realizaremos una sesión de vídeo exhaustiva para cubrir todos los aspectos de las funciones de array analizadas en las Partes 5 y 6. Para disipar cualquier duda restante, este vídeo ofrece un manual visual para mejorar su comprensión de estas ideas cruciales de programación MQL5.