Introdução ao MQL5 (Parte 5): Um Guia para Iniciantes sobre Funções de Array em MQL5

Introdução

A Parte 5 da nossa série irá apresentá-lo ao fascinante mundo do MQL5, especialmente projetado para novatos completos que buscam uma introdução suave às complexidades das funções de array. Esta seção tem como objetivo desmantelar as concepções errôneas frequentemente associadas às funções de array, garantindo que cada linha de código seja não apenas entendida, mas compreendida minuciosamente. Independentemente da experiência anterior em codificação, acredito sinceramente que todos devem ter a oportunidade de aprender sobre a linguagem MQL5, razão pela qual estou sempre comprometido em criar um ambiente inclusivo.

Neste artigo, simplicidade e clareza são os temas principais. Quero servir como um canal para pessoas que estão curiosas sobre codificação e o território inexplorado dela. Embora possam ser confusas no início, pretendo guiá-lo através de cada função de array linha por linha para que você tenha uma experiência de aprendizado divertida e educativa. Juntos, desvendaremos os mistérios das funções de array e lhe forneceremos o conhecimento necessário para negociar com sucesso o complexo mundo do trading algorítmico. Este não é apenas um artigo — é um convite para uma incrível jornada de transformação na codificação. 

Mas as coisas não param por aqui. Além do código, esperamos criar uma comunidade onde tanto programadores novatos quanto experientes possam se reunir para trocar ideias, fazer perguntas e promover o trabalho em equipe. Este é um convite para uma aventura de codificação transformadora, não apenas um artigo. Bem-vindo à Parte 5, onde conhecimento e acessibilidade se encontram e todos que codificam são valorizados. Divirta-se com a codificação!

Neste artigo, cobriremos as seguintes funções de array:

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

Gostaria de compartilhar um vídeo que resume as lições que aprendemos na Parte 4 antes de entrarmos na Parte 5. Este é um resumo para garantir que todos estejam cientes da situação. Vamos continuar tornando os arrays MQL5 mais fáceis de entender para iniciantes absolutos enquanto construímos uma comunidade de apoio e compartilhamento de conhecimento. Embarque comigo nesta jornada de codificação!

1. ArrayBsearch

Você pode usar a função "ArrayBsearch()" para arrays que estão organizados em ordem crescente. Isso sugere ordenar os valores no array do menor para o maior em ordem crescente. A função emprega uma técnica de busca binária, que produz resultados confiáveis para arrays ordenados, mas pode não funcionar bem para arrays desordenados ou ordenados aleatoriamente. Portanto, para realizar buscas eficazes e precisas, você deve garantir que seu array esteja corretamente ordenado antes de usar "ArrayBsearch()".

Analogia

Assuma que você tem um conjunto de números que estão ordenados do menor para o maior em uma ordem específica. Imagine que você está tentando procurar um número específico nessa lista ordenada, digamos 30. Em vez de passar manualmente por cada número, a função "ArrayBsearch()" funciona como um consultor inteligente. Ela informa que 30 está localizado na posição 2 (Índice 2) na lista e rapidamente o direciona para o local apropriado. É como ter um amigo prestativo que agiliza metodicamente sua busca!

Síntaxe:

int ArrayBsearch(array[],value);

Explicação:

• “int": Este é o tipo de dado que a função retorna. Neste caso, é um inteiro, que representa o índice da posição encontrada ou sugerida do valor no array.
• “ArrayBsearch”: Este é o nome da função.
• “array[]”: Array a ser pesquisado.
• “value”: Este é o valor a ser pesquisado no array.

Exemplo:

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

  }

Explicação:

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

• Esta linha declara um array chamado "sortedArray" contendo números ordenados {10, 20, 30, 40, 50}.

“double searchValue = 30;”:

• Esta linha define o "searchValue" como 30, o número que queremos encontrar no array.

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

• Esta linha chama a função "ArrayBsearch()", passando o "sortedArray" e o "searchValue" como argumentos. Ela retorna o índice onde o "searchValue" é encontrado ou o ponto de inserção sugerido se o valor não estiver presente.

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

• Esta linha imprime o resultado da busca. Se o "searchValue" for encontrado, imprime o índice; caso contrário, imprime o ponto de inserção sugerido.

Neste exemplo, "sortedArray" é o array onde estamos procurando, e "searchValue" é o valor que queremos encontrar no array. A função retorna o índice onde o valor é encontrado e imprime o resultado.

2. ArrayResize

A função MQL5 "ArrayResize()" permite modificar o tamanho de um array dinâmico enquanto o programa está em execução. Os arrays dinâmicos permitem ajustes de tamanho durante a execução do programa, ao contrário dos arrays estáticos, cujo tamanho é predeterminado. Em outras palavras, "ArrayResize()" é uma ferramenta que permite redimensionar ou expandir um array dinâmico conforme suas necessidades no momento exato em que seu programa está sendo executado. Isso aumenta a flexibilidade para manipular dados durante a execução de maneira mais eficaz.

Os arrays estáticos na programação têm um tamanho fixo definido na fase de compilação do programa. O número de elementos permanece constante porque o tamanho é fixo e não pode ser alterado durante a execução. A memória alocada para esses arrays é determinada pelo tamanho no qual são declarados. Um array com cinco elementos, por exemplo, sempre teria espaço para cinco elementos.

Exemplo:

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

Por outro lado, os arrays dinâmicos oferecem flexibilidade, pois permitem que o tamanho seja ajustado ou determinado enquanto o programa está em execução. Esses arrays são declarados inicialmente sem um tamanho e, no MQL5, funções como "ArrayResize()" podem ser usadas para alterar a alocação de memória. Os arrays dinâmicos são especialmente úteis quando o tamanho de uma estrutura de dados precisa ser flexível para acomodar diferentes números de elementos conforme necessário durante a execução do programa.

