Введение в MQL5 (Часть 5): Функции для работы с массивами для начинающих

Введение

В пятой части нашей серии мы познакомимся с функциями для работы с массивами. Эта статья специально для новичков. Мы постараемся развеять мифы о функциях массивов и объяснить каждую строку кода максимально понятно. Неважно, есть ли у вас опыт программирования, я хочу, чтобы каждый мог изучить язык MQL5, поэтому стремлюсь сделать обучение доступным для всех.

Главное в этой статье — простота и ясность. Я хочу помочь тем, кто интересуется программированием. Хотя тема может показаться сложной, мы будем изучать каждую функцию массива по одной строке, чтобы процесс обучения был интересным и полезным. Мы вместе будем решать задачи и учиться применять знания в алгоритмической торговле. Это не просто статья — это приглашение начать изучение программирования.

Кроме того, я хочу собрать группу единомышленников, где новички и опытные программисты смогут обмениваться идеями, задавать вопросы и решать задачи вместе. Это не просто статья, а приглашение к командному программированию. Итак, давайте начнем изучать новый материал и наслаждаться программированием!

В этой статье мы рассмотрим следующие функции для работы с массивами:

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

Это уже не первая статья в серии, поэтому, прежде чем перейти к основному материалу, я бы хотел поделиться видео, в котором собран материал из Части 4. Освежим знания, что бы у каждого читателя была необходимая база. Рассмотрим с вами различные аспекты массивов в MQL5. Итак, начнем!

1. ArrayBsearch

Функцию ArrayBsearch() можно использовать для массивов, расположенных в порядке возрастания. Это предполагает сортировку значений в массиве от наименьшего к наибольшему в порядке возрастания. В функции используется метод двоичного поиска, который надежно выдает результаты для отсортированных массивов, но может работать не так хорошо для несортированных или случайно упорядоченных массивов. Поэтому для выполнения эффективного и точного поиска нужно убедиться, что массив правильно отсортирован, прежде чем использовать ArrayBsearch().

Аналогия

Предположим, у вас есть набор чисел, отсортированных от наименьшего к наибольшему в определенном порядке. Представьте, что вы пытаетесь найти в этом отсортированном списке определенное число, скажем, 30. Вместо того чтобы вручную перебирать каждое число, функция ArrayBsearch() действует умнее. Она сообщает, что 30 находится на позиции 2 (индекс 2) в списке, и быстро направляет в нужное место. Это как полезный помощник, который методично ускоряет ваш поиск.

Синтаксис:

int ArrayBsearch(array[],value);

Объяснение:

• “int" — тип данных, которые возвращает функция. В данном случае это целочисленное значение, представляющее собой индекс найденной или предлагаемой позиции значения в массиве.
• “ArrayBsearch” — имя функции.
• “array[]” — массив, в котором ведется поиск.
• “value” — значение, которое ищется в массиве.

Пример:

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

  }

Объяснение:

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

• В этой строке объявляется массив с именем sortedArray, содержащий отсортированные числа {10, 20, 30, 40, 50}.

“double searchValue = 30;”:

• В этой строке значение параметра searchValue устанавливается равным 30, означает значение, которое мы хотим найти в массиве.

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

• в этой строке у нас идет вызов функции ArrayBsearch(), с передачей в качестве аргументов sortedArray и searchValue. Возвращается, по которому найдено значение searchValue, или предлагаемая точка вставки, если значение отсутствует.

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

• Эта строка выводит результат поиска. Если значение searchValue найдено, выводится индекс; в противном случае он выводится предложенная точка вставки.

В этом примере sortedArray — это массив, в котором мы ищем, а searchValue — это значение, которое мы хотим найти в массиве. Функция возвращает индекс, в котором найдено значение, и выводит результат.

2. ArrayResize

Функция MQL5 ArrayResize() позволяет изменять размер динамического массива во время работы программы. Для динамических массивов можно корректировать размер во время выполнения программы, в отличие от статических массивов, размер которых заранее определен. Другими словами, ArrayResize() — это инструмент, который во время работы вашей программы позволяет изменять размер или расширять динамический массив в соответствии с вашими потребностями в данный момент. Это повышает гибкость и позволяет более эффективно обрабатывать данные во время выполнения.

Статические массивы программирования имеют фиксированный размер, который задается на этапе компиляции программы. Количество элементов остается постоянным, поскольку размер фиксирован и не может быть изменен во время выполнения. Память, выделенная для этих массивов, определяется размером, в котором они объявлены. Например, в массиве из пяти элементов всегда будет место для пяти элементов.

Пример:

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

И наоборот, динамические массивы обеспечивают гибкость, поскольку позволяют корректировать и определять размер во время работы программы. Эти массивы сначала объявляются без указания размера. Затем для изменения распределения памяти, например в MQL5, можно использовать функцию ArrayResize(). Динамические массивы полезны, когда размер структуры данных должен быть гибким, чтобы вместить различное количество элементов, необходимое во время выполнения программы.

Пример:

// Dynamic array declaration
int dynamicArray[];

Аналогия

