Кодирование свечных моделей (Часть 2): Моделирование движения цены в виде упорядоченной последовательности

Введение

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

В предыдущей части этой серии мы присвоили различным типам свечей определенные буквенные метки. Для бычьих свечей мы использовали набор заглавных букв "AHEGD", где каждая буква обозначает заранее заданный свечной паттерн (например, A = бычий марубозу, H = бычий пин-бар, G = бычий "волчок" и т. д.). Для медвежьих свечей мы использовали набор строчных букв "ahegd" (например, a = медвежий марубозу, h = медвежий пин-бар, g = медвежий "волчок" и т. д.). Эта алфавитная кодировка преобразует динамику цены в компактное символьное представление.

Затем мы создали функцию CandleType(), которая анализирует цены открытия, максимума, минимума и закрытия каждой свечи и возвращает соответствующий буквенный код. После обработки последовательности свечей мы сохранили полученную упорядоченную строку букв в двух отдельных функциях — bullishPattern и bearishPattern, которые используются для выявления конкретных торговых сигналов.

Цель

В этой части наша цель — разработать калькулятор перестановок на MQL5. Этот инструмент вычислит общее ожидаемое количество уникальных паттернов, которые могут быть сгенерированы из заданного входного набора, например, "AHEGD" (бычий набор) или "ahegd" (медвежий набор). Например, если взять подмножество из трех букв из пяти доступных, сколько различных упорядоченных последовательностей (перестановок) мы можем составить? Калькулятор ответит на такие вопросы, учитывая, разрешено ли повторение (например, один и тот же тип свечи может появляться последовательно) или нет (каждый тип используется не более одного раза).

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

Концепция перестановки

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

• Подсчет паттернов: перестановки без повторений

В наиболее строгом случае количество способов расположить r различных элементов, выбранных из набора n различных элементов, где каждый элемент используется не более одного раза, и порядок имеет значение, определяется известной формулой для перестановок без повторений:

Где:

• n = общее количество различных типов свечей в кодирующем алфавите.
• r = длина паттерна (количество располагаемых свечей), где 0≤r≤n.
• ! (факториал) = произведение всех положительных целых чисел до этого числа (например, 5!=5×4×3×2×1=120).
• P(n, r) = общее количество уникальных возможных упорядоченных размещений при условии отсутствия повторений.

Например, если наш алфавит содержит 7 различных кодов свечей, и мы хотим изучить все комбинации из 2 свечей, состоящие из свечей разных типов, то таких размещений будет P(7,2)=7!/5!=7×6=42. Эта формула является основополагающей, поскольку отражает суть упорядоченного выбора без повторений — сценарий, который может применяться, когда трейдер хочет изучить паттерны, в которых никакие две последовательные свечи не принадлежат к одной и той же закодированной категории.

Для визуализации этой концепции рассмотрим бычий набор, определенный как AGH. Количество способов расположить все три элемента вычисляется как P(n=3,r=3)=6. На рисунке 1 показаны все возможные перестановки.

Рисунок 1: Все возможные перестановки для бычьего набора из 3 свечей

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

• Более общий случай: перестановки с повторениями

Однако в реальном рыночном анализе один и тот же тип свечи часто встречается несколько раз в рамках паттерна (например, две последовательные медвежьи свечи марубозу). Поэтому более распространенным принципом подсчета является принцип перестановок с повторениями. Когда повторения допускаются, количество возможных паттернов длины r, взятых из набора из n элементов, просто равно:

Используя тот же 7-буквенный алфавит, количество всех паттернов из 2 свечей (с учетом повторения) становится 7^2=49, а для паттернов из 3 свечей оно резко возрастает до 7^3=343. Этот экспоненциальный рост отражает удивительно большое комбинаторное пространство, которое игнорируется традиционным, основанным на интуиции, распознаванием паттернов. Сгенерировав полный набор последовательностей n^r  и проверив каждую из них на исторических данных, трейдер может выявить высоковероятные торговые сценарии, которые никогда не были описаны в классической литературе по техническому анализу.

Для наглядного понимания этой концепции рассмотрим бычий набор AGH. Количество способов расположить три элемента с учетом повторений рассчитывается как 3^3=27 (где n=3,r=3). На рисунке 2 показаны шесть конкретных перестановок из двадцати семи возможных размещений.