Exemplo:

// Dynamic array declaration
int dynamicArray[];

Analogia

Vamos imaginar que você tem uma mochila mágica (array) que possui muitos brinquedos (elementos) dentro dela. Quando embarcar em uma aventura, você pode escolher quantos brinquedos uma mochila estática pode acomodar, e ela permanecerá assim durante toda a jornada. Você estará em apuros se quiser carregar mais brinquedos do que ela pode acomodar.

Uma mochila dinâmica pode ser vista como algo especial que pode crescer para acomodar brinquedos adicionais ou brinquedos que você deseja compartilhar com amigos. Para mudar o tamanho da sua mochila e carregar quantos brinquedos precisar para sua aventura mágica, use "ArrayResize()" como se fosse um feitiço.

Você pode mudar o tamanho da mochila dinâmica enquanto está fora de casa, então não está limitado a isso Essa adaptabilidade ajuda a garantir que sua jornada mágica esteja sempre cheia de surpresas e emoções, seja encontrando novos brinquedos ou decidindo compartilhá-los com outros! É como dizer para o array: "Ei, prepare-se para mais elementos!" ou "Tudo bem, vamos abrir espaço." Esse ajuste dinâmico que ocorre enquanto o programa está sendo executado oferece versatilidade e flexibilidade, tornando-o uma ferramenta inestimável para arrays cujo tamanho inicial é desconhecido.

Sintaxe:

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[]”: Esta é sua caixa de brinquedos (array) que você quer redimensionar.
• “new_size”: Este é o número de brinquedos (elementos) que você quer que sua caixa comporte agora. Se você tinha 5 brinquedos e queria espaço para 10, “new_size” seria 10.
•  “reserve_size = 0”: Às vezes, você pode querer fazer espaço para ainda mais brinquedos no futuro sem redimensionar novamente. O “reserve_size” é como dizer: "Ei, esteja pronto para mais brinquedos!"

Exemplo:

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

  }

Explicação:

Declaração de array dinâmico:

int dynamicArray[];

• Aqui, declaramos um array dinâmico chamado “dynamicArray” sem especificar seu tamanho inicial.

Redimensionando o Array Dinâmico para 5 Elementos:

ArrayResize(dynamicArray, 5);

• A função “ArrayResize()” é usada para definir o tamanho do array dinâmico para 5 elementos.

Atribuindo Valores aos Elementos do Array Dinâmico:

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

• Valores são atribuídos a elementos individuais do array dinâmico.

Acessando Elementos em um Array Dinâmico:

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

• A função “Print” é usada para exibir o valor no índice 2 do array dinâmico. Neste caso, ele imprimirá “30”.

Redimensionando o Array Dinâmico para 8 Elementos:

ArrayResize(dynamicArray, 8);

• O array dinâmico é redimensionado novamente para ter 8 elementos, e ele mantém os valores do redimensionamento anterior.

Atribuindo Valores aos Elementos Adicionais:

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

• Valores adicionais são atribuídos aos novos elementos adicionados após o redimensionamento.

Acessando Elementos após o Redimensionamento:

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

• A função “Print” é usada para exibir o valor no índice 6 do array dinâmico após o segundo redimensionamento. Neste caso, ele imprimirá “70”.

3. ArrayCopy

Em MQL5, a função "ArrayCopy()" é usada para duplicar elementos entre arrays. Ela permite replicar uma parte específica, definida por um intervalo, de um array em outro array de maneira seletiva. Esta função facilita o gerenciamento e a organização de dados dentro de arrays, tornando mais fácil extrair e mover elementos específicos entre arrays.

Analogia

Considere que você tem duas listas de itens e deseja copiar certos itens exatamente da primeira lista para a segunda. É aqui que a função "ArrayCopy()" do MQL5 é útil. Ela funciona como um assistente de cópia, permitindo que você selecione itens específicos de um array e os copie ordenadamente para outra lista.

Aqui está um exemplo mais concreto: imagine que você tem um array com cinco preços de itens diferentes e deseja criar um segundo array que contenha os preços de apenas três itens específicos. Você pode extrair e duplicar apenas esses três preços para um novo array enquanto mantém o array original, utilizando a função "ArrayCopy()". É como ter uma ferramenta útil que facilita a cópia e a seleção de itens de uma coleção para outra, aumentando a eficiência e a organização de suas tarefas de manipulação de arrays.

Síntaxe:

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

Este comando poderoso capacita você a mesclar arrays com precisão e controle. Neste processo encantador, “dst_array” serve como o destino onde os elementos serão copiados, e “src_array” atua como a origem de onde os elementos são retirados. Parâmetros adicionais como “dst_start”, “src_start” e “count” fornecem a flexibilidade para ajustar finamente a operação de mesclagem. Pense nisso como criar um comando que orquestra a fusão impecável de arrays no cativante domínio da programação MQL5!

Exemplo:

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

  }

Explicação:

Declaração de Arrays:

int sourceArray[];
int destinationArray[];

• Aqui, declaramos dois arrays dinâmicos chamados "sourceArray" e "destinationArray".
  

Redimensionamento de Arrays:

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

• A função “ArrayResize()” é usada para definir o tamanho dos arrays dinâmicos. Neste caso, ambos os arrays são redimensionados para ter 5 elementos cada.
  

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

• Valores são atribuídos a elementos individuais de “sourceArray” e “destinationArray”.
  

Cópia de Arrays:

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

• A função “ArrayCopy()” é utilizada para copiar elementos de “sourceArray” para “destinationArray”. Especifica a cópia de 5 elementos a partir do índice 0.
  