Допустим, у вас есть рюкзак (массив), в котором лежит куча игрушек (элементов). Отправляясь в приключение, вы можете выбрать количество игрушек, которое может поместиться в статический рюкзак, и оно останется таким на протяжении всего пути. Но если вы захотите вместить больше игрушек, будут проблемы.

Динамичный рюкзак можно рассматривать как нечто особенное, которое может расти и вмещать в себя дополнительные, которыми вы хотите поделиться с друзьями. Чтобы изменить размер рюкзака и взять с собой столько игрушек, сколько вам нужно в данный момент для данного конкретного путешествия, используйте ArrayResize().

Что самое удобное, вы можете изменить размер динамического рюкзака, находясь в пути. Такая адаптивность гарантирует, что при изменении содержимого, при добавлении новых элементов, у вас не возникнет проблем! Это как будто вы сообщаете массиву, что он должен быть готов принять большее количество элементов или освободить неиспользуемое место. Такая динамическая настройка, происходящая во время работы программы, обеспечивает универсальность и гибкость, что делает ее бесценным инструментом для массивов, начальные размеры которых неизвестны.

Синтаксис:

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

Параметры:

• “Array[]” — ваш рюкзак (массив), размер которого нужно изменить.
• “new_size” — количество игрушек (элементов), которые должны находиться в массиве. Если у вас было 5 игрушек, но вам нужно место для 10, new_size будет равно 10.
•  “reserve_size = 0” — иногда нужно оставить место для вмещения большего количества игрушек в будущем, чтобы при этом не приходилось снова менять размер. Параметр reserve_size информирует массив о том, что будет еще больше элементов.

Пример:

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

  }

Объяснение:

Объявление динамического массива:

int dynamicArray[];

• Здесь мы объявляем динамический массив с именем dynamicArray() без указания его начального размера.

Изменение размера динамического массива до 5 элементов:

ArrayResize(dynamicArray, 5);

• Используем функцию ArrayResize() для установки размера динамического массива в 5 элементов.

Присвоение значений элементам динамического массива:

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

• Значения присваиваются отдельным элементам динамического массива.

Доступ к элементам динамического массива:

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

• Функция Print используется для вывода значения по индексу 2 динамического массива. В нашем примере будет выведено значение 30.

Изменение размера динамического массива до 8 элементов:

ArrayResize(dynamicArray, 8);

• Размер динамического массива снова изменяется, чтобы вместить 8 элементов, и при этом в нем сохраняются значения предыдущего изменения размера.

Присвоение значений дополнительным элементам:

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

• Дополнительные значения присваиваются вновь добавленным элементам после изменения размера.

Доступ к элементам после изменения размера:

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

• Функция Print используется для отображения значения по индексу 6 динамического массива после второго изменения размера. В этом случае будет выведено значение 70

3. ArrayCopy

В MQL5 функция ArrayCopy() используется для дублирования элементов между массивами. Она позволяет выборочно реплицировать определенную часть массива, обозначенную диапазоном, в другой массив. Эта функция упрощает управление и упорядочение данных внутри массивов, что упрощает извлечение и перемещение определенных элементов между массивами.

Аналогия

Предположим, у вас есть два списка элементов и вы хотите точно скопировать определенные элементы из первого списка во второй. Вот тут-то и пригодится функция MQL5 ArrayCopy(). Она действует как копировщик, позволяя выбирать определенные элементы из массива и аккуратно копировать их в другой список.

Вот более конкретный пример: представьте, что у вас есть массив с пятью различными ценами на товары, и вы хотите создать второй массив, содержащий цены только на три конкретных товара. С помощью функции ArrayCopy() вы можете аккуратно извлечь и скопировать только эти три цены в новый массив, сохранив исходный массив. Этот полезный инструмент упрощает копирование и выбор элементов из одной коллекции в другую, повышая эффективность и организацию задач при работе с массивами.

Синтаксис:

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

Эта функция позволяет объединять массивы с необходимой точностью и контролем. Здесь dst_array — это место назначения, куда будут копироваться элементы, а src_array — это источник, из которого извлекаются элементы. Дополнительные параметры dst_start, src_start и count обеспечивают гибкость и позволяют точнее настраивать операции копирования. Давайте рассмотрим на примере, как происходит операция копирования в MQL5.

Пример:

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

  }

Объяснение:

Объявление массивов:

int sourceArray[];
int destinationArray[];

• Объявляем два динамических массива с именами sourceArray и destinationArray.
  

Изменение размера массивов:

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

• Функция ArrayResize() позволяет установить размер динамических массивов. В этом случае размер обоих массивов изменяется так, чтобы в каждом было по 5 элементов.
  

Присвоение значений:

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;

• Значения присваиваются отдельным элементам sourceArray и destinationArray.
  

Копирование массива:

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

• Функция ArrayCopy() используется для копирования элементов из sourceArray в destinationArray. Он определяет копирование 5 элементов, начиная с индекса 0.
  

Вывод на печать:

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

• функция выводит комментарий, отображающий значение по индексу 7 в destinationArray.
  

