Библиотека численного анализа ALGLIB в MQL5

Введение

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

Многофункциональность ALGLIB
На сегодняшний день ALGLIB признана одной из лучших библиотек для работы с численными методами, она поддерживает несколько языков программирования (C++, C#, Java, Python, Delphi) и операционных систем (Windows и POSIX, включая Linux).

Среди многочисленных возможностей ALGLIB выделяются:

• Линейная алгебра: Включает в себя прямые алгоритмы, методы вычисления собственных значений (EVD) и сингулярных значений (SVD), что является важным для анализа данных.
• Решение уравнений: Поддерживает как линейные, так и нелинейные системы уравнений, что пригодится при моделировании сложных финансовых процессов.
• Интерполяция и аппроксимация: Имеется поддержка различных методов интерполяции и аппроксимации данных, что полезно при анализе и прогнозировании рыночных трендов.
• Оптимизация: ALGLIB предоставляет алгоритмы для поиска оптимальных решений, что важно для оптимизации портфеля инвестиций и других финансовых решений.
• Численное интегрирование: Позволяет вычислять определенные интегралы, что полезно при оценке финансовых инструментов.
• Машинное обучение: Включает в себя анализ данных, классификацию, регрессию и даже использование нейронных сетей, что открывает новые возможности для прогнозирования рыночных трендов.

Преимущества ALGLIB
Почему стоит выбрать ALGLIB при работе с финансовыми данными?

Вот ключевые преимущества этой библиотеки:

• Портативность: ALGLIB легко компилируется на различных платформах с использованием различных компиляторов, что делает ее доступной для разработчиков с разным опытом.
• Простота использования: Поддержка нескольких языков программирования позволяет выбирать наиболее удобный для вас язык, не требуя изучать новый синтаксис.
• Открытый исходный код: ALGLIB поставляется с открытым исходным кодом и может использоваться на условиях GPL 2+. Это делает ее доступной как для научных исследований, так и для коммерческих проектов.
• Поддержка коммерческих пользователей: Коммерческие пользователи могут приобрести лицензию, что обеспечивает им правовую защиту при использовании ALGLIB.

Кроме того, библиотека ALGLIB содержит огромный набор тесткейсов, максимально покрывающих функционал предлагаемых методов. Это позволит вам самостоятельно произвести тесты и сообщить о найденных ошибках авторам проекта. Более подробную информацию о библиотеке можно найти на сайте проекта https://www.alglib.net/

ALGLIB была впервые адаптирована для использования на языке MQL5 в 2012 году. Эта адаптация представляла собой перевод библиотеки с версии 3.5, и с тех пор прошло более 10 лет. За это время ALGLIB приобрела широкую известность среди разработчиков и аналитиков в области торговли на финансовых рынках. За эти годы команда разработчиков активно работала над усовершенствованием библиотеки, внесла более 70 изменений, включая добавление новых классов, функций и улучшений.

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

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

Важно отметить также, что кроме самих библиотек, были обновлены и тестировочные сценарии, теперь их 91 для классов и 152 для интерфейсов. Это способствует более надежному и всестороннему тестированию функционала библиотеки.

Новая версия ALGLIB доступна по ссылке ALGLIB - библиотека численного анализа - библиотека для MetaTrader 5 и в составе терминала MetaTrader 5 (\MQL5\Include\Math\Alglib\, включая тест кейсы в \MQL5\Scripts\UnitTests\Alglib\).

1. Что появилось нового в ALGLIB 3.19 (список изменений с версии 3.5)

3.19:

• Самой важной особенностью в ALGLIB 3.19.0 является новый решатель RBF (радиальной базисной функции) для работы с крупными наборами данных, который поддерживает тонкопластинчатые сплайны, бигармонические сплайны и мультиквадрики. Этот решатель поддерживает как задачи интерполяции, так и задачи подгонки (сглаживания);
• Новый алгоритм RBF использует метод декомпозиции области для решения линейных систем. В результате он имеет требования к памяти O(N) и время выполнения O(N2), что представляет собой значительное улучшение по сравнению с требованиями к памяти O(N2) и временем выполнения O(N3), необходимыми для других реализаций с открытым исходным кодом. Его можно использовать для наборов данных с более чем 100 000 точек.

3.18:

• Добавлен решатель Sparse GMRES для линейных уравнений;
• Улучшена производительность алгоритма AMD (при оптимизации обработки матриц с плотными строками);
• Увеличена скорость работы солверов interior point для линейного программирования (LP) и квадратичного программирования (QP) благодаря новому разложению Холецкого и обширной оптимизации кода самого солвера.

3.17:

• Добавлены разложение Sparse Supernodal Cholesky (с экспертными функциями и удобными оболочками) и соответствующий Sparse Direct Linear Solver. Включено уменьшение заполнения перестановкой и неопределенные факторизации;
• Введен солвер для крупномасштабных задач интерьерного точечного линейного программирования (LP);
• Введен солвер для крупномасштабных задач интерьерного точечного полуопределенного квадратичного программирования (QP).

3.16:

• Реализован солвер для задач интерьерного точечного квадратичного программирования (QP) с плотными и разреженными версиями;
• Добавлена новая подпрограмма для быстрого подгонки пенальных кубических сплайнов с временем выполнения O(N*logN);
• Введен новый солвер SQP для нелинейного программирования;
• Внедрен сжатый двоичный формат хранения для больших случайных лесов (с уменьшением использования памяти на 3.7-5.7 раз);
• Добавлена функция sparsegemv() для матриц CRS и Skyline;
• Реализованы бивариантные нормальные функции CDF и PDF.
• Теперь солверы QP сообщают множители Лагранжа;
• QP-cолверы теперь поддерживают двусторонние линейные ограничения;
• Улучшена устойчивость SLP-солвера;
• Улучшен выбор опорного элемента в солвере LP для более точного решения.

3.15:

• Реализован алгоритм Singular Spectrum Analysis (SSA, "гусеница") для временных рядов. Реализация оптимизирована и включает извлечение тренда, предсказание, предсказание с усреднением и быстрые инкрементальные обновления модели;
• Добавлен прямой солвер для разреженных линейных систем, хранящихся в формате Skyline (SKS);
• Увеличена производительность солвера QP-DENSE-AUL для квадратных задач с огромным количеством неравенств;
• Существенно увеличена скорость солверов BLEIC и QP-BLEIC (до 4 раз). Внутренний код этих солверов был значительно переработан, что привело к существенному улучшению обработки ограничений;
• Поддержка теплового запуска для субпространственных солверов собственных значений. При решении последовательности связанных задач на собственные значения можно повторно использовать ранее найденное базисное решение в качестве начальной точки для новой сессии решения;
• Упрощено создание полосчатых матриц в формате SKS (функция sparsecreatesksband());
• Добавлен новый набор функций BLAS уровня 2 для вещественных чисел: GEMV, SYMV, TRSV;
• Функция sparseset() теперь поддерживает матрицы SKS;
• Солвер minqp теперь поддерживает автоматическое вычисление масштабов переменных на основе диагонали квадратичного члена.

3.12:

• Функция rbfsetpoints() теперь проверяет на наличие NAN/INF во входных данных;
• Алгоритмы кластеризации k-means и обратной итерации для собственных значений теперь используют детерминированные исходные значения для инициализации, что обеспечивает воспроизводимость результатов при разных запусках;
• Исправлена небольшая ошибка в солвере QQP - неправильное автоматическое масштабирование квадратичного члена.

3.11:

• Добавлена возможность выполнять линейно ограниченную нелинейную наименьших квадратов (MinLM и LSFit) - теперь можно проводить нелинейное приближение с линейными ограничениями на параметры;
• Добавлена поддержка приближенного наименьшего описывающего, минимальной области и максимальной вписанной N-сфер для данных (в 2D - описывающих кругов, в 3D - вписанных сфер);
• Улучшена устойчивость солвера MinNLC и добавлен еще один режим предварительной обработки - "точный устойчивый";
• Введен новый оптимизатор - MinBC с ограничениями только по переменным в состоянии "активно". Эти ограничения позволяют использовать стратегии активации, которые невозможны для общих линейных ограничений;
• Добавлена потоковая сериализация/десериализация в версии ALGLIB для C# и C++;
• Реализованы прямые/разреженные/внеочередные солверы собственных значений методом подпространства и быстрый усеченный метод главных компонент (PCA) с использованием метода подпространства;
• Значительно улучшены иерархические RBF с поддержкой параллелизма - на несколько порядков быстрее на некоторых наборах данных, могут обрабатывать более 100 000 точек;
• Добавлен солвер линейно ограниченной задачи квадратичного программирования (QP);
• Улучшены kd-деревья - с запросами по прямоугольным областям и потокобезопасными версиями функций запроса.

3.10:

• Добавлена функциональность импорта CSV - теперь можно читать 2D матрицы из CSV-файлов;
• Внедрен алгоритм AGS (Adaptive Gradient Sampling) для оптимизации нелинейных, несглаживаемых и несогласованных задач с ограничениями, что делает ALGLIB одним из немногих коммерческих пакетов, поддерживающих несглаживаемую оптимизацию;
• Добавлен метод Ward для иерархической кластеризации;
• Реализованы легковесные линейные солверы без оценки числа обусловленности и итерационной коррекции - они многократно быстрее своих "богатых функциональностью" аналогов.

3.9:

• Существенные улучшения в поддержке разреженной/плотной линейной алгебры: формат хранения разреженных матриц SKS, операции линейной алгебры для матриц на основе SKS, факторизатор Холецкого для SKS, множество дополнительных функций для разреженных матриц;
• Улучшения в солверах и оптимизаторах: новый солвер ограниченной задачи квадратичного программирования с ограничениями по переменным - QuickQP, нелинейный Augmented Lagrangian оптимизатор, улучшенный BLEIC оптимизатор, полиномиальный солвер и множество других мелких улучшений;
• Добавлены дополнительные функции интерполяции/подгонки: подгонка логистической кривой с 4/5 параметрами, алгоритм Рамера-Дугласа-Пеккера (RDP);
• Увеличена скорость работы алгоритма линейного дискриминантного анализа (LDA).

3.8:

• Добавлена функциональность ранжирования (описательной статистики) - функция, которая заменяет данные их рангами;
• Введен новый солвер QP-BLEIC, способный решать разреженные и несогласованные задачи квадратичного программирования с ограничениями по границам и линейными ограничениями;
• Улучшена производительность FFT (больше производительности, но по-прежнему однопотоковый);
• Множество мелких улучшений (шаги вверх в оптимизаторе BLEIC, лучшая инициализация весов для MLP, Akima сплайн для менее чем 5 точек).

3.7:

• Оптимизатор BLEIC был существенно переработан. Во-первых, в нем используется новый трехэтапный алгоритм активных множеств, предложенный Эльвирой Илларионовой, который комбинирует градиентную проекцию с итерациями равенств ограничений метода L-BFGS. Во-вторых, так как в алгоритме больше нет вложенных внешних/внутренних итераций, можно задать более прозрачные критерии остановки для алгоритма. В-третьих, он использует новую стратегию активации/деактивации ограничений, которая корректно обрабатывает вырожденные ограничения;
• Значительно улучшена поддержка нейронных сетей в ALGLIB. Введен новый интерфейс обучения, который значительно упрощает обучение нескольких сетей с одинаковыми настройками и данными. Теперь можно указать обучающий набор с помощью разреженной матрицы;
• Улучшена поддержка кластеризации - новая версия ALGLIB включает алгоритм иерархического кластерного анализа из подпакета кластеризации. Этот алгоритм включает несколько метрик расстояния (евклидова, 1-норма, бесконечность-норма, метрики, основанные на корреляции Пирсона и Спирмена, косинусное расстояние) и несколько типов связей (одиночная связь, полная связь, средняя связь). Функциональность кластеризации K-средних (которая существовала задолго до нового алгоритма) была объединена с новым алгоритмом кластеризации;
• Разреженные линейные солверы (CG и LSQR) теперь поддерживают автоматический диагональный предварительный обработчик;
• Линейные/нелинейные солверы наименьших квадратов (подпакеты lsfit) теперь сообщают об ошибках в коэффициентах;
• Функциональность разреженных матриц теперь включает новые функции для преобразования между хэш-таблицей и представлениями CRS, а также улучшение производительности функции SparseRewriteExisting.

3.6:

• Теперь квадратичный оптимизатор поддерживает произвольное сочетание граничных и линейных равенств/неравенств. Новая версия оптимизатора использует комбинацию увеличенного метода Лагранжа и метода активных множеств;
• Модуль Spline1D теперь поддерживает интерполяцию монотонными кубическими сплайнами;
• Поддержка векторных билинейных и бикубических сплайнов;
• Поддержка скалярных и векторных трилинейных (3D) сплайнов;
• Улучшена поддержка разреженных матриц: эффективное перечисление ненулевых элементов с помощью функции SparseEnumerate(), более быстрый SparseGet() для матриц, хранящихся в формате CRS;
• Алгоритмы оптимизации и нелинейного приближения (подпакеты LSFit, MinLM, MinBLEIC, MinLBFGS, MinCG) могут проверять правильность предоставленного пользователем градиента (самая распространенная ошибка в численных программах).

2. Библиотека ALGLIB в научных исследованиях

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

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

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

Исследователи отмечают высокое качество и эффективность алгоритмов библиотеки ALGLIB, что делает её предпочтительным выбором при решении сложных и научно-исследовательских задач в различных областях, включая фундаментальные исследования и инженерные разработки.

2.1. ALGLIB в задачах оптимизации

2014: Hugo J. Kuijf, Susanne J. van Veluw, Mirjam I. Geerlings, Max A. Viergever, Geert Jan Biessels & Koen L. Vincken. Automatic Extraction of the Midsagittal Surface from Brain MR Images using the Kullback–Leibler Measure. Neuroinform 12, 395–403 (2014)

The midsagittal plane computed in the previous section was used to initialize the computation of the midsagittal surface. The midsagittal surface was represented as a bicubic spline, as implemented in ALGLIB (Bochkanov and Bystritsky (2012)). Control points for the spline were placed in a regular grid on the computed midsagittal plane, with distance m between the control points.

2017: Vadim Bulavintsev, A GPU-enabled Black-box Optimization in Application to Dispersion-based Geoacoustic Inversion, 2017, in Yu. G. Evtushenko, M. Yu. Khachay, O. V. Khamisov, Yu. A. Kochetov, V.U. Malkova, M.A. Posypkin (eds.): Proceedings of the OPTIMA-2017 Conference, Petrovac, Montenegro, 02-Oct-2017

For reference, we provide the double-precision version based on the AlgLib library [Bochkanov & Bystritsky, 2016], that we used in our previous work [Zaikin et al., press]. The AlgLib library includes a state-of-the-art implementation of the bisection algorithm, thoroughly tuned to produce the most accurate results possible with the modern CPUs floating point units (FPUs). Our CPU-based implementation of bisection algorithm can not boast such accuracy. However, it is notably faster than AlgLib due to its simplicity. That is why, our and AlgLib-based algorithm’s results are different. The discrepancy between the outputs (residue) of the same algorithm on the CPU and GPU is the result of the different implementations of floating-point units on these platforms.

2.2. ALGLIB в задачах интерполяции

2021: Jasek K., Pasternak M., Miluski W., Bugaj J., Grabka M, Application of Gaussian Radial Basis Functions for Fast Spatial Imaging of Ground Penetration Radar Data Obtained on an Irregular Grid. Electronics 2021, 10, 2965.

The ALGLIB package implements both kinds of RBFs: the global Gaussian function and compactly supported. The classical Gaussian function takes small values already at a distance of about 3R0 from the center and can easily be modified to be compactly supported.

In this paper, the RBF-ML algorithm implemented in the ALGLIB package was used. It has three parameters: the initial radius, R0, the number of layers, NL, and the regularisation coefficient, l. This algorithm builds a hierarchy of models with decreasing radii [13]. In the initial (optional) iteration, the algorithm builds a linear least squares model. The values predicted by the linear model are subtracted from the function values at the nodes, and the residual vector is passed to the next iteration. In the first iteration, a traditional RBF model with a radius equal to R0 is built. However, it does not use a dense solver and does not try to solve the problem exactly. It solves the least squares problem by performing a fixed number (approximately 50) of LSQR [22] iterations. Usually, the first iteration is sufficient. Additional iterations will not improve the situation because with such a large radius, the linear system is ill-conditioned. The values predicted by the first layer of the RBF model are subtracted from the function values at the nodes, and, again, the residual vector is passed to the next iteration. With each successive iteration, the radius is halved by performing the same constant number of LSQR iterations, and the forecasts of the new models are subtracted from the residual vector.

In all subsequent iterations, a fine regularisation can be applied to improve the convergence of the LSQR solver. Larger values for the regularisation factor can help reduce data noise. Another way of controlled smoothing is to select the appropriate number of layers. Figure 2 shows an example of B-scan and a method of approximation by a hierarchical model. Subsequent layers have a radius that is twice as small and explain the residues after the previous layer. As the radius decreases, the finer details of the B-scan are reproduced.

The hierarchical algorithm has several significant advantages:

• Gaussian CS-RBFs produce linear systems with sparse matrices, enabling the use of the sparse LSQR solver, which can work with the rank defect matrix;
• The time of the model building depends on the number of points, N, as N logN in contrast to simple RBF’s implementations with O(N3) efficiency;
• An iterative algorithm (successive layers correct the errors of the previous ones) creates a robust model, even with a very large initial radius. Successive layers have smaller radii and correct the inaccuracy introduced by the previous layer;
• The multi-layer model allows for control smoothing both by changing the regularisation coefficient and by a different number of layers.

The presented hierarchical RBF approximation algorithm is one of the most efficient algorithms for processing large, scattered data sets. Its implementation, located in the ALGLIB library, enables simple software development, which can be successfully used to analyse GPR images.

2022: Ruiz M., Nieto J., Costa V., Craciunescu T., Peluso E., Vega J, Murari A, JET Contributors, Acceleration of an Algorithm Based on the Maximum Likelihood Bolometric Tomography for the Determination of Uncertainties in the Radiation Emission on JET Using Heterogeneous Platforms. Appl. Sci. 2022, 12, 6798.

ALGLIB is a numeric library focused on solving general numerical problems. It can be used with different programming languages such as C++, C#, and Delphi. It offers a great variety of functions for different science fields. In this specific application, it is required to interpolate the 2D data arrays that can or cannot be equally spaced (nonuniformly distributed). The development of the function implementing the equivalent to griddata requires the use of ALGLIB 2D interpolation functions for sparse/non-uniform data. For the fitting part, the least square solver function is used, for which two options are available: BlockLLS or FastDDDM. The FastDDDM option was chosen to achieve the best possible performance.

ArrayFire provides a complete API that solves the most common functionalities implemented with MATLAB language. Therefore, it can be considered that porting MATLAB to C++ using ArrayFire API is relatively straightforward, and some parts of the code are even equivalent line by line. Nevertheless, ArrayFire does not include some powerful functions available in MATLAB. For example, the function “griddata” allows different types of interpolations using uniform and not-uniform input data distribution. This function in MATLAB has some parts of the internal code visible to the user, but other parts are not available, making it impossible to reproduce its calculations. While ArrayFire version 3.8.0 includes a function for interpolation, it expects that input data will be uniformly organized. To solve this problem, we chose the open-source library ALGLIB, which provides a set of functions for 2D interpolation that can be used to circumvent the problem.

While most of the code and functions of the algorithm in MATLAB were translated into C++ and optimized, others could not be translated directly. The reason is that there is no information about the internal calculations of some of the functions in MATLAB. This implies that the results obtained in both implementations are slightly different. These differences are mainly evident in the implementation of the griddata function. For this application, it has been used with the “bicubic splines” interpolation method, incorporated in the FastDDM solver belonging to the ALGLIB library.

2.3. Алгоритмы ALGLIB как эталон для сравнения

2015: Tarek Ibn Ziad, M. & Alkabani, Yousra & El-Kharashi, M. W. & Salah, Khaled & Abdelsalam, Mohamed. (2015). Accelerating electromagnetic simulations: A hardware emulation approach. 10.1109/ICECS.2015.7440386.

...Ibn Ziad et al. implemented a Jacobi iterative solver on a physical hardware emulation platform to accelerate the finite element solver of an EM simulator [5]. They demonstrated the efficiency of their solution via implementing a twodimensional (2D) edge element code for solving Maxwell’s equations for metamaterials using FEM. Their design achieved 101x speed-up over the same pure software implementation on MATLAB [13]  and 35x over the best iterative software solver from ALGLIB C++ library [14] in case of solving 2 million equations.

In this paper, we present a scalable architecture that can efficiently accelerate the solver core of an EM simulator. The architecture is implemented on a physical hardware emulation platform and is compared to the state-of-the-art solvers. Experimental results show that the proposed solver is capable of 522x speed-up over the same pure software implementation on Matlab, 184x speed-up over the best iterative software solver from the ALGLIB C++ library, and 5x speed-up over another emulation-based hardware implementation from the literature, solving 2 million equations.

2016: Liu, Yongchao & Pan, Tony & Aluru, Srinivas (2016), Parallel Pairwise Correlation Computation On Intel Xeon Phi Clusters.

Using both artificial and real gene expression datasets, we have compared LightPCC to two CPU-based counterparts: a sequential C++ implementation in ALGLIB (http://www.alglib.net) and an implementation based on a parallel GEMM routine in Intel Math Kernel Library(MKL). Our experimental results showed that by using one 5110P Phi and 16 Phis, LightPCC is able to run up to 20.6× and 218.2× faster than ALGLIB, and up to 6.8× and 71.4× faster than singled-threaded MKL, respectively.

2.4. Алгоритмы ALGLIB как часть специализированного ПО

2015: Kraff S, Lindauer A, Joerger M, Salamone SJ, Jaehde U. Excel-Based Tool for Pharmacokinetically Guided Dose Adjustment of Paclitaxel. Ther Drug Monit. 2015 Dec;37(6):725-32

Methods: Population PK parameters of paclitaxel were taken from a published PK model. An Alglib VBA code was implemented in Excel 2007 to compute differential equations for the paclitaxel PK model. Maximum a posteriori Bayesian estimates of the PK parameters were determined with the Excel Solver using individual drug concentrations. Concentrations from 250 patients were simulated receiving 1 cycle of paclitaxel chemotherapy. Predictions of paclitaxel Tc > 0.05 μmol/L as calculated by the Excel tool were compared with NONMEM, whereby maximum a posteriori Bayesian estimates were obtained using the POSTHOC function.

2017: Hogland, John & Anderson, Nathaniel. (2017). Function Modeling Improves the Efficiency of Spatial Modeling Using Big Data from Remote Sensing. Big Data and Cognitive Computing.1.3.

While the statistical and machine learning transformations can be used to build surfaces and calculate records within a tabular field, they do not in themselves define the relationships between response and explanatory variables like a predictive model. To define these relationships, we built a suite of classes that perform a wide variety of statistical testing and predictive modeling using many of the optimization algorithms and mathematical procedures found within ALGLIB and Accord.net [15,16]

Furthermore, we introduce a new coding library that integrates Accord.NET and ALGLIB numeric libraries and uses lazy evaluation to facilitate a wide range of spatial, statistical, and machine learning procedures within a new GIS modeling framework called function modeling. Results from simulations show a 64.3% reduction in processing time and an 84.4% reduction in storage space attributable to function modeling. In an applied case study, this translated to a reduction in processing time from 2247 h to 488 h and a reduction is storage space from 152 terabytes to 913 gigabytes.

3. Библиотека ALGLIB для анализа финансовых рынков

Первая версия библиотеки для MQL5 (ALGLIB 3.5) приобрела широкое применение в анализе финансовых данных, решая разнообразные задачи с использованием современных алгоритмов.

Представляем список статей, в которых активно использовались классы и функции из библиотеки ALGLIB:

• Грокаем "память" рынка через дифференцирование и энтропийный анализ
  Алгоритм логистической регрессии (класс CLogitModel)
  
  
• Статистические рецепты для трейдера - Гипотезы
  Проверка гипотез: 
  Знаковый ранговый тест Уилкоксона (класс CWilcoxonSignedRank)
  U критерий Манна-Уитни (класс CMannWhitneyU)
  Тест на значимость коэффициента ранговой корреляции Спирмена (SpearmanRankCorrelationSignificance)
  
  
• Роль статистических распределений в работе трейдера
  Проверка гипотез:  Тест Харке — Бера (класс CJarqueBera)
  
  
• Нейросеть: Самооптимизирующийся советник
  Алгоритмы для работы с нейронными сетями
  класс CMLPBase — многослойный персептрон
  класс CMLPTrain — обучение многослойного персептрона
  класс CMLPE — наборы нейросетей
  
  
• Оптимизируем стратегию по графику баланса и сравниваем результаты с критерием "Balance + max Sharpe Ratio
  Классы для работы с линейной регрессией CLinReg, CLinearModel и CLRReport
  
  
• R-квадрат как оценка качества кривой баланса стратегии 
  Класс для работы с линейной регрессией CLinReg
  Расчет коэффициентов линейной корреляции Пирсона и ранговой корреляции Спирмена
  
  
• Визуальная оценка результатов оптимизации
  Модель линейной регресии;
  Расчет коэффициента линейной корреляции Пирсона
  
  
• Пример разработки спредовой стратегии на фьючерсах Московской биржи
  Модель линейной регресии
  
  
• Руководство по написанию DLL для MQL5 на Delphi
  Модель линейной регресии
  
  
• Изучаем класс CCanvas. Сглаживание и тени
• Графика в библиотеке DoEasy (Часть 77): Класс объекта Тень 
• DoEasy. Элементы управления (Часть 27): Продолжаем работу над WinForms-объектом "ProgressBar
  Формирование и размытие теней по Гауссу
  
  
• Портфельная торговля в MetaTrader 4
  Метод главных компонент Principal Component Analysis (функции LRBuildZ, LSFitLinearC и PCABuildBasis)
  
  
• Управляемая оптимизация: метод отжига
  Генератор случайных чисел (класс CHighQualityRandStateShell, функции HQRndRandomize, HQRndNormal, HQRndNormal2, HQRndUniformR)
  
  
• Практическое использование нейросетей Кохонена в алгоритмическом трейдинге (Часть I): Инструментарий
  Алгоритм кластеризации K-means  
  
  
• Рецепты MQL5 - Создаем кольцевой буфер для быстрого расчета индикаторов в скользящем окне
  Расчет основных статистических характеристик
  - среднее значение (Mean)
  - стандартное отклонение (StdDev)
  - асимметричность колокола распределения (Skewness)
  - эксцесс (Kurtosis)
  
  
• Возможности Мастера MQL5, которые вам нужно знать (Часть 6): Преобразование Фурье
  Быстрое преобразование Фурье (FFTR1D)
  
  
• Представления частотной области временных рядов: Спектральная функция
  Быстрое преобразование Фурье (FFTR1D)
  
  
• Random Decision Forest в обучении с подкреплением
  Алгоритм случайного леса Random Decision Forest (RDF)
  
  
• Возможности Мастера MQL5, которые вам нужно знать (Часть 5): Цепи Маркова 
  Цепи Маркова (класс CMarkovCPD)
  
  
• Прогнозирование временных рядов (Часть 2): метод наименьших квадратов опорных векторов (LS-SVM) 
  Линейные "решатели" библиотеки ALGLIB
  
  
• Возможности Мастера MQL5, которые вам нужно знать (Часть 04): Линейный дискриминантный анализ
  Линейный дискриминантный анализ (Класс CLDA)
  
  
• Прогнозирование рыночных движений с помощью байес-классификации и индикаторов на основе сингулярного спектрального анализа
  Матричные функции ALGLIB
  

Таким образом, функционал математической библиотеки ALGLIB оказался полезным инструментом для анализа финансовых данных.

4. Singular Spectrum Analysis в ALGLIB

Помимо уже существующих методов, новая версия библиотеки ALGLIB теперь включает в себя метод Singular Spectrum Analysis (SSA, также известный как "гусеница"). Этот метод значительно расширяет возможности анализа финансовых временных рядов, особенно в задачах их прогнозирования. Алгоритм SSA стал доступен начиная с версии 3.15, и его реализация оптимизирована. Он предоставляет функциональность для извлечения тренда, предсказания временных рядов, предсказания с усреднением и обладает быстрыми инкрементальными обновлениями модели.

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

Ниже приведен тестовый скрипт с примерами использования метода SSA. Дополнительную информацию о примерах и подробности использования метода SSA в библиотеке ALGLIB можно найти в справке на официальном сайте библиотеки в разделе "Singular Spectrum Analysis".

//+------------------------------------------------------------------+
//|                                                     SSA_Test.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Math\Alglib\alglib.mqh>

// Examples of SSA usage with ALGLIB
// https://www.alglib.net/translator/man/manual.cpp.html#example_ssa_d_basic
// https://www.alglib.net/translator/man/manual.cpp.html#example_ssВa_d_realtime
// https://www.alglib.net/translator/man/manual.cpp.html#example_ssa_d_forecast

//+------------------------------------------------------------------+
//| PrintMatrix                                                      |
//+------------------------------------------------------------------+
void PrintMatrix(CMatrixDouble &x)
  {
//--- print matrix
   string str="[";
   for(int i=0; i<x.Rows(); i++)
     {
      str+="[";
      for(int j=0; j<x.Cols(); j++)
        {
         str+=StringFormat("%f",x.Get(i,j));
         if(j<x.Cols()-1)
            str+=",";
        }
      str+="]";
      if(i<x.Rows()-1)
         str+=",";
     }
   str+="]";
   printf("%s",str);
  }
//+------------------------------------------------------------------+
//| PrintVector                                                      |
//+------------------------------------------------------------------+
void PrintVector(CRowDouble &x)
  {
//--- print vector
   string str="[";
   for(int i=0; i<x.Size(); i++)
     {
      str+=StringFormat("%f",x[i]);
      if(i<x.Size()-1)
         str+=",";
     }
   str+="]";
   printf("%s",str);
  }
//+------------------------------------------------------------------+
//| ssa_d_basic                                                      |
//+------------------------------------------------------------------+
//| Here we demonstrate SSA trend/noise separation for some toy      |
//| problem: small monotonically growing series X are analyzed with  |
//| 3-tick window and "top-K" version of SSA, which selects K largest|
//| singular vectors for analysis, with K=1.                         |
//+------------------------------------------------------------------+
int ssa_d_basic(void)
  {
//--- prepare input data
   double input_data[]= {0,0.5,1,1,1.5,2};
   CRowDouble x=input_data;
//--- first, we create SSA model, set its properties and add dataset.
//--- we use window with width=3 and configure model to use direct SSA algorithm which runs exact O(N*W^2) analysis - to extract one top singular vector.
//--- NOTE: SSA model may store and analyze more than one sequence (say, different sequences may correspond to data collected from different devices)
//--- ALGLIB wrapper class
   CAlglib alglib;
//--- SSA model
   CSSAModel ssa_model;
//--- create SSA model
   alglib.SSACreate(ssa_model);
//--- set window width for SSA model
   alglib.SSASetWindow(ssa_model,3);
//--- adds data sequence to SSA model
   alglib.SSAAddSequence(ssa_model,x);
//--- set SSA algorithm to "direct top-K" algorithm
   alglib.SSASetAlgoTopKDirect(ssa_model,1);
//--- now we begin analysis. Internally SSA model stores everything it needs:
//--- data, settings, solvers and so on. Right after first call to analysis-related function it will analyze dataset, build basis and perform analysis.
//--- subsequent calls to analysis functions will reuse previously computed basis, unless you invalidate it by changing model settings (or dataset).
//--- trend and noise
   CRowDouble trend,noise;
//--- build SSA basis using internally stored (entire) dataset and return reconstruction for the sequence being passed to this function
   alglib.SSAAnalyzeSequence(ssa_model,x,x.Size(),trend,noise);
//--- print result
   PrintVector(trend);
//--- output:   [0.381548,0.558290,0.781016,1.079470,1.504191,2.010505]
//--- EXPECTED: [0.3815,0.5582,0.7810,1.0794,1.5041,2.0105]
   return 0;
  }

//+------------------------------------------------------------------+
//| ssa_d_forecast                                                   |
//+------------------------------------------------------------------+
//| Here we demonstrate SSA forecasting on some toy problem with     |
//| clearly visible linear trend and small amount of noise.          |
//+------------------------------------------------------------------+
int ssa_d_forecast(void)
  {
//--- ALGLIB wrapper
   CAlglib alglib;
//--- model
   CSSAModel ssa_model;
//--- prepare input data
   double input_data[] = {0.05,0.96,2.04,3.11,3.97,5.03,5.98,7.02,8.02};
   CRowDouble x=input_data;
//--- first, we create SSA model, set its properties and add dataset.
//--- we use window with width=3 and configure model to use direct SSA algorithm - one which runs exact O(N*W^2) analysis-to extract two top singular vectors
//--- NOTE: SSA model may store and analyze more than one sequence (say, different sequences may correspond to data collected from different devices)
//--- create SSA model
   alglib.SSACreate(ssa_model);
//--- set window width for SSA model
   alglib.SSASetWindow(ssa_model,3);
//--- set window width for SSA model
   alglib.SSAAddSequence(ssa_model,x);
//--- set SSA algorithm to "direct top-K" algorithm
   alglib.SSASetAlgoTopKDirect(ssa_model,2);
//--- now we begin analysis. Internally SSA model stores everything it needs:
//--- data, settings, solvers and so on. Right after first call to analysis-related function it will analyze dataset, build basis and perform analysis.
//--- subsequent calls to analysis functions will reuse previously computed basis, unless you invalidate it by changing model settings (or dataset).
//--- in this example we show how to use ssaforecastlast() function, which predicts changed in the last sequence of the dataset.
//--- if you want to perform prediction for some other sequence, use alglib.SSAForecastSequence().
//--- trend
   CRowDouble trend;
   alglib.SSAForecastLast(ssa_model,3,trend);
//--- print result
   PrintVector(trend);
//--- output:   [9.000587,9.932294,10.805125]
//--- EXPECTED: [9.0005,9.9322,10.8051]
//--- well, we expected it to be [9,10,11]. There exists some difference, which can be explained by the artificial noise in the dataset.
   return 0;
  }
//+------------------------------------------------------------------+
//| ssa_d_realtime                                                   |
//+------------------------------------------------------------------+
//| Suppose that you have a constant stream of incoming data, and    |
//| you want to regularly perform singular spectral analysis         |
//| of this stream.                                                  |
//|                                                                  |
//| One full run of direct algorithm costs O(N*Width^2) operations,  |
//| so the more points you have, the more it costs to rebuild basis  |
//| from scratch.                                                    |
//|                                                                  |
//| Luckily we have incremental SSA algorithm which can perform      |
//| quick updates of already computed basis in O(K*Width^2) ops,     |
//| where K is a number of singular vectors extracted. Usually it    |
//| is orders of magnitude faster than full update of the basis.     |
//|                                                                  |
//| In this example we start from some initial dataset x0. Then we   |
//| start appending elements one by one to the end of the last       |
//| sequence                                                         |
//|                                                                  |
//| NOTE: direct algorithm also supports incremental updates, but    |
//|       with O(Width^3) cost. Typically K<<Width, so specialized   |
//|       incremental algorithm is still faster.                     |
//+------------------------------------------------------------------+
int ssa_d_realtime(void)
  {
//--- ALGLIB wrapper
   CAlglib alglib;
//--- model
   CSSAModel ssa_model1;
//---
   CMatrixDouble a1;
   CRowDouble sv1;
   int w,k;
//--- prepare input data
   double input_data[]= {0.009,0.976,1.999,2.984,3.977,5.002};
   CRowDouble x0=input_data;
//--- create SSA model
   alglib.SSACreate(ssa_model1);
//--- set window width for SSA model
   alglib.SSASetWindow(ssa_model1,3);
//--- adds data sequence to SSA model
   alglib.SSAAddSequence(ssa_model1,x0);
//--- set algorithm to the real-time version of top-K, K=2
   alglib.SSASetAlgoTopKRealtime(ssa_model1,2);
//--- one more interesting feature of the incremental algorithm is "power-up" cycle.
//--- even with incremental algorithm initial basis calculation costs O(N*Width^2) ops.
//--- if such startup cost is too high for your real-time app, then you may divide initial basis calculation
//--- across several model updates. It results in better latency at the price of somewhat lesser precision during first few updates.
   alglib.SSASetPowerUpLength(ssa_model1,3);
//--- now, after we prepared everything, start to add incoming points one by one;
//--- in the real life, of course, we will perform some work between subsequent update (analyze something, predict, and so on).
//--- after each append we perform one iteration of the real-time solver. Usually
//--- one iteration is more than enough to update basis. If you have REALLY tight performance constraints,
//--- you may specify fractional amount of iterations, which means that iteration is performed with required probability.
   double updateits = 1.0;
//--- append single point to last data sequence stored in the SSA model and update model in the incremental manner
   alglib.SSAAppendPointAndUpdate(ssa_model1,5.951,updateits);
//--- execute SSA on internally stored dataset and get basis found by current method
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- append single point to last data sequence
   alglib.SSAAppendPointAndUpdate(ssa_model1,7.074,updateits);
//--- execute SSA
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- append single point to last data sequence
   alglib.SSAAppendPointAndUpdate(ssa_model1,7.925,updateits);
//--- execute SSA
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- append single point to last data sequence
   alglib.SSAAppendPointAndUpdate(ssa_model1,8.992,updateits);
//--- execute SSA
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- append single point to last data sequence
   alglib.SSAAppendPointAndUpdate(ssa_model1,9.942,updateits);
//--- execute SSA
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- append single point to last data sequence
   alglib.SSAAppendPointAndUpdate(ssa_model1,11.051,updateits);
//--- execute SSA
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- append single point to last data sequence
   alglib.SSAAppendPointAndUpdate(ssa_model1,11.965,updateits);
//--- execute SSA
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- append single point to last data sequence
   alglib.SSAAppendPointAndUpdate(ssa_model1,13.047,updateits);
//--- execute SSA
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- append single point to last data sequence
   alglib.SSAAppendPointAndUpdate(ssa_model1,13.970,updateits);
//--- execute SSA
   alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k);
//--- ok, we have our basis in a1[] and singular values at sv1[]. But is it good enough? Let's print it.
   PrintMatrix(a1);
//--- output:   [[0.510607,0.753611],[0.575201,0.058445],[0.639081,-0.654717]]
//--- EXPECTED: [[0.510607,0.753611],[0.575201,0.058445],[0.639081,-0.654717]]
//--- ok, two vectors with 3 components each. but how to understand that is it really good basis? let's compare it with direct SSA algorithm on the entire sequence.
   CSSAModel ssa_model2;
   CMatrixDouble a2;
   CRowDouble sv2;
//--- input data
   double input_data2[]= {0.009,0.976,1.999,2.984,3.977,5.002,5.951,7.074,7.925,8.992,9.942,11.051,11.965,13.047,13.970};
   CRowDouble x2=input_data2;
//--- create SSA model
   alglib.SSACreate(ssa_model2);
//--- set window width for SSA model
   alglib.SSASetWindow(ssa_model2,3);
//--- add data sequence to SSA model
   alglib.SSAAddSequence(ssa_model2,x2);
//--- set SSA algorithm to "direct top-K" algorithm
   alglib.SSASetAlgoTopKDirect(ssa_model2,2);
//--- execute SSA on internally stored dataset and get basis found by current method
   alglib.SSAGetBasis(ssa_model2,a2,sv2,w,k);
//--- it is exactly the same as one calculated with incremental approach!
   PrintMatrix(a2);
//--- output:   [[0.510607,0.753611],[0.575201,0.058445],[0.639081,-0.654717]]
//--- EXPECTED: [[0.510607,0.753611],[0.575201,0.058445],[0.639081,-0.654717]]
   return 0;
  }
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- the very simple example of trend/noise separation
   ssa_d_basic();
//--- forecasting with SSA
   ssa_d_forecast();
//--- real-time analysis of constantly arriving data
   ssa_d_realtime();
  }
//+------------------------------------------------------------------+

Заключение

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

Со своей стороны, разработчики платформы MetaTrader 5 предоставляют трейдерам наилучшие решения:

• Язык MQL5, который не уступает по скорости языку C++;
• Встроенную работу с базами данных SQLite, возможность проведения расчетов с использованием OpenCL, поддержку DirectX, использование ONNX-моделей и интеграцию с Python;
• Математические библиотеки, включая нечеткую логику, статистику и обновленную версию ALGLIB.