Imprimir Valor:

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

• Um comentário é impresso, exibindo o valor no índice 7 em “destinationArray”.
  

O objetivo geral do código é demonstrar a função “ArrayCopy()” copiando elementos de “sourceArray” para “destinationArray” a partir de índices específicos. A última linha imprime o valor de um elemento em “destinationArray” para confirmar a cópia bem-sucedida.

4. ArrayCompare

A função “ArrayCompare()” no MQL5 serve como uma ferramenta para comparar dois arrays e avaliar seus elementos sistematicamente. Ela inicia a comparação desde o início (índice 0) de ambos os arrays, verificando se os elementos nos índices correspondentes são iguais. Se todos os elementos coincidirem, os arrays são considerados iguais. No entanto, se surgir uma discrepância em algum índice, a função avalia qual array possui o elemento numericamente maior, fornecendo uma base para determinar sua relação. Esta função é particularmente útil para medir a similaridade ou dissimilaridade entre arrays em termos de seu conteúdo.

Analogia

Imagine um cenário onde você tem duas listas de números: Lista A e Lista B. "ArrayCompare()" funciona como uma espécie de investigador especializado, analisando essas listas e nos informando sobre suas relações. Começando com os números no início de ambas as listas, o investigador os compara. Quando detecta uma discrepância nos números, determina qual lista é "maior" ou "menor" imediatamente. Determina que as listas são "iguais" se puder revisar ambas as listas e não encontrar nada incomum.

 

Agora, o detetive tem uma maneira única de relatar suas descobertas:

• Se a Lista A for considerada menor que a Lista B, ele relata -1.
• Se ambas as listas forem consideradas iguais, o relatório é 0.
• Se a Lista A for considerada maior que a Lista B, o relatório é 1.
• Se houver qualquer confusão ou problema durante a investigação, ele relata -2.

Então, “ArrayCompare()” nos ajuda a entender a relação entre duas listas de números, assim como um detetive descobrindo quem é quem em um caso.

Síntaxe:

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

Parâmetros:

• array1[]: Primeiro array.
•  array2[]: Segundo array.
• start1: O índice do elemento inicial no primeiro array a partir do qual a comparação começa. O índice inicial padrão é 0.
• start2: O índice do elemento inicial no segundo array a partir do qual a comparação começa. O índice inicial padrão é 0.
• count: O número de elementos a serem comparados. Todos os elementos de ambos os arrays participam da comparação por padrão (count = WHOLE_ARRAY).

Exemplo:

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

  }

Explicação:

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

• Declara um array de inteiros chamado “ListA” e o inicializa com os valores 1, 2, 3, 4 e 5.

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

• Declara um array de inteiros chamado “ListB” e o inicializa com os valores 1, 2, 3, 4 e 6.

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

• Usa a função “ArrayCompare()” para comparar os arrays “ListA” e “ListB”. A comparação começa do índice 0 de ambos os arrays e compara os arrays inteiros.

As declarações condicionais (“if”, “else if”) verificam o valor da variável result e imprimem mensagens com base no resultado da comparação:

• Se “result” for “-1”, isso significa que “ListA” é considerado menor que “ListB”.
• Se “result” for “0”, isso significa que “ListA” é igual a “ListB”.
• Se “result” for “1”, isso significa que “ListA” é considerado maior que “ListB”.
• Se “result” for “-2”, isso indica um erro devido a arrays incompatíveis ou parâmetros inválidos.

Dado os arrays:

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

O resultado de “ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY)” será -1.

Explicação:

• A comparação começa no primeiro elemento (índice 0) de ambos os arrays.
• Os elementos nos índices de 0 a 3 são os mesmos em ambos os arrays.
• No índice 4, ListA tem 5, enquanto ListB tem 6.
• Como 5 < 6, ListA é considerado menor que ListB.

Portanto, o resultado será -1. Sinta-se à vontade para modificar os valores em ListA e ListB para ver como o resultado da comparação muda!

5. ArrayFree

Em MQL5, chamar “ArrayFree()” é semelhante a pressionar o botão de reset para seu array dinâmico. Considere seu array como um recipiente para diferentes itens. É como esvaziar o recipiente e prepará-lo para conter novos itens ao usar “ArrayFree()”. É um meio de liberar espaço para novos dados, eliminando informações desatualizadas. De uma forma diferente, pense nisso como limpar a lousa para o que vem a seguir. Ao usar esta função, você pode ter certeza de que seu array está vazio e preparado para novas experiências de programação em MQL5.

Analogia

Imagine que você tem uma bolsa mágica — seu array. Às vezes, você quer usá-la para diferentes coisas, como coletar brinquedos. Mas antes de pegar novos brinquedos, você precisa garantir que a bolsa esteja vazia. É isso que “ArrayFree()” faz — agita uma varinha e limpa sua bolsa para que você possa colocar novos brinquedos ou números. É como dizer: “Ok, bolsa, prepare-se para mais coisas legais!” Assim, você está pronto para novas aventuras com sua bolsa mágica no mundo do MQL5.

Síntaxe:

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

Exemplo:

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

  }

Explicação:

Declare um array dinâmico:

int dynamicArray[];

• Inicializa um array dinâmico vazio.
  

Redimensione e atribua valores:

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

• Redimensiona o array dinâmico para ter 5 elementos e atribui valores a cada elemento.
  

Imprima elementos antes de liberar:

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

• Imprime o valor no primeiro índice do array, que é 10.
  

Liberar o array dinâmico:

ArrayFree(dynamicArray);

• Libera a memória ocupada pelo array dinâmico.
  

Tentar acessar elementos após liberar:

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