Общая цель кода — продемонстрировать функцию ArrayCopy(). Он копирует элементы из sourceArray в destinationArray, начиная с определенных индексов. Последняя строка выводит значение элемента в destinationArray, чтобы подтвердить успешное копирование.

4. ArrayCompare

Функция ArrayCompare() в MQL5 сравнивает поэлементно два массива. Он сравнивает массивы с самого начала (с индекса 0) и проверяет на равенство элементы в соответствующих индексах. Если все элементы совпадают, массивы считаются равными. Если же по какому-либо индексу возникает несоответствие, функция оценивает, какой массив содержит численно больший элемент, обеспечивая основу для определения их взаимосвязи. Эта функция используется для оценки сходства или различия между массивами с точки зрения их содержимого.

Аналогия

Представьте себе сценарий, в котором у вас есть два списка чисел: список A и список B. ArrayCompare()анализирует эти списки и информирует об их отношениях. Начиная с цифр в начале обоих списков, следователь сравнивает их. Когда обнаруживается несоответствие в числах, функция сразу определяет, какой список больше или меньше. Она определяет, что списки равны, если может просмотреть оба списка и не найти различий.

 

Далее мы получаем выводы из этого сравнения:

• Если список A считается меньшим, чем список B, функция сообщает -1.
• Если оба списка равны, результатом будет 0.
• Если список A считается большим, чем список B, результат будет 1.
• Если во время анализа возникает какая-либо путаница или проблема, выводится результат -2.

Итак, ArrayCompare() помогает понять взаимосвязь между двумя списками чисел.

Синтаксис:

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

Параметры:

• array1[] — первый массив.
•  array2[] — второй массив.
• start1 — индекс начального элемента в первом массиве, с которого начинается сравнение. Начальный индекс по умолчанию равен 0.
• start2 — индекс начального элемента во втором массиве, с которого начинается сравнение. Начальный индекс по умолчанию равен 0.
• count — количество сравниваемых элементов. По умолчанию в сравнении участвуют все элементы обоих массивов (count = WHOLE_ARRAY).

Пример:

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

  }

Объяснение:

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

• Объявляет целочисленный массив с именем ListA и инициализирует его значениями 1, 2, 3, 4 и 5.

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

• Объявляет целочисленный массив с именем ListB и инициализирует его значениями 1, 2, 3, 4 и 6.

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

• Использует функцию ArrayCompare() для сравнения массивов ListA и ListB. Сравнение начинается с индекса 0 обоих массивов и сравнивает все массивы.

Условные операторы (if, else if) проверяют значение результирующей переменной и выводит сообщения на основе результата сравнения:

• Если result = -1, это означает, что список ListA меньше, чем список ListB.
• Если result = 0, это означает, что список ListA равен списку ListB.
• Если result = 1, это означает, что список ListA больше, чем ListB.
• Если result = -2, это означает ошибку из-за несовместимых массивов или недопустимых параметров.

Имеем массивы:

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

Результат сравнения ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY)” будет равен -1.

Объяснение:

• Сравнение начинается с первого элемента (индекс 0) обоих массивов.
• Элементы с индексами от 0 до 3 одинаковы в обоих массивах.
• Индекс 4 у ListA — 5, а у ListB — 6.
• Поскольку 5 < 6, ListA считается меньшим, чем ListB.

Следовательно, результат будет -1. Поэкспериментируйте со значениями в ListA и ListB, чтобы увидеть, как изменится результат сравнения.

5. ArrayFree

В MQL5 вызов ArrayFree() аналогичен нажатию кнопки сброса динамического массива. Рассмотрим массив как контейнер для разных элементов. Действие функции ArrayFree() схоже с очисткой контейнера и подготовкой его к хранению новых элементов. Она освобождает места для новых данных путем избавления от устаревшей информации. Другими словами, это очистка для дальнейшего использования. Использование функции позволяет быть уверенным, что массив пуст и подготовлен к новым возможностям программирования на MQL5.

Аналогия

Представьте, что у вас есть волшебная сумка — ваш массив. Иногда вы используете ее для разных целей, например, для сбора игрушек. Но прежде чем приобретать новые игрушки, нужно убедиться, что сумка пуста. Именно это и делает функция ArrayFree() — очищает вашу сумку, чтобы вы могли положить туда новые игрушки или значения. То есть мы удаляем оттуда все, что в ней содержалось, прежде чем положить туда что-то новое.

Синтаксис:

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

Пример:

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

  }

Объяснение:

Объявление динамического массива:

int dynamicArray[];

• Инициализация пустого динамического массива.
  

Изменение размера и присвоение значения:

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

• Изменение размера динамического массива, чтобы он содержал 5 элементов, и присвоение значения каждому элементу.
  

Вывод элементов перед очисткой:

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

• Вывод значения по первому индексу массива, равному 10.
  

Освобождаем динамический массив:

ArrayFree(dynamicArray);

• Освобождает память, занятую динамическим массивом.
  

Попытка получить доступ к элементам после освобождения массива:

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

