Libreria di analisi numerica ALGLIB in MQL5

Introduzione

I mercati finanziari generano dati con un'enorme quantità di relazioni complesse. Per analizzarli, dobbiamo utilizzare i metodi più moderni della matematica applicata. Combinare con successo l'elevata complessità dei dati finanziari con la semplicità e l'efficienza dell'analisi è un compito impegnativo. ALGLIB è una libreria ad alte prestazioni progettata specificamente per lavorare con metodi numerici e algoritmi di analisi dei dati. È un assistente affidabile nell'analisi dei mercati finanziari.

Versatilità di ALGLIB
Oggi ALGLIB è riconosciuta come una delle migliori librerie per lavorare con i metodi numerici. Supporta diversi linguaggi di programmazione (C++, C#, Java, Python, Delphi) e sistemi operativi (Windows e POSIX, incluso Linux).

Tra le numerose caratteristiche di ALGLIB, spiccano le seguenti:

• Algebra lineare: Include algoritmi diretti, metodo degli autovalori (EVD) e dei valori singolari (SVD), importanti per l'analisi dei dati.
• Risolvere equazioni: Supporta sia sistemi di equazioni lineari che non lineari, utili per la modellazione di processi finanziari complessi.
• Interpolazione e approssimazione: Sono supportati vari metodi di interpolazione e approssimazione dei dati, utili per analizzare e prevedere le tendenze di mercato.
• Ottimizzazione: ALGLIB fornisce algoritmi per trovare soluzioni ottimali, importanti per ottimizzare un portafoglio di investimenti e altre decisioni finanziarie.
• Integrazione numerica: Consente di calcolare gli integrali definiti, utili per la valutazione degli strumenti finanziari.
• Apprendimento automatico: Comprende l'analisi dei dati, la classificazione, la regressione e persino l'uso di reti neurali, che aprono a nuove possibilità di prevedere le tendenze del mercato.

Vantaggi di ALGLIB
Perché scegliere ALGLIB quando si lavora con i dati finanziari?

Ecco i principali vantaggi della libreria:

• Portabilità: ALGLIB si compila facilmente su una varietà di piattaforme utilizzando una varietà di compilatori, rendendolo accessibile a sviluppatori con background diversi.
• Facilità d'uso: Supporto per vari linguaggi di programmazione, in modo da poter scegliere il linguaggio con cui ci si sente più a proprio agio, senza dover imparare una nuova sintassi.
• Codice sorgente aperto: ALGLIB è open source e può essere utilizzato con licenza GPL 2+. Questo lo rende accessibile sia per la ricerca scientifica che per i progetti commerciali.
• Supporto agli utenti commerciali: Gli utenti commerciali possono acquistare una licenza che fornisce loro una protezione legale quando utilizzano ALGLIB.

Inoltre, la libreria contiene un'ampia raccolta di casi test che coprono la maggior parte delle funzionalità dei metodi proposti. Questo vi permetterà di riportare i test e e gli errori rilevati agli autori del progetto. Informazioni più dettagliate sulla libreria sono disponibili sul sito web del progetto https://www.alglib.net/.

ALGLIB è stata adattata per la prima volta per l'uso nel linguaggio MQL5 nel 2012. Questo adattamento era una conversione della libreria dalla versione 3.5. Da allora sono passati più di 10 anni. Durante questo periodo, ALGLIB è divenuta ampiamente conosciuta da sviluppatori e analisti nel campo del trading sui mercati finanziari. Nel corso degli anni, il team di sviluppo ha lavorato attivamente per migliorare la libreria, apportando più di 70 modifiche, tra cui l'aggiunta di nuove classi, funzioni e miglioramenti.

Va anche notato che le classi della libreria esistenti sono state riviste per utilizzare matrici e vettori e sono state aggiunte nuove funzionalità introdotte in ALGLIB 3.19. Il tipo di dati 'Complex' viene ora utilizzato per lavorare con i numeri complessi. Tutto il codice sorgente è stato rivisto e strutturato secondo lo stile di progettazione unificato.

Purtroppo, le modifiche apportate alla libreria ALGLIB nella versione 3.19 per MQL5 sono state piuttosto significative e quindi non è prevista la retrocompatibilità. Si consiglia agli utenti che applicano la versione 3.5 di ALGLIB nei loro progetti di rivedere accuratamente i loro programmi e di apportare le modifiche necessarie.

Oltre alle librerie stesse, sono stati aggiornati anche gli script di test. Ora ce ne sono 91 per le classi e 152 per le interfacce. Questo facilita un test più affidabile e completo della funzionalità della libreria.

La nuova versione di ALGLIB è disponibile qui: ALGLIB - Libreria di Analisi Numerica - libreria per MetaTrader 5, nonché parte della piattaforma MetaTrader 5 (\MQL5\Include\Math\Alglib\, compresi i casi di test in \MQL5\Scripts\UnitTests\Alglib\).

1. ALGLIB 3.19 cosa c'è di nuovo (elenco delle modifiche rispetto alla versione 3.5)

3.19:

• La caratteristica più importante di ALGLIB 3.19.0 è il nuovo risolutore RBF (Radial Basis Function) per la gestione di grandi insiemi di dati, che supporta thin-plate spline, spline biarmoniche e multiquadriche. Questo risolutore supporta sia problemi di interpolazione che di adattamento (smoothing);
• Il nuovo algoritmo RBF utilizza il metodo della decomposizione del dominio per risolvere sistemi lineari. Di conseguenza, ha requisiti di memoria O(N) e tempi di esecuzione O(N2), un miglioramento significativo rispetto ai requisiti di memoria O(N2) e ai tempi di esecuzione O(N3) richiesti da altre implementazioni open source. Può essere utilizzato per insiemi di dati con più di 100.000 punti.

3.18:

• Aggiunto risolutore Sparse GMRES per le equazioni lineari;
• Miglioramento delle prestazioni dell'algoritmo AMD (quando si ottimizza l'elaborazione di matrici con righe dense);
• Migliorata la velocità dei risolutori di punti interni per la programmazione lineare (LP) e quadratica (QP) grazie alla nuova decomposizione Cholesky e a un'ampia ottimizzazione del codice del risolutore.