• Esta linha está comentada para evitar erros em tempo de execução, já que o array foi liberado.
  

Atribuir novos valores:

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

• Redimensiona o array para 3 elementos e atribui novos valores a cada elemento.
  

Imprimir elementos após reatribuir valores:

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

• Imprime o novo valor no primeiro índice do array, que é 100.
  

Neste exemplo, após liberar o array dinâmico usando “ArrayFree()”, redimensionamos novamente para ter 3 elementos e atribuímos novos valores a esses elementos. Isso demonstra como você pode reutilizar um array dinâmico após liberá-lo.

Há mais magia a ser descoberta enquanto trabalhamos nas complexidades das funções de arrays do MQL5. Fique atento para explorações aprofundadas de mais recursos que melhorarão sua proficiência com o código. O caminho está longe de acabar, independentemente do seu nível de experiência como desenvolvedor. À medida que nos aprofundamos nas maravilhas nas próximas seções, descobertas empolgantes estão por vir. Vamos continuar essa jornada de codificação juntos enquanto você mantém sua curiosidade!

6. ArraySetAsSeries

Na programação MQL5, “ArraySetAsSeries()” é uma função que permite modificar a direção de indexação de um array. Usando esta função, você pode definir o array para ser acessado do fim para o começo, alterando a direção padrão para frente. Isso é particularmente útil ao lidar com dados financeiros ou outros arrays onde acessar elementos em ordem cronológica inversa é benéfico.

Nota: É importante notar que este encantamento funciona especificamente em arrays dinâmicos, aqueles que podem ajustar seu tamanho graciosamente durante o tempo de execução.

Analogia

Imagine que você tem uma pilha de livros de histórias encantadas cuidadosamente arrumados em uma prateleira. Cada livro é como um número especial, esperando que você explore sua história emocionante. Normalmente, você lê as histórias na ordem em que aparecem na prateleira, começando pelo primeiro livro e indo em direção ao último.

Imagine que você quer embarcar em uma jornada para descobrir a história mais recente que você adicionou à sua coleção sem tirar todos os livros da prateleira. É aí que entra o encantamento do “ArraySetAsSeries()”! Quando você lança esse feitiço na sua prateleira (array), é como dizer: "Vamos reorganizar as histórias para que a mais nova que você adicionou apareça magicamente primeiro." Isso é especialmente útil quando suas histórias (números) mudam ao longo do tempo, como registrar quantos novos livros você coleciona a cada dia. Com "ArraySetAsSeries()," você pode abrir o livro de histórias mais recente primeiro e viajar de volta pela sua biblioteca mágica para ver como sua coleção cresceu. É como ter um feitiço de leitura reversa para suas aventuras literárias extraordinárias!

Síntaxe:

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

Parâmetros:

• “array[]”: Este é o array que você deseja encantar com propriedades de séries temporais. É como selecionar o artefato mágico que você deseja imbuir com poderes especiais.
• “bool flag”: Este é um valor booleano. Quando configurado como “true”, ele ativa a reversão mística da indexação, transformando o array em uma maravilha de séries temporais onde o último elemento se torna o primeiro. Se configurado como “false”, o array se comporta de maneira regular, não mágica.

Exemplo:

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

  }

Explicação:

Declaração de array dinâmico:

double magicalArray[];

• Declara um array dinâmico chamado “magicalArray” sem especificar seu tamanho.
  

Atribuir Valores ao Array:

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

• Redimensionamos o array para ter 5 elementos.
  
• Em seguida, atribuímos valores específicos a cada elemento do array.
  

Imprimir Elementos antes de Configurar como Série:

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

• Esta seção imprime os valores de cada elemento do array antes de configurá-lo como uma série.
  

Configurar o Array como uma Série:

ArraySetAsSeries(magicalArray, true);

• Usamos “ArraySetAsSeries()” para configurar o array como uma série. O segundo parâmetro “true” indica a ordem inversa de indexação.
  

Imprimir Elementos após Configurar como Série:

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

• Finalmente, imprimimos os valores de cada elemento após configurar o array como uma série. A ordem de impressão reflete a indexação inversa devido à configuração como série.
  

Resumindo, o código demonstra como atribuir valores a um array dinâmico, imprimir seus elementos antes e depois de configurá-lo como uma série e observar a mudança na ordem de indexação.

Na jornada encantadora da programação MQL5, exploramos a função mágica “ArraySetAsSeries()”. É como agitar uma varinha para reverter a ordem das capacidades de viagem no tempo de um array! Lembre-se de que a prática leva à perfeição enquanto encerramos este capítulo. Tente coisas novas, leia devagar e sinta-se à vontade para fazer perguntas. Você pode obter assistência da comunidade em suas aventuras mágicas de codificação. Para mais codificação, saúde!"

7. ArrayGetAsSeries

A função “ArrayGetAsSeries()” no MQL5 é usada para determinar se um array tem o flag AS_SERIES definido. Este flag afeta a ordem em que os elementos do array são acessados. Se a função retornar true, isso indica que os elementos são acessados em ordem inversa; caso contrário, se retornar false, o array mantém sua ordem padrão. Esta função é útil ao lidar com arrays onde a sequência de acesso aos dados é crucial, e ela fornece uma maneira de verificar e adaptar o padrão de acesso aos dados com base na configuração do array.

Analogia

Imagine que você tem uma lista mágica de números e, às vezes, essa lista gosta de jogar um jogo especial chamado "Viagem no Tempo." Quando você pergunta a esta ferramenta mágica, "ArrayGetAsSeries()", ela te diz se a sua lista está jogando ou não. Se ela disser "true", significa que a lista está jogando e você lê os números de trás para frente, como uma contagem regressiva. Se ela disser "false", a lista está normal e você lê os números do início ao fim, como uma contagem crescente. Então, isso te ajuda a entender as regras da sua lista mágica!