Рисунок 2: Перестановки с разрешенными повторениями

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

Для перестановок без повторений количество выбранных элементов r не может превышать общее количество элементов n (r≤n). Напротив, для перестановок с повторениями "r может быть любым положительным целым числом ( r>0 )".

В таблице 1 приведена сводка количества перестановок при размере набора n=5.

r	Без повторений : n!/(n-r)!	Разрешенные повторения : n^r
1	5	5
2	20	25
3	60	125
4	120	625
5	120	3125
6	не определено (r > n)	15625

В таблице 1 показано количество перестановок для различных длин паттернов (r) при n = 5. По мере увеличения количества символов и длины последовательности число размещений быстро растет. Это делает ручной анализ нецелесообразным.

Демонстрация: Расчет перестановок

Мы разработали калькулятор перестановок — скрипт, который принимает ввод пользователя для вычисления общего числа возможных вариантов размещения для заданного размера набора (n)  и размера паттерна (r). Программа реализует функции как для перестановок с повторениями, так и для перестановок без повторений, поскольку каждая из них использует различный вычислительный подход. Также была включена функция факториала для поддержки вычислений для перестановок без повторений.

Для повышения эффективности функция PermNoRep использует упрощенную формулу перестановки: P(n,r)=n×(n−1)×(n−2)×⋯×(n−r+1).

Этот метод умножает r последовательных целых чисел в порядке убывания от n, избегая ненужных вычислений факториала.

Например:       

Таким образом, число возможных размещений 2 элементов, выбранных из 7 элементов, равно 42.

Прежде чем продемонстрировать работу permCalculator, давайте сначала рассмотрим структуру и логику кода.

Этот раздел кода вычисляет количество возможных размещений без повторений. Функция принимает два входных параметра: общее количество элементов (n) и длину паттерна (r). Если r<0 или r>n, функция возвращает 0, поскольку такие размещения невозможны. В противном случае она вычисляет и возвращает результат перестановки, используя формулу перестановки без повторений.

//+------------------------------------------------------------------+
//| Permutations without repetition: n!/(n-r)!                       |
//+------------------------------------------------------------------+
long PermNoRep(int n, int r)
  {
   if(r < 0 || r > n)
      return 0;
   long res = 1;
   for(int i = 0; i < r; i++)
      res *= (n - i);
   return res;
  }

Аналогично, функция PermWithRep принимает два входных аргумента: общее количество элементов (n) и длину паттерна (r). Если r<0, функция возвращает 0, поскольку отрицательная длина паттерна недопустима. В противном случае функция вычисляет и возвращает общее количество возможных размещений, используя формулу перестановки с повторениями.

//+------------------------------------------------------------------+
//| Permutations with repetition: n^r                                |
//+------------------------------------------------------------------+
long PermWithRep(int n, int r)
  {
   if(r < 0)
      return 0;
   /*
      if (r == 0) return 1;
      long res = 1;
      for (int i = 0; i < r; i++) res *= n;
      return res;
   */
   return (long)MathPow(n, r);
  }

Функция factorial принимает в качестве входных данных общее количество элементов (n) и возвращает результат факториала. Если n≤1, функция возвращает 1, поскольку факториал 0 и 1 определяется как 1. В противном случае функция вычисляет произведение всех положительных целых чисел от 1 до n. 

//+------------------------------------------------------------------+
//| Factorial function: n!                                           |
//+------------------------------------------------------------------+
long Factorial(int n)
  {
   if(n <= 1)
      return 1;
   long res = 1;
   for(int i = 2; i <= n; i++)
      res *= i;
   return res;
  }

Код позволяет пользователям задавать входные значения для (n) и (r), которые затем передаются в соответствующую функцию для вычисления и возврата результатов перестановки.

//--- input parameters
input int      N=5;  // Total number of elements
input int      R=2;  // Number of selections

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

   MessageBox(StringFormat(
                 "Total Permutation for: ( n=%d, r=%d )\r\n\tWithout repetition: %d\r\n\tWith repetition   : %d",
                 N, R, PermNoRep(N, R), PermWithRep(N, R)
              ), "Result");

