Introducción a MQL5 (Parte 5): Funciones de trabajo con arrays para principiantes

Introducción

En la quinta parte de nuestra serie, hablaremos de las funciones para trabajar con arrays. Este artículo va dirigido específicamente a principiantes. Intentaremos disipar mitos sobre las funciones de array y explicaremos cada línea de código de la forma más clara posible. No importa si el lector tiene experiencia en programación, quiero que todo el mundo sea capaz de aprender MQL5, así que me esforzaré para que el aprendizaje sea accesible para todos.

Lo principal de este artículo es la sencillez y la claridad, porque quiero ayudar a quienes se interesan por la programación. Aunque el tema pueda parecer complejo, aprenderemos cada función de array línea por línea para que el proceso de aprendizaje siga siendo interesante y gratificante. Trabajaremos juntos para resolver problemas y aprender a aplicar los conocimientos al trading algorítmico. Esto no es solo un artículo: es una invitación a empezar a aprender a programar.

Además, quiero crear un grupo de personas con ideas afines en el que programadores principiantes y experimentados puedan intercambiar ideas, hacer preguntas y resolver problemas juntos. El presente material no es simplemente un artículo, sino una invitación a la programación en equipo. Así que, ¡empecemos a aprender material nuevo y a disfrutar programando!

En este artículo, veremos las siguientes funciones de trabajo con arrays:

• ArrayBsearch
  
• ArrayResize
  
• ArrayCopy
  
• ArrayCompare
  
• ArrayFree
• ArraySetAsSeries
• ArrayGetAsSeries
  
• ArrayIsSeries
  
• ArrayInitialize
  
• ArrayFill
  
• ArrayIsDynamic
  
• ArrayMaximum
  
• ArrayMinimum

Este no es el primer artículo de la serie, así que antes de pasar al material principal, me gustaría compartir un vídeo que recopila material de la cuarta parte. Vamos a refrescar los conocimientos para que cada lector tenga el bagaje necesario: para ello, veremos diferentes aspectos de los arrays en MQL5. ¡Manos a la obra!

1. ArrayBsearch

La función ArrayBsearch() puede usarse para arrays clasificados de forma ascendente. Esto presupone clasificar los valores del array de menor a mayor en orden ascendente. La función usa un método de búsqueda binaria que produce resultados fiables para arrays clasificados, pero puede no funcionar tan bien para arrays no clasificados o clasificados aleatoriamente. Por ello, para realizar una búsqueda eficiente y precisa, deberemos asegurarnos de que el array esté clasificado correctamente antes de utilizar ArrayBsearch().

Analogía

Suponga que tiene un conjunto de números clasificados de menor a mayor en un orden determinado. Imagine que intenta encontrar un número determinado, digamos 30, en esta lista clasificada. En lugar de recorrer manualmente cada número, la función ArrayBsearch() actuará de forma más inteligente. Le indicará que 30 se encuentra en la posición 2 (índice 2) de la lista y le dirigirá rápidamente al lugar correcto. Es como un útil asistente que acelerará metódicamente su búsqueda.

Sintaxis:

int ArrayBsearch(array[],value);

Explicación:

• “int" — tipo de dato que retorna la función. En este caso, es un valor entero que representará el índice de la posición encontrada o propuesta del valor en el array.
• “ArrayBsearch” — nombre de la función.
• “array[]” — array en el que se realiza la búsqueda.
• “value” — valor que se busca en el array.

Ejemplo:

void OnStart()
  {

// Declare an array of sorted numbers
   double sortedArray[] = {10, 20, 30, 40, 50};

// Value to search for
   double searchValue = 30;

// Call ArrayBsearch function
   int resultIndex = ArrayBsearch(sortedArray, searchValue);

// Print out the index of 30 in the array
   Print("Found the resultIndex at index ", resultIndex); // The output will be index 2

  }

Explicación:

“double sortedArray[] = {10, 20, 30, 40, 50};”:

• Esta línea declara un array llamado sortedArray que contiene los números clasificados {10, 20, 30, 40, 50}.

“double searchValue = 30;”:

• Esta línea establece el valor del parámetro searchValue en 30, es decir, el valor que queremos buscar en el array.

  “int resultIndex = ArrayBsearch(sortedArray, searchValue);”:

• En esta línea tenemos una llamada a la función ArrayBsearch(), con sortedArray y searchValue transmitidos como argumentos. Retorna el motivo por el que se ha encontrado searchValue, o un punto de inserción sugerido si no hay ningún valor presente.

“Print("Found the resultIndex at index ", resultIndex);”:

• Esta línea muestra el resultado de la búsqueda. Si se encuentra el searchValue, se emitirá el índice; en caso contrario, se emitirá el punto de inserción sugerido.

En este ejemplo, sortedArray es el array en el que estamos buscando, mientras que searchValue es el valor que queremos encontrar en el array. La función retorna el índice donde se encuentra el valor y emite el resultado.

2. ArrayResize

La función MQL5 ArrayResize() permite cambiar el tamaño de un array dinámico mientras se ejecuta el programa. En el caso de los arrays dinámicos, podemos ajustar el tamaño durante la ejecución, a diferencia de los arrays estáticos, cuyo tamaño está predeterminado. En otras palabras, ArrayResize() es una herramienta que, mientras su programa se está ejecutando, nos permite redimensionar o expandir un array dinámico para adaptarlo a las necesidades del momento. Esto aumenta la flexibilidad, permitiendo un procesamiento más eficaz de los datos durante la ejecución.

Los arrays de programación estática tienen un tamaño fijo, que se establece en la fase de compilación del programa. El número de elementos permanece constante porque el tamaño es fijo y no puede modificarse durante la ejecución. La memoria asignada a estos arrays viene determinada por el tamaño en el que se declaran. Por ejemplo, siempre habrá espacio para cinco elementos en un array de cinco elementos.

Ejemplo:

// Static array declaration
int staticArray[5] = {1, 2, 3, 4, 5};

Por el contrario, los arrays dinámicos ofrecen flexibilidad porque permiten los ajustes y el dimensionamiento durante la ejecución. Estos arrays se declaran primero sin especificar el tamaño. Entonces podemos usar la función ArrayResize() para cambiar la distribución de memoria, por ejemplo, en MQL5. Los arrays dinámicos son útiles cuando el tamaño de la estructura de datos debe ser flexible para adaptarse a un número variable de elementos necesarios durante la ejecución.

Ejemplo:

// Dynamic array declaration
int dynamicArray[];

Analogía

Digamos que usted tiene una mochila (array) que contiene un montón de juegos (items). Al irse de excursión, podrá elegir el número de juegos que cabe en su mochila estática, y así se mantendrá durante todo el viaje. Pero si quiere acomodar más juegos, habrá problemas.

Una mochila dinámica puede verse como algo especial que puede crecer y guardar cosas adicionales que usted quiera compartir con sus amigos. Para redimensionar su mochila y llevar tantos juegos como necesite en ese momento para ese viaje en particular, se utilizará ArrayResize().

Y lo que es más cómodo, podrá cambiar el tamaño de la mochila dinámica mientras se desplaza. Esta adaptabilidad le garantizará que cuando cambie su contenido o añada nuevos elementos, no tenga ningún problema. Es como si le dijera al array que debe estar preparado para aceptar más elementos o liberar espacio no utilizado. Este ajuste dinámico que se produce durante ejecución ofrece versatilidad y flexibilidad, lo que lo convierte en una herramienta inestimable para arrays cuyas dimensiones iniciales se desconocen.