Síntaxe:

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

Exemplo:

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.");
     }

  }

Explicação:

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

• Estas linhas declaram dois arrays dinâmicos chamados “timeSeriesArray” e “regularArray”. Arrays dinâmicos no MQL5 podem mudar de tamanho durante a execução.
  

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

• Estas linhas usam a função “ArrayResize()” para definir o tamanho de ambos os arrays para 5 elementos. Esta etapa garante que os arrays tenham espaço suficiente para armazenar 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;

• Estas linhas atribuem valores específicos aos elementos de ambos os arrays. “timeSeriesArray” recebe valores em ordem crescente, enquanto “regularArray” recebe valores em ordem decrescente.
  

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

• Esta linha usa a função “ArraySetAsSeries()” para definir o sinalizador de série temporal para “timeSeriesArray” como “true”. Isso significa que os elementos em “timeSeriesArray” serão acessados de trás para frente.
  

// 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.");
    }

• O trecho de código fornecido verifica se os arrays dinâmicos, “timeSeriesArray” e “regularArray”, aderem à convenção de série temporal usando instruções condicionais. Ele utiliza a função “ArrayGetAsSeries()” para determinar se o sinalizador de série temporal está definido para cada array. A primeira instrução “if” verifica “timeSeriesArray” e, se for identificado como uma série temporal, uma mensagem correspondente é impressa indicando que seus elementos são acessados de trás para frente. Caso contrário, o bloco “else” imprime uma mensagem afirmando que “timeSeriesArray” mantém sua ordem original, e os elementos são acessados de frente para trás. O processo é repetido para “regularArray”. Esta verificação condicional é crucial para entender como os elementos dentro desses arrays dinâmicos são indexados, fornecendo insights valiosos sobre a direção do acesso ao array.
  

Compreender as complexidades de “ArrayGetAsSeries()” é uma habilidade valiosa em MQL5. Quer você esteja navegando por dados de séries temporais ou trabalhando com arrays em sua ordem original, essas funções o capacitam em sua jornada de negociação algorítmica. Como iniciante, você deve fazer perguntas, e com isso, podemos construir a comunidade juntos. Feliz codificação!

8. ArrayIsSeries

Ao determinar se um array em MQL5 representa uma série temporal, a função "ArrayIsSeries()" é essencial. Um array que contém dados relacionados ao tempo é chamado de série temporal em programação financeira e é frequentemente usado para armazenar valores de preço, como preços de abertura, alta, baixa e fechamento. Quando uma série temporal é detectada, a função analisa o array fornecido e retorna "true"; caso contrário, retorna "false". Esta determinação é essencial ao trabalhar com dados financeiros em um gráfico, onde entender a natureza temporal dos dados é crucial.

Ao criar indicadores personalizados em MQL5, especialmente no contexto da análise técnica, torna-se essencial diferenciar entre arrays regulares e arrays de séries temporais. A função “ArrayIsSeries()” simplifica esse processo, permitindo que os desenvolvedores adaptem seu código com base em se o array contém informações dependentes do tempo. Esta função contribui para a eficiência e precisão das estratégias de negociação algorítmica, ferramentas de análise técnica e outras aplicações financeiras desenvolvidas usando a linguagem MQL5.

Diferença entre ArrayGetAsSeries e ArrayIsSeries

Tanto “ArrayGetAsSeries()” quanto “ArrayIsSeries()” são funções que se relacionam ao comportamento de arrays, mas servem a propósitos distintos. “ArrayGetAsSeries()” é utilizada para verificar se o indexamento de um array está configurado para recuperar elementos de trás para frente, comumente referido como ordem reversa. Esta função é valiosa ao manipular arrays, permitindo que os desenvolvedores verifiquem se os dados são acessados de maneira cronológica ou invertida. Ela retorna “true” se o array estiver configurado como uma série (acessado em ordem reversa) e “false” caso contrário.

Por outro lado, “ArrayIsSeries()” está focada em identificar se um array é uma série temporal. Arrays de séries temporais são prevalentes na programação financeira, representando dados como preços de abertura, alta, baixa e fechamento ao longo do tempo. Diferente de “ArrayGetAsSeries()”, “ArrayIsSeries()” não se preocupa com a direção do indexamento do array. Em vez disso, ela verifica se o array contém informações relacionadas ao tempo. Se o array for uma série temporal, retorna “true”; caso contrário, retorna “false”. Essas funções se complementam ao fornecer um conjunto abrangente de ferramentas para lidar com o comportamento de arrays, oferecendo flexibilidade ao lidar com diversos tipos de dados financeiros em sistemas de negociação algorítmica e ferramentas de análise técnica.

Analogia

Imagine que você tem uma lista de coisas, como os preços dos seus brinquedos favoritos, todos os dias. Agora, se quisermos saber se essa lista é especial e relacionada ao tempo, assim como uma história, podemos usar o feitiço mágico chamado “ArrayIsSeries()”. Esse feitiço verifica se nossa lista tem um toque de viagem no tempo, tornando-a uma "série temporal". Ele não se importa se a lista é lida de trás para frente ou de frente para trás; está mais interessado em saber se é como uma aventura no tempo.

Então, se o feitiço disser "true", significa que nossa lista é como um conto de viagem no tempo, talvez mostrando os preços dos brinquedos ao longo dos dias. Mas se disser "false", nossa lista pode ser apenas uma coleção regular de números sem qualquer magia relacionada ao tempo. É como perguntar, "Essa lista é uma história especial de viagem no tempo?" E o feitiço nos dá uma resposta simples — sim ou não!