На рисунке 3 ниже показано, как работает скрипт.

Рисунок 3: Демонстрация PermCalculator

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

Создание скрипта на MQL5 для генерации перестановок

В первой части этой серии мы использовали предварительно обработанные списки перестановок для обнаружения сигналов. Как показано на рисунках 1 и 2, из бычьего набора было сгенерировано несколько возможных комбинаций свечей. Однако остается важный вопрос: как можно генерировать эти перестановки непосредственно в MQL5 для обнаружения сигналов и статистического анализа?

Хотя permCalculator оценивает общее количество возможных размещений, он не генерирует фактические списки перестановок, необходимые для анализа. Для устранения этого ограничения мы разработали дополнительный скрипт на MQL5, предназначенный для автоматической генерации всех возможных комбинаций.

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

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

• Перестановки без повторений

При выборе перестановок без повторений каждый элемент может появляться в сгенерированном размещении только один раз. Этот подход подходит, когда дублирование свечных паттернов в одной последовательности не допускается. На рисунке 4 представлен псевдокод, используемый для реализации этой логики.

Псевдокод перестановки K

Рисунок 4: Псевдокод для перестановок без повторений

При вызове функция GenerateKPermutation инициализирует следующие параметры:

• n: длина строки ввода
• results: массив для хранения всех допустимых перестановок
• current: временная строка для формируемого размещения
• used: логический массив для отслеживания обработанных элементов

Затем вызывается рекурсивная функция бэктрекинга. Используемый массив гарантирует, что каждый элемент рассматривается только один раз на каждом пути перестановки. Когда длина строки current достигает требуемого размера паттерна (k), текущее размещение добавляется к результатам, и функция возвращает управление. После обработки всех элементов GenerateKPermutation формирует полный набор перестановок.

Ниже представлена реализация генерации перестановок без повторений на MQL5.

Мы разработали рекурсивную функцию с именем PermuteBacktrack с семью параметрами. Параметры pos, current, elements, n и k передаются по значению, а used и results передаются по ссылке, что позволяет обновлять данные во время рекурсии. Для завершения рекурсивного процесса после достижения требуемой длины перестановки определяется базовое условие pos == k.

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

//+------------------------------------------------------------------+
//|   permutation without repetition (recursive backtracking)        |
//+------------------------------------------------------------------+
void PermuteBacktrack(int pos, string current, bool &used[], string &results[],
                      string elements, int n, int k)
  {
//--- Base condition
   if(pos == k)
     {
      int size = ArraySize(results);
      ArrayResize(results, size + 1);
      results[size] = current;
      return;
     }
//--- Try every unused element
   for(int i = 0; i < n; i++)
     {
      if(!used[i])
        {
         used[i] = true;
         //-- append character
         string next = current + CharToString(StringGetCharacter(elements, i));
         //-- recursive call
         PermuteBacktrack(pos + 1, next, used, results, elements, n, k);
         //-- backtrack
         used[i] = false;
        }
     }
  }

Функция GetKPermutations принимает три входных аргумента: elements, k и results. Сначала функция определяет общее количество элементов, обозначаемое как n, из предоставленного множества.

В реализации предусмотрено, что когда k <= 0, значение k автоматически устанавливается равным полной длине множества элементов. И наоборот, если k > n, функция возвращает пустой результат и отображает предупреждение "undefined", поскольку такие перестановки невозможны. 

Перед генерацией перестановок функция очищает все предыдущие результаты и инициализирует необходимые параметры. Далее она вызывает функцию PermuteBacktrack, начиная с pos = 0 и пустой текущей строки, чтобы рекурсивно построить все допустимые перестановки без повторений.

//+------------------------------------------------------------------+
//| Construct list of permutations without repetition                |
//+------------------------------------------------------------------+
void GetKPermutations(string elements, int k, string &results[])
  {
   int n = StringLen(elements);
//-- default to full length
   if(k <= 0)
      k = n;
//-- invalid case
   if(k > n)
     {
      ArrayResize(results, 0);
      Alert("Undefined! k>n");
      return;
     }
   ArrayResize(results, 0);  // clear previous results
   bool used[];
   ArrayResize(used, n);
   for(int i = 0; i < n; i++)
      used[i] = false;
   PermuteBacktrack(0, "", used, results, elements, n, k);
  }