• Эта строка закомментирована, чтобы избежать ошибок во время выполнения, поскольку массив освобожден.
  

Присвоение новых значений:

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

• Изменяем размер массива, чтобы он содержал 3 элемента, и присваивает новые значения.
  

Вывод на экран после переназначения значений:

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

• Вывод значения по первому индексу массива после переназначения, здесь это 100.
  

В этом примере после освобождения динамического массива с помощью ArrayFree() мы снова изменяем его размер, чтобы в нем было 3 элемента, и присваиваем этим элементам новые значения. Это показывает, как можно повторно использовать динамический массив после его освобождения.

При работе со сложными функциями массивов MQL5, можно открыть для себя еще больше возможностей. Следите за обновлениями, чтобы узнать больше о дополнительных функциях, которые позволят эффективнее работать с кодом. Есть еще много неизвестного, что предстоит узнать, независимо от опыта разработчика. По мере продвижения по этим темам, мы будем открывать для себя все более сложные понятия. Итак, продолжим путешествие по программированию вместе.

6. ArraySetAsSeries

В программировании на MQL5 ArraySetAsSeries() — это функция, позволяющая изменить направление индексации массива. Используя эту функцию, вы можете настроить доступ к массиву от конца к началу, изменив используемое по умолчанию прямое направление. Это особенно полезно при работе с финансовыми данными или другими массивами, где нужен доступ к элементам в обратном хронологическом порядке.

Примечание. Важно отметить, что такое особенно хорошо работает с динамическими массивами, которые могут корректно изменять свой размер во время выполнения.

Аналогия

Представьте, что у вас на полке аккуратно разложена стопка сборников рассказов. Каждая книга похожа на особый номер. Обычно вы читаете рассказы в том порядке, в котором они появляются на полке, начиная с первой книги и продвигаясь к последней.

Допустим, что захотели найти последнюю историю, которую вы добавили в свою коллекцию, не снимая при этом все книги с полки. Вот здесь то и пригодится заклинание ArraySetAsSeries(). Когда вы накладываете это заклинание на свою книжную полку (массив), вы заставляете переставить книги таким образом, чтобы самая новая, которую вы добавили, стала первой. Это особенно полезно, когда ваши истории (цифры) меняются со временем, например, когда вы записываете, сколько новых книг вы собираете каждый день. С помощью ArraySetAsSeries() вы можете сначала открыть последний сборник рассказов и затем продвигаться по библиотеке в обратном порядке в направлении первой книге, чтобы увидеть, как выросла ваша коллекция. То есть вы начинаете читать вашу коллекцию в обратном порядке.

Синтаксис:

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

Параметры:

• array[] — массив, на который вы хотите наложить свойства временного ряда. К этому массиву будет применена новая индексация.
• bool flag — значение типа bool. При установке в значение true, активируется обратная индексация, превращая массив в таймсерию, в которой последний элемент становится первым. Если установлено значение false, массив ведет себя обычным образом.

Пример:

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

  }

Объяснение:

Объявление динамического массива:

double magicalArray[];

• Объявляем динамический массив с именем magicalArray без указания его размера.
  

Присваиваем значения массиву:

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

• Изменяем размер массива, чтобы в нем было 5 элементов.
  
• Затем присваиваем конкретные значения каждому элементу массива.
  

Вывод элементов перед установкой параметров как в таймсерии:

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

• Здесь выводятся на экран значения каждого элемента массива перед тем, как задать ему свойства таймсерии.
  

Установим массив как таймсерию:

ArraySetAsSeries(magicalArray, true);

• Используем функцию ArraySetAsSeries(), чтобы превратить массив в таймсерию. Второй параметр true указывает обратный порядок индексации.
  

Вывод элементов после настройки как таймсерии:

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

• Наконец, выводим значения каждого элемента после установки массива в виде таймсерии. Порядок вывода значений отражает обратную индексацию из-за установки нового свойства.
  

Таким образом, код демонстрирует, как присваивать значения динамическому массиву, выводить на экран его элементы до и после установки свойства таймсерии и наблюдать за изменением порядка индексации.

Так работает функция ArraySetAsSeries() в языке MQL5. Еще раз: функция устанавливает обратную индексацию0 элементам массива. Я бы хотел напомнить, что для наиболее полного понимания материала нужна практика. Пробуйте новое, читайте внимательно и задавайте вопросы. Вы можете получить помощь от целого сообщества программистов. Итак, продолжим.

7. ArrayGetAsSeries

Функция ArrayGetAsSeries() в MQL5 используется для определения того, установлен ли у массива флаг AS_SERIES. Этот флаг влияет на порядок доступа к элементам массива. Если функция возвращает true, это означает, что доступ к элементам осуществляется в обратном порядке. В противном случае, если он возвращает false, массив сохраняет порядок по умолчанию. Эта функция удобна при работе с массивами, где последовательность доступа к данным имеет решающее значение, и позволяет проверить и адаптировать способ доступа к данным на основе конфигурации массива.

Аналогия