Síntaxe:

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

Exemplo:

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.");
     }

  }

Explicação:

// Declare an array
double priceSeries[];

• Esta linha declara um array dinâmico vazio chamado “priceSeries” para armazenar valores do 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;

• Aqui, o array é redimensionado para ter 5 elementos, e valores específicos são atribuídos a cada elemento. Esses valores representam uma série temporal hipotética.
  

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

• Esta linha usa a função “ArrayIsSeries()” para verificar se o array “priceSeries” é considerado uma série temporal. O resultado (“true” ou “false”) é armazenado na variável booleana “isSeries”.
  

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

• Finalmente, o código imprime uma mensagem indicando se o array é considerado uma série temporal com base no resultado obtido de “ArrayIsSeries()”. Se for uma série temporal, imprime uma mensagem; caso contrário, imprime outra mensagem.
  

A saída neste caso é 'Este array não é uma série temporal.' Por quê? Porque nosso array não representa uma série temporal, mesmo após atribuir valores a ele. Percebo que, no início, especialmente para iniciantes, isso pode parecer um pouco confuso. Mas por enquanto, vamos manter as coisas simples. Perguntas são bem-vindas enquanto investigamos mais e aprendemos juntos.

9. ArrayInitialize

“ArrayInitialize()” é uma função em MQL5 que define os valores iniciais de todos os elementos em um array numérico para um valor preset especificado. Em vez de atribuir manualmente o mesmo valor a cada elemento um por um, “ArrayInitialize()” simplifica o processo aplicando o valor escolhido a todos os elementos de uma vez. Esta função é útil para preparar um array com um ponto de partida consistente, especialmente ao lidar com dados numéricos onde a inicialização uniforme é necessária. Lembre-se de que ela apenas define os valores iniciais e não afeta elementos reservados ou futuras expansões feitas usando “ArrayResize()”.

Analogia

Imagine que você tem um conjunto de contêineres mágicos chamados arrays, e cada contêiner tem alguns espaços especiais dentro para armazenar valores. Agora, quando você quer começar com um valor específico em todos esses espaços, você usa um comando especial chamado “ArrayInitialize()”. Este comando define magicamente o valor inicial que você deseja em todos aqueles espaços de uma vez, economizando o esforço de fazer isso para cada espaço individualmente.

No entanto, aqui está a parte interessante: se mais tarde você decidir tornar esses contêineres maiores e adicionar mais espaços a eles usando outro comando mágico (ArrayResize), os novos espaços estarão lá, mas não terão os mesmos valores mágicos que os originais. Você terá que escolher os valores a serem inseridos em cada um separadamente, pois eles serão ligeiramente diferentes. É semelhante a expandir o espaço interno do seu castelo — você nem sempre decora os novos cômodos com os mesmos móveis dos antigos.

Síntaxe:

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

Exemplo:

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


  }

Explicação:

// Declare a dynamic array
   int myArray[];

• Aqui, declaramos um array dinâmico de inteiros chamado “myArray”. Ele não possui um tamanho pré-definido.
  

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

• Redimensionamos “myArray” para ter um tamanho inicial de 3 elementos. Isso significa que alocamos memória para três inteiros no array.
  

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

• Antes de inicializar o array, atribuiremos manualmente valores aos seus elementos. Neste caso, definimos “myArray[0]” como 10, “myArray[1]” como 20 e “myArray[2]” como 30.
  

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

• Agora, usamos a função “ArrayInitialize()” para definir todos os elementos de “myArray” para o valor especificado, que é 0 neste caso.
  

// 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

• Imprimimos os valores de todos os elementos em “myArray” após a inicialização. Como esperado, todos os elementos agora estão definidos como 0.
  

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

• Em seguida, redimensionamos “myArray” para ter um total de 5 elementos. Isso significa que o array agora pode acomodar dois elementos a mais.
  

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

• Após o redimensionamento, atribuímos valores aos elementos adicionais (“myArray[3]” e “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, imprimimos os valores de todos os elementos em “myArray” após o redimensionamento, incluindo os novos elementos adicionados.
  

Uma ferramenta poderosa que permite aos programadores definir o valor de cada elemento em um array para um valor especificado é a função "ArrayInitialize()" em MQL5. Isso garante um ponto de partida consistente para cada elemento do array e fornece clareza e controle sobre o estado inicial do array. Lembre-se de que a função inicializa cada elemento com o mesmo número especificado. Isso pode parecer simples, mas é um passo importante na configuração de arrays para diferentes tipos de aplicações. Em artigos futuros, vamos nos aprofundar no campo da negociação algorítmica, o que destacará a importância de "ArrayInitialize()". Mantenha o foco e aproveite sua codificação!

10. ArrayFill

“ArrayFill()” é uma função em MQL5 que desempenha um papel vital na simplificação das tarefas de manipulação de arrays. Esta função permite que os desenvolvedores preencham de forma eficiente um intervalo de elementos do array com um valor especificado, eliminando a necessidade de iteração e atribuição manual. Em vez de escrever várias linhas de código para definir individualmente cada elemento, “ArrayFill()” fornece uma solução concisa e eficaz. Essa capacidade melhora a legibilidade do código e reduz as chances de erros, especialmente ao lidar com grandes arrays ou atribuições repetitivas. A habilidade da função em preencher rapidamente os elementos do array com um valor comum agiliza o processo de codificação, tornando-a uma ferramenta valiosa para lidar com vários cenários onde a inicialização em massa é necessária.

Analogia

Vamos supor que você tem uma caixa com vários compartimentos e deseja usar alguns desses compartimentos para o mesmo brinquedo sem ter que passar por cada um individualmente. Como um feitiço mágico, "ArrayFill()" permite que você escolha um brinquedo e instruir para "Preencher esses compartimentos com esse brinquedo." Assim, você pode colocar todos os brinquedos de uma vez, em vez de colocar cada um individualmente! É semelhante a dizer a alguém que tem uma coleção de carros de brinquedo: "Preencha os primeiros cinco compartimentos com carros vermelhos e os próximos cinco com carros azuis." Esse truque mágico que economiza tempo ajuda a manter a ordem na sua caixa de brinquedos!

Síntaxe:

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[]”: Este é o seu conjunto de prateleiras.
• “start”: Isso é como especificar a primeira prateleira onde você quer começar a colocar os itens. Você fornece o índice ou a posição.
•  “count”: É como dizer, "Eu quero colocar este item nas próximas X prateleiras." Você determina o número de prateleiras a preencher.
• “value”: Este é o item que você quer colocar nas prateleiras. Pode ser qualquer item – um número, uma cor ou qualquer coisa que caiba nas prateleiras.

Exemplo:

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

  }