Sintaxis:

ArrayResize
(
    array[],          // Reference to the array to be resized
    new_size,         // New size for the array
    reserve_size = 0  // Optional space reserved for future elements
);

Parámetros:

• “Array[]” — su mochila (array) a redimensionar.
• “new_size” — número de juegos (elementos) que debe haber en el array. Si tenía 5 juegos pero necesita espacio para 10, new_size será igual a 10.
•  “reserve_size = 0” — a veces es necesario dejar espacio para acomodar más juegos en el futuro, para no tener que volver a cambiar el tamaño. El parámetro reserve_size informará al array de que habrá más elementos en el futuro.

Ejemplo:

void OnStart()
  {

// Dynamic array declaration
   int dynamicArray[];

// Resizing the dynamic array to have 5 elements
   ArrayResize(dynamicArray, 5);

// Assigning values to dynamic array elements
   dynamicArray[0] = 10;
   dynamicArray[1] = 20;
   dynamicArray[2] = 30;
   dynamicArray[3] = 40;
   dynamicArray[4] = 50; 

// Accessing elements in a dynamic array
   Print("Element at index 2: ", dynamicArray[2]); // Output: 30

// Resizing the dynamic array to have 8 elements
   ArrayResize(dynamicArray, 8);

// Assigning values to the additional elements
   dynamicArray[5] = 60;
   dynamicArray[6] = 70;
   dynamicArray[7] = 80;

// Accessing elements after resizing
   Print("Element at index 6: ", dynamicArray[6]); // Output: 70

  }

Explicación:

Declaración de un array dinámico:

int dynamicArray[];

• Aquí declararemos un array dinámico llamado dynamicArray() sin especificar su tamaño inicial.

Redimensionamiento de un array dinámico a 5 elementos:

ArrayResize(dynamicArray, 5);

• Utilizaremos la función ArrayResize() para establecer el tamaño del array dinámico en 5 elementos.

Asignación de valores a los elementos de un array dinámico:

dynamicArray[0] = 10;
dynamicArray[1] = 20;
dynamicArray[2] = 30;
dynamicArray[3] = 40;
dynamicArray[4] = 50;

• Los valores se asignan a elementos individuales del array dinámico.

Acceso a los elementos de un array dinámico:

Print("Element at index 2: ", dynamicArray[2]); // Output: 30

• La función Print se utiliza para imprimir el valor del índice 2 de un array dinámico. En nuestro ejemplo, se mostrará un valor de 30.

Redimensionamiento de un array dinámico a 8 elementos:

ArrayResize(dynamicArray, 8);

• El array dinámico se redimensiona de nuevo para alojar 8 elementos, conservando los valores del redimensionamiento anterior.

Asignación de valores a los elementos adicionales:

dynamicArray[5] = 60;
dynamicArray[6] = 70;
dynamicArray[7] = 80;

• Los valores adicionales se asignan a los elementos recién añadidos después de redimensionarlos.

Acceso a los elementos después de redimensionarlos:

Print("Element at index 6: ", dynamicArray[6]); // Output: 70

• La función Print se utiliza para mostrar el valor en el índice 6 del array dinámico después del segundo redimensionamiento. En este caso se mostrará el valor 70

3. ArrayCopy

En MQL5, la función ArrayCopy() se utiliza para duplicar elementos entre arrays. Permite replicar selectivamente en otro array una parte específica de un array, denotada por un rango. Esta función simplifica la gestión y clasificación de los datos dentro de los arrays, facilitando la recuperación y el desplazamiento de determinados elementos entre arrays.

Analogía

Suponga que tiene dos listas de elementos y desea copiar con exactitud determinados elementos de la primera lista a la segunda. Aquí es donde la función MQL5 ArrayCopy() resultará útil. Actúa como una copiadora, permitiéndole seleccionar determinados elementos de un array y copiarlos ordenadamente en otra lista.

Veamos un ejemplo más concreto: imagina que tienes un array con cinco precios diferentes de artículos y quieres crear un segundo array que contenga solo los precios de tres artículos concretos. Con ArrayCopy(), podrá extraer y copiar cuidadosamente solo estos tres precios en un nuevo array, conservando el array original. Esta útil herramienta facilita el copiado y selección de elementos de una colección a otra, mejorando la eficacia y la organización de las tareas al trabajar con arrays.

Sintaxis:

ArrayCopy( 
          dst_array[],         // The destination array to receive copied elements 
          src_array[],         // The source array from which elements will be copied
          dst_start=0,         // The index in the destination array to start writing from  
          src_start=0,         // The index in the source array from which to start copying 
          count                // The number of elements to copy; default is to copy the entire array
);

Esta función permite combinar arrays con la precisión y el control necesarios. Aquí, dst_array será el destino al que se copiarán los elementos, mientras que src_array será el origen desde el que se recuperarán los elementos. Los parámetros opcionales dst_start, src_start y count ofrecen flexibilidad y permiten afinar las operaciones de copiado. Veamos como ejemplo una operación de copiado en MQL5.

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] = 2;
   sourceArray[2] = 3;
   sourceArray[3] = 4;
   sourceArray[4] = 5;

   destinationArray[0] = 10;
   destinationArray[1] = 20;
   destinationArray[2] = 30;
   destinationArray[3] = 40;
   destinationArray[4] = 50;

// Copy elements from sourceArray to destinationArray starting from index 1
   ArrayCopy(destinationArray, sourceArray, 5, 0, WHOLE_ARRAY);

// Print the value of the element at index 7 in destinationArray
   Comment("Value at index 7 in destinationArray: ", destinationArray[7]);

  }

Explicación:

Declaración de arrays:

int sourceArray[];
int destinationArray[];

• Declara dos arrays dinámicos llamados sourceArray y destinationArray.
  

Modificación del tamaño de los arrays:

ArrayResize(sourceArray, 5);
ArrayResize(destinationArray, 5);

• La función ArrayResize() permite establecer el tamaño de los arrays dinámicos. En este caso, el tamaño de ambos arrays se cambiará para que haya 5 elementos en cada uno.
  

Asignación de valores:

sourceArray[0] = 1;
sourceArray[1] = 2;
sourceArray[2] = 3;
sourceArray[3] = 4;
sourceArray[4] = 5;

destinationArray[0] = 10;
destinationArray[1] = 20;
destinationArray[2] = 30;
destinationArray[3] = 40;
destinationArray[4] = 50;

• Los valores se asignan a los elementos individuales sourceArray y destinationArray.
  

Copiar un array:

ArrayCopy(destinationArray, sourceArray, 5, 0, WHOLE_ARRAY);

• La función ArrayCopy() se usa para copiar elementos de sourceArray a destinationArray. Define el copiado de 5 elementos a partir del índice 0.
  

Imprimir la salida:

Comment("Value at index 7 in destinationArray: ", destinationArray[7]);

• Produce un comentario que muestra el valor en el índice 7 de destinationArray.
  

El propósito general del código es mostrar la función ArrayCopy(). Copia elementos de sourceArray a destinationArray, empezando por índices específicos. La última línea muestra el valor del elemento en destinationArray para confirmar que el copiado se ha realizado correctamente.

4. ArrayCompare