Представьте, что у вас есть список чисел, и иногда этот список играет в игру «Путешествие во времени». Когда вы используете инструмент ArrayGetAsSeries(), он сообщает вам, играет ли ваш список в игру или нет. Если он говорит true, это означает, что список играет, и вы читаете числа задом наперед, как при обратном отсчете. Если это false, список нормальный, и вы читаете числа от начала до конца, как при подсчете. Это позволит понять, как сейчас обращаться со списком!

Синтаксис:

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

Пример:

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

  }

Объяснение:

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

• Эти строки объявляют два динамических массива с именами timeSeriesArray и regularArray. Динамические массивы в MQL5 могут изменяться в размере во время выполнения.
  

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

• Здесь используется функция ArrayResize() 3 с помощью нее размер обоих массивов устанавливается равным 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;

• Здесь присваиваются определенные значения элементам обоих массивов. Массиву timeSeriesArray присваиваются значения в порядке возрастания, а regularArray — в порядке убывания.
  

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

• В этой строке используется функция ArraySetAsSeries(), чтобы установить флаг таймсерии для timeSeriesArray в значение true. Это означает, что доступ к элементам в массиве timeSeriesArray будет осуществляться от начала до конца.
  

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

• Предоставленный фрагмент кода проверяет, соответствуют ли динамические массивы timeSeriesArray и regularArray условиям таймсерии с использованием условных операторов. Используется функция ArrayGetAsSeries(), чтобы определить, установлен ли флаг временного ряда для каждого массива. Первый оператор if проверяет timeSeriesArray. Если оператор определяет его как временной ряд, выводится соответствующее сообщение, указывающее, что доступ к его элементам осуществляется от конца к началу. В противном случае блок else выводит сообщение о том, что timeSeriesArray сохраняет свой первоначальный порядок, и доступ к элементам осуществляется от начала до конца. Процесс повторяется для regularArray. Эта условная проверка важна для понимания того, как индексируются элементы в динамических массивах, и дает информацию о направлении доступа к массиву.
  

Понимание работы ArrayGetAsSeries() — нудный навык в MQL5. Независимо от того, перемещаетесь ли вы по данным временных рядов или работаете с массивами в исходном порядке, эти функции прямо используются в программах алгоритмической торговли. Надеюсь, пока все понятно.

8. ArrayIsSeries

При определении того, представляет ли массив в MQL5 таймсерию, необходима функция ArrayIsSeries(). Массив, содержащий данные, связанные со временем, в финансовом программировании называется временным рядом (таймсерией) и часто используется для хранения значений цен, таких как цены открытия, максимума, минимума и закрытия. При обнаружении таймсерии функция анализирует предоставленный массив и возвращает true. В противном случае возвращается false. Это определение важно при работе с финансовыми данными на графике, где понимание временного характера данных имеет очень важное значение.

При создании пользовательских индикаторов в MQL5, особенно в контексте технического анализа, нужно различать обычные массивы и массивы таймсерий. Функция ArrayIsSeries() упрощает этот процесс, позволяя разработчикам адаптировать код в зависимости от того, содержит ли массив информацию, привязанную ко времени. Функция способствует повышению эффективности и точности алгоритмических торговых стратегий, инструментов технического анализа и других финансовых приложений, разработанных на MQL5.

Разница между ArrayGetAsSeries и ArrayIsSeries

ArrayGetAsSeries() и ArrayIsSeries() — это функции, относящиеся к поведению массива, но они служат разным целям. ArrayGetAsSeries() используется для проверки того, установлена ли индексация массива для извлечения элементов в обратном порядке. Эта функция полезна при работе с массивами, позволяя разработчикам определить, осуществляется ли доступ к данным в хронологическом или обратном порядке. Она возвращает true, если массив задан как серия (доступ в обратном порядке), и false в противном случае.

А функция ArrayIsSeries() служит для определения того, является ли массив таймсерией. Массивы таймсерий широко используются в финансовом программировании и представляют такие данные, как цены открытия, максимума, минимума и закрытия с течением времени. В отличие от ArrayGetAsSeries(), функция ArrayIsSeries() не заботится о направлении индексации массива. Он просто проверяет, содержит ли массив информацию, связанную со временем. Если массив представляет собой таймсерию, он возвращает true; в противном случае возвращается false. Эти функции дополняют друг друга, предоставляя комплексный набор инструментов для обработки поведения массива, обеспечивая гибкость при работе с различными типами финансовых данных в алгоритмических торговых системах и инструментах технического анализа.

Аналогия

Допустим, у вас есть ежедневный список, например список цен на ваши любимые игрушки. Теперь, если нудно узнать, является ли этот список особенным и связан ли он со временем, как история, можно использовать ArrayIsSeries(). Она проверяет, имеет ли список связь с изменением времени, то есть является ли он таймсерией. Неважно, читается ли список вперед или назад; ей важно знать, похоже ли это на изменение во времени.

Если в ответ получаем true, это означает, что наш список связан с путешествием во времени, возможно, он показывает цены на игрушки за несколько дней. Но если ответ false, список может представлять собой обычный набор чисел без какой-либо магии, связанной со временем. Это простой и надежный способ узнать, связана ли последовательность в массиве с изменением во времени.