Explicação:

“int roomShelves[];”:

• Declara um array de inteiros chamado “roomShelves” para representar as prateleiras em um quarto.

“ArrayResize(roomShelves, 10);”:

• Redimensiona o array “roomShelves” para ter 10 elementos, representando 10 prateleiras na sala.

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

• Preenche as primeiras 5 prateleiras (índices de 0 a 4) com o valor 42, representando livros nessas prateleiras.

“ArrayFill(roomShelves, 5, 5, 99);”:

• Preenche as próximas 5 prateleiras (índices de 5 a 9) com o valor 99, representando brinquedos nessas prateleiras.

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

• Imprime uma mensagem indicando que as próximas linhas exibirão o conteúdo das prateleiras.

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

• Imprime o conteúdo de cada prateleira, exibindo o índice da prateleira e seu valor correspondente.

Este código MQL5 ilustra como preencher um array dinâmico chamado "roomShelves" usando a função "ArrayFill()". Inicialmente, o array foi redimensionado para ter dez prateleiras. O próximo passo envolve usar "ArrayFill()" para preencher as primeiras cinco prateleiras com 42 e as próximas cinco prateleiras com 99. Os valores atribuídos a cada elemento do array após o processo de preenchimento são finalmente revelados quando o conteúdo de cada prateleira é impresso. O código demonstra como "ArrayFill()" oferece um método flexível para definir valores predefinidos dentro de uma estrutura de array, inicializando de maneira eficaz segmentos designados de um array dinâmico com valores predefinidos.

Nota: “ArrayFill()” e “ArrayInitialize()” são ambas funções de manipulação de arrays no MQL5, mas servem a propósitos distintos. “ArrayFill()” é projetado para preencher um intervalo específico de elementos dentro de um array com um valor determinado. Permite uma atribuição eficiente em massa a um subconjunto do array, tornando-o útil para modificar ou inicializar partes do array seletivamente. Em contraste, “ArrayInitialize()” é uma função mais geral que define uniformemente o valor de todos os elementos no array inteiro. Ela garante um estado inicial consistente para todo o array, fornecendo uma maneira rápida de inicializar todos os elementos com o mesmo valor. Então, enquanto “ArrayFill()” é especializado para atribuições direcionadas, “ArrayInitialize()” é uma ferramenta mais ampla para inicialização uniforme em todo o array.

11. ArrayIsDynamic

Para determinar se um array é dinâmico ou estático, uma ferramenta útil no MQL5 é a função "ArrayIsDynamic()". O tamanho de um array estático é fixo no momento da compilação, enquanto o tamanho de um array dinâmico pode ser alterado durante a execução. "ArrayIsDynamic()" determina se um array é dinâmico ou estático e retorna uma resposta simples "true" ou "false" dependendo da natureza do array. Com o uso dessa informação, o programa pode modificar seu comportamento de acordo com a flexibilidade do array, determinando se seu tamanho pode ser alterado enquanto o programa está em execução.

Analogia

Um array é semelhante a uma caixa mágica no mundo da programação que pode conter vários objetos. Algumas caixas possuem uma magia especial que permite redimensioná-las para caber mais itens ou ocupar menos espaço quando necessário. Essas são chamadas de caixas dinâmicas. Por outro lado, algumas caixas têm tamanho fixo e não mudam de tamanho em nenhuma circunstância. Essas são chamadas de caixas estáticas.

Agora, para determinar se uma caixa é dinâmica ou estática, você pode usar a função semelhante a um feiticeiro chamada "ArrayIsDynamic()". Os resultados desse feitiço indicam se a caixa é estática — seu tamanho permanece constante — ou dinâmica — pode mudar de tamanho. Os programadores precisam saber disso porque faz sentido ao decidir como manipular a caixa em seu código mágico. Se for estática, eles devem ter cuidado para não ultrapassar seu tamanho fixo; se for dinâmica, podem fazer com que cresça ou encolha conforme necessário.

Síntaxe:

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

Exemplo:

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.
     }
     
  }

Explicação:

“int staticArray[5];”:

• Esta linha declara um array chamado “staticArray” com um tamanho fixo de 5 elementos.

“int dynamicArray[];”:

• Esta linha declara um array dinâmico chamado “dynamicArray” sem especificar um tamanho fixo.

“bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);”:

• Esta linha usa a função “ArrayIsDynamic()” para verificar se “staticArray” é dinâmico e atribui o resultado a “isStaticArrayDynamic”.

“bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);”:

• Esta linha usa a função “ArrayIsDynamic()” para verificar se “staticArray” é dinâmico e atribui o resultado a “isStaticArrayDynamic”.

Imprima o resultado para o array estático:

• O bloco “if-else” subsequente imprime uma mensagem indicando se “staticArray” é dinâmico ou estático com base no resultado obtido na etapa anterior.

“bool isDynamicArrayDynamic = ArrayIsDynamic(dynamicArray);”:

• Esta linha usa a função “ArrayIsDynamic()” para verificar se “dynamicArray” é dinâmico e atribui o resultado a “isDynamicArrayDynamic”.

Imprima o resultado para o array dinâmico:

• O bloco “if-else” subsequente imprime uma mensagem indicando se “dynamicArray” é dinâmico ou estático com base no resultado obtido na etapa anterior.

O código demonstra o uso de “ArrayIsDynamic()” para determinar se um array é dinâmico ou estático.

12. ArrayMaximum

A função “ArrayMaximum()” no MQL5 é uma ferramenta poderosa projetada para identificar o índice do elemento máximo dentro de um array numérico. Essa função se mostra particularmente útil em cenários onde determinar o valor mais alto é crucial para a tomada de decisões. Ao pesquisar eficientemente no array, a função retorna o índice do elemento máximo, levando em consideração a ordem serial do array Em situações onde o array representa dados financeiros ou técnicos, encontrar o valor máximo é um passo fundamental para extrair insights significativos ou tomar decisões de negociação informadas.

Analogia

Imagine que você tem uma lista de números, como as pontuações de diferentes jogos que você jogou. A função “ArrayMaximum()” é como um pequeno ajudante que olha pela sua lista e te diz em qual jogo você teve o melhor desempenho. Então, se você quer saber qual jogo teve a maior pontuação, esse ajudante verifica cada pontuação e, quando encontra a maior, aponta para esse jogo e diz: “Este é o seu melhor jogo!” É como ter um amigo que rapidamente encontra o jogo onde você se saiu melhor, sem você precisar passar por toda a lista sozinho. Nos programas de computador, esse ajudante é útil para encontrar o maior número em um conjunto de números.

Síntaxe:

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[]”: Este é o array para o qual você deseja encontrar o valor máximo.
• “start": Este parâmetro permite especificar o índice no array a partir do qual você deseja começar a busca pelo valor máximo.
• “count = WHOLE_ARRAY”: Representa o número de elementos a serem considerados na busca. O valor padrão “WHOLE_ARRAY” significa que a função irá buscar no array inteiro.

Agora, quando você chama “ArrayMaximum(array, start, count)”, a função encontrará o maior elemento na faixa especificada do array e retornará seu índice. Se nenhum máximo for encontrado, ela retornará -1.

Exemplo:

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.");
     }

  }

Explicação:

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

• Esta linha declara um array de inteiros chamado “myArray” e o inicializa com seis valores inteiros.

“int maxIndex = ArrayMaximum(myArray);”:

• A função “ArrayMaximum()” é chamada em “myArray” para encontrar o índice do valor máximo no array. O resultado é armazenado na variável “maxIndex”.

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

• Esta instrução condicional verifica se um valor máximo foi encontrado. Se “maxIndex” não for igual a “-1”, significa que um valor máximo existe no array.

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

• Se um valor máximo for encontrado, esta linha imprime o valor máximo usando o índice obtido de “maxIndex”.

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

• Esta linha imprime o índice do valor máximo.

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

• Quando maxIndex é -1, o que ocorre quando nenhum valor máximo é encontrado, este bloco é executado e uma mensagem informando que nenhum valor máximo foi encontrado é impressa.

Para determinar o valor máximo e seu índice em um array, utilize "ArrayMaximum()" como este código ilustra.

13. ArrayMinimum

Uma função útil em MQL5 chamada "ArrayMinimum()" permite determinar o índice do menor (mínimo) elemento na primeira dimensão de um array numérico. Esta função trabalha com arrays de diferentes tamanhos e é muito flexível. Ela garante resultados precisos ao levar em consideração a ordem serial do array.

"ArrayMinimum()" é usada principalmente para encontrar o índice do menor elemento no array. Ela fornece o índice do valor mais baixo enquanto considera a ordem dos elementos do array. A função retorna -1 se nenhum valor mínimo for encontrado na busca. Quando você precisa determinar a localização exata do menor elemento dentro de um array, esse recurso pode ser útil.

Síntaxe:

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

Exemplo:

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

  }

Assim como em "ArrayMaximum()", este código encontrará o índice do menor elemento em todo o "myArray" e imprimirá o resultado.

Conclusão

Neste artigo, discutimos o mundo das funções de array em MQL5, desvendando suas funcionalidades e aplicações. Desde busca e cópia até redimensionamento e manipulação de arrays de séries temporais, exploramos uma variedade de funções, incluindo ArrayBsearch, ArrayCopy, ArrayCompare, ArrayResize, ArrayFree, ArraySetAsSeries, ArrayGetAsSeries, ArrayInitialize, ArrayFill, ArrayIsDynamic, ArrayIsSeries, ArrayMaximum e ArrayMinimum. Cada função desempenha um papel crucial na manipulação de arrays e na melhoria das capacidades dos algoritmos de negociação.

Ao concluir este artigo, é importante notar que intencionalmente não cobri todas as funções de array para garantir uma experiência de aprendizado focada e compreensível. O próximo artigo expandirá nossas funções de array, como ArrayPrint, ArrayRange, ArrayInsert, ArrayRemove, ArrayReverse, ArraySize, ArraySort, ArraySwap, ArrayToFP16, ArrayToFP8, ArrayFromFP16 e ArrayFromFP8. Essa abordagem gradual visa facilitar um aprendizado mais suave. Então, prepare-se para o próximo artigo, onde continuaremos nossa exploração das funções de array em MQL5!