La función ArrayCompare() en MQL5 compara dos arrays elemento por elemento. Compara los arrays desde el principio (desde el índice 0) y comprueba que los elementos en los índices correspondientes sean iguales. Si todos los elementos coinciden, los arrays se considerarán iguales. Si existe un desajuste en cualquier índice, la función evaluará qué array contiene el elemento numéricamente mayor, ofreciendo una base para determinar su relación. Esta función se usa para evaluar la similitud o diferencia entre arrays según su contenido.

Analogía

Imagine un escenario en el que tiene dos listas de números: la lista A y la lista B. ArrayCompare() analizará estas listas y le informará sobre sus relaciones. Empezando por los números al principio de ambas listas, el «investigador» los comparará. Cuando se detecte un desajuste en los números, la función determinará inmediatamente qué lista es mayor o menor. Así, si podemos mirar ambas listas y no encontrar diferencias, se determinará que las listas son iguales.

 

A continuación, sacaremos conclusiones de esta comparación:

• Si la lista A se considera más pequeña que la lista B, la función mostrará -1.
• Si ambas listas son iguales, el resultado será 0.
• Si la lista A se considera mayor que la lista B, el resultado será 1.
• Si hay alguna confusión o problema durante el análisis, se imprimirá un resultado de -2.

Así, ArrayCompare() nos ayudará a comprender la relación entre dos listas de números.

Sintaxis:

int ArrayCompare(const void& array1[], const void& array2[], int start1 = 0, int start2 = 0, int count = WHOLE_ARRAY);

Parámetros:

• array1[] — primer array.
•  array2[] — segundo array.
• start1 — índice del elemento inicial del primer array a partir del cual comenzará la comparación. El índice inicial por defecto será 0.
• start2 - índice del elemento inicial del segundo array a partir del cual comenzará la comparación. El índice inicial por defecto será 0.
• count — número de elementos a comparar. Por defecto, todos los elementos de ambos arrays participarán en la comparación (count = WHOLE_ARRAY).

Ejemplo:

void OnStart()
  {

// Declare two arrays
   int ListA[] = {1, 2, 3, 4, 5};
   int ListB[] = {1, 2, 3, 4, 6};
// Use ArrayCompare to compare the arrays
   int result = ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY);  
// Print the result
   if(result == -1)
      {
      Print("ListA is less than ListB");
      }
   else if(result == 0)
      {
      Print("ListA is equal to ListB");
      }
   else if(result == 1)
      {
      Print("ListA is greater than ListB");
      }
    else if(result == -2)
      {
       Print("Error: Incompatible arrays or invalid parameters");
      }

  }

Explicación:

“int ListA[] = {1, 2, 3, 4, 5};”:

• Declara un array de enteros llamado ListA y lo inicializa con los valores 1, 2, 3, 4 y 5.

“int ListB[] = {1, 2, 3, 4, 6};”:

• Declara un array de enteros llamado ListB y lo inicializa con los valores 1, 2, 3, 4 y 6.

“int result = ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY);”:

• Usa la función ArrayCompare() para comparar los arrays ListA y ListB. La comparación comienza en el índice 0 de ambos arrays y compara todos los arrays.

Los operadores condicionales (if, else if) comprueban el valor de la variable resultante y muestran mensajes en función del resultado de la comparación:

• Si el resultado = -1, significará que ListA es menor que ListB.
• Si el resultado = 0, significará que ListA es igual a ListB.
• Si el resultado = 1, significará que ListA es mayor que ListB.
• Si result = -2, indica un error debido a arrays incompatibles o parámetros no válidos.

Tenemos arrays:

int ListA[] = {1, 2, 3, 4, 5};
int ListB[] = {1, 2, 3, 4, 6};

El resultado de la comparación ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY)" será -1.

Explicación:

• La comparación comienza con el primer elemento (índice 0) de ambos arrays.
• Los elementos con índices 0 a 3 son los mismos en ambos arrays.
• El índice 4 de ListA tiene 5 y el de ListB tiene 6.
• Como 5 < 6, la ListA se considerará más pequeña que ListB.

Por lo tanto, el resultado será -1. Experimente con los valores de ListA y ListB para ver cómo cambia el resultado de la comparación.

5. ArrayFree

En MQL5, llamar a ArrayFree() resulta similar a pulsar el botón para reiniciar un array dinámico. Consideraremos un array como contenedor de diferentes elementos. La acción de la función ArrayFree() será similar a limpiar el contenedor y prepararlo para almacenar nuevos elementos. Así, eliminando información obsoleta, se liberará espacio para nueva. En otras palabras, se trata de una limpieza para el uso futuro. El uso de la función nos permitirá estar seguros de que el array está vacío y preparado para las nuevas características de programación MQL5.

Analogía

Imagine que tiene una bolsa mágica: su array. A veces lo utiliza para otros fines, como coleccionar juegos. Pero antes de comprar nuevos juegos, debe asegurarse de que la bolsa está vacía. Eso es exactamente lo que hace ArrayFree(): limpia su bolsa para que pueda poner nuevos juegos o valores ahí. Es decir, sacaremos de allí todo lo que contenía antes de meter algo nuevo.

Sintaxis:

ArrayFree(array[] // dynamic array to be freed);

Ejemplo:

void OnStart()
  {

// Declare a dynamic array
   int dynamicArray[];
// Resize the dynamic array and assign values
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 10;
   dynamicArray[1] = 20;
   dynamicArray[2] = 30;
   dynamicArray[3] = 40;
   dynamicArray[4] = 50;
   
// Print elements before freeing the array
   Print("Index 0 before freeing: ", dynamicArray[0]); // Output will be 10
   
// Free the dynamic array using ArrayFree
   ArrayFree(dynamicArray);
   
// Attempting to access elements after freeing (should result in an error)
//   Print("Index 0 after freeing: ", dynamicArray[0]);

// Reassign new values to the array
   ArrayResize(dynamicArray, 3);
   dynamicArray[0] = 100;
   dynamicArray[1] = 200;
   dynamicArray[2] = 300;
   
// Print elements after reassigning values
   Print("Index 0 after reassigning: ", dynamicArray[0]); // Output will be 100

  }

Explicación:

Declaración de un array dinámico:

int dynamicArray[];

• Inicialización de un array dinámico vacío.
  

Redimensionamiento y asignación de un valor:

ArrayResize(dynamicArray, 5);
dynamicArray[0] = 10;
dynamicArray[1] = 20;
dynamicArray[2] = 30;
dynamicArray[3] = 40;
dynamicArray[4] = 50;

• Redimensiona un array dinámico para que contenga 5 elementos y asigna un valor a cada elemento.
  

Muestra de los elementos antes de la limpieza:

Print("Elements before freeing: ", dynamicArray[0]); // Output will be 10

• Imprime un valor del primer índice del array igual a 10.
  

Libera el array dinámico:

ArrayFree(dynamicArray);

• Libera la memoria ocupada por el array dinámico.
  

Intento de acceder a elementos después de que el array haya sido liberado:

// Print("Elements after freeing: ", dynamicArray[0]);

• Esta línea se comentará para evitar errores de ejecución al liberar el array.
  

Asignación de nuevos valores:

ArrayResize(dynamicArray, 3);
dynamicArray[0] = 100;
dynamicArray[1] = 200;
dynamicArray[2] = 300;

• Redimensionamos el array para que contenga 3 elementos y asignamos los nuevos valores.
  

Muestra tras la reasignación de valores:

Print("Elements after reassigning: ", dynamicArray[0]); // Output will be 100

• Imprime el valor en el primer índice del array después de la reasignación, aquí será 100.
  

En este ejemplo, después de liberar el array dinámico usando ArrayFree(), lo redimensionaremos de nuevo para tener 3 elementos y asignaremos nuevos valores a esos elementos. Esto muestra cómo un array dinámico puede ser reutilizado después de haber sido liberado.

Cuando trabaje con funciones complejas de arrays MQL5, podrá descubrir aún más posibilidades. Permanezca atento a las actualizaciones para obtener más información sobre funciones adicionales que le permitan escribir código de forma más eficaz. Aún quedan muchas incógnitas por resolver, independientemente de la experiencia del desarrollador. A medida que progresemos en estos temas, iremos descubriendo conceptos cada vez más complejos. Vamos a continuar nuestro viaje por la programación.

6. ArraySetAsSeries

En la programación MQL5, ArraySetAsSeries() es una función que permite cambiar la dirección de indexación de los arrays. Con esta función, podemos configurar el array para acceder a él desde el final hasta el principio cambiando la dirección de avance predeterminada. Esto resultará especialmente útil al trabajar con datos financieros u otros arrays en los que sea necesario acceder a los elementos en orden cronológico inverso.

Nota. Debemos señalar que esto funciona especialmente bien con arrays dinámicos, que pueden cambiar su tamaño correctamente durante la ejecución.

Analogía

Imagínese que tiene una pila de colecciones de relatos cortos clasificados en su estantería. Cada libro es como un número especial. Normalmente las historias se leen en el orden en que aparecen en la estantería, empezando por el primer libro y avanzando hasta el último.

Supongamos que quiere encontrar la última historia que ha añadido a su colección sin sacar todos los libros de la estantería. Aquí es donde la magia de ArraySetAsSeries() resultará útil. Cuando lance este hechizo sobre su estantería (array), hará que los libros se reordenen de forma que el más nuevo que añada se convierta en el primero. Esto resulta especialmente útil cuando sus historias (números) cambien con el tiempo, como cuando registre cuántos libros nuevos colecciona cada día. Con ArraySetAsSeries(), podrá abrir primero la última colección de cuentos y luego avanzar por la biblioteca en orden inverso hacia el primer libro para ver cómo ha crecido su colección. Es decir, empezará a leer su colección en orden inverso.

Sintaxis:

ArraySetAsSeries(
   array[],    // array to be set as series
   bool   flag // true denotes reverse order of indexing
);

Parámetros:

• array[] — array sobre el que desea aplicar las propiedades de las series temporales. Se aplicará una nueva indexación a este array.
• bool flag — valor de tipo bool. Cuando se establece en true, se activa la indexación inversa, convirtiendo el array en una serie temporal en la que el último elemento se convertirá en el primero. Si se establece en false, el array se comportará de la forma habitual.

Ejemplo:

void OnStart()
  {

// Declare a dynamic array
   int magicalArray[];

// Assign values to the array
   ArrayResize(magicalArray, 5);
   magicalArray[0] = 10;
   magicalArray[1] = 20;
   magicalArray[2] = 30;
   magicalArray[3] = 40;
   magicalArray[4] = 50;

// Print elements before setting as series
   Print("Elements before setting as series:");
   Print("Index 0: ", magicalArray[0]);
   Print("Index 1: ", magicalArray[1]);
   Print("Index 2: ", magicalArray[2]);
   Print("Index 3: ", magicalArray[3]);
   Print("Index 4: ", magicalArray[4]);

// Set the array as a series
   ArraySetAsSeries(magicalArray, true);

// Print elements after setting as series
   Print("Elements after setting as series:");
   Print("Index 0: ", magicalArray[0]);
   Print("Index 1: ", magicalArray[1]);
   Print("Index 2: ", magicalArray[2]);
   Print("Index 3: ", magicalArray[3]);
   Print("Index 4: ", magicalArray[4]);

  }

Explicación:

Declaración de un array dinámico:

double magicalArray[];

• Declara un array dinámico llamado magicalArray sin especificar su tamaño.
  

Asigna valores al array:

ArrayResize(magicalArray, 5);
magicalArray[0] = 10;
magicalArray[1] = 20;
magicalArray[2] = 30;
magicalArray[3] = 40;
magicalArray[4] = 50;

• Redimensiona el array para que tenga 5 elementos.
  
• A continuación, asigna valores específicos a cada elemento del array.
  

Muestra de elementos antes de ajustar los parámetros como en la serie temporal:

Print("Elements before setting as series:");
Print("Index 0: ", magicalArray[0]); // output will be 10
Print("Index 1: ", magicalArray[1]); // output will be 20
Print("Index 2: ", magicalArray[2]); // output will be 30
Print("Index 3: ", magicalArray[3]); // output will be 40
Print("Index 4: ", magicalArray[4]); // output will be 50

• Aquí se muestran los valores de cada elemento del array antes de establecer sus propiedades de serie temporal.
  

Configuramos el array como una serie temporal:

ArraySetAsSeries(magicalArray, true);

• Utilizamos la función ArraySetAsSeries() para convertir un array en una serie temporal. El segundo parámetro true especifica el orden inverso de indexación.
  

Muestra de elementos después de configurarlos como una serie temporal:

Print("Elements after setting as series:");
Print("Index 0: ", magicalArray[0]); // output will be 50
Print("Index 1: ", magicalArray[1]); // output will be 40
Print("Index 2: ", magicalArray[2]); // output will be 30
Print("Index 3: ", magicalArray[3]); // output will be 20
Print("Index 4: ", magicalArray[4]); // output will be 10

• Por último, obtenemos los valores de cada elemento después de configurar el array como una serie temporal. El orden en que se muestran los valores refleja la indexación inversa debida a la configuración de una nueva propiedad.
  

Así, el código demuestra cómo asignar valores a un array dinámico, mostrar sus elementos antes y después de establecer la propiedad de la serie temporal, y observar cómo cambia el orden de indexación.

Así es como opera la función ArraySetAsSeries() en MQL5. Una vez más: la función establece la indexación inversa a los elementos del array. Me gustaría recordarles que se necesita práctica para entender mejor el material. Pruebe cosas nuevas, lea atentamente y formule preguntas. Puede obtener ayuda de toda una comunidad de programadores. Así que, vamos a continuar.

7. ArrayGetAsSeries

La función ArrayGetAsSeries() en MQL5 se usa para determinar si la bandera AS_SERIES está establecida para un array. Esta bandera afecta al orden en que se accede a los elementos del array. Si la función retorna true, significa que se accederá a los elementos en orden inverso. En caso contrario, si retorna false, el array conservará el orden por defecto. Esta función resulta útil al trabajar con arrays en los que la secuencia de acceso a los datos tiene una importancia vital, y permite probar y adaptar la forma de acceder a los datos en función de la configuración del array.

Analogía

Imagine que tiene una lista de números y que a veces esa lista juega al juego «viajes en el tiempo». Cuando usted usa la herramienta ArrayGetAsSeries(), le dirá si su lista está en el juego o no. Si el valor es true, significará que la lista participará en el juego y usted estará leyendo los números al revés, como una cuenta atrás. Si es false, la lista será normal y usted leerá los números de principio a fin, como si estuviera contando. Esto le dará una idea de cómo manejar la lista ahora.

Sintaxis:

bool ArrayGetAsSeries(
array[]    // // The array that is being examined for its time series configuration.
);

Ejemplo:

void OnStart()
  {

// Declare two dynamic arrays
   int timeSeriesArray[];
   int regularArray[];
// Resize the arrays to have 5 elements
   ArrayResize(timeSeriesArray, 5);
   ArrayResize(regularArray, 5);
// Assign values to the arrays
   timeSeriesArray[0] = 1;
   timeSeriesArray[1] = 2;
   timeSeriesArray[2] = 3;
   timeSeriesArray[3] = 4;
   timeSeriesArray[4] = 5;

   regularArray[0] = 5;
   regularArray[1] = 4;
   regularArray[2] = 3;
   regularArray[3] = 2;
   regularArray[4] = 1;
// Set the time series flag for the first array
   ArraySetAsSeries(timeSeriesArray, true);
// Check if the dynamic arrays follow the time series convention using if statements
   if(ArrayGetAsSeries(timeSeriesArray))
     {
      Print("timeSeriesArray is a time series. Elements are accessed from end to beginning.");
     }
   else
     {
      Print("timeSeriesArray maintains its original order. Elements are accessed from beginning to end.");
     }

   if(ArrayGetAsSeries(regularArray))
     {
      Print("regularArray is a time series. Elements are accessed from end to beginning.");
     }
   else
     {
      Print("regularArray maintains its original order. Elements are accessed from beginning to end.");
     }

  }

Explicación:

// Declare two dynamic arrays
int timeSeriesArray[];
int regularArray[];

• Estas líneas declaran dos arrays dinámicos llamados timeSeriesArray y regularArray. Los arrays dinámicos en MQL5 pueden cambiar de tamaño durante la ejecución.
  

// Resize the arrays to have 5 elements
ArrayResize(timeSeriesArray, 5);
ArrayResize(regularArray, 5);

• La función ArrayResize() 3 se usa aquí para establecer el tamaño de ambos arrays en 5 elementos. Este paso garantiza que los arrays tengan espacio suficiente para guardar los elementos.
  

// Assign values to the arrays
timeSeriesArray[0] = 1;
timeSeriesArray[1] = 2;
timeSeriesArray[2] = 3;
timeSeriesArray[3] = 4;
timeSeriesArray[4] = 5;

regularArray[0] = 5;
regularArray[1] = 4;
regularArray[2] = 3;
regularArray[3] = 2;
regularArray[4] = 1;

• Aquí es donde se asignarán valores específicos a los elementos de ambos arrays. Al array timeSeriesArray se le asignan valores en orden ascendente, mientras que al array regularArray se le asignan valores en orden descendente.
  

// Set the time series flag for the first array
ArraySetAsSeries(timeSeriesArray, true);

• Esta línea usa ArraySetAsSeries() para establecer la bandera de serie temporal para timeSeriesArray en true. Y esto significa que se accederá a los elementos del timeSeriesArray de principio a fin.
  

// Check if the dynamic arrays follow the time series convention using if statements
    if(ArrayGetAsSeries(timeSeriesArray))
    {
        Print("timeSeriesArray is a time series. Elements are accessed from end to beginning.");
    }
    else
    {
        Print("timeSeriesArray maintains its original order. Elements are accessed from beginning to end.");
    }

    if(ArrayGetAsSeries(regularArray))
    {
        Print("regularArray is a time series. Elements are accessed from end to beginning.");
    }
    else
    {
        Print("regularArray maintains its original order. Elements are accessed from beginning to end.");
    }

• El fragmento de código comprueba si los arrays dinámicos timeSeriesArray y regularArray coinciden con las condiciones de timeSeriesArray usando operadores condicionales. La función ArrayGetAsSeries() se utiliza para determinar si la bandera de serie temporal está activada para cada array. El primer operador if comprueba timeSeriesArray. Si el operador lo define como una serie temporal, aparecerá el mensaje correspondiente indicando que se accede a sus elementos desde el final hasta el principio. En caso contrario, el bloque else emitirá un mensaje que indicará que timeSeriesArray conserva su orden original y que el acceso a los elementos se produce de principio a fin. El proceso se repetirá para regularArray. Esta comprobación condicional resulta importante para comprender cómo se indexan los elementos en los arrays dinámicos y proporciona información sobre la dirección de acceso al array.
  

Entender el funcionamiento de ArrayGetAsSeries() supone una habilidad tediosa en MQL5. Ya se trate de navegar por datos de series temporales o de trabajar con arrays en el orden original, estas funciones se usan directamente en los programas de trading algorítmico. Espero que haya quedado claro hasta ahora.

8. ArrayIsSeries

Para determinar si un array en MQL5 representa una serie temporal, utilizaremos la función ArrayIsSeries(). Los arrays que contienen datos relacionados con el tiempo se denominan series temporales (time series) en programación financiera y suelen utilizarse para almacenar valores de precios como los precios de apertura, máximo, mínimo y cierre. Cuando se detecta una serie temporal, la función analiza el array proporcionado y retorna true. En caso contrario, retornará false. Esta definición es esencial al trabajar con datos financieros en un gráfico donde comprender la naturaleza temporal de los datos resulta muy importante.

Al crear indicadores personalizados en MQL5, especialmente en el contexto del análisis técnico, debemos distinguir entre arrays regulares y arrays de series temporales. La función ArrayIsSeries() simplifica este proceso permitiendo a los desarrolladores adaptar el código según si el array contiene información basada en el tiempo. Esta función ayuda a mejorar la eficacia y precisión de las estrategias de trading algorítmico, las herramientas de análisis técnico y otras aplicaciones financieras desarrolladas en MQL5.

Diferencia entre ArrayGetAsSeries y ArrayIsSeries

ArrayGetAsSeries() y ArrayIsSeries() son funciones relacionadas con el comportamiento de los arrays, pero tienen objetivos diferentes. ArrayGetAsSeries() se usa para comprobar si la indexación del array está configurada para recuperar elementos en orden inverso. Esta función resulta útil al trabajar con arrays, ya que permite a los desarrolladores determinar si se accede a los datos en orden cronológico o inverso. Retorna true si el array se especifica como una serie (se accede en orden inverso), y false en caso contrario.

La función ArrayIsSeries(), por su parte, se utiliza para determinar si un array es una serie temporal. Los arrays de series temporales se utilizan mucho en programación financiera y representan datos como los precios de apertura, máximo, mínimo y cierre a lo largo del tiempo. A diferencia de ArrayGetAsSeries(), ArrayIsSeries() no se preocupa por la dirección de indexación del array. Simplemente comprueba si el array contiene información relacionada con el tiempo. Si el array representa una serie temporal, retornará true; en caso contrario, retornará false. Estas funciones se complementan entre sí para ofrecer un conjunto completo de herramientas de procesamiento del comportamiento de los arrays, que proporcionan la flexibilidad necesaria para trabajar con distintos tipos de datos financieros en sistemas de trading algorítmico y herramientas de análisis técnico.

Analogía

Supongamos que tiene una lista diaria, por ejemplo una lista de precios de sus juegos favoritos. Ahora, si necesita saber si esta lista es especial y está relacionada con el tiempo igual que la historia, podrá usar ArrayIsSeries(). Este comprueba si la lista tiene relación con el cambio temporal, es decir, si se trata de una serie temporal. No importa si la lista se lee hacia delante o hacia atrás; a ArrayIsSeries() le interesa saber si parece un cambio en el tiempo.

Si obtenemos true como respuesta, significará que nuestra lista está relacionada con un viaje en el tiempo, quizá muestre los precios de los juegos durante unos días. Pero si la respuesta es false, la lista podría ser un conjunto regular de números sin ninguna magia relacionada con el tiempo. Se trata de una forma sencilla y fiable de averiguar si una secuencia de un array está asociada a un cambio temporal.

Sintaxis:

bool ArrayIsSeries(
array[] //the array you want to check if it's a timeseries.
)

Ejemplo:

void OnStart()
  {

// Declare an array
   double priceSeries[];
// Resize the array and assign values (considering it as a time series)
   ArrayResize(priceSeries, 5);
   priceSeries[0] = 1.1;
   priceSeries[1] = 1.2;
   priceSeries[2] = 1.3;
   priceSeries[3] = 1.4;
   priceSeries[4] = 1.5;
// Check if the array is a time series
   bool isSeries = ArrayIsSeries(priceSeries);
// Print the result
   if(isSeries)
     {
      Print("This array is a time series!");
     }
   else
     {
      Print("This array is not a time series.");
     }

  }

Explicación:

// Declare an array
double priceSeries[];

• Esta línea declara un array dinámico vacío llamado priceSeries para guardar valores de tipo double.
  

// Resize the array and assign values (considering it as a time series)
ArrayResize(priceSeries, 5);
priceSeries[0] = 1.1;
priceSeries[1] = 1.2;
priceSeries[2] = 1.3;
priceSeries[3] = 1.4;
priceSeries[4] = 1.5;

• Aquí el tamaño del array se cambia a 5 elementos y a cada elemento se le asignan ciertos valores. Estos valores suponen una serie temporal hipotética.
  

// Check if the array is a time series
bool isSeries = ArrayIsSeries(priceSeries);

• Esta línea usa la función ArrayIsSeries() para comprobar si el array priceSeries se considera una serie temporal. El resultado (true o falso) se guarda en la variable lógica isSeries.
  

// Print the result
if (isSeries) {
    Print("This array is a time series!");
} else {
    Print("This array is not a time series.");
}

• Por último, el código muestra un mensaje que indicará si el array se considera una serie temporal, basándose en el resultado de ArrayIsSeries(). Si se trata de una serie temporal, el código mostrará un mensaje; en caso contrario, otro.
  

El resultado en este caso será: 'This array is not a time series' ('Este array no es una serie temporal'). ¿Por qué? Porque el array no supone una serie temporal incluso después de que le hayamos asignado valores. Entiendo que de inicio, sobre todo a los novatos, puede parecerles un poco confuso. Pero no vamos a entrar ahora en discusiones más profundas. Si sigue teniendo preguntas, hágalas en los comentarios al artículo.

9. ArrayInitialize

La función ArrayInitialise() en MQL5 establece en el valor especificado los valores iniciales de todos los elementos del array numérico. En lugar de asignar manualmente el mismo valor a cada elemento de uno en uno, ArrayInitialise() aplica el valor elegido a todos los elementos a la vez. Esta función resulta útil para preparar un array con un punto de partida definido, especialmente al trabajar con datos numéricos en los que se requiere una inicialización uniforme. Tenga en cuenta que solo establece los valores iniciales y no afectará a los elementos redundantes o futuras ampliaciones realizadas con ArrayResize().

Analogía

Supongamos que tiene un conjunto de contenedores llamados arrays, y cada contenedor tiene lugares especiales para guardar valores. Y que usted quiere empezar con un valor específico en todos estos espacios y utilizar un comando especial llamado ArrayInitialise(). Este comando establecerá el valor inicial requerido en todos estos espacios al mismo tiempo, eliminando la necesidad de hacerlo para cada espacio por separado.

Pero aquí viene lo interesante: si más tarde decide ampliar estos contenedores y añadirles más espacios utilizando un comando diferente (ArrayResize), los nuevos espacios se añadirán, pero no tendrán los mismos valores que los originales. Entonces deberá seleccionar los valores a introducir para cada uno por separado, ya que diferirán ligeramente. Es como ampliar el espacio interior: las habitaciones nuevas no siempre se decoran con los mismos muebles que las antiguas.

Sintaxis:

int ArrayInitialize(
   array[],   // initialized array
   value       // value that will be set
);

Ejemplo:

void OnStart()
  {

// Declare a dynamic array
   int myArray[];

// Resize the array to have an initial size (let's use 3 elements)
   ArrayResize(myArray, 3);

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

// Initialize the array with a value (let's use 0.0)
   ArrayInitialize(myArray, 0);

// Print the values of all elements after initialization
   Print("Values after initialization:");
   Print("myArray[0] = ", myArray[0]); // outpot wil be 0
   Print("myArray[1] = ", myArray[1]); // outpot wil be 0
   Print("myArray[2] = ", myArray[2]); // outpot wil be 0
// Resize the array to have 5 elements
   ArrayResize(myArray, 5);

// Assign values to the additional elements after resizing
   myArray[3] = 40;
   myArray[4] = 50;

// Print the values of all elements after resizing
   Print("Values after resizing:");
   Print("myArray[3] = ", myArray[3]); // outpot wil be 40
   Print("myArray[4] = ", myArray[4]); // outpot wil be 50


  }

Explicación:

// Declare a dynamic array
   int myArray[];

• Aquí declaramos un array dinámico de números enteros llamado myArray. No posee un tamaño predeterminado.
  

// Resize the array to have an initial size (let's use 3 elements)
   ArrayResize(myArray, 3);

• Luego cambiamos el tamaño del array myArray para que su tamaño original sea de 3 elementos. Y esto significará que estamos asignando memoria para los tres enteros del array.
  

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

• Antes de inicializar un array, debemos asignar manualmente valores a sus elementos. En este caso, establecemos myArray[0] en 10, myArray[1] en 20 y myArray[2] en 30.
  

// Initialize the array with a value (let's use 0.0)
   ArrayInitialize(myArray, 0);

• Ahora tenemos que usar la función ArrayInitialise() para establecer todos los elementos de myArray en el valor especificado, que en este caso será 0.
  

// Print the values of all elements after initialization
Print("Values after initialization:");
Print("myArray[0] = ", myArray[0]); // Output will be 0
Print("myArray[1] = ", myArray[1]); // Output will be 0
Print("myArray[2] = ", myArray[2]); // Output will be 0

• Después imprimimos los valores de todos los elementos de myArray tras la inicialización. Como era de esperar, todos los elementos se han puesto ahora a 0.
  

// Resize the array to have 5 elements
ArrayResize(myArray, 5);

• Luego redimensionamos myArray para que solo tenga 5 elementos, lo que significa que ahora el array puede alojar dos elementos más.
  

// Assign values to the additional elements after resizing
myArray[3] = 40;
myArray[4] = 50;

• Después de realizar el redimensionamiento, asignaremos valores a los elementos adicionales (myArray[3] y myArray[4]).
  

// Print the values of all elements after resizing
Print("Values after resizing:");
Print("myArray[3] = ", myArray[3]); // Output will be 40
Print("myArray[4] = ", myArray[4]); // Output will be 50

• Finalmente, tras modificar el tamaño, mostraremos los valores de todos los elementos de myArray, incluyendo los nuevos elementos añadidos.
  

La función ArrayInitialise() en MQL5 es una herramienta útil que permite a los programadores establecer un valor concreto para cada elemento del array. Ofrece un punto de partida definido para cada elemento del array, y proporciona claridad y control sobre el estado inicial del mismo. Recuerde que la función inicializa cada elemento con el mismo número indicado. Esto puede parecer sencillo, pero supone un paso importante a la hora de configurar arrays para distintos tipos de aplicaciones. En los siguientes artículos profundizaremos en el esfera del trading algorítmico y revisitaremos de nuevo la función ArrayInitialize().

10. ArrayFill

La función ArrayFill() también facilita el trabajo con arrays. Permite rellenar eficazmente un rango de elementos del array con el valor especificado, eliminando la necesidad de iteración y asignación manual. En lugar de escribir varias líneas de código para configurar individualmente cada elemento, ArrayFill() ofrece una solución concisa y eficaz. Esta función mejora la legibilidad del código y reduce la posibilidad de errores, sobre todo al trabajar con arrays grandes o tareas repetitivas. La capacidad de la función para rellenar rápidamente los elementos del array con un valor común simplifica el proceso en los casos en que necesitamos una inicialización masiva.

Analogía

Supongamos que tiene una caja con varias ranuras, y quiere utilizar algunas de esas ranuras para el mismo juego sin pasar por cada una de ellas individualmente. ArrayFill() le permitirá seleccionar un juego y darle la indicación: "Rellenar las ranuras con este juego". Así podrá colocar todos los juegos a la vez en lugar de colocar cada uno por separado. Esta función ahorra tiempo y ayuda a mantener el contenedor ordenado.

Sintaxis:

ArrayFill(
    array[], // array to be filled
    start,   // Starting slot (index) for filling
    count,   // Number of slots to fill
    value    // The value to fill the slots with
);

Parámetros

• array[] — array.
• start — posición inicial para colocar el valor requerido. Aquí se especifica el índice o la posición.
•  count — número de posiciones a rellenar.
• value — valor con el que rellenar las posiciones. Puede ser un número, un color o cualquier cosa que quepa en las ranuras.

Ejemplo:

void OnStart()
  {

// Declare an array of shelves
   int roomShelves[];

// Set the size of the array (number of shelves)
   ArrayResize(roomShelves, 10);

// Fill the first 5 shelves with books (value 42)
   ArrayFill(roomShelves, 0, 5, 42);

// Fill the next 5 shelves with toys (value 99)
   ArrayFill(roomShelves, 5, 5, 99);

// Display the contents of the shelves after filling
   Print("Contents of the shelves after filling:");
   Print("Shelf 0: ", roomShelves[0]); // output will be 42
   Print("Shelf 1: ", roomShelves[1]); // output will be 42
   Print("Shelf 2: ", roomShelves[2]); // output will be 42
   Print("Shelf 3: ", roomShelves[3]); // output will be 42
   Print("Shelf 4: ", roomShelves[4]); // output will be 42
   Print("Shelf 5: ", roomShelves[5]); // output will be 99
   Print("Shelf 6: ", roomShelves[6]); // output will be 99
   Print("Shelf 7: ", roomShelves[7]); // output will be 99
   Print("Shelf 8: ", roomShelves[8]); // output will be 99
   Print("Shelf 9: ", roomShelves[9]); // output will be 99

  }

Explicación:

“int roomShelves[];”:

• Declaramos un array de enteros llamado roomShelves que representa los estantes de la habitación.

“ArrayResize(roomShelves, 10);”:

• Redimensionamos el array roomShelves para que contenga 10 elementos que representen los 10 estantes de la habitación.

“ArrayFill(roomShelves, 0, 5, 42);”:

• Rellenamos los 5 primeros estantes (índices de 0 a 4) con el valor 42, que denota los libros de estos estantes.

"ArrayFill(roomShelves, 5, 5, 5, 99);":

• Rellenamos los 5 estantes siguientes (índices de 5 a 9) con el valor 99, que indicará los juegos de estos estantes.

“Print("Contents of the shelves after filling:");”:

• Muestra el contenido de los estantes en las siguientes líneas.

“Print("Shelf 0: ", roomShelves[0]);” to “Print("Shelf 9: ", roomShelves[9]);”:

• Muestra el contenido de cada estante, mostrando el índice del estante y su valor correspondiente.

Este código MQL5 muestra como llenar el array dinámico roomShelves utilizando la función ArrayFill(). Inicialmente, el tamaño del array se ha aumentado a diez estantes. El siguiente paso consiste en utilizar ArrayFill() para rellenar los cinco primeros estantes con un valor de 42 y los cinco siguientes con un valor de 99. Los valores asignados a cada elemento del array después del proceso de llenado se revelarán finalmente cuando se imprima el contenido de cada estante. El código muestra cómo la función ArrayFill() ofrece un método flexible para establecer valores predefinidos dentro de una estructura de array mediante la inicialización eficiente de segmentos de array dinámicos designados con valores predefinidos.

Nota: tanto ArrayFilд() como ArrayInitialize()” son funciones para trabajar con arrays en MQL5, pero tienen propósitos diferentes. ArrayFill()() está diseñado para rellenar un cierto rango de elementos del array con un valor dado. Permite realizar de forma efectiva la asignación masiva a un subconjunto de un array, por lo que resulta útil para modificar o inicializar selectivamente partes de un array. Por el contrario, ArrayInitialise() es una función más general que establece uniformemente los valores de todos los elementos del array completo. Posibilita el mismo estado inicial para todo el array, ofreciendo una forma rápida de inicializar todos los elementos con el mismo valor. Así, aunque ArrayFill() se especializa en asignaciones objetivo, ArrayInitialize() supone una herramienta más amplia para inicializar uniformemente un array entero.

11. ArrayIsDynamic

Para determinar si un array es dinámico o estático, MQL5 dispone de una útil herramienta, la función ArrayIsDynamic(). El tamaño de un array estático se fija durante la compilación, mientras que el de un array dinámico puede modificarse durante la ejecución. La función ArrayIsDynamic() determina si un array es dinámico o estático, y retorna una respuesta true o false dependiendo de la naturaleza del array. Con estos datos, el programa puede modificar su comportamiento según la flexibilidad del array, determinando si puede cambiar de tamaño mientras se ejecuta el programa.

Analogía

Un array es como una caja que puede contener varios objetos. Algunas cajas tienen una magia especial que les permite cambiar de tamaño para alojar más objetos o que estos ocupen menos espacio cuando sea necesario. Se denominan cajas dinámicas. Por el contrario, algunas cajas se ajustan al tamaño y no cambian bajo ninguna circunstancia. Estas se denominan cajas estáticas.

Para determinar si un bloque es dinámico o estático, podemos utilizar la función ArrayIsDynamic(). Sus resultados muestran si la caja es estática (su tamaño permanece constante) o dinámica (puede cambiar). Los programadores necesitan saber estas cosas porque tienen sentido a la hora de decidir cómo trabajar con la caja en el código. Si es estática, deberemos tener cuidado de no sobrepasar el tamaño fijado; si es dinámica, podremos aumentarlo o disminuirlo según necesitemos.

Sintaxis:

bool ArrayIsDynamic(array[]   // array to be checked);

Ejemplo:

void OnStart()
  {

// Declare a static array
   int staticArray[5];

// Declare a dynamic array
   int dynamicArray[];

// Check if the static array is dynamic
   bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);

   if(isStaticArrayDynamic)
     {
      Print("The staticArray is dynamic.");  // This message won't be printed.
     }
   else
     {
      Print("The staticArray is static, meaning its size is fixed.");
     }

// Check if the dynamic array is dynamic
   bool isDynamicArrayDynamic = ArrayIsDynamic(dynamicArray);

   if(isDynamicArrayDynamic)
     {
      Print("The dynamicArray is dynamic, meaning its size can be changed.");
     }
   else
     {
      Print("The dynamicArray is static.");  // This message won't be printed.
     }
     
  }

Explicación:

“int staticArray[5];”:

• Esta línea declara un array llamado staticArray con un tamaño fijo de 5 elementos.

“int dynamicArray[];”:

• Esta línea declara un array dinámico llamado dynamicArray sin indicar un tamaño fijo.

“bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);”:

• Esta línea usa la función ArrayIsDynamic() para comprobar si el array staticArray es dinámico y asigna el resultado isStaticArrayDynamic.

“bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);”:

• Esta línea usa la función ArrayIsDynamic() para comprobar si el array staticArray es dinámico y asigna el resultado isStaticArrayDynamic.

Muestra el resultado de un array estático:

• El siguiente bloque if-else emite un mensaje indicando si staticArray es dinámico o estático, basándose en el resultado del paso anterior.

“bool isDynamicArrayDynamic = ArrayIsDynamic(dynamicArray);”:

• Esta línea usa la función ArrayIsDynamic() para comprobar si el array dynamicArray es dinámico y asigna el resultado isDynamicArrayDynamic.

Obtiene el resultado del array dinámico:

• El siguiente bloque if-else emite un mensaje que indica si el array dynamicArray es dinámico o estático, basándose en el resultado del paso anterior.

El código muestra el uso de ArrayIsDynamic() para determinar si un array es dinámico o estático.

12. ArrayMaximum

La función ArrayMaximum() en MQL5 está diseñada para determinar el índice del elemento máximo en un array numérico. Esta función resulta especialmente útil cuando debemos determinar el valor máximo de un array. Iterando el array de forma eficiente, la función retorna el índice del elemento máximo dado el número de serie del array. En situaciones en las que el array representa datos financieros o técnicos, encontrar el valor máximo supone un paso muy importante para extraer información significativa o tomar decisiones comerciales.