3.17:

• Aggiunta la decomposizione Sparse Supernodal Cholesky (con funzioni esperte e wrapper di facile utilizzo) e il corrispondente Sparse Direct Linear Solver. Abilitata la riduzione del padding di permutazione e le fattorizzazioni non definite;
• Aggiunto un risolutore per problemi di programmazione lineare (LP) a punti interni su larga scala;
• Aggiunto un risolutore per problemi di programmazione quadratica semidefinita (QP) a punti interni su larga scala.

3.16:

• Implementato un risolutore per problemi di programmazione quadratica (QP) a punti interni con versioni dense e sparse;
• Aggiunta una nuova subroutine per l'adattamento rapido di spline cubiche penalizzate con tempo di esecuzione O(N*logN);
• Aggiunto un nuovo risolutore SQP per la programmazione non lineare;
• Introdotto un formato di archiviazione binario compresso per le foreste casuali di grandi dimensioni (riducendo l'uso della memoria di 3,7-5,7 volte);
• Aggiunta la funzione sparsegemv() per le matrici CRS e Skyline;
• Implementate le funzioni normali bivariate CDF e PDF.
• I risolutori QP ora riportano i moltiplicatori di Lagrange;
• I risolutori QP ora supportano i vincoli lineari bidirezionali;
• Miglioramento della stabilità del risolutore SLP;
• Miglioramento della selezione degli elementi di riferimento nel risolutore LP per una soluzione più accurata.

3.15:

• Implementazione dell'algoritmo Singular Spectrum Analysis (SSA, "caterpillar") per le serie temporali. L'implementazione è ottimizzata e comprende l'estrazione delle tendenze, la previsione, la media delle previsioni e i veloci aggiornamenti incrementali del modello;
• Aggiunto un risolutore diretto per i sistemi lineari sparsi memorizzati nel formato Skyline (SKS);
• Miglioramento delle prestazioni del risolutore QP-DENSE-AUL per problemi quadratici con un numero enorme di disuguaglianze;
• Aumento significativo della velocità dei risolutori BLEIC e QP-BLEIC (fino a quattro volte). Revisione del codice interno dei risolutori con conseguente miglioramento della gestione dei vincoli;
• Aggiunto il supporto dell'attivazione termica per i risolutori di autovalori sub-dimensionali. Quando si risolve una sequenza di problemi di autovalori correlati, è possibile riutilizzare una soluzione di base trovata in precedenza come punto di partenza per una nuova sessione di risoluzione;
• Semplificata la creazione di matrici a strisce nel formato SKS (funzione sparsecreatesksband());
• Aggiunta di una nuova serie di funzioni BLAS di livello 2 per i numeri reali: GEMV, SYMV, TRSV;
• La funzione sparseset() ora supporta le matrici SKS;
• Il risolutore minqp ora supporta il calcolo automatico delle scale delle variabili in base alla diagonale del termine quadratico.

3.12:

• La funzione rbfsetpoints() ora controlla la presenza di NAN/INF nei dati di input;
• Gli algoritmi di clustering k-means e di iterazione degli autovalori utilizzano ora valori di seme deterministici per l'inizializzazione, rendendo i risultati riproducibili in diverse esecuzioni;
• Corretto un piccolo bug nel risolutore QQP - scalabilità automatica errata del termine quadratico.

3.11:

• Aggiunta la possibilità di eseguire minimi quadrati non lineari con vincoli lineari (MinLM e LSFit). Ora è possibile effettuare un'approssimazione non lineare con vincoli lineari sui parametri;
• È stato aggiunto il supporto per l'approssimazione della più piccola circonferenza, dell'area minima e massima di N sfere inscritte per i dati (in 2D - cerchi circoscritti, in 3D - sfere inscritte);
• È stata migliorata la stabilità del risolutore MinNLC e aggiunta un'altra modalità di preelaborazione - "precise stable";
• Aggiunto un nuovo ottimizzatore - MinBC con restrizioni solo sulle variabili in stato "attivo". Queste restrizioni consentono strategie di attivazione che non sono possibili con i vincoli lineari generali;
• Aggiunta la serializzazione/deserializzazione dello streaming nelle versioni di ALGLIB per C# e C++;
• Implementazione di risolutori di autovalori diretti, sparsi e fuori ordine con il metodo del sottospazio e di un'analisi delle componenti principali (PCA) rapida e troncata con il metodo del sottospazio;
• RBF gerarchiche migliorate con il supporto del parallelismo - più veloci di diversi ordini di grandezza su alcuni set di dati e in grado di elaborare più di 100.000 punti;
• Aggiunto risolutore di problemi di programmazione quadratica (QP) con vincoli lineari;
• Alberi kd migliorati - con interrogazioni su aree rettangolari e versioni thread-safe delle funzioni di interrogazione.

3.10:

• Aggiunta funzionalità di importazione CSV - ora è possibile leggere matrici 2D da file CSV;
• Introdotto l'algoritmo AGS (Adaptive Gradient Sampling) per ottimizzare problemi non lineari, non regolari e con vincoli inconsistenti, rendendo ALGLIB uno dei pochi pacchetti commerciali che supporta l'ottimizzazione non regolare;
• Aggiunto il metodo Ward per il clustering gerarchico;
• Implementazione di risolutori lineari leggeri senza stima del numero di condizioni e correzione iterativa - sono molto più veloci dei loro analoghi "functionality-rich".

3.9:

• Miglioramenti significativi nel supporto dell'algebra lineare sparsa/densa: Formato di memorizzazione delle matrici sparse SKS, operazioni di algebra lineare per le matrici basate su SKS, fattorizzatore di Cholesky per SKS, molte funzioni aggiuntive per le matrici sparse;
• Miglioramenti nei risolutori e negli ottimizzatori: un nuovo risolutore per un problema di programmazione quadratica limitata con vincoli sulle variabili - QuickQP, ottimizzatore Augmented Lagrangian non lineare, ottimizzatore BLEIC migliorato, risolutore polinomiale e molti altri miglioramenti minori;
• Aggiunte ulteriori funzioni di interpolazione/adattamento: adattamento della curva logistica con 4/5 parametri, algoritmo Ramer-Douglas-Peucker (RDP);
• Migliorata la velocità dell'algoritmo di analisi discriminante lineare (LDA).

3.8:

• Aggiunta della funzionalità di classificazione (statistiche descrittive) - la funzione che sostituisce i dati con i loro ranghi;
• È stato introdotto un nuovo risolutore, QP-BLEIC, in grado di risolvere problemi di programmazione quadratica sparsa e non costante con limiti e vincoli lineari;
• Prestazioni FFT migliorate (maggiori prestazioni, ma sempre a thread singolo);
• Numerosi miglioramenti minori (passi avanti nell'ottimizzatore BLEIC, migliore inizializzazione dei pesi per MLP, spline Akima per meno di cinque punti).

3.7:

• L'ottimizzatore BLEIC è stato riprogettato in modo significativo. In primo luogo, utilizza un nuovo algoritmo di set attivo a tre stadi proposto da Elvira Illarionova, che combina la proiezione del gradiente con iterazioni dell'uguaglianza dei vincoli L-BFGS. In secondo luogo, poiché l'algoritmo non ha più iterazioni esterne/interne annidate, è possibile impostare criteri di arresto più trasparenti per l'algoritmo. In terzo luogo, utilizza una nuova strategia di attivazione/disattivazione dei vincoli che gestisce correttamente i vincoli degenerati;
• Supporto notevolmente migliorato per le reti neurali in ALGLIB. È stata introdotta una nuova interfaccia di addestramento che semplifica notevolmente l'addestramento di più reti con le stesse impostazioni e gli stessi dati. È ora possibile specificare l'insieme di addestramento utilizzando una matrice sparsa;
• Supporto migliorato per il clustering - la nuova versione di ALGLIB include l'algoritmo di analisi gerarchica dei cluster dal sottopacchetto clustering. Questo algoritmo include diverse metriche di distanza (Euclidea, 1-norm, infinity-norm, metrica basata sulla correlazione Pearson-Spearman, distanza del coseno) e diversi tipi di collegamento (collegamento singolo, collegamento completo, collegamento medio). La funzionalità di clustering K-means (che esisteva già da molto tempo prima del nuovo algoritmo) è stata combinata con il nuovo algoritmo di clustering;
• I risolutori lineari sparsi (CG e LSQR) ora supportano il preprocessore diagonale automatico;
• I risolutori dei minimi quadrati lineari/non lineari (sottopacchetti lsfit) ora riportano gli errori nei rapporti;
• La funzionalità di matrice sparsa include ora nuove funzioni per la conversione tra tabelle hash e viste CRS, nonché miglioramenti delle prestazioni della funzione SparseRewriteExisting.

3.6:

• L'ottimizzatore quadratico ora supporta una combinazione arbitraria dei limiti e di uguaglianze/disuguaglianza lineare. La nuova versione dell'ottimizzatore utilizza una combinazione del metodo Augmented di Lagrange e del metodo degli insiemi attivi;
• Il modulo Spline1D ora supporta l'interpolazione con spline cubiche monotoniche;
• Aggiunto il supporto per le spline vettoriali bilineari e bicubiche;
• Aggiunto il supporto per le spline trilineari (3D) scalari e vettoriali;
• Supporto migliorato per le matrici sparse: enumerazione efficiente degli elementi non nulli mediante la funzione SparseEnumerate(), SparseGet() più veloce per le matrici memorizzate in formato CRS;
• Gli algoritmi di ottimizzazione e di approssimazione non lineare (sottopacchetti LSFit, MinLM, MinBLEIC, MinLBFGS, MinCG) possono verificare la validità del gradiente fornito dall'utente (l'errore più comune nei programmi numerici).

2. La libreria ALGLIB nella ricerca scientifica

Grazie alla disponibilità open source e all'uso gratuito per progetti non commerciali, ALGLIB è diventato uno strumento importante nel mondo della ricerca scientifica. Viene utilizzato con successo per risolvere problemi diversi e complessi.

L'impatto significativo di ALGLIB è evidente nello sviluppo di software personalizzato, dove molti algoritmi di ALGLIB diventano la base per creare soluzioni innovative.

Inoltre, gli algoritmi single-threaded di ALGLIB servono come benchmark e punto di riferimento per lo sviluppo di versioni parallele di algoritmi iterativi progettati per risolvere enormi sistemi di equazioni contenenti circa 2 milioni di equazioni. Questo dimostra l'affidabilità e l'eccezionale efficienza degli algoritmi forniti dalla libreria ALGLIB.

I ricercatori hanno notato l'alta qualità e l'efficienza degli algoritmi di ALGLIB, che lo rendono la scelta preferita per la risoluzione di problemi di ricerca complessi in diversi campi, tra cui la ricerca di base e l'ingegneria.

2.1. ALGLIB nei problemi di ottimizzazione

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 nei problemi di interpolazione

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. Algoritmi ALGLIB come benchmark di confronto

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. Algoritmi ALGLIB come parte di software specializzato

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. Libreria ALGLIB per l'analisi dei mercati finanziari

La prima versione della libreria per MQL5 (ALGLIB 3.5) è stata ampiamente utilizzata nell'analisi dei dati finanziari, risolvendo vari problemi con algoritmi moderni.

Di seguito è riportato un elenco di articoli che applicano attivamente classi e funzioni della libreria ALGLIB:

• Scoprire la "memoria" del mercato attraverso l'analisi della differenziazione e dell'entropia
  Algoritmo di regressione logistica (classe CLogitModel)
  
  
• Ricette statistiche per un trader: Ipotesi
  Verifica delle ipotesi: 
  Test dei segni per ranghi di Wilcoxon (classe CWilcoxonSignedRank)
  Test U di Mann-Whitney(classe CMannWhitneyU)
  Test di significatività del coefficiente di correlazione di rango Spearman (SpearmanRankCorrelationSignificance)
  
  
• Il ruolo delle distribuzioni statistiche nel lavoro del trader
  Test delle ipotesi: Test di Jarque-Bera (classe CJarqueBera)
  
  
• Rete neurale: Expert Advisor auto-ottimizzante
  Algoritmi per lavorare con le reti neurali
  Classe CMLPBase — perceptron multistrato
  Classe CMLPTrain — addestramento del perceptron multistrato
  Classe CMLPE — set di reti neurali
  
  
• Ottimizzare la strategia in base al valore del bilancio e confrontare i risultati con il criterio "Bilancio + max Sharpe Ratio".
  Classi CLinReg, CLinearModel e CLRReport per lavorare con la regressione lineare.
  
  
• R-quadro come stima della qualità della curva del bilancio della strategia 
  Classe CLinReg per lavorare con la regressione lineare
  Calcolo dei coefficienti di correlazione lineare di Pearson e di correlazione di rango di Spearman
  
  
• Valutazione visiva dei risultati dell'ottimizzazione
  Modello di regressione lineare;
  Calcolo del coefficiente di correlazione lineare di Pearson
  
  
• Un Esempio di Sviluppo di una Strategia di Spread sui Futures della Borsa di Mosca
  Modello di regressione lineare
  
  
• Guida alla scrittura di una DLL per MQL5 in Delphi
  Modello di regressione lineare
  
  
• Studio della classe CCanvas. Anti-aliasing e ombre
• Grafica nella libreria DoEasy (parte 77): Classe di oggetti ombra 
• DoEasy. Controlli (Parte 27): Lavorare sull'oggetto ProgressBar di WinForms
  Modellamento e sfocatura delle ombre gaussiane
  
  
• Portafoglio di trading in MetaTrader 4
  Metodo dell'Analisi delle Componenti Principali (funzioni LRBuildZ, LSFitLinearC e PCABuildBasis)
  
  
• Ottimizzazione controllata: Simulated annealing
  Generatore di numeri casuali (classe CHighQualityRandStateShell, funzioni HQRndRandomize, HQRndNormal, HQRndNormal2 e HQRndUniformR)
  
  
• Uso Pratico delle Reti Neurali di Kohonen nel Trading Algoritmico. Parte I. Strumenti
  Algoritmo di clustering K-means  
  
  
• MQL5 Cookbook - Creazione di un buffer ad anello per il calcolo rapido degli indicatori in una finestra scorrevole
  Calcolo dei parametri statistici di base
  - Media
  - deviazione standard (StdDev)
  - asimmetria della distribuzione a campana (Skewness)
  - Curtosi
  
  
• Tecniche di MQL5 Wizard da conoscere (Parte 06): Trasformata di Fourier
  Trasformazione rapida di Fourier (FFTR1D)
  
  
• Rappresentazioni nel dominio della frequenza delle serie temporali: Lo Spettro di Potenza
  Trasformazione rapida di Fourier (FFTR1D)
  
  
• Foresta Decisionale Casuale nel consolidamento dell'apprendimento
  Algoritmo della Foresta Decisionale Casuale (RDF)
  
  
• Tecniche di MQL5 Wizard da conoscere (Parte 5): Catene di Markov 
  catene markov (classe CMarkovCPD)
  
  
• Previsione delle Serie Temporali (parte 2): Least-Square Support-Vector Machine (LS-SVM) 
  “Risolutori” lineari della libreria ALGLIB
  
  
• Tecniche di MQL5 Wizard da conoscere (Parte 04): Analisi discriminante lineare
  Analisi discriminante lineare (classe CLDA)
  
  
• Previsione dei movimenti di mercato utilizzando la classificazione Bayesiana e gli indicatori basati sull'Analisi dello Spettro Singolare
  Funzioni matriciali ALGLIB
  

Pertanto, le funzionalità della libreria matematica ALGLIB si sono rivelate uno strumento utile per l'analisi dei dati finanziari.

4. Analisi dello Spettro Singolare in ALGLIB

Oltre ai metodi già esistenti, la nuova versione della libreria ALGLIB include ora il metodo Singular Spectrum Analysis (SSA, noto anche come "caterpillar"). Questo metodo espande in modo significativo le capacità di analisi delle serie temporali finanziarie, soprattutto per quanto riguarda i problemi della loro previsione. L'algoritmo SSA è disponibile dalla versione 3.15 e la sua implementazione è stata ottimizzata. Fornisce funzionalità per l'estrazione delle tendenze, la previsione delle serie temporali, la previsione della media e dispone di aggiornamenti rapidi e incrementali del modello.

Vi invitiamo a familiarizzare con il funzionamento pratico di questo metodo e a condividere la vostra esperienza di utilizzo nello sviluppo di strategie di trading.

Di seguito è riportato uno script di test con esempi di utilizzo del metodo SSA. Per ulteriori informazioni su esempi e dettagli sull'uso del metodo SSA nella libreria ALGLIB, consultare la sezione "Singular Spectrum Analysis" della guida ufficiale della libreria.

//+------------------------------------------------------------------+
//|                                                     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();
  }
//+------------------------------------------------------------------+

Conclusioni

ALGLIB è un potente strumento per l'analisi dei dati dei mercati finanziari. La multilateralità, la natura multipiattaforma, la ricchezza di funzionalità e l'open source lo rendono una scelta interessante per ricercatori e sviluppatori nel campo dell'analisi e della modellazione finanziaria. C'è un bisogno costante di strumenti di analisi dei dati affidabili e ALGLIB risponde con successo a questa sfida supportando continuamente lo sviluppo e il miglioramento.

Da parte loro, gli sviluppatori della piattaforma MetaTrader 5 offrono ai trader le migliori soluzioni:

• Il linguaggio MQL5, che è ottimo quanto C++ in termini di velocità;
• Elaborazione integrata di database SQLite, possibilità di eseguire calcoli con OpenCL, supporto DirectX, utilizzo di modelli ONNX e integrazione con Python;
• Librerie matematiche, tra cui logica fuzzy, statistica e versione aggiornata di ALGLIB.