• Перестановки с повторениями

Когда трейдеру требуются все возможные размещения, допускающие повторения (т.е. каждый элемент может появляться несколько раз), используется функция PermWithRepetition. На рисунке 5 представлен соответствующий псевдокод.

Псевдокод перестановки с повторениями

Рисунок 5: Псевдокод для перестановок с повторениями

При вызове PermWithRepetition функция инициализирует:

• n = длина исходной строки
• массив results – хранит все сгенерированные перестановки
• current — текущее формируемое размещение

Затем вызывается рекурсивная функция бэктрекинга. Рекурсия продолжается до тех пор, пока длина current не сравняется с желаемым размером паттерна (r). На этом этапе текущее размещение добавляется к результатам и функция возвращает управление. После того, как все возможные комбинации были исследованы (т.е. каждый элемент в наборе был протестирован в каждой позиции), функция формирует полный массив results.

Ниже представлена реализация генерации перестановок с повторениями.

Мы разработали рекурсивную функцию под названием BacktrackRepetition, принимающую шесть аргументов. Параметры pos, current, elements, n и r передаются по значению, а results передается по ссылке для хранения сгенерированных перестановок. Базовое условие pos == r определено для завершения рекурсии после достижения требуемой длины паттерна.

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

//+------------------------------------------------------------------+
//| Recursive backtracking for permutations with repetition          |
//+------------------------------------------------------------------+
void BacktrackRepetition(int pos, string current, string &results[],
                         string elements, int n, int r)
  {
   if(pos == r)
     {
      //--- base condition
      int size = ArraySize(results);
      ArrayResize(results, size + 1);
      results[size] = current;
      return;
     }
//--- try every element
   for(int i = 0; i < n; i++)
     {
      //-- append character
      string next = current + CharToString(StringGetCharacter(elements, i));
      //-- recursive call
      BacktrackRepetition(pos + 1, next, results, elements, n, r);
     }
  }

Функция PermuteWithRepetition принимает три входных аргумента: elements, r и results. Сначала функция определяет общее количество элементов, обозначаемое как n, из предоставленного множества.

В реализации предусмотрено, что когда r <= 0, значение r автоматически устанавливается равным полной длине множества элементов. Если n = 0, функция возвращает пустой результат, поскольку из пустого множества нельзя сгенерировать перестановки.

Перед генерацией перестановок функция очищает все предыдущие результаты и инициализирует необходимые параметры. Далее она вызывает функцию BacktrackRepetition, начиная с pos = 0 и пустой текущей строки, чтобы рекурсивно сгенерировать все допустимые перестановки с повторениями

//+------------------------------------------------------------------+
//| Construct list of permutations with r repetition                 |
//+------------------------------------------------------------------+
void PermuteWithRepetition(string elements, int r, string &results[])
  {
   int n = StringLen(elements);
   ArrayResize(results, 0);          // clear output
   if(n == 0)
      return;
   if(r <= 0)
      r=n ;                // default to length of string
   BacktrackRepetition(0, "", results, elements, n, r);
  }

Сохранение сгенерированных перестановок

После выполнения функции GetKPermutations или PermuteWithRepetition сгенерированные результаты сохраняются в массивах для дальнейшего использования. Чтобы сделать эти перестановки легкодоступными для других алгоритмов и торговых моделей, мы разработали дополнительную функцию, которая экспортирует результаты в текстовый файл (.txt).

Функция SavePermutationsToFile принимает три аргумента: Cperm1, Cperm2 и имя файла, где Cperm1 и Cperm2 передаются по ссылке, а имя файла инициализируется как "patterns.txt".

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

