Biblioteca de análisis numérico ALGLIB en MQL5

Introducción

Los mercados financieros generan datos con una enorme cantidad de relaciones complejas. Para analizarlos, debemos utilizar los métodos más modernos de matemáticas aplicadas. Sin embargo, combinar con éxito la alta complejidad de los datos financieros y la simplicidad y eficiencia del análisis no siempre es una tarea fácil. ALGLIB es una biblioteca de alto rendimiento diseñada específicamente para trabajar con métodos numéricos y algoritmos de análisis de datos, y es un asistente fiable en el análisis de mercados financieros.

La versatilidad de ALGLIB
Hoy en día, ALGLIB es reconocida como una de las mejores bibliotecas para trabajar con métodos numéricos; admite varios lenguajes de programación (C++, C#, Java, Python, Delphi) y sistemas operativos (Windows y POSIX, incluido Linux).

Entre las muchas características de ALGLIB, podemos destacar las siguientes:

• Álgebra lineal: Incluye algoritmos directos, métodos de valores propios (EVD) y valores singulares (SVD), esenciales para el análisis de datos.
• Resolución de ecuaciones: Admite sistemas de ecuaciones tanto lineales como no lineales, lo cual resulta útil a la hora de modelar procesos financieros complejos.
• Interpolación y aproximación: Existe soporte para varios métodos de interpolación y aproximación de datos, lo cual resulta útil para analizar y pronosticar las tendencias del mercado.
• Optimización: ALGLIB ofrece algoritmos para encontrar soluciones óptimas, lo que resulta importante para optimizar nuestro portafolio de inversiones y otras decisiones financieras.
• Integración numérica: Esta permite calcular integrales definidas, lo cual es útil al evaluar instrumentos financieros.
• Aprendizaje automático: Incluye análisis de datos, clasificación, regresión e incluso el uso de redes neuronales, lo que descubre nuevas oportunidades para predecir las tendencias del mercado.

Ventajas de ALGLIB
¿Por qué elegir ALGLIB al trabajar con datos financieros?

Estas son las ventajas clave de esta biblioteca:

• Portabilidad: ALGLIB se compila fácilmente en una amplia variedad de plataformas utilizando diferentes compiladores, lo cual lo hace accesible para desarrolladores con distinto nivel de experiencia.
• Facilidad de uso: La compatibilidad con múltiples lenguajes de programación nos permite elegir el lenguaje que nos resulte más cómodo, sin necesidad de aprender una nueva sintaxis.
• Código fuente abierto: ALGLIB es de código abierto y se puede usar bajo los términos de GPL 2+. Esto lo hace accesible tanto para investigaciones científicas como para proyectos comerciales.
• Soporte a usuarios comerciales: Los usuarios comerciales pueden adquirir una licencia que les ofrezca protección legal al utilizar ALGLIB.

Además, la biblioteca ALGLIB contiene un enorme conjunto de casos de prueba que abarcan al máximo la funcionalidad de los métodos propuestos. Esto nos permitirá realizar pruebas por nosotros mismos y informar sobre cualquier error encontrado a los autores del proyecto. Encontrará información más detallada sobre la biblioteca en el sitio web del proyecto https://www.alglib.net/

ALGLIB se adaptó por primera vez al uso en el lenguaje MQL5 en 2012. Esta adaptación supuso una conversión de la biblioteca desde la versión 3.5, y han pasado más de 10 años desde entonces. Durante este tiempo, ALGLIB se ha vuelto ampliamente conocido entre los desarrolladores y analistas en el campo del comercio en los mercados financieros. A lo largo de los años, el equipo de desarrollo ha trabajado activamente en la mejora de la biblioteca, realizando más de 70 cambios, incluida la adición de nuevas clases, funciones y mejoras.

También debemos tener en cuenta que las clases de biblioteca existentes se han rediseñado para usar matrices y vectores, y se ha añadido una nueva funcionalidad introducida en ALGLIB 3.19. Para trabajar con números complejos, ahora se utiliza el tipo de datos complex. Todo el código fuente ha sido revisado y estructurado según el mismo estilo de diseño.

Desafortunadamente, los cambios realizados en la biblioteca ALGLIB en la versión 3.19 para MQL5 fueron bastante significativos y, debido a ello, no se ofrece compatibilidad con versiones anteriores. Recomendamos a los usuarios que utilicen ALGLIB versión 3.5 en sus proyectos que revisen minuciosamente sus programas y realicen los ajustes necesarios.

Asimismo, debemos considerar que, además de las bibliotecas en sí, también se han actualizado los scripts de prueba, ahora hay 91 para las clases y 152 para las interfaces. Esto hace posible la ejecución de pruebas más fiables y completas de la funcionalidad de la biblioteca.

La nueva versión de ALGLIB está disponible en el enlace ALGLIB - Biblioteca de análisis numérico - librería para MetaTrader 5 y como parte del terminal MetaTrader 5 (\MQL5\Include\Math\Alglib\, incluidos los casos de prueba en \MQL5\Scripts\UnitTests\ Alglib\).

1. Novedades de ALGLIB 3.19 (lista de cambios desde la versión 3.5)

3.19:

• La característica más importante de ALGLIB 3.19.0 es el nuevo solucionador RBF (función de base radial) para trabajar con grandes conjuntos de datos, que admite splines de placa delgada, splines biarmónicos y multicuadricos. Este solucionador admite problemas de interpolación y ajuste (suavizado);
• El nuevo algoritmo RBF usa el método de descomposición de dominios para resolver sistemas lineales. Como resultado, tiene requisitos de memoria O(N) y tiempo de ejecución O(N2), lo cual supone una mejora significativa con respecto a los requisitos de memoria O(N2) y el tiempo de ejecución O(N3) demandados por otras implementaciones de código abierto. Podemos utilizar para conjuntos de datos con más de 100 000 puntos.

3.18:

• Añadido el solucionador Sparse GMRES para ecuaciones lineales;
• Mejorado el rendimiento del algoritmo AMD (al optimizar el procesamiento de matrices con filas densas);
• La velocidad de los solucionadores interior point para programación lineal (LP) y programación cuadrática (QP) se ha incrementado gracias a la nueva descomposición de Cholesky y a la extensa optimización del código del solucionador.

3.17:

• Añadida la descomposición Sparse Supernodal Cholesky (con funciones expertas y envoltorios fáciles de usar) y el correspondiente Sparse Direct Linear Solver. Activada la reducción del rellenado de permutación y las factorizaciones indefinidas;
• Introducido un solucionador de problemas de programación lineal (LP) de puntos interiores a gran escala;
• Introducido un solucionador de problemas de programación cuadrática semidefinida (QP) de puntos interiores a gran escala.

3.16:

• Implementado un solucionador de problemas de programación cuadrática (QP) de puntos interiores con versiones densas y dispersas;
• Añadida una nueva subrutina para el ajuste rápido de splines cúbicos con penalizaciones con tiempo de ejecución O(N*logN);
• Introducido un nuevo solucionador SQP para programación no lineal;
• Implementado un formato de almacenamiento binario comprimido para grandes bosques aleatorios (reduciendo el uso de memoria entre 3,7 y 5,7 veces);
• Añadida la función sparsegemv() para matrices CRS y Skyline;
• Implementadas funciones normales bivariadas CDF y PDF.
• Los solucionadores de QP ahora notifican al multiplicador de Lagrange;
• Los solucionadores de QP ahora admiten restricciones lineales bidireccionales;
• Mejorada la estabilidad del solucionador SLP;
• Mejorada la selección de elementos de referencia en el solucionador LP para una solución más precisa.

3.15:

• Implementado el algoritmo Singular Spectrum Analysis (SSA, "caterpillar") para series temporales. La implementación está optimizada e incluye la extracción de tendencias, la predicción, la predicción de promedios y las actualizaciones incrementales rápidas del modelo;
• Añadido un solucionador directo para sistemas lineales dispersos almacenados en formato Skyline (SKS);
• Aumentado el rendimiento del solucionador QP-DENSE-AUL para problemas cuadráticos con una gran cantidad de desigualdades;
• Incrementada significativamente la velocidad (hasta 4 veces) de los solucionadores BLEIC y QP-BLEIC. El código interno de estos solucionadores se ha rediseñado sustancialmente, lo que ha dado como resultado una gestión de restricciones significativamente mejorado;
• Soporte de activación térmica para solucionadores de valores propios subdimensionales. Al resolver una secuencia de problemas de valores propios relacionados, se puede reutilizar una solución básica encontrada previamente como punto de partida para una nueva sesión de resolución;
• Simplificada la creación de matrices banda en formato SKS (función sparsecreatesksband());
• Añadido un nuevo conjunto de funciones BLAS de nivel 2 para números reales: GEMV, SYMV, TRSV;
• La función sparseset() ahora admite matrices SKS;
• El solucionador minqp ahora soporta el cálculo automático de escalas variables basadas en la diagonal del término cuadrático.

3.12:

• La función rbfsetpoints() ahora comprueba la presencia de NAN/INF en los datos de entrada;
• Los algoritmos de iteración inversa de valores propios y clusterización de K-medias ahora utilizan valores iniciales deterministas para la inicialización, lo que hace que los resultados sean reproducibles en diferentes ejecuciones;
• Corregido un pequeño error en el solucionador QQP: escalado automático incorrecto del término cuadrático.

3.11:

• Añadida la capacidad de realizar mínimos cuadrados no lineales restringidos linealmente (MinLM y LSFit); ahora es posible realizar aproximaciones no lineales con restricciones lineales en los parámetros;
• Añadido el soporte para circunscripción menor aproximada, área mínima y N-esferas inscritas máximas para datos (en 2D - círculos circunscritos, en 3D - esferas inscritas);
• Mejorada la estabilidad del solucionador MinNLC; se ha añadido otro modo de preprocesamiento: "estable preciso";
• Introducido un nuevo optimizador: MinBC con restricciones solo en variables en el estado "activo". Estas restricciones permiten estrategias de activación que no son posibles con restricciones lineales generales;
• Añadida la serialización/deserialización de flujo en las versiones ALGLIB para C# y C++;
• Implementados solucionadores de valores propios directos/dispersos/fuera de orden usando el método subespacial y el análisis de componentes principales (PCA) truncado rápido usando el método subespacial;
• Mejorados significativamente los RBF jerárquicos con soporte de paralelismo: son varios órdenes de magnitud más rápidos en algunos conjuntos de datos, pueden procesar más de 100 000 puntos;
• Añadido un solucionador de problemas de programación cuadrática (QP) con restricciones lineales;
• Mejorados los árboles kd: con consultas sobre áreas rectangulares y versiones seguras para subprocesos de las funciones de consulta.

3.10:

• Añadida la funcionalidad de importación CSV: ahora es posible leer matrices 2D desde archivos CSV;
• El algoritmo AGS (Adaptive Gradient Sampling) se ha introducido para optimizar problemas restringidos no lineales, no suavizados e inconsistentes, lo que convierte a ALGLIB en uno de los pocos paquetes comerciales que admite la optimización no suavizada;
• Añadido el método Ward para clusterización jerárquica;
• Los solucionadores lineales livianos se han implementado sin estimación de números de condición ni corrección iterativa; son muchas veces más rápidos que sus análogos "ricos en funcionalidades".

3.9:

• Mejoras significativas en el soporte de álgebra lineal densa/dispersa: formato de almacenamiento de matriz dispersa SKS, operaciones de álgebra lineal para matrices basadas en SKS, factorizador de Cholesky para SKS, y muchas funciones adicionales para matrices dispersas;
• Mejoras en solucionadores y optimizadores: un nuevo solucionador para un problema de programación cuadrática limitado con restricciones de variables: QuickQP, un optimizador de Lagrange aumentado no lineal, un optimizador BLEIC mejorado, un solucionador polinómico y muchas otras mejoras menores;
• Añadidas funciones adicionales de interpolación/ajuste: ajuste de curva logística con 4/5 parámetros, algoritmo Ramer–Douglas–Peucker (RDP);
• Aumentada la velocidad del algoritmo de análisis discriminante lineal (LDA).

3.8:

• Añadida la funcionalidad de clasificación (estadísticas descriptivas): una función que reemplaza los datos con sus clasificaciones;
• Introducido un nuevo solucionador, QP-BLEIC, capaz de resolver problemas de programación cuadrática dispersos e inconsistentes con restricciones de límites y restricciones lineales;
• Rendimiento FFT mejorado (más rendimiento, pero aún con un solo flujo);
• Muchas pequeñas mejoras (mejoras en el optimizador BLEIC, mejorada la inicialización de pesos para MLP, spline de Akima para menos de 5 puntos).

3.7:

• Optimizador BLEIC significativamente rediseñado. Primero, utiliza un nuevo algoritmo de conjunto activo de tres etapas propuesto por Elvira Illarionova, que combina proyección de gradiente con iteraciones de igualdad de restricciones L-BFGS. En segundo lugar, como el algoritmo ya no tiene iteraciones externas/internas anidadas, es posible establecer criterios de parada más transparentes para el algoritmo. En tercer lugar, utiliza una nueva estrategia de activación/desactivación de restricciones que gestiona correctamente las restricciones degeneradas;
• Mejorado significativamente el soporte para redes neuronales en ALGLIB. Introducida una nueva interfaz de entrenamiento que simplifica enormemente el entrenamiento de múltiples redes con la misma configuración y datos. Ahora es posible especificar el conjunto de entrenamiento usando una matriz dispersa;
• Soporte de clusterización mejorado: la nueva versión de ALGLIB incluye el algoritmo de análisis de clústeres jerárquico del subpaquete de clusterización. Este algoritmo incluye varias métricas de distancia (euclidiana, norma 1, norma infinita, métricas basadas en correlación de Pearson-Spearman, distancia coseno) y varios tipos de enlaces (enlace único, enlace completo, enlace promedio). La funcionalidad de clusterización de K-medias (que existía mucho antes del nuevo algoritmo) se ha combinado con el nuevo algoritmo de clusterización;
• Los solucionadores lineales dispersos (CG y LSQR) ahora admiten un manejador diagonal automático;
• Los solucionadores de mínimos cuadrados lineales/no lineales (subpaquetes lsfit) ahora informan sobre errores en los coeficientes;
• La funcionalidad de matriz dispersa ahora incluye nuevas funciones para convertir entre tablas hash y vistas CRS, así como mejoras de rendimiento en la función SparseRewriteExisting.

3.6:

• El optimizador cuadrático ahora admite una combinación arbitraria de igualdades/desigualdades lineales y de límites. La nueva versión del optimizador usa una combinación del método de Lagrange aumentado y el método de conjunto activo;
• El módulo Spline1D ahora admite la interpolación con splines cúbicos monótonos;
• Soporte para splines vectoriales bilineales y bicúbicos;
• Soporte para splines trilineales (3D) escalares y vectoriales;
• Soporte mejorado para matrices dispersas: enumeración eficiente de elementos distintos a cero usando la función SparseEnumerate(), SparseGet() más rápida para matrices almacenadas en formato CRS;
• Los algoritmos de optimización y aproximación no lineal (subpaquetes LSFit, MinLM, MinBLEIC, MinLBFGS, MinCG) pueden verificar la validez del gradiente ofrecido por el usuario (el error más común en los programas numéricos).

2. La biblioteca ALGLIB en la investigación científica

Gracias a la disponibilidad del código fuente abierto y la posibilidad de su uso gratuito en proyectos no comerciales, la biblioteca ALGLIB se ha convertido en una herramienta importante en el mundo de la investigación científica. Se usa con éxito para resolver problemas diversos y complejos.

El impacto significativo de ALGLIB resulta evidente en el desarrollo de software personalizado, donde muchos algoritmos de ALGLIB se convierten en la base para crear soluciones innovadoras.

Además, los algoritmos de flujo único de ALGLIB sirven como punto de referencia para el desarrollo de versiones paralelas de algoritmos iterativos diseñados para resolver enormes sistemas de ecuaciones que contienen alrededor de 2 millones de ecuaciones. Esto demuestra la fiabilidad y eficiencia sobresaliente de los algoritmos ofrecidos por la biblioteca ALGLIB.

Los investigadores han observado la alta calidad y eficiencia de los algoritmos de ALGLIB, lo cual los convierte en la opción preferida para resolver problemas de investigación complejos en una amplia variedad de campos, incluida la investigación básica y la ingeniería.

2.1. ALGLIB en problemas de optimización

2014: Hugo J. Kuijf, Susanne J. van Veluw, Mirjam I. Geerlings, Max A. Viergever, Geert Jan Biessels y 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 en problemas de interpolación

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 punto de referencia para la comparación

2015: Tarek Ibn Ziad, M. & Alkabani, Yousra & El-Kharashi, M. W. & Salah, Khaled & Abdelsalam, Mohamed. (2015). Aceleración de simulaciones electromagnéticas: 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álisis de mercados financieros

La primera versión de la biblioteca para MQL5 (ALGLIB 3.5) se ha usado ampliamente en el análisis de datos financieros y resuelve diversos problemas utilizando algoritmos modernos.

Le presentamos una lista de artículos en los que se han utilizado activamente clases y funciones de la biblioteca ALGLIB:

• Comprendemos la "memoria" del mercado usando la diferenciación y el análisis entrópico
  Algoritmo de regresión logística (clase CLogitModel)
  
  
• Recetas de estadística para el trader - Hipótesis
  Evaluación de hipótesis: 
  Prueba de rango con signo de Wilcoxon (clase CWilcoxonSignedRank)
  Prueba U de Mann-Whitney (clase CMannWhitneyU)
  Prueba de significancia del coeficiente de correlación de rangos de Spearman (SpearmanRankCorrelationSignificance)
  
  
• El Papel de las Distribuciones Estadísticas en el Trabajo del Trader
  Evaluación de hipótesis:  Prueba Jarque-Bera (clase CJarqueBera)
  
  
• Red neuronal: EA autooptimizable
  Algoritmos para trabajar con redes neuronales.
  clase CMLPBase - perceptrón multicapa
  clase CMLPTrain - entrenamiento de perceptrones multicapa
  clase CMLPE - conjuntos de redes neuronales
  
  
• Optimizamos la estrategia usando el gráfico del balance y comparamos los resultados con el criterio "Balance + max Sharpe Ratio"
  Clases para trabajar con la regresión lineal CLinReg, CLinearModel y CLRReport
  
  
• R cuadrado como evaluación de la calidad de la curva del balance de la estrategia 
  Clase para trabajar con la regresión lineal CLinReg
  Cálculo de la correlación lineal de Pearson y los coeficientes de correlación de rango de Spearman
  
  
• Valoración visual de los resultados de optimización
  Modelo de regresión lineal;
  Cálculo del coeficiente de correlación lineal de Pearson
  
  
• Ejemplo de desarrollo de una estrategia con spread para futuros en la bolsa de Moscú
  Modelo de regresión lineal
  
  
• Guía para escribir una DLL para MQL5 en Delphi
  Modelo de regresión lineal
  
  
• Estudiamos la clase CCanvas. Suavizado y sombras
• Gráficos en la biblioteca DoEasy (Parte 77): Clase de objeto Sombra 
• DoEasy. Elementos de control (Parte 27): Seguimos trabajando en el objeto WinForms "ProgressBar"
  Formación y desenfoque de sombras gaussianas
  
  
• Comercio con portafolio en MetaTrader 4
  Método de Análisis de Componentes Principales (funciones LRBuildZ, LSFitLinearC y PCABuildBasis)
  
  
• Optimización controlable: el método del recocido
  Generador de números aleatorios (clase CHighQualityRandStateShell, funciones HQRndRandomize, HQRndNormal, HQRndNormal2, HQRndUniformR)
  
  
• Uso práctico de las redes neuronales de Kohonen en el trading algorítmico (Parte I): Instrumental
  Algoritmo de clusterización de K-medias  
  
  
• Recetas MQL5 - Creando el búfer circular para calcular rápidamente los indicadores en la ventana móvil
  Cálculo de características estadísticas básicas.
  - valor medio (Media)
  - desviación estándar (StdDev)
  - asimetría de la campana de distribución (Skewness)
  - curtosis
  
  
• Características del Wizard MQL5 que debe conocer (Parte 6): Transformada de Fourier
  Transformada rápida de Fourier (FFTR1D)
  
  
• Representaciones en el dominio de la frecuencia de series temporales: Función espectral
  Transformada rápida de Fourier (FFTR1D)
  
  
• Random Decision Forest en el aprendizaje reforzado
  Algoritmo de bosque de decisión aleatoria (RDF)
  
  
• Características del Wizard MQL5 que debe conocer (Parte 5): Cadenas de Markov 
  Cadenas de Markov (clase CLMarkovCPD)
  
  
• Pronosticación de series temporales (Parte 2): el método de los mínimos cuadrados de los vectores de soporte (LS-SVM) 
  "Solucionadores" lineales de la biblioteca ALGLIB
  
  
• Características del Wizard MQL5 que debe conocer (Parte 04): Análisis Discriminante Lineal
  Análisis discriminante lineal (clase CLDA)
  
  
• Pronóstico de los movimientos de mercado con la ayuda de la clasificación bayesiana e indicadores basados en el análisis espectral singular
  Funciones de matriz ALGLIB
  

Así, la funcionalidad de la biblioteca matemática ALGLIB ha resultado ser una herramienta útil para analizar datos financieros.

4. Singular Spectrum Analysis en ALGLIB

Además de los métodos ya existentes, la nueva versión de la biblioteca ALGLIB ahora incluye el método Singular Spectrum Analysis (SSA , también conocida como "caterpillar"). Este método amplía significativamente las posibilidades de análisis de las series temporales financieras, especialmente en problemas de pronóstico. El algoritmo SSA está disponible desde la versión 3.15 y su implementación ha sido optimizada. Ofrece una funcionalidad útil para extraer tendencias, predecir series temporales, predecir promedios y disponer de actualizaciones rápidas de modelos incrementales.

Le invitamos a familiarizarse con el funcionamiento de este método en la práctica y a compartir su experiencia de uso al desarrollar estrategias comerciales.

A continuación le mostramos un script de prueba con ejemplos del uso del método SSA. Encontrará información adicional sobre ejemplos y detalles del uso del método SSA en la biblioteca ALGLIB en la guía de ayuda del sitio web oficial de la biblioteca en la sección 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();
  }
//+------------------------------------------------------------------+

Conclusión

ALGLIB es una poderosa herramienta para analizar datos en los mercados financieros. Multilingüe, multiplataforma, con una amplia funcionalidad y código abierto es sin lugar a dudas una opción atractiva para investigadores y desarrolladores en el campo del análisis y el modelado financiero. En esta esfera existe una necesidad constante de herramientas de análisis de datos fiables y ALGLIB enfrenta con éxito los desafíos respaldando el desarrollo y la mejora continuos.

Por su parte, los desarrolladores de la plataforma MetaTrader 5 ofrecen a los tráders las mejores soluciones:

• El lenguaje MQL5, cuya velocidad no es inferior a la del lenguaje C++;
• Trabajo integrado con bases de datos SQLite, capacidad de realizar cálculos usando OpenCL, soporte para DirectX, uso de modelos ONNX e integración con Python;
• Bibliotecas matemáticas, incluidas fuzzy logic, stats y una versión actualizada de ALGLIB.