Biblioteca de análise numérica ALGLIB em MQL5

Introdução

Os mercados financeiros geram dados com um volume imenso de complexas interrelações. Para analisá-los, é necessário aplicar os métodos mais modernos de matemática aplicada. Contudo, combinar com sucesso a alta complexidade dos dados financeiros com a simplicidade e eficiência da análise não é sempre uma tarefa fácil. ALGLIB é uma biblioteca de alto desempenho, criada especificamente para trabalhar com métodos numéricos e algoritmos de análise de dados, sendo um assistente confiável na análise dos mercados financeiros.

Multifuncionalidade do ALGLIB
Atualmente, ALGLIB é reconhecida como uma das melhores bibliotecas para trabalhar com métodos numéricos, suportando várias linguagens de programação (C++, C#, Java, Python, Delphi) e sistemas operacionais (Windows e POSIX, incluindo Linux).

Entre as numerosas capacidades do ALGLIB, destacam-se:

• Álgebra Linear: Inclui algoritmos diretos, métodos de cálculo de valores próprios (EVD) e valores singulares (SVD), que são importantes para a análise de dados.
• Resolução de Equações: Suporta tanto sistemas de equações lineares quanto não-lineares, útil na modelagem de processos financeiros complexos.
• Interpolação e Aproximação: Fornece suporte a vários métodos de interpolação e aproximação de dados, útil na análise e previsão de tendências de mercado.
• Otimização: ALGLIB oferece algoritmos para encontrar soluções ótimas, importantes para a otimização de portfólios de investimento e outras decisões financeiras.
• Integração Numérica: Permite calcular integrais definidos, útil na avaliação de instrumentos financeiros.
• Aprendizado de Máquina: Inclui análise de dados, classificação, regressão e até o uso de redes neurais, abrindo novas possibilidades para a previsão de tendências de mercado.

Vantagens do ALGLIB
Por que escolher o ALGLIB ao trabalhar com dados financeiros?

Aqui estão as principais vantagens desta biblioteca:

• Portabilidade: O ALGLIB é facilmente compilado em diferentes plataformas usando vários compiladores, tornando-o acessível para desenvolvedores com diferentes experiências.
• Facilidade de Uso: O suporte a múltiplas linguagens de programação permite escolher a mais conveniente para você, sem a necessidade de aprender uma nova sintaxe.
• Código Aberto: O ALGLIB vem com código aberto e pode ser utilizado sob os termos da GPL 2+. Isso o torna acessível tanto para pesquisas científicas quanto para projetos comerciais.
• Suporte a Usuários Corporativos: Usuários corporativos podem adquirir uma licença, o que lhes proporciona proteção legal ao usar o ALGLIB.

Além disso, a biblioteca ALGLIB contém um vasto conjunto de casos de teste, cobrindo ao máximo as funcionalidades dos métodos oferecidos. Isso permite que você faça seus próprios testes e relate quaisquer erros encontrados aos autores do projeto. Mais informações sobre a biblioteca podem ser encontradas no site do projeto https://www.alglib.net/

O ALGLIB foi adaptado pela primeira vez para uso na linguagem MQL5 em 2012. Esta adaptação foi uma transferência da biblioteca da versão 3.5, e desde então mais de 10 anos se passaram. Durante esse tempo, o ALGLIB ganhou ampla notoriedade entre desenvolvedores e analistas no campo do comércio nos mercados financeiros. Ao longo desses anos, a equipe de desenvolvimento trabalhou ativamente no aprimoramento da biblioteca, introduzindo mais de 70 mudanças, incluindo a adição de novas classes, funções e melhorias.

Também é importante mencionar que as classes existentes da biblioteca foram redesenhadas para uso de matrizes e vetores, e novas funcionalidades foram adicionadas, conforme apresentado no ALGLIB 3.19. Para trabalhar com números complexos, agora é utilizado o tipo de dado complex. Todo o código-fonte foi revisado e estruturado, mantendo um estilo uniforme de formatação.

Infelizmente, as mudanças introduzidas na versão 3.19 da biblioteca ALGLIB para MQL5 foram bastante significativas, e, portanto, não é prevista a compatibilidade retroativa. Usuários que utilizam a biblioteca ALGLIB versão 3.5 em seus projetos são aconselhados a realizar uma verificação cuidadosa de seus programas e fazer as correções necessárias.

Também é importante mencionar que, além das próprias bibliotecas, os cenários de teste foram atualizados, agora com 91 para classes e 152 para interfaces. Isso contribui para um teste mais confiável e abrangente da funcionalidade da biblioteca.

A nova versão do ALGLIB está disponível no link ALGLIB - numerical analysis library - biblioteca para MetaTrader 5 e faz parte do terminal MetaTrader 5 (\MQL5\Include\Math\Alglib\, incluindo casos de teste em \MQL5\Scripts\UnitTests\Alglib\).

1. Novidades no ALGLIB 3.19 (lista de mudanças desde a versão 3.5)

3.19:

• A característica mais importante do ALGLIB 3.19.0 é o novo solucionador RBF (função de base radial) para trabalhar com grandes conjuntos de dados, que suporta splines de placa fina, splines bigarmônicas e multiquádricas. Este solucionador suporta tanto tarefas de interpolação quanto de ajuste (suavização);
• O novo algoritmo RBF usa o método de decomposição de domínio para resolver sistemas lineares. Como resultado, ele tem requisitos de memória O(N) e tempo de execução O(N2), o que representa uma melhoria significativa em comparação com os requisitos de memória O(N2) e tempo de execução O(N3), necessários para outras implementações de código aberto. Ele pode ser usado para conjuntos de dados com mais de 100.000 pontos.

3.18:

• Adicionado o solucionador Sparse GMRES para equações lineares;
• Melhoria no desempenho do algoritmo AMD (na otimização do processamento de matrizes com linhas densas);
• A velocidade dos solucionadores de ponto interior para programação linear (LP) e programação quadrática (QP) foi aumentada graças a uma nova decomposição de Cholesky e extensa otimização do código do próprio solucionador.

3.17:

• Adicionadas a decomposição Sparse Supernodal Cholesky (com funções especialistas e invólucros convenientes) e o correspondente Sparse Direct Linear Solver. Incluída a redução de preenchimento por permutação e fatorizações indefinidas;
• Introduzido um solucionador para grandes tarefas de ponto interior de programação linear (LP);
• Introduzido um solucionador para grandes tarefas de ponto interior de programação quadrática semi-definida (QP).

3.16:

• Implementado um solucionador para tarefas de ponto interior de programação quadrática (QP) com versões densas e esparsas;
• Adicionada uma nova sub-rotina para ajuste rápido de splines cúbicos penais com tempo de execução O(N*logN);
• Introduzido um novo solucionador SQP para programação não linear;
• Implementado um formato binário compactado para armazenamento de grandes florestas aleatórias (com redução de uso de memória de 3.7-5.7 vezes);
• Adicionada a função sparsegemv() para matrizes CRS e Skyline;
• Implementadas funções bivariadas normais CDF e PDF.
• Agora os solucionadores QP reportam os multiplicadores de Lagrange;
• Os solucionadores QP agora suportam restrições lineares bilaterais;
• Melhorada a estabilidade do solucionador SLP;
• Melhorada a seleção do elemento pivô no solucionador LP para soluções mais precisas.

3.15:

• Implementado o algoritmo Singular Spectrum Analysis (SSA, "lagarta") para séries temporais. A implementação é otimizada e inclui extração de tendência, previsão, previsão com média e atualizações incrementais rápidas do modelo;
• Adicionado um solucionador direto para sistemas lineares esparsos armazenados no formato Skyline (SKS);
• Aumento do desempenho do solucionador QP-DENSE-AUL para tarefas quadráticas com um grande número de desigualdades;
• Significativamente aumentada a velocidade dos solucionadores BLEIC e QP-BLEIC (até 4 vezes). O código interno desses solucionadores foi significativamente reestruturado, resultando em uma melhora substancial no tratamento de restrições;
• Suporte para inicialização térmica em solucionadores de valores próprios de subespaços. Ao resolver uma sequência de tarefas relacionadas com valores próprios, é possível reutilizar uma solução de base previamente encontrada como ponto de partida para uma nova sessão de resolução;
• Simplificado a criação de matrizes em banda no formato SKS (função sparsecreatesksband());
• Adicionado um novo conjunto de funções BLAS de nível 2 para números reais: GEMV, SYMV, TRSV;
• A função sparseset() agora suporta matrizes SKS;
• O solucionador minqp agora suporta cálculo automático de escalas de variáveis com base na diagonal do termo quadrático.

3.12:

• A função rbfsetpoints() agora verifica a presença de NAN/INF nos dados de entrada;
• Os algoritmos de clusterização k-means e de iteração inversa para valores próprios agora usam valores iniciais determinísticos para inicialização, garantindo a reprodutibilidade dos resultados em diferentes execuções;
• Corrigido um pequeno erro no solucionador QQP - escalonamento automático incorreto do termo quadrático.

3.11:

• Adicionada a capacidade de realizar mínimos quadrados não lineares com restrições lineares (MinLM e LSFit) - agora é possível fazer aproximação não linear com restrições lineares nos parâmetros;
• Adicionado suporte para descrição aproximada do menor envoltório, área mínima e esfera N-dimensional máxima inscrita para dados (em 2D - círculos envolventes, em 3D - esferas inscritas);
• Melhorada a estabilidade do solucionador MinNLC e adicionado outro modo de pré-processamento - "estável preciso";
• Introduzido um novo otimizador - MinBC com restrições apenas nas variáveis no estado "ativo". Essas restrições permitem o uso de estratégias de ativação, que são impossíveis para restrições lineares gerais;
• Adicionada serialização/deserialização em fluxo nas versões ALGLIB para C# e C++.
• Implementados solucionadores de valores próprios diretos/esparsos/excepcionais usando o método de subespaço e um método rápido de componentes principais truncados (PCA) utilizando o método de subespaço;
• Significativamente melhorados os RBF hierárquicos com suporte a paralelismo - várias ordens de magnitude mais rápidos em alguns conjuntos de dados, podem processar mais de 100.000 pontos;
• Adicionado um solucionador para tarefas de programação quadrática com restrições lineares (QP);
• Melhorados os kd-trees - com consultas por áreas retangulares e versões thread-safe das funções de consulta.

3.10:

• Adicionada a funcionalidade de importação de CSV - agora é possível ler matrizes 2D de arquivos CSV;
• Implementado o algoritmo AGS (Amostragem de Gradiente Adaptativa) para otimização de tarefas não lineares, não suavizáveis e não concordantes com restrições, tornando o ALGLIB um dos poucos pacotes comerciais a suportar otimização não suavizável;
• Adicionado o método Ward para clusterização hierárquica;
• Implementados solucionadores lineares leves sem avaliação do número de condicionamento e correção iterativa - são muitas vezes mais rápidos do que seus análogos "ricos em funcionalidades".

3.9:

• Melhorias significativas no suporte a álgebra linear densa/esparsa: formato de armazenamento de matrizes esparsas SKS, operações de álgebra linear para matrizes baseadas em SKS, fatorizador de Cholesky para SKS, muitas funções adicionais para matrizes esparsas;
• Melhorias em solucionadores e otimizadores: novo solucionador de tarefas de programação quadrática restrita com restrições nas variáveis - QuickQP, otimizador não linear Augmented Lagrangian, otimizador BLEIC melhorado, solucionador polinomial e muitas outras pequenas melhorias;
• Adicionadas funções adicionais de interpolação/ajuste: ajuste da curva logística com 4/5 parâmetros, algoritmo Ramer-Douglas-Peucker (RDP);
• Aumento da velocidade do algoritmo de análise discriminante linear (LDA).

3.8:

• Adicionada funcionalidade de ranking (estatística descritiva) - função que substitui os dados pelos seus rankings;
• Introduzido o novo solucionador QP-BLEIC, capaz de resolver tarefas de programação quadrática esparsa e não concordante com restrições de borda e restrições lineares;
• Melhoria no desempenho da FFT (maior desempenho, mas ainda de thread único);
• Muitas pequenas melhorias (passos para frente no otimizador BLEIC, melhor inicialização de pesos para MLP, spline de Akima para menos de 5 pontos).

3.7:

• O otimizador BLEIC foi significativamente reformulado. Primeiramente, utiliza um novo algoritmo de conjuntos ativos de três estágios proposto por Elvira Illarionova, que combina projeção de gradiente com iterações de igualdade de restrições do método L-BFGS. Em segundo lugar, como o algoritmo não tem mais iterações externas/internas aninhadas, critérios de parada mais transparentes podem ser estabelecidos. Em terceiro lugar, utiliza uma nova estratégia de ativação/desativação de restrições, que lida corretamente com restrições degeneradas;
• Significativa melhoria no suporte a redes neurais no ALGLIB. Introduzido um novo interface de treinamento, que simplifica consideravelmente o treinamento de várias redes com as mesmas configurações e dados. Agora é possível especificar um conjunto de treinamento usando uma matriz esparsa;
• Melhorada a suporte à clusterização - a nova versão do ALGLIB inclui um algoritmo de análise de cluster hierárquico do subpacote de clusterização. Este algoritmo inclui várias métricas de distância (euclidiana, norma-1, norma-infinita, métricas baseadas na correlação de Pearson e Spearman, distância cosseno) e vários tipos de ligações (ligação única, ligação completa, ligação média). A funcionalidade de clusterização K-means (que existia muito antes do novo algoritmo) foi integrada com o novo algoritmo de clusterização;
• Solucionadores lineares esparsos (CG e LSQR) agora suportam um pré-processador diagonal automático;
• Solucionadores de mínimos quadrados lineares/não lineares (subpacotes lsfit) agora reportam erros nos coeficientes;
• A funcionalidade de matrizes esparsas agora inclui novas funções para conversão entre representações de tabela hash e CRS, além de melhorias no desempenho da função SparseRewriteExisting.

3.6:

• Agora, o otimizador quadrático suporta uma combinação arbitrária de restrições de borda e igualdades/desigualdades lineares. A nova versão do otimizador utiliza uma combinação do método de Lagrange aumentado e do método de conjuntos ativos;
• O módulo Spline1D agora suporta interpolação com splines cúbicos monótonos;
• Suporte para splines bilineares e bicúbicos vetoriais;
• Suporte para splines trilineares (3D) escalares e vetoriais;
• Melhoria no suporte a matrizes esparsas: enumeração eficiente de elementos não nulos com a função SparseEnumerate(), SparseGet() mais rápido para matrizes armazenadas no formato CRS;
• Algoritmos de otimização e aproximação não linear (subpacotes LSFit, MinLM, MinBLEIC, MinLBFGS, MinCG) podem verificar a correção do gradiente fornecido pelo usuário (um dos erros mais comuns em programas numéricos).

2. A Biblioteca ALGLIB em Pesquisas Científicas

Graças à disponibilidade de código aberto e à possibilidade de uso gratuito em projetos não comerciais, a biblioteca ALGLIB tornou-se uma ferramenta importante no mundo das pesquisas científicas. Ela é aplicada com sucesso na solução de uma variedade de tarefas complexas.

A influência significativa da biblioteca ALGLIB é evidente no desenvolvimento de software especializado, onde muitos algoritmos do ALGLIB se tornam a base para a criação de soluções inovadoras.

Além disso, os algoritmos de thread único da ALGLIB servem como referência e ponto de partida para o desenvolvimento de versões paralelas de algoritmos iterativos destinados a resolver sistemas de equações enormes, contendo cerca de 2 milhões de equações. Isso demonstra a confiabilidade e a eficiência excepcional dos algoritmos fornecidos pela biblioteca ALGLIB.

Os pesquisadores destacam a alta qualidade e eficácia dos algoritmos da biblioteca ALGLIB, tornando-a a escolha preferencial para resolver tarefas complexas e de pesquisa científica em diversas áreas, incluindo pesquisas fundamentais e desenvolvimentos de engenharia.

2.1. ALGLIB em Tarefas de Otimização

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 em Tarefas de Interpolação

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. Algoritmos ALGLIB como Referência para Comparação

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. Algoritmos ALGLIB como Parte de Software Especializado

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. Biblioteca ALGLIB para análise de mercados financeiros

A primeira versão da biblioteca para MQL5 (ALGLIB 3.5) ganhou ampla aplicação na análise de dados financeiros, resolvendo uma variedade de tarefas usando algoritmos modernos.

Apresentamos uma lista de artigos nos quais as classes e funções da biblioteca ALGLIB foram ativamente utilizadas:

• Aprofundando na "memória" do mercado através da diferenciação e do análise de entropia
  Algoritmo de regressão logística (classe CLogitModel)
  
  
• Guia prático estatística do trader: hipóteses
  Testes de hipóteses: 
  Teste de Ranks Assinalados de Wilcoxon (classe CWilcoxonSignedRank)
  Teste U de Mann-Whitney (classe CMannWhitneyU)
  Teste de Significância do Coeficiente de Correlação de Ranks de Spearman (SpearmanRankCorrelationSignificance)
  
  
• O papel das distribuições estatísticas no trabalho de negociação
  Testes de hipóteses:  Teste Jarque-Bera (classe CJarqueBera)
  
  
• Rede neural: Expert Advisor auto-otimizável
  Algoritmos para trabalhar com redes neurais
  classe CMLPBase — perceptron multicamadas
  classe CMLPTrain — treinamento do perceptron multicamadas
  classe CMLPE — conjuntos de redes neurais
  
  
• Otimizando uma estratégia usando o gráfico do saldo e comparando os resultados com o critério "Balance + max Sharpe Ratio"
  Classes para trabalhar com regressão linear CLinReg, CLinearModel e CLRReport
  
  
• R quadrado como uma estimativa da qualidade da curva de saldo da estratégia 
  Classe para trabalhar com regressão linear CLinReg
  Cálculo dos coeficientes de correlação linear de Pearson e correlação de postos de Spearman
  
  
• Avaliação visual de resultados de otimização
  Modelo de regressão linear;
  Cálculo do coeficiente de correlação linear de Pearson
  
  
• Exemplo de desenvolvimento de uma estratégia de spread nos futuros da MICEX-RTS
  Modelo de regressão linear
  
  
• Guia para escrever uma DLL para MQL5 em Delphi
  Modelo de regressão linear
  
  
• Estudando a classe CCanvas. Anti-aliasing e sombras
• Gráficos na biblioteca DoEasy (Parte 77): classe do objeto Sombra 
• DoEasy. Controles (Parte 27): continuamos a trabalhar no objeto WinForms "ProgressBar"
  Formação e desfocagem de sombras pelo método de Gauss
  
  
• Carteira de investimentos no MetaTrader 4
  Método de análise de componentes principais (funções LRBuildZ, LSFitLinearC e PCABuildBasis)
  
  
• Otimização controlada: recozimento simulado
  Gerador de números aleatórios (classe CHighQualityRandStateShell, funções HQRndRandomize, HQRndNormal, HQRndNormal2, HQRndUniformR)
  
  
• Uso prático das redes neurais de Kohonen na negociação algorítmica. Parte I. Ferramentas
  Algoritmo de clusterização K-means  
  
  
• Receitas MQL5 - Criamos um buffer circular para calcular rapidamente indicadores numa janela deslizante
  Cálculo das principais características estatísticas
  - valor médio (Mean)
  - desvio padrão (StdDev)
  - assimetria da distribuição (Skewness)
  - curtose (Kurtosis)
  
  
• Funcionalidades do assistente MQL5 que você precisa conhecer (Parte 6): transformada de Fourier
  Transformada rápida de Fourier (FFTR1D)
  
  
• Representações no domínio da frequência de séries temporais: O espectro de potência
  Transformada rápida de Fourier (FFTR1D)
  
  
• Floresta de decisão aleatória no aprendizado por reforço
  Algoritmo de floresta de decisão aleatória (Random Decision Forest - RDF)
  
  
• Funcionalidades do assistente MQL5 que você precisa conhecer (Parte 05): cadeias de Markov 
  Cadeias de Markov (classe CMarkovCPD)
  
  
• Previsão de séries temporais (parte 2): método de vetores de suporte por mínimos quadrados (LS-SVM) 
  Soluções lineares da biblioteca ALGLIB
  
  
• Funcionalidades do assistente MQL5 que você precisa conhecer (Parte 04): análise discriminante linear
  Análise discriminante linear (Classe CLDA)
  
  
• Previsão de movimentos do mercado utilizando a classificação Bayesiana e indicadores com base na análise de espectro singular
  Funções matriciais ALGLIB
  

Assim, o conjunto de funções da biblioteca matemática ALGLIB se mostrou uma ferramenta útil para a análise de dados financeiros.

4. Análise de Espectro Singular (Singular Spectrum Analysis) no ALGLIB

Além dos métodos já existentes, a nova versão da biblioteca ALGLIB agora inclui o método Análise de Espectro Singular (SSA, também conhecido como "lagarta"). Este método expande significativamente as capacidades de análise de séries temporais financeiras, especialmente em tarefas de previsão. O algoritmo SSA está disponível a partir da versão 3.15 e sua implementação foi otimizada. Ele oferece funcionalidades para extração de tendência, previsão de séries temporais, previsão com média e possui atualizações incrementais rápidas do modelo.

Convidamos você a se familiarizar com a aplicação prática deste método e compartilhar sua experiência no uso para desenvolvimento de estratégias de negociação.

Abaixo está um script de teste com exemplos de uso do método SSA. Informações adicionais sobre os exemplos e detalhes do uso do método SSA na biblioteca ALGLIB podem ser encontradas na ajuda no site oficial da biblioteca na seção "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();
  }
//+------------------------------------------------------------------+

Conclusão

ALGLIB é uma ferramenta poderosa para análise de dados nos mercados financeiros. Sua multilinguagem, capacidade multiplataforma, amplas funcionalidades e código aberto a tornam uma escolha atraente para pesquisadores e desenvolvedores em análise e modelagem financeira. A necessidade constante de ferramentas confiáveis para análise de dados permanece relevante, e ALGLIB atende com sucesso a essa demanda, mantendo um desenvolvimento e aprimoramento contínuos.

Por sua parte, os desenvolvedores da plataforma MetaTrader 5 oferecem aos traders as melhores soluções:

• Linguagem MQL5, que é comparável em velocidade à linguagem C++;
• Trabalho integrado com bancos de dados SQLite, capacidade de realizar cálculos usando OpenCL, suporte a DirectX, uso de modelos ONNX e integração com Python;
• Bibliotecas matemáticas, incluindo lógica difusa, estatística e a versão atualizada do ALGLIB.