//+------------------------------------------------------------------+
//| Write permutation results to TXT file                            |
//+------------------------------------------------------------------+
void SavePermutationsToFile(string &Cperms1[], string &Cperms2[],
                            string filename="patterns.txt")
  {
//--- opru/create file
   int handle = FileOpen(filename, FILE_TXT | FILE_WRITE, '\t');
//--- check if file opened successfully
   if(handle == INVALID_HANDLE)
     {
      Print("Failed to open file: ", filename);
      return;
     }
//--- header
   FileWrite(handle, "No.", "|", "BullishPattern", "|", "BearishPattern");
   FileWrite(handle, "----------------------------------------------------");
//--- write rows
   int size = MathMin(ArraySize(Cperms1), ArraySize(Cperms2));
   for(int i = 0; i < size; i++)
     {
      FileWrite(handle, i+1, "|", Cperms1[i], "|", Cperms2[i]);
     }
//--- close file
   FileClose(handle);
//-- output message
   MessageBox(StringFormat("Results saved to file: %s", filename), "Prompt");
  }

Рабочий процесс PermGenerator

При выполнении кода из раздела "Скрипты" панели навигации платформы MQL5 алгоритм сначала проверяет, имеют ли бычьи и медвежьи наборы свечей одинаковую длину. Если длины не совпадают, отображается сообщение "Set must be equal length!" (Оба набора должны иметь одинаковую длину!), и программа завершает работу.

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

Общий рабочий сценарий и структура реализации представлены ниже.

• enum permType — Определяет два режима генерации перестановок: одиночный (без повторений) и повторный (с повторениями).
• allowPermType — Позволяет пользователю выбрать режим перестановки через диалоговое окно ввода MQL5. Значение по умолчанию, 0, выбирает режим перестановок без повторений.
• p — Задает длину перестановки или размер выбора (p), представляющий количество элементов в каждом сгенерированном паттерне. Значение по умолчанию составляет 2.
• bullCandles = "AHEGD" — Представляет собой набор идентификаторов бычьих свечных паттернов, где каждый символ соответствует уникальному типу бычьего паттерна.
• bearCandles = "ahegd" — Представляет собой соответствующие идентификаторы медвежьих свечных паттернов. Каждый медвежий символ напрямую соответствует своему бычьему аналогу, и алгоритм гарантирует, что обе строки имеют одинаковую длину перед обработкой.
• perms1 & perms2 — Динамические массивы, используемые для хранения сгенерированных бычьих и медвежьих перестановок соответственно.

enum permType{single, repeat};
input permType allowPermType = 0;
input int  p = 2;                // number of selections
string bullCandles = "AHEGD";    // bullish candles 
string bearCandles = "ahegd";    // bearish candles
string perms1[];                 // store bullish patterns
string perms2[];                 // store bearish patterns

Наборы bullCandles и bearCandles, размер паттерна (p) и массивы, предназначенные для хранения перестановок, передаются в функции GetKPermutations или PermuteWithRepetition. В зависимости от выбранного пользователем режима перестановки алгоритм выполняет соответствующий процесс генерации. Сгенерированные бычьи и медвежьи перестановки затем сохраняются в массивах и экспортируются в текстовый файл, что делает их легкодоступными для использования в обнаружении сигналов, статистическом анализе и других торговых алгоритмах.

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- check for matching length of bull and bear string
   if(StringLen(bullCandles) != StringLen(bearCandles))
     {
      MessageBox("Set must be equal length!", "Note");
      return;
     }
   if(allowPermType==0)
     {
      GetKPermutations(bullCandles, p, perms1);
      GetKPermutations(bearCandles, p, perms2);
     }
   else
     {
      PermuteWithRepetition(bullCandles, p, perms1);
      PermuteWithRepetition(bearCandles, p, perms2);
     }
//-- save to txt file
   SavePermutationsToFile(perms1, perms2);
  }

Демонстрация PermGenerator

Эта демонстрация показывает, как выполнить скриптовый файл и найти сгенерированный текстовый файл на платформе MQL5 после завершения обработки. После появления сообщения "Результаты сохранены в файл" подтверждается успешное выполнение программы и сохранение данных о перестановках в указанном текстовом файле, готовом для использования в других приложениях или торговых алгоритмах.

Рисунок 6: Демо 1 работы PermGenerator

Рисунок 7: Демо 2 работы PermGenerator

Рисунок 8: Демо 3 работы PermGenerator

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

Файлы	Назначение
PermCalculator.mq5	Вычисляет количество перестановок для заданного набора и длины паттерна.
PermGenerator.mq5	Генерирует список перестановок для заданного набора и длины паттерна

Заключение

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

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

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

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