Синтаксис:

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

Пример:

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

  }

Объяснение:

// Declare an array
double priceSeries[];

• Эта строка объявляет пустой динамический массив с именем priceSeries для хранения значений типа 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;

• Здесь размер массива изменяется до 5 элементов, и каждому элементу присваиваются определенные значения. Эти значения представляют собой гипотетический временной ряд.
  

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

• В этой строке используется функция ArrayIsSeries(), чтобы проверить, считается ли массив priceSeries временным рядом. Результат (true или false) сохраняется в логической переменной isSeries.
  

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

• Наконец, код выводит сообщение, указывающее, считается ли массив временным рядом, на основе результата от функции ArrayIsSeries(). Если это временной ряд, код выводит одно сообщение; в противном случае другое.
  

Результатом в этом случае будет: 'This array is not a time series' («Этот массив не является временным рядом»). Почему? Поскольку массив не представляет собой временной ряд даже после того, как мы присвоили ему значения. Я понимаю, что поначалу, особенно для новичков, это может показаться немного запутанным. Но сейчас мы не будем переходим к более сложным обсуждениям. Если у вас остались вопросы, задавайте их в обсуждении к статье.

9. ArrayInitialize

Функция ArrayInitialize() в MQL5 устанавливает начальные значения всех элементов числового массива в заданное значение. Вместо того чтобы вручную присваивать одно и то же значение каждому элементу по одному, функция ArrayInitialize() применяет выбранное значение ко всем элементам одновременно. Эта функция полезна для подготовки массива с определенной начальной точкой, особенно при работе с числовыми данными, где требуется унифицированная инициализация. Обратите внимание, что она устанавливает только начальные значения и не влияет на резервные элементы или будущие расширения, выполненные с помощью ArrayResize().

Аналогия

Допустим, у вас есть набор контейнеров, называемых массивами, и в каждом контейнере есть специальные места для хранения значений. Вы хотите начать с определенного значения во всех этих пространствах и используете специальную команду под названием ArrayInitialize(). Эта команда устанавливает желаемое начальное значение во всех этих пространствах одновременно, избавляя от необходимости делать это для каждого пространства отдельно.

Однако вот что интересно: если позже вы решите увеличить эти контейнеры и добавить к ним больше пространств с помощью другой команды (ArrayResize), новые пространства добавятся, но они не будут иметь те же значения, что и оригинальные. Вам придется выбирать значения для ввода каждого из них отдельно, поскольку они будут незначительно отличаться. Это похоже на расширение внутреннего пространства — вы не всегда украшаете новые комнаты той же мебелью, что и старые.

Синтаксис:

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

Пример:

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


  }

Объяснение:

// Declare a dynamic array
   int myArray[];

• Здесь мы объявляем динамический целочисленный массив с именем myArray. У него нет заранее заданного размера.
  

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

• Изменяем размер массива myArray, чтобы его первоначальный размер составлял 3 элемента. Это означает, что мы выделяем память для трех целых чисел в массиве.
  

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

• Перед инициализацией массива мы вручную присваиваем значения его элементам. В этом случае мы устанавливаем myArray[0] в значение 10, myArray[1] 20 и myArray[2] 30.
  

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

• Теперь используем функцию ArrayInitialize(), чтобы установить для всех элементов myArray указанное значение, которое в данном случае равно 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

• Мы печатаем значения всех элементов в myArray после инициализации. Как и ожидалось, все элементы теперь установлены в значение 0.
  

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

• Затем изменяем размер myArray, чтобы в нем было всего 5 элементов. Это означает, что теперь массив может вместить еще два элемента.
  

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

• После изменения размера присваиваем значения дополнительным элементам (myArray[3] и 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

• Наконец, после изменения размера выводим значения всех элементов в myArray, включая вновь добавленные элементы.
  

Полезным инструментом, позволяющим программистам устанавливать для каждого элемента массива заданное значение, является функция ArrayInitialize() в MQL5. Он обеспечивает определенную стартовую точку для каждого элемента массива, а также обеспечивает ясность и контроль над начальным состоянием массива. Помните, что функция инициализирует каждый элемент одним и тем же указанным номером. Это может показаться простым, но это важный шаг в настройке массивов для различных типов приложений. В следующих статьях мы углубимся в область алгоритмической торговли и еще раз вернемся к функции ArrayInitialize().

10. ArrayFill

Функция ArrayFill() также позволяет проще работать с массивами. Она позволяет эффективно заполнять диапазон элементов массива указанным значением, устраняя необходимость ручной итерации и присваивания. Вместо написания нескольких строк кода для индивидуальной установки каждого элемента, ArrayFill() предоставляет краткое и эффективное решение. Эта возможность повышает читаемость кода и снижает вероятность ошибок, особенно при работе с большими массивами или повторяющимися заданиями. Способность функции быстро заполнять элементы массива общим значением упрощает процесс в случаях, где требуется массовая инициализация.

Аналогия

Допустим, у вас есть коробка с несколькими слотами, и вы хотите использовать некоторые из этих слотов для одной и той же игрушки, не просматривая каждый из них по отдельности. ArrayFill() позволяет вам выбрать игрушку и дать ей указание «Заполнить слоты этой игрушкой». Таким образом, вы можете разместить все игрушки сразу, а не размещать каждую по отдельности! Эта функция экономит время и помогает поддерживать порядок в вашем контейнере.

Синтаксис:

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

Параметры

• array[] — массив.
• start — начальная позиция для размещения нужного значения. Здесь указывается индекс или позицию.
•  count — количество позиций, которые нужно заполнить.
• value — значение, которым нужно заполнить позиции. Это может быть число, цвет или что-нибудь, что поместится в слотах.

Пример:

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

  }