Analogía

Imagine que tiene una lista de números, como los resultados de diferentes juegos a los que ha jugado. La función ArrayMaximum() mira su lista y le dice en qué partida lo ha hecho mejor. Así, si quiere saber qué partida ha obtenido la puntuación más alta, comprobará los resultados de cada una, encontrará el máximo de ellos y le dirá cuál es su mejor partida. Todo sin tener que repasar usted mismo toda la lista. En los programas informáticos, así es como se encuentra el número mayor de un grupo de números.

Sintaxis:

int ArrayMaximum(
    array[],       // Array for search
    start,          // Index to start checking with
    count = WHOLE_ARRAY    // Number of checked elements (default: search in the entire array)
);

Parámetros:

• array[] — array para el que deseamos encontrar el valor máximo.
• start — el parámetro permite especificar el índice en el array a partir del cual se desea iniciar la búsqueda del valor máximo.
• “count = WHOLE_ARRAY” — representa el número de elementos a considerar en la búsqueda. El valor por defecto WHOLE_ARRAY significa que la función buscará en todo el array.

Llamando a ArrayMaximum(array, start, count), la función encontrará el mayor elemento en el rango de array especificado y retornará su índice. Si no se encuentra ningún máximo, se retornará -1.

Ejemplo:

void OnStart()
  {
  
// Declare an array with integer values
   int myArray[] = {42, 18, 56, 31, 75, 23};

// Find the maximum value and its index
   int maxIndex = ArrayMaximum(myArray);

// Check if a maximum was found
   if(maxIndex != -1)
     {
      Print("The maximum value in the array is: ", myArray[maxIndex]);
      Print("Index of the maximum value: ", maxIndex);
     }
   else
     {
      Print("No maximum value found in the array.");
     }

  }

