MetaTrader 5 / Örnekler
English Русский 中文 Español Deutsch 日本語 Português 한국어 Français Italiano
preview
MQL5'te ALGLIB sayısal analiz kütüphanesi

MQL5'te ALGLIB sayısal analiz kütüphanesi

MetaTrader 5 — Örnekler | 27 Mayıs 2024, 16:11
437 0
MetaQuotes
MetaQuotes

Giriş

Finansal piyasalar çok sayıda karmaşık ilişki içeren veriler üretir. Bunları analiz etmek için uygulamalı matematiğin en modern yöntemlerini kullanmamız gerekiyor. Finansal verilerin yüksek karmaşıklığını analizin basitliği ve verimliliği ile başarılı bir şekilde birleştirmek zorlu bir görevdir. ALGLIB, özellikle sayısal yöntemler ve veri analizi algoritmaları ile çalışmak için tasarlanmış yüksek performanslı bir kütüphanedir. Finansal piyasaların analizinde güvenilir bir yardımcıdır.

ALGLIB’in çok yönlülüğü
Günümüzde ALGLIB, sayısal yöntemlerle çalışmak için en iyi kütüphanelerden biri olarak kabul edilmektedir. Çeşitli programlama dillerini (C++, C#, Java, Python, Delphi) ve işletim sistemlerini (Linux dahil olmak üzere Windows ve POSIX) destekler.

ALGLIB'in birçok özelliği arasında aşağıdakiler öne çıkmaktadır:

  • Lineer cebir: Veri analizi için önemli olan doğrudan algoritmalar, özdeğer (EVD) ve tekil değer (SVD) yöntemlerini içerir.
  • Denklem çözme: Hem lineer hem de lineer olmayan denklem sistemlerini destekler, bu da karmaşık finansal süreçleri modellerken kullanışlıdır.
  • İnterpolasyon ve yaklaşım: Piyasa trendlerini analiz etmek ve tahmin etmek için yararlı olan çeşitli veri interpolasyonu ve yaklaşım yöntemleri için destek vardır.
  • Optimizasyon: ALGLIB, bir yatırım portföyünü ve diğer finansal kararları optimize etmek için önemli olan optimum çözümleri bulmak için algoritmalar sağlar.
  • Sayısal entegrasyon: Finansal enstrümanların değerlendirilmesinde yararlı olan belirli integrallerin hesaplanmasına olanak tanır.
  • Makine öğrenimi: Veri analizi, sınıflandırma, regresyon ve hatta piyasa trendlerini tahmin etmek için yeni olanaklar sunan sinir ağlarının kullanımını içerir.


ALGLIB’in avantajları
Finansal verilerle çalışırken neden ALGLIB'i seçmelisiniz?

Kütüphanenin temel faydaları:

  • Portatiflik: ALGLIB, çeşitli derleyiciler kullanılarak çeşitli platformlarda kolayca derlenebilir ve farklı özgeçmişlere sahip geliştiriciler için erişilebilir hale gelir.
  • Kullanım kolaylığı: Birden fazla programlama dili desteği sayesinde yeni sözdizimi öğrenmek zorunda kalmadan en rahat ettiğiniz dili seçebilirsiniz.
  • Açık kaynak: ALGLIB açık kaynak kodludur ve GPL 2+ şartları altında kullanılabilir. Bu da onu hem bilimsel araştırmalar hem de ticari projeler için erişilebilir kılmaktadır.
  • Ticari kullanıcı desteği: Ticari kullanıcılar ALGLIB'i kullanırken kendilerine yasal koruma sağlayan bir lisans satın alabilirler.

Ayrıca kütüphane, sunulan yöntemlerin işlevselliğinin büyük bir kısmını kapsayan geniş bir test senaryosu koleksiyonu da içermektedir. Bu, testler gerçekleştirmenize ve tespit edilen hataları proje yazarlarına bildirmenize olanak tanır. Kütüphane hakkında daha ayrıntılı bilgiye https://www.alglib.net/ adresindeki proje web sitesinden ulaşabilirsiniz.

ALGLIB ilk olarak 2012 yılında MQL5 dilinde kullanılmak üzere uyarlanmıştır. Bu uyarlama, kütüphanenin 3.5 sürümünden dönüştürülmesiydi. O zamandan bu yana 10 yıldan fazla zaman geçti. Bu süre zarfında ALGLIB, finansal piyasalarda ticaret alanında geliştiriciler ve analistler arasında yaygın olarak tanınmıştır. Geliştirme ekibi yıllar boyunca kütüphaneyi geliştirmek için aktif olarak çalışmış, yeni sınıfların, fonksiyonların ve iyileştirmelerin eklenmesi de dahil olmak üzere 70'ten fazla değişiklik yapmıştır.

Ayrıca mevcut kütüphane sınıflarının matris ve vektörleri kullanacak şekilde yeniden tasarlandığını ve ALGLIB 3.19'da tanıtılan yeni işlevlerin eklendiğini de belirtmek gerekir. 'complex' veri türü artık karmaşık sayılarla çalışmak için kullanılmaktadır. Tüm kaynak kodu revize edilmiş ve birleşik tasarım stiline uygun olarak yapılandırılmıştır.

Ne yazık ki, MQL5 için 3.19 sürümünde ALGLIB kütüphanesinde yapılan değişiklikler oldukça önemlidir ve bu nedenle geriye dönük uyumluluk sağlanmamaktadır. ALGLIB sürüm 3.5'i projelerinde uygulayan kullanıcıların programlarını iyice gözden geçirmeleri ve gerekli düzeltmeleri yapmaları tavsiye edilir.

Kütüphanelerin yanı sıra test komut dosyaları da güncellenmiştir. Şimdi sınıflar için 91 ve arayüzler için 152 tane mevcuttur. Bu, kütüphane işlevselliğinin daha güvenilir ve kapsamlı bir şekilde test edilmesine katkıda bulunur.

ALGLIB'in yeni sürümüne buradan ulaşabilirsiniz: ALGLIB - Sayısal Analiz Kütüphanesi - MetaTrader 5 için kütüphane ve MetaTrader 5 platformunun bir parçası (\MQL5\Include\Math\Alglib\ - \MQL5\Scripts\UnitTests\Alglib\ içindeki testler dahil).


1. ALGLIB 3.19’daki yenilikler (3.5 sürümünden bu yana yapılan değişikliklerin listesi)

3.19:

  • ALGLIB 3.19.0'daki en önemli özellik, ince plaka splineları, biharmonik splineları ve multikuadriki destekleyen büyük veri setlerini işlemek için yeni RBF (Radial Basis Function, radyal taban fonksiyonu) çözücüsüdür. Bu çözücü hem interpolasyon hem de uydurma (yumuşatma) problemlerini destekler;
  • Yeni RBF algoritması, lineer sistemleri çözmek için alan ayrıştırma yöntemini kullanır. Sonuç olarak, O(N) bellek gereksinimine ve O(N2) yürütme süresine sahiptir; bu da diğer açık kaynak uygulamalarının gerektirdiği O(N2) bellek gereksinimi ve O(N3) yürütme süresine göre önemli bir gelişmedir. 100.000'den fazla noktaya sahip veri kümeleri için kullanılabilir.

3.18:

  • Lineer denklemler için Sparse GMRES çözücüsü eklendi;
  • AMD algoritmasının performansı iyileştirildi (yoğun satırlı matrislerin işlenmesi optimize edilirken);
  • Yeni Cholesky ayrıştırması ve çözücü kodunun kapsamlı optimizasyonu sayesinde lineer programlama (Linear Programming, LP) ve kuadratik programlama (Quadratic Programming, QP) için iç nokta çözücülerinin hızı artırıldı.

3.17:

  • Sparse Supernodal Cholesky ayrıştırması (uzman fonksiyonlar ve kullanıcı dostu sarmalayıcılar ile) ve ilgili Sparse Direct Linear Solver eklendi. Permütasyon dolgusu azaltma ve tanımsız ayrıştırmalar eklendi;
  • Büyük ölçekli iç nokta lineer programlama (LP) problemleri için bir çözücü eklendi;
  • Büyük ölçekli iç nokta yarı sonsuz kuadratik programlama (QP) problemleri için bir çözücü eklendi.

3.16:

  • Yoğun ve seyrek versiyonları olan iç nokta kuadratik programlama (QP) problemleri için bir çözücü uygulandı;
  • O(N*logN) yürütme süresine sahip cezalı kübik splineların hızlı bir şekilde uydurulması için yeni bir alt rutin eklendi;
  • Lineer olmayan programlama için yeni bir SQP çözücüsü eklendi;
  • Büyük rastgele ormanlar için sıkıştırılmış bir ikili depolama formatı tanıtıldı (bellek kullanımını 3.7-5.7 kat azalttı);
  • CRS ve Skyline matrisleri için sparsegemv() fonksiyonu eklendi;
  • CDF ve PDF iki değişkenli normal fonksiyonları uygulandı;
  • QP çözücüleri artık Lagrange çarpanlarını bildiriyor;
  • QP çözücüleri artık iki yönlü lineer kısıtlamaları desteklemektedir;
  • SLP çözücüsünün kararlılığı artırıldı;
  • Daha doğru bir çözüm için LP çözücüsünde referans eleman seçimi iyileştirildi.

3.15:

  • Zaman serileri için SSA [Singular Spectrum Analysis, tekil spektrum analizi - aynı zamanda “caterpillar” (tırtıl) olarak da adlandırılır] algoritması uygulandı. Uygulama optimize edilmiştir ve trend çıkarma, tahmin, ortalama alma tahmini ve hızlı artımlı model güncellemelerini içerir;
  • Skyline (SKS) formatında saklanan seyrek lineer sistemler için doğrudan çözücü eklendi;
  • Çok sayıda eşitsizlik içeren kuadratik problemler için QP-DENSE-AUL çözücüsünün performansı iyileştirildi;
  • BLEIC ve QP-BLEIC çözücülerinin hızı önemli ölçüde artırıldı (dört kata kadar). Çözücülerin dahili kodu revize edilerek kısıtlamaların işlenmesi önemli ölçüde iyileştirildi;
  • Alt boyutlu özdeğer çözücüleri için termal tetikleme desteği eklendi. Bir dizi ilgili özdeğer problemini çözerken, daha önce bulunan bir temel çözümü yeni bir çözüm oturumu için başlangıç noktası olarak yeniden kullanmak mümkündür;
  • SKS formatında bantlı matrislerin oluşturulması basitleştirildi (sparsecreatesksband() fonksiyonu);
  • Reel sayılar için yeni bir BLAS seviye 2 fonksiyon seti eklendi: GEMV, SYMV, TRSV;
  • sparseset() fonksiyonu artık SKS matrislerini desteklemektedir;
  • minqp çözücüsü artık kuadratik terimin köşegenine dayalı olarak değişken ölçeklerinin otomatik hesaplanmasını desteklemektedir.

3.12:

  • rbfsetpoints() fonksiyonu artık girdi verilerinde NAN/INF olup olmadığını kontrol etmektedir;
  • K-ortalama kümeleme ve özdeğer geri yineleme algoritmaları artık başlatma için deterministik tohum değerleri kullanmakta ve sonuçları farklı çalıştırmalarda tekrarlanabilir hale getirmektedir;
  • QQP çözücüsündeki küçük bir hata düzeltildi - kuadratik terimin yanlış otomatik ölçeklendirilmesi.

3.11:

  • Lineer olarak kısıtlanmış lineer olmayan en küçük kareler (MinLM ve LSFit) gerçekleştirme yeteneği eklendi. Artık parametreler üzerinde lineer kısıtlamalarla lineer olmayan yaklaşım gerçekleştirmek mümkündür;
  • Veriler için yaklaşık minimum dış teğet, minimum alan ve maksimum iç teğet N-küreler için destek eklendi (2D'de - dış teğet daireler, 3D'de - iç teğet küreler);
  • MinNLC çözücüsünün kararlılığı iyileştirildi ve başka bir ön işleme modu eklendi - "hassas kararlı";
  • Sadece "aktif" durumdaki değişkenler üzerinde kısıtlamaları olan yeni bir optimize edici - MinBC eklendi. Bu kısıtlamalar, genel lineer kısıtlamalarla mümkün olmayan aktivasyon stratejilerine izin verir;
  • C# ve C++ için ALGLIB sürümlerine akış serileştirme/seri dışı bırakma eklendi;
  • Alt uzay yöntemini kullanan doğrudan/seyrek/sıra dışı özdeğer çözücüleri ve alt uzay yöntemini kullanan hızlı kesilmiş temel bileşen analizi (Principal Component Analysis, PCA) uygulandı;
  • Paralellik desteği ile hiyerarşik RBF'ler iyileştirildi - bazı veri setlerinde birkaç kat daha hızlı ve 100.000'den fazla noktayı işleyebiliyor;
  • Lineer kısıtlı kuadratik programlama (QP) problem çözücüsü eklendi;
  • Geliştirilmiş kd ağaçları - dikdörtgen alanlar üzerinde sorgular ve sorgu fonksiyonlarının iş parçacığı güvenli sürümleri ile.

3.10:

  • CSV içe aktarma işlevi eklendi - artık CSV dosyalarından 2D matrisleri okumak mümkün;
  • Lineer olmayan, yumuşatılmamış ve tutarsız kısıtlı problemleri optimize etmek için AGS (Adaptive Gradient Sampling) algoritması tanıtıldı ve bu da ALGLIB'i yumuşatılmamış optimizasyonu destekleyen birkaç ticari paketten biri haline getirdi;
  • Hiyerarşik kümeleme için Ward yöntemi eklendi;
  • Koşul sayısı tahmini ve yinelemeli düzeltme olmadan hafif lineer çözücüler uygulandı - bunlar "işlevsellik açısından zengin" muadillerinden kat kat daha hızlıdır.

3.9:

  • Seyrek/yoğun lineer cebir desteğinde önemli gelişmeler: SKS seyrek matris depolama formatı, SKS tabanlı matrisler için lineer cebir işlemleri, SKS için Cholesky ayrıştırıcısı, seyrek matrisler için birçok ek fonksiyon;
  • Çözücüler ve optimize edicilerdeki iyileştirmeler: değişkenler üzerinde kısıtlamalara sahip sınırlı kuadratik programlama problemi için yeni bir çözücü - QuickQP, lineer olmayan Augmented Lagrangian optimize edicisi, geliştirilmiş BLEIC optimize edicisi, polinom çözücü ve diğer birçok küçük iyileştirme;
  • Ek interpolasyon/uydurma fonksiyonları eklendi: 4/5 parametreli lojistik eğri uydurma, Ramer-Douglas-Peucker (RDP) algoritması;
  • Lineer diskriminant analizi (LDA) algoritmasının hızı artırıldı.

3.8:

  • Sıralama işlevi (tanımlayıcı istatistikler) eklendi - verileri sıralarıyla değiştiren fonksiyon;
  • Sınır ve lineer kısıtlamalara sahip seyrek ve tutarsız kuadratik programlama problemlerini çözebilen yeni bir çözücü olan QP-BLEIC tanıtıldı;
  • FFT performansı geliştirildi (daha fazla performans, ancak hala tek iş parçacıklı);
  • Çok sayıda küçük iyileştirme (BLEIC optimize edicisinde yukarı adımlar, MLP için daha iyi ağırlık başlatma, beşten az nokta için Akima spline).

3.7:

  • BLEIC optimize edicisi önemli ölçüde yeniden tasarlandı. İlk olarak, Elvira Illarionova tarafından önerilen ve gradyan projeksiyonunu L-BFGS eşitlik kısıtı yinelemeleriyle birleştiren yeni bir üç aşamalı aktif küme algoritması kullanır. İkinci olarak, algoritma artık iç içe geçmiş dış/iç yinelemelere sahip olmadığından, algoritma için daha şeffaf durma kriterleri belirlemek mümkündür. Üçüncü olarak, dejenere kısıtlamaları doğru şekilde işleyen yeni bir kısıtlama etkinleştirme/devre dışı bırakma stratejisi kullanır;
  • ALGLIB'de sinir ağları için destek önemli ölçüde geliştirildi. Aynı ayarlar ve verilerle birden fazla ağın eğitimini büyük ölçüde basitleştiren yeni bir eğitim arayüzü tanıtıldı. Artık eğitim setini seyrek bir matris kullanarak belirlemek mümkündür;
  • Kümeleme desteği iyileştirildi - ALGLIB'in yeni sürümü, kümeleme alt paketindeki hiyerarşik küme analizi algoritmasını içerir. Bu algoritma çeşitli mesafe metriklerini (Öklid, 1-norm, sonsuz-norm, Pearson-Spearman korelasyon tabanlı metrikler, kosinüs mesafesi) ve çeşitli bağlantı türlerini (tek bağlantı, tam bağlantı, ortalama bağlantı) içerir. K-ortalama kümeleme işlevi (yeni algoritmadan çok önce mevcuttu) yeni kümeleme algoritmasıyla birleştirildi;
  • Seyrek lineer çözücüler (CG ve LSQR) artık otomatik diyagonal ön işlemciyi desteklemektedir;
  • Lineer/lineer olmayan en küçük kareler çözücüleri (lsfit alt paketleri) artık hataları oranlar olarak bildiriyor;
  • Seyrek matris işlevi artık hash tablosu ve CRS görünümleri arasında dönüştürme yapmak için yeni fonksiyonlar içermektedir. SparseRewriteExisting fonksiyonunda da performans iyileştirmeleri yapılmıştır.

3.6:

  • Kuadratik optimize edici artık sınır ve lineer eşitliklerin/eşitsizliklerin rastgele bir kombinasyonunu desteklemektedir. Optimize edicinin yeni versiyonu, Augmented Lagrange yöntemi ile aktif küme yönteminin bir kombinasyonunu kullanmaktadır;
  • Spline1D modülü artık monotonik kübik splinelar ile interpolasyonu desteklemektedir;
  • Vektör bilineer ve bikübik splinelar için destek eklendi;
  • Skaler ve vektör trilineer (3D) splinelar için destek eklendi;
  • Seyrek matrisler için destek geliştirildi: SparseEnumerate() fonksiyonunu kullanarak sıfır olmayan elemanların verimli bir şekilde numaralandırılması, CRS formatında saklanan matrisler için daha hızlı SparseGet();
  • Optimizasyon ve lineer olmayan yaklaşım algoritmaları (LSFit, MinLM, MinBLEIC, MinLBFGS, MinCG alt paketleri) kullanıcı tarafından sağlanan gradyanın geçerliliğini kontrol edebilir (sayısal programlarda en yaygın hata).

2. Bilimsel araştırmalarda ALGLIB kütüphanesi

Açık kaynak kullanılabilirliği ve ticari olmayan projeler için ücretsiz kullanımı ile ALGLIB, bilimsel araştırma dünyasında önemli bir araç haline gelmiştir. Çeşitli ve karmaşık problemleri çözmek için başarıyla kullanılmaktadır.

ALGLIB'in önemli etkisi, ALGLIB'in birçok algoritmasının yenilikçi çözümler yaratmanın temeli haline geldiği özel yazılımların geliştirilmesinde açıkça görülmektedir.

Buna ek olarak, ALGLIB'in tek iş parçacıklı algoritmaları, yaklaşık 2 milyon denklem içeren büyük denklem sistemlerini çözmek için tasarlanmış yinelemeli algoritmaların paralel sürümlerinin geliştirilmesi için bir ölçüt ve referans noktası olarak hizmet eder. Bu, ALGLIB kütüphanesi tarafından sağlanan algoritmaların güvenilirliğini ve olağanüstü verimliliğini göstermektedir.

Araştırmacılar, ALGLIB'in algoritmalarının yüksek kalitesi ve verimliliğine dikkat çekerek, onu temel araştırma ve mühendislik dahil olmak üzere çeşitli alanlarda karmaşık araştırma problemlerini çözmek için tercih edilen bir seçenek haline getirmiştir.


2.1. Optimizasyon problemlerinde ALGLIB

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

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

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

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

2.2. İnterpolasyon problemlerinde ALGLIB

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

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

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

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

The hierarchical algorithm has several significant advantages:

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

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


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

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

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

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

2.3. Karşılaştırma için bir ölçüt olarak ALGLIB algoritmaları

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. Özel yazılımların bir parçası olarak ALGLIB algoritmaları

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. Finansal piyasa analizi için ALGLIB kütüphanesi

MQL5 için kütüphanenin ilk sürümü (ALGLIB 3.5), modern algoritmalar kullanarak çeşitli problemleri çözerek finansal verilerin analizinde yaygın olarak kullanılmaya başlanmıştır.

Aşağıda, ALGLIB kütüphanesindeki sınıfları ve fonksiyonları aktif olarak uygulayan makalelerin bir listesi bulunmaktadır:

Böylece, ALGLIB matematik kütüphanesinin işlevselliği, finansal verilerin analizi için yararlı bir araç haline gelmiştir.


4. ALGLIB'de Singular Spectrum Analysis

Mevcut yöntemlere ek olarak, ALGLIB kütüphanesinin yeni sürümü artık Singular Spectrum Analysis yöntemini (SSA, "caterpillar" (tırtıl) olarak da bilinir) içermektedir. Bu yöntem, özellikle tahmin problemlerinde finansal zaman serilerini analiz etme yeteneklerini önemli ölçüde genişletmektedir. SSA algoritması 3.15 sürümünden beri mevcuttur ve uygulanması optimize edilmiştir. Trend çıkarma, zaman serisi tahmini, ortalama alma tahmini için işlevsellik sağlar ve hızlı artımlı model güncellemelerine sahiptir.


Sizi bu yöntemin pratikte nasıl işlediğini öğrenmeye ve ticaret stratejileri geliştirirken bu yöntemi kullanma deneyiminizi paylaşmaya davet ediyoruz.

Aşağıda SSA yönteminin kullanım örneklerini içeren bir test komut dosyası bulunmaktadır. ALGLIB kütüphanesinde SSA yönteminin kullanımına ilişkin örnekler ve ayrıntılar hakkında ek bilgileri resmi kütüphane yardımının Singular Spectrum Analysis bölümünde bulabilirsiniz.

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


Sonuç

ALGLIB, finansal piyasalardaki verileri analiz etmek için güçlü bir araçtır. Çok dillilik, platformlar arası yapı, zengin işlevsellik ve açık kaynak olması, onu finansal analiz ve modelleme alanındaki araştırmacılar ve geliştiriciler için cazip bir seçenek haline getirmektedir. Güvenilir veri analizi araçlarına olan ihtiyaç devam etmektedir ve ALGLIB sürekli gelişim ve iyileştirmeyi destekleyerek bu zorluğu başarıyla karşılamaktadır.

MetaTrader 5 platformu geliştiricileri, yatırımcılara en iyi çözümleri sunmaktadır:

  • Hız açısından C++ kadar iyi olan MQL5 dili;
  • SQLite veritabanlarının yerleşik olarak işlenmesi, OpenCL kullanarak hesaplamalar yapabilme, DirectX desteği, ONNX modellerini kullanma ve Python ile entegrasyon;
  • Bulanık mantık, istatistik ve güncellenmiş ALGLIB sürümü dahil olmak üzere matematiksel kütüphaneler.

MetaQuotes Ltd tarafından Rusçadan çevrilmiştir.
Orijinal makale: https://www.mql5.com/ru/articles/13289

Ekli dosyalar |
ZIP indir
SSA_Test.mq5 (26.56 KB)
Uyarı: Bu materyallerin tüm hakları MetaQuotes Ltd.'a aittir. Bu materyallerin tamamen veya kısmen kopyalanması veya yeniden yazdırılması yasaktır.

Bu yazarın diğer makaleleri

Tartışmaya git
Freelance hizmetinde yatırımcıların siparişlerini yerine getirerek nasıl para kazanılır? Freelance hizmetinde yatırımcıların siparişlerini yerine getirerek nasıl para kazanılır?
MQL5 Freelance, yatırımcı müşteriler tarafından sipariş verilen ticaret uygulamalarını oluşturmaları için geliştiricilere ödeme yapılan çevrimiçi bir hizmettir. Hizmet 2010 yılından bu yana başarılı bir şekilde faaliyet göstermekte olup, bugüne kadar tamamlanan 100.000'den fazla projenin toplam değeri 7 milyon dolardır. Gördüğümüz gibi, burada önemli miktarda para söz konusu.
MQL4 ve MQL5 geliştirme çerçevesinde OpenAI'ın ChatGPT özellikleri MQL4 ve MQL5 geliştirme çerçevesinde OpenAI'ın ChatGPT özellikleri
Bu makalede, Uzman Danışmanlar, göstergeler ve komut dosyaları geliştirmenin zaman ve emek yoğunluğunu azaltma açısından yeteneklerini anlamak için OpenAI'dan ChatGPT ile uğraşacağız. Size bu teknolojide hızlı bir şekilde yol göstereceğim ve MQL4 ve MQL5'te programlama için doğru şekilde nasıl kullanılacağını göstermeye çalışacağım.
Scikit-learn kütüphanesinin regresyon modelleri ve bunların ONNX'e aktarılması Scikit-learn kütüphanesinin regresyon modelleri ve bunların ONNX'e aktarılması
Bu makalede, Scikit-learn paketinden regresyon modellerinin uygulanmasını inceleyecek, bunları ONNX formatına dönüştürmeye çalışacak ve sonuçta ortaya çıkan modelleri MQL5 programlarında kullanacağız. Ayrıca, orijinal modellerin doğruluğunu hem float hem de double hassasiyet için ONNX versiyonlarıyla karşılaştıracağız. Ek olarak, regresyon modellerinin ONNX temsilini inceleyerek iç yapılarının ve çalışma prensiplerinin daha iyi anlaşılmasını sağlayacağız.
Ticaret için kombinatorik ve olasılık teorisi (Bölüm III): İlk matematiksel model Ticaret için kombinatorik ve olasılık teorisi (Bölüm III): İlk matematiksel model
Daha önce tartışılan konunun mantıksal bir devamı, ticaret görevleri için çok işlevli matematiksel modellerin geliştirilmesi olacaktır. Bu makalede, fraktalları tanımlayan ilk matematiksel modelin geliştirilmesiyle ilgili tüm süreci sıfırdan anlatacağım. Bu model önemli bir yapı taşı haline gelmeli, çok işlevli ve evrensel olmalıdır. Bu fikrin daha da geliştirilmesi için teorik temelimizi oluşturacaktır.