Объяснение:

“int roomShelves[];”:

• Объявляем целочисленный массив с именем roomShelves, представляющий полки в комнате.

“ArrayResize(roomShelves, 10);”:

• Изменяем размер массива roomShelves, чтобы он содержал 10 элементов, представляющих 10 полок в комнате.

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

• Заполняем первые 5 полок (индексы от 0 до 4) значением 42, обозначающим книги на этих полках.

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

• Заполняем следующие 5 полок (индексы от 5 до 9) значением 99, обозначающим игрушки на этих полках.

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

• Выводим сообщение о том, что в следующих строках будет отображаться содержимое полок.

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

• Выводим содержимое каждой полки, отображая индекс полки и соответствующее ему значение.

Этот код MQL5 показывает, как заполнить динамический массив roomShelves с помощью функции ArrayFill(). Первоначально размер массива был увеличен до десяти полок. Следующий шаг предполагает использование ArrayFill() для заполнения первых пяти полок значением 42 и следующих пяти полок значением 99. Значения, присвоенные каждому элементу массива после процесса заполнения, окончательно раскрываются при печати содержимого каждой полки. Код демонстрирует, как функция ArrayFill() предлагает гибкий метод установки предопределенных значений внутри структуры массива путем эффективной инициализации назначенных сегментов динамического массива с предопределенными значениями.

Примечание: и ArrayFilд(), и ArrayInitialize()” — это функции для работы с массивами в MQL5, но они служат разным целям. ArrayFill()() предназначена для заполнения определенного диапазона элементов массива заданным значением. Он позволяет эффективно выполнять массовое присвоение подмножеству массива, что делает его полезным для выборочного изменения или инициализации частей массива. Напротив, ArrayInitialize() — это более общая функция, которая равномерно устанавливает значения всех элементов во всем массиве. Она обеспечивает одинаковое начальное состояние для всего массива, предоставляя быстрый способ инициализировать все элементы одним и тем же значением. Итак, хотя ArrayFill() специализируется на целевых назначениях, ArrayInitialize() — более широкий инструмент для единообразной инициализации всего массива.

11. ArrayIsDynamic

Чтобы определить, является ли массив динамическим или статическим, в MQL5 есть полезный инструмент — функция ArrayIsDynamic(). Размер статического массива фиксируется во время компиляции, тогда как размер динамического массива может быть изменен во время выполнения. Функция ArrayIsDynamic() определяет, является ли массив динамическим или статическим, и возвращает ответ true или false в зависимости от характера массива. Используя эти данные, программа может изменять свое поведение в соответствии с гибкостью массива, определяя, можно ли изменить его размер во время работы программы.

Аналогия

Массив похож на коробку, в которой может храниться несколько объектов. Некоторые коробки обладают особой магией, которая позволяет изменять их размер, чтобы вместить больше предметов или занимать меньше места, когда это необходимо. Они называются динамическими коробками. И наоборот, некоторые коробки установлены по размеру и не сдвинутся с места ни при каких обстоятельствах. Их называют статическими коробками.

Чтобы определить, является ли блок динамическим или статическим, вы можете использовать для него функцию ArrayIsDynamic(). Результаты ее работы показывают, является ли коробка статической (ее размер остается постоянным) или динамической (она может менять свой размер). Программистам необходимо знать эти вещи, потому что это имеет смысл при принятии решения о том, как работать с коробкой в коде. Если она статическая, следует позаботиться о том, чтобы не превысить установленный размер; если динамическая, они могут увеличивать или уменьшать его по мере необходимости.

Синтаксис:

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

Пример:

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

Объяснение:

“int staticArray[5];”:

• Эта строка объявляет массив с именем staticArray с фиксированным размером в 5 элементов.

“int dynamicArray[];”:

• Эта строка объявляет динамический массив с именем dynamicArray без указания фиксированного размера.

“bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);”:

• В этой строке используется функция ArrayIsDynamic(), чтобы проверить, является ли массив staticArray динамическим, и присваивает результат isStaticArrayDynamic.

“bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);”:

• В этой строке используется функция ArrayIsDynamic(), чтобы проверить, является ли массив staticArray динамическим, и присваивает результат isStaticArrayDynamic.

Выводится результат для статического массива:

• Последующий блок if-else выводит сообщение, указывающее, является ли staticArray динамическим или статическим, на основе результата, полученного на предыдущем шаге.

“bool isDynamicArrayDynamic = ArrayIsDynamic(dynamicArray);”:

• В этой строке используется функция ArrayIsDynamic(), чтобы проверить, является ли массив dynamicArray динамическим, и присваивает результат isDynamicArrayDynamic.

Выводим результат для динамического массива:

• Последующий блок if-else выводит сообщение, указывающее, является ли массив dynamicArray динамическим или статическим, на основе результата, полученного на предыдущем шаге.

Код демонстрирует использование функции ArrayIsDynamic() для определения того, является ли массив динамическим или статическим.

12. ArrayMaximum

Функция ArrayMaximum() в MQL5 предназначена для определения индекса максимального элемента в числовом массиве. Эта функция оказывается особенно полезной, когда важно определить максимальное значение в массиве. Эффективно перебирая массив, функция возвращает индекс максимального элемента с учетом серийного номера массива. В ситуациях, когда массив представляет финансовые или технические данные, нахождение максимального значения является очень важным шагом в извлечении значимой информации или принятии торговых решений.

Аналогия

Представьте, что у вас есть список чисел, например, результаты различных игр, в которые вы играли. Функция ArrayMaximum() просматривает ваш список и сообщает, в какой игре вы справились лучше всего. Итак, если вы хотите узнать, какая игра получила самый высокий балл, она проверит результаты по каждой, найдет максимальный из них и сообщит, сто это ваша лучшая игра. Все это без необходимости просматривать весь список самостоятельно. В компьютерных программах так происходит поиск самого большого числа в группе чисел.

Синтаксис:

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

Параметры:

• array[] — массив, для которого вы хотите найти максимальное значение.
• start — параметр позволяет указать индекс в массиве, с которого вы хотите начать поиск максимального значения.
• “count = WHOLE_ARRAY” — представляет количество элементов, которые следует учитывать при поиске. Значение по умолчанию WHOLE_ARRAY означает, что функция будет искать во всем массиве.

При вызове ArrayMaximum(array, start, count), функция найдет самый большой элемент в указанном диапазоне массива и вернет его индекс. Если максимум не найден, возвращается -1.

Пример:

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

  }

Объяснение:

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

• Эта строка объявляет целочисленный массив с именем myArray и инициализирует его шестью целочисленными значениями.

“int maxIndex = ArrayMaximum(myArray);”:

• Функция ArrayMaximum() вызывается для myArray, чтобы найти индекс максимального значения в массиве. Результат сохраняется в переменной maxIndex.

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

• Этот условный оператор проверяет, найдено ли максимальное значение. Если maxIndex не равен -1, это означает, что в массиве есть максимальное значение.

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

• Если обнаружено максимальное значение, выводится максимальное значение, используя индекс, полученный из maxIndex.

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

• Эта строка выводит индекс максимального значения.

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

• Если maxIndex равен -1, что бывает, когда максимальное значение не найдено, выполняется этот блок. Выводится сообщение о том, что максимальное значение не найдено.

Чтобы определить максимальное значение и его индекс в массиве, используйте ArrayMaximum(), как показано в этом коде.

13. ArrayMinimum

Полезная функция ArrayMinimum() позволяет определить индекс наименьшего (минимального) элемента в первом измерении числового массива. Эта функция работает с массивами разных размеров. Она обеспечивает точные результаты за счет учета последовательного порядка массива.

Функция ArrayMinimum() предназначена для поиска индекса наименьшего элемента массива. Она возвращает индекс наименьшего значения с учетом порядка элементов в массиве. Функция возвращает -1, если при поиске не найдено минимальное значение. Эта функция может пригодиться, когда вам нужно определить точное расположение наименьшего элемента в массиве.

Синтаксис:

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

Пример:

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

  }

Как и в случае с ArrayMaximum(), этот код найдет индекс минимального элемента в массиве myArray и выведет результат.

Заключение

В этой статье мы познакомились с функциями для работы с массивами в MQL5, с их возможностями и применением. Мы изучили различные функции от поиска и копирования до изменения размера и обработки массивов временных рядов: ArrayBsearch, ArrayCopy, ArrayCompare, ArrayResize, ArrayFree, ArraySetAsSeries, ArrayGetAsSeries, ArrayInitialize, ArrayFill, ArrayIsDynamic, ArrayIsSeries, ArrayMaximum и ArrayMinimum. Каждая функция важна при работе с массивами и расширении возможностей торговых алгоритмов.

В завершении хотел бы отметить, что я намеренно не осветил все функции массивов, чтобы обеспечить целенаправленное и удобоваримое обучение. В следующей статье мы рассмотрим другие функции работы с массивами: ArrayPrint, ArrayRange, ArrayInsert, ArrayRemove, ArrayReverse, ArraySize, ArraySort, ArraySwap, ArrayToFP16, ArrayToFP8, ArrayFromFP16 и ArrayFromFP8. Такой постепенный подход направлен на облегчение кривой обучения. До встречи в следующей статье!