Explicación:

“int myArray[] = {42, 18, 56, 31, 75, 23};”:

• Esta línea declara un array de enteros llamada myArray y lo inicializa con seis valores enteros.

“int maxIndex = ArrayMaximum(myArray);”:

• La función ArrayMaximum() es llamada para myArray para encontrar el índice del valor máximo en el array. El resultado se guarda en la variable maxIndex.

“if (maxIndex != -1) {“:  

• Este operador condicional comprueba si se encuentra el valor máximo. Si maxIndex no es -1, significará que hay un valor máximo en el array.

“Print("The maximum value in the array is: ", myArray[maxIndex]);”:

• Si se detecta un valor máximo, se mostrará el valor máximo utilizando el índice obtenido de maxIndex.

“Print("Index of the maximum value: ", maxIndex);”:

• Esta línea muestra el índice del valor máximo.

“} else { Print("No maximum value found in the array."); }”:

• Si maxIndex es -1, lo cual ocurre cuando no se encuentra ningún valor máximo, se ejecuta este bloque, aparecerá un mensaje indicando que no se ha encontrado ningún valor máximo.

Para determinar el valor máximo y su índice en un array, utilizaremos ArrayMaximum() como se muestra en este código.

13. ArrayMinimum

La útil función ArrayMinimum() permite determinar el índice del elemento más pequeño (mínimo) de la primera dimensión de un array numérico. Esta función opera con arrays de diferentes tamaños. Ofrece resultados precisos al considerar el orden secuencial del array.

La función ArrayMinimum() está diseñada para encontrar el índice del elemento más pequeño del array. Retorna el índice del valor más pequeño dado el orden de los elementos en el array. La función retornará -1 si no se encuentra ningún valor mínimo durante la búsqueda. Esta función puede resultar útil cuando necesitamos determinar la posición exacta del elemento más pequeño de un array.

Sintaxis:

int ArrayMinimum(array[],start,count = WHOLE_ARRAY);

Ejemplo:

void OnStart()
  {

// Declare an integer array
   int myArray[] = {10, 5, 8, 3, 12};

// Find the index of the minimum element in the entire array
   int minIndex = ArrayMinimum(myArray, 0, WHOLE_ARRAY);

// Print the result
   Print("Index of the minimum element: ", minIndex);

  }

Al igual que con ArrayMaximum(), este código encontrará el índice del elemento mínimo en el array myArray e imprimirá el resultado.

Conclusión

En este artículo, nos hemos familiarizado con las funciones para trabajar con arrays en MQL5, y hemos visto sus capacidades y aplicación. Asimismo, hemos explorado varias funciones, desde la búsqueda y el copiado hasta el redimensionamiento y procesamiento de arrays de series temporales: ArrayBsearch, ArrayCopy, ArrayCompare, ArrayResize, ArrayFree, ArraySetAsSeries, ArrayGetAsSeries, ArrayInitialize, ArrayFill, ArrayIsDynamic, ArrayIsSeries, ArrayMaximum y ArrayMinimum. Cada función es importante al trabajar con arrays y potenciar los algoritmos comerciales.

Para terminar, querría señalar que no he abarcado deliberadamente todas las funciones de los arrays, para así ofrecer una experiencia de aprendizaje centrada y digerible. En el próximo artículo, veremos otras funciones de trabajo con arrays: ArrayPrint, ArrayRange, ArrayInsert, ArrayRemove, ArrayReverse, ArraySize, ArraySort, ArraySwap, ArrayToFP16, ArrayToFP8, ArrayFromFP16 y ArrayFromFP8. Este enfoque gradual pretende facilitar la curva de aprendizaje. ¡Nos vemos en el próximo artículo!