ALGLIB Bibliothek für numerische Analysen in MQL5
209
0
Einführung
Die Finanzmärkte erzeugen Daten mit einer riesigen Menge komplexer Beziehungen. Um sie zu analysieren, müssen wir die modernsten Methoden der angewandten Mathematik anwenden. Die hohe Komplexität der Finanzdaten mit der Einfachheit und Effizienz der Analyse zu verbinden, ist eine anspruchsvolle Aufgabe. ALGLIB ist eine Hochleistungsbibliothek, die speziell für die Arbeit mit numerischen Methoden und Datenanalysealgorithmen entwickelt wurde. Sie ist ein zuverlässiger Helfer bei der Analyse der Finanzmärkte.
Die Vielseitigkeit von ALGLIB
Heute ist ALGLIB als eine der besten Bibliotheken für die Arbeit mit numerischen Methoden anerkannt. Es unterstützt mehrere Programmiersprachen (C++, C#, Java, Python, Delphi) und Betriebssysteme (Windows und POSIX, einschließlich Linux).
Unter den zahlreichen Funktionen der ALGLIB sind die folgenden hervorzuheben:
- Lineare Algebra: Dazu gehören direkte Algorithmen, Eigenwert- (EVD) und Singulärwertverfahren (SVD), die für die Datenanalyse wichtig sind.
- Lösen von Gleichungen: Unterstützt sowohl lineare als auch nichtlineare Gleichungssysteme, was bei der Modellierung komplexer Finanzprozesse nützlich ist.
- Interpolation und Approximation: Es werden verschiedene Methoden der Dateninterpolation und -annäherung unterstützt, die bei der Analyse und Vorhersage von Markttrends nützlich sind.
- Optimierung: ALGLIB stellt Algorithmen zur Verfügung, um optimale Lösungen zu finden, was für die Optimierung eines Investitionsportfolios und andere finanzielle Entscheidungen wichtig ist.
- Numerische Integration: Ermöglicht die Berechnung von definitiven Integralen, was bei der Bewertung von Finanzinstrumenten nützlich ist.
- Maschinelles Lernen: Dazu gehören Datenanalyse, Klassifizierung, Regression und sogar der Einsatz neuronaler Netze, was neue Möglichkeiten für die Vorhersage von Markttrends eröffnet.
ALGLIB-Vorteile
Warum sollte man sich bei der Arbeit mit Finanzdaten für ALGLIB entscheiden?
Hier sind die wichtigsten Vorteile der Bibliothek:
- Portabilität: ALGLIB lässt sich auf einer Vielzahl von Plattformen mit einer Vielzahl von Compilern kompilieren, sodass es für Entwickler mit unterschiedlichem Hintergrund zugänglich ist.
- Nutzerfreundlichkeit: Unterstützung von mehreren Programmiersprachen, sodass Sie die Sprache wählen können, mit der Sie am besten zurechtkommen, ohne eine neue Syntax lernen zu müssen.
- Open source: ALGLIB ist quelloffen und kann unter den Bedingungen der GPL 2+ verwendet werden. Damit ist es sowohl für die wissenschaftliche Forschung als auch für kommerzielle Projekte zugänglich.
- Unterstützung für kommerzielle Nutzer: Kommerzielle Nutzer können eine Lizenz erwerben, die ihnen rechtlichen Schutz bei der Nutzung von ALGLIB bietet.
Daneben enthält die Bibliothek eine große Menge von Testdaten, die den Hauptteil der Funktionalität der vorgeschlagenen Methoden abdecken. So können Sie die Tests und erkannte Fehler an die Autoren eines Projekts weiterleiten. Ausführlichere Informationen über die Bibliothek finden Sie auf der Projektwebsite https://www.alglib.net/
ALGLIB wurde erstmals 2012 für die Verwendung in der Sprache MQL5 angepasst. Diese Anpassung war eine Konvertierung der Bibliothek von Version 3.5. Seitdem sind mehr als 10 Jahre vergangen. In dieser Zeit ist ALGLIB bei Entwicklern und Analysten im Bereich des Finanzmarkthandels weithin bekannt geworden. Im Laufe der Jahre hat das Entwicklungsteam aktiv an der Verbesserung der Bibliothek gearbeitet und mehr als 70 Änderungen vorgenommen, darunter das Hinzufügen neuer Klassen, Funktionen und Verbesserungen.
Zu beachten ist auch, dass die bestehenden Bibliotheksklassen für die Verwendung von Matrizen und Vektoren umgestaltet wurden und neue, in ALGLIB 3.19 eingeführte Funktionen hinzugefügt wurden. Der Datentyp ‚Complex‘ wird jetzt für die Arbeit mit komplexen Zahlen verwendet. Der gesamte Quellcode wurde überarbeitet und im Einklang mit dem einheitlichen Designstil strukturiert.
Leider wurden in der Version 3.19 für MQL5 erhebliche Änderungen an der ALGLIB-Bibliothek vorgenommen, sodass eine Abwärtskompatibilität nicht gegeben ist. Nutzern, die ALGLIB Version 3.5 in ihren Projekten einsetzen, wird empfohlen, ihre Programme gründlich zu überprüfen und gegebenenfalls anzupassen.
Zusätzlich zu den Bibliotheken selbst wurden auch die Testskripte aktualisiert. 91 davon sind für Klassen und 152 für Schnittstellen. Dies ermöglicht eine zuverlässigere und umfassendere Prüfung der Bibliotheksfunktionalität.
Die neue Version der ALGLIB ist hier verfügbar: ALGLIB - Numerical Analysis Library - Bibliothek für MetaTrader 5, sowie Teil der MetaTrader 5 Plattform (\MQL5\Include\Math\Alglib\, einschließlich Testfälle in \MQL5\Scripts\UnitTests\Alglib\).
1. ALGLIB 3.19 - was ist neu (Liste der Änderungen seit Version 3.5)
3.19:
- Die wichtigste Funktion in ALGLIB 3.19.0 ist der neue RBF-Solver (Radial Basis Function) für die Bearbeitung großer Datensätze, der dünne Splines, biharmonische Splines und Multiquadriken unterstützt. Dieser Solver (math. Plroblemlösung) unterstützt sowohl Interpolations- als auch Anpassungsprobleme (Glättung);
- Der neue RBF-Algorithmus nutzt die Methode der Bereichszerlegung zur Lösung linearer Systeme. Das Ergebnis ist ein Speicherbedarf von O(N) und eine Ausführungszeit von O(N2), was eine erhebliche Verbesserung gegenüber dem Speicherbedarf von O(N2) und der Ausführungszeit von O(N3) darstellt, die andere Open-Source-Implementierungen benötigen. Es können Datensätze mit mehr als 100.000 Punkten verwendet werden.
3.18:
- Hinzugefügt wurde der Solver für dünn besetzte (sparse) GMRES für lineare Gleichungen hinzugefügt;
- Verbesserte Leistung des AMD-Algorithmus (bei der Optimierung der Verarbeitung von Matrizen mit dichten Zeilen);
- Die Geschwindigkeit der Solver für lineare Programmierung (LP) und quadratische Programmierung (QP) wurde dank der neuen Cholesky-Zerlegung und einer umfassenden Optimierung des Solver-Codes verbessert.
3.17:
- Hinzugefügt wurden Sparse Supernodal Cholesky Zerlegung (mit Expertenfunktionen und nutzerfreundlichen Wrappern) und entsprechende Sparse Direct Linear Solver. Aktivierte Permutationsauffüllungsreduktion und undefinierte Faktorisierungen;
- Hinzugefügt wurde ein Solver für große Probleme der linearen Programmierung (LP) mit inneren Punkten;
- Hinzugefügt wurde ein Solver für große Probleme der semidefiniten quadratischen Programmierung (QP) mit inneren Punkten.
3.16:
- Implementierung eines Solvers für quadratische Innenpunktprogrammierungsprobleme (QP) mit dichten und dünn besetzen Versionen;
- Neue Subroutine zur schnellen Anpassung von bestraften kubischen Splines mit O(N*logN) Ausführungszeit hinzugefügt;
- Es wurde ein neuer SQP-Solver für nichtlineare Programmierung hinzugefügt;
- Eingefgührt wurde ein komprimiertes binäres Speicherformat für große Random Forests (Reduzierung des Speicherbedarfs um das 3,7-5,7-fache);
- Die Funktion sparsegemv() für CRS- und Skyline-Matrizen wurde hinzugefügt;
- Implementierung der bivariaten Normalfunktionen CDF und PDF;
- QP-Solver berichten jetzt die jetzt Lagrange-Multiplikatoren;
- QP-Solver unterstützen jetzt zweiseitige lineare Nebenbedingungen;
- Verbesserte Stabilität des SLP-Solvers;
- Verbesserte Referenzelementauswahl im LP-Solver für eine genauere Lösung.
3.15:
- Implementierung des Singular Spectrum Analysis (SSA, „caterpillar“) Algorithmus für Zeitreihen. Die Implementierung ist optimiert und umfasst Trendermittlung, Vorhersage, Durchschnittsvorhersage und schnelle inkrementelle Modellaktualisierungen;
- Direkter Solver für dünn besetzte lineare (sparse) Systeme, die im Skyline (SKS) Format gespeichert sind, wurde hinzugefügt;
- Verbesserung der Leistung des Solvers QP-DENSE-AUL für quadratische Probleme mit einer großen Anzahl von Ungleichungen;
- Erhebliche Steigerung der Geschwindigkeit der Solver von BLEIC- und QP-BLEIC (bis zum Vierfachen). Überarbeitung des internen Codes der Solver mit dem Ergebnis einer deutlich verbesserten Handhabung von Nebenbedingungen;
- Unterstützung für thermische Triggerung für subdimensionale Eigenwert-Solver hinzugefügt. Bei der Lösung einer Reihe von zusammenhängenden Eigenwertproblemen ist es möglich, eine zuvor gefundene Basislösung als Ausgangspunkt für eine neue Lösungssitzung zu verwenden;
- Vereinfachte Erstellung von Bandmatrizen im SKS-Format (Funktion sparsecreatesksband());
- Ein neuer Satz von BLAS Level 2 Funktionen für reelle Zahlen wurde hinzugefügt: GEMV, SYMV, TRSV;
- Die Funktion sparseset() unterstützt jetzt SKS-Matrizen;
- Der minqp Solver unterstützt nun die automatische Berechnung von Variablenskalen basierend auf der Diagonale des quadratischen Terms.
3.12:
- Die Funktion rbfsetpoints() prüft jetzt auf das Vorhandensein von NAN/INF in den Eingabedaten;
- Die Algorithmen für k-means-Clustering und Eigenwert-Back-Iteration verwenden jetzt deterministische Seed-Werte für die Initialisierung, wodurch die Ergebnisse über verschiedene Läufe hinweg reproduzierbar sind;
- Ein kleiner Fehler im QQP-Solver wurde behoben - eine falsche automatische Skalierung des quadratischen Terms.
3.11:
- Es wurde die Möglichkeit hinzugefügt, linear eingeschränkte, nichtlineare, kleinste Quadrate (MinLM und LSFit) durchzuführen. Nun ist es möglich, eine nichtlineare Approximation mit linearen Parameterbeschränkungen durchzuführen;
- Unterstützung für annähernd kleinste umschreibende, minimale Fläche und maximal eingeschriebene N-Kugeln für Daten (in 2D - umschreibende Kreise, in 3D - eingeschriebene Kugeln) hinzugefügt;
- Die Stabilität des MinNLC-Solvers wurde verbessert und ein weiterer Vorverarbeitungsmodus - „präzise stabil“ - hinzugefügt;
- Hinzugefügt wurde ein neuer Optimierer - MinBC mit Einschränkungen nur für Variablen im „aktiven“ Zustand. Diese Einschränkungen ermöglichen Aktivierungsstrategien, die mit allgemeinen linearen Beschränkungen nicht möglich sind;
- Streaming Serialisierung/Deserialisierung in ALGLIB-Versionen für C# und C++ hinzugefügt;
- Implementierung direkter/sparscher/außerordentlicher Eigenwert-Solver unter Verwendung der Unterraummethode und schneller verkürzter Hauptkomponentenanalyse (PCA) unter Verwendung der Unterraummethode;
- Verbessert wurden hierarchische RBFs mit Parallelitätsunterstützung - bei einigen Datensätzen um mehrere Größenordnungen schneller und in der Lage, mehr als 100.000 Punkte zu verarbeiten;
- Hinzugefügt wurde ein Problem-Solver für linear beschränkte quadratische Programmierung (QP);
- Verbessert wurden kd-Bäume - mit Abfragen über rechteckige Flächen und thread-sicheren Versionen der Abfragefunktionen.
3.10:
- Hinzugefügt wurde die CSV-Importfunktionalität - jetzt ist es möglich, 2D-Matrizen aus CSV-Dateien einzulesen;
- Eingeführt wurde der AGS-Algorithmus (Adaptive Gradient Sampling) zur Optimierung nichtlinearer, ungeglätteter und inkonsistenter eingeschränkter Probleme, was ALGLIB zu einem der wenigen kommerziellen Pakete macht, das ungeglättete Optimierung unterstützt;
- Die Ward-Methode für hierarchisches Clustering wurde hinzugefügt;
- Implementiert wurden leichtgewichtige lineare Solvern ohne Zustandszahlschätzung und iterative Korrektur - sie sind um ein Vielfaches schneller als ihre „funktionsreichen“ Analoga.
3.9:
- Erhebliche Verbesserungen bei der Unterstützung dicht/dünn besetzter linearer Algebra: SKS-Speicherformat für dünn besetzter Matrizen, lineare Algebra-Operationen für SKS-basierte Matrizen, Cholesky-Faktorisierer für SKS, viele zusätzliche Funktionen für dünn besetzte Matrizen;
- Verbesserungen bei den Solvern und Optimierern: ein neuer Solver für ein begrenztes quadratisches Programmierproblem mit Variablenbeschränkungen - QuickQP, ein nichtlinearer Augmented Lagrangian Optimierer, ein verbesserter BLEIC Optimierer, ein Polynomial Solver und viele andere kleinere Verbesserungen;
- Zusätzliche Interpolations-/Anpassungsfunktionen hinzugefügt: logistische Kurvenanpassung mit 4/5 Parametern, Ramer-Douglas-Peucker (RDP)-Algorithmus;
- Die Geschwindigkeit des Algorithmus der linearen Diskriminanzanalyse (LDA) wurde verbessert.
3.8:
- Hinzufügung der Ranking-Funktionalität (deskriptive Statistik) - die Funktion, die die Daten durch ihre Ränge ersetzt;
- Einführung eines neuen Solvers, QP-BLEIC, der in der Lage ist, dünn besetzte und inkonsistente quadratische Programmierprobleme mit Randbedingungen und linearen Beschränkungen zu lösen;
- Verbesserte FFT-Leistung (mehr Leistung, aber immer noch single threaded);
- Mehrere kleinere Verbesserungen (Schritte nach oben im BLEIC-Optimierer, bessere Initialisierung der Gewichte für MLP, Akima-Spline für weniger als fünf Punkte).
3.7:
- Der BLEIC-Optimierer wurde grundlegend überarbeitet. Zunächst wird ein neuer dreistufiger Active-Set-Algorithmus verwendet, der von Elvira Illarionova vorgeschlagen wurde und die Gradientenprojektion mit Iterationen der L-BFGS-Zwangsgleichheit kombiniert. Zweitens: Da der Algorithmus keine verschachtelten äußeren/inneren Iterationen mehr hat, ist es möglich, transparentere Kriterien für das Anhalten des Algorithmus festzulegen. Drittens verwendet es eine neue Strategie zur Aktivierung/Deaktivierung von Beschränkungen, die degenerierte Beschränkungen korrekt behandelt;
- Erheblich verbesserte Unterstützung für neuronale Netze in ALGLIB. Einführung einer neuen Trainingsoberfläche, die das Training mehrerer Netze mit denselben Einstellungen und Daten erheblich vereinfacht. Es ist nun möglich, die Trainingsmenge durch eine dünn besetzte Matrix zu spezifizieren;
- Verbesserte Clustering-Unterstützung - die neue Version von ALGLIB enthält den hierarchischen Cluster-Analyse-Algorithmus aus dem Clustering-Subpackage. Dieser Algorithmus umfasst mehrere Abstandsmetriken (Euklidischer Abstand, 1-Norm, Unendlichkeits-Norm, Pearson-Spearman-Korrelationsmetrik, Kosinusabstand) und mehrere Link-Typen (Einzel-Link, Voll-Link, Durchschnitts-Link). Die Funktionsweise des k-means-Clustering (die lange vor dem neuen Algorithmus existierte) wurde mit dem neuen Clustering-Algorithmus kombiniert;
- Die dünn besetzten lineare Solver (CG und LSQR) unterstützen nun einen automatischen Diagonal-Präprozessor;
- Lineare/nichtlineare Solver der kleinsten Quadrate (lsfit-Unterpakete) melden jetzt Fehler in Verhältnissen;
- Die Funktionen für dünn besetzte Matrizen umfassen nun neue Funktionen für die Konvertierung zwischen Hash-Tabellen- und CRS-Ansichten sowie Leistungsverbesserungen an der Funktion SparseRewriteExisting.
3.6:
- Der quadratische Optimierer unterstützt nun eine beliebige Kombination von Randbedingungen und linearen Gleichungen/Ungleichungen. Die neue Version des Optimierers verwendet eine Kombination aus der erweiterten Lagrange-Methode und der Active-Set-Methode;
- Das Spline1D-Modul unterstützt nun die Interpolation mit monotonen kubischen Splines;
- Hinzugefügt wurde die Unterstützung für bilineare und bikubische Vektorsplines;
- Hinzugefügt wurde die Unterstützung für skalare und vektorielle trilineare (3D) Splines;
- Verbesserte Unterstützung für dünn besetzte Matrizen: effiziente Aufzählung von Nicht-Null-Elementen mit der Funktion SparseEnumerate(), schnelleres SparseGet() für Matrizen, die im CRS-Format gespeichert sind;
- Optimierungs- und nichtlineare Approximationsalgorithmen (Unterpakete LSFit, MinLM, MinBLEIC, MinLBFGS, MinCG) können die Gültigkeit des vom Nutzer eingegebenen Gradienten überprüfen (der häufigste Fehler in numerischen Programmen).
2. ALGLIB-Bibliothek in der wissenschaftlichen Forschung
Durch die Verfügbarkeit von Open Source und die kostenlose Nutzung für nicht-kommerzielle Projekte ist ALGLIB zu einem wichtigen Werkzeug in der Welt der wissenschaftlichen Forschung geworden. Sie wird erfolgreich zur Lösung vielfältiger und komplexer Probleme eingesetzt.
Der bedeutende Einfluss der ALGLIB zeigt sich in der Entwicklung kundenspezifischer Software, bei der viele Algorithmen der ALGLIB die Grundlage für die Entwicklung innovativer Lösungen bilden.
Darüber hinaus dienen die Single-Thread-Algorithmen von ALGLIB als Benchmark und Referenzpunkt für die Entwicklung paralleler Versionen iterativer Algorithmen zur Lösung großer Gleichungssysteme mit etwa 2 Millionen Gleichungen. Dies beweist die Zuverlässigkeit und herausragende Effizienz der von der ALGLIB-Bibliothek bereitgestellten Algorithmen.
Forscher haben die hohe Qualität und Effizienz der ALGLIB-Algorithmen festgestellt, was sie zur bevorzugten Wahl für die Lösung komplexer Forschungsprobleme in einer Vielzahl von Bereichen macht, einschließlich Grundlagenforschung und Ingenieurwesen.
2.1. ALGLIB bei Optimierungsproblemen
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)
Die im vorangegangenen Abschnitt berechnete Midsagittalebene wurde zur Initialisierung der Berechnung der Midsagittalfläche verwendet. Die midsagittale Oberfläche wurde als bikubischer Spline dargestellt, wie in ALGLIB (Bochkanov und Bystritsky (2012)) implementiert. Die Kontrollpunkte für den Spline wurden in einem regelmäßigen Raster auf der berechneten Midsagittalebene platziert, mit einem Abstand m zwischen den Kontrollpunkten.
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 (Hrsg.): Proceedings der OPTIMA-2017 Konferenz, Petrovac, Montenegro, 02-Okt-2017
Als Referenz stellen wir die Version mit doppelter Genauigkeit zur Verfügung, die auf der AlgLib-Bibliothek [Bochkanov & Bystritsky, 2016] basiert, die wir in unserer früheren Arbeit [Zaikin et al., press] verwendet haben. Die AlgLib-Bibliothek enthält eine hochmoderne Implementierung des Bisektionsalgorithmus, die sorgfältig darauf abgestimmt ist, die genauesten Ergebnisse zu liefern, die mit den modernen CPUs mit Fließkommaeinheiten (FPUs) möglich sind. Unsere CPU-basierte Implementierung des Bisektionsalgorithmus kann eine solche Genauigkeit nicht vorweisen. Aufgrund seiner Einfachheit ist er jedoch deutlich schneller als AlgLib. Deshalb sind die Ergebnisse unseres und des auf AlgLib basierenden Algorithmus unterschiedlich. Die Diskrepanz zwischen den Ausgaben (Residuen) desselben Algorithmus auf der CPU und der GPU ist das Ergebnis der unterschiedlichen Implementierungen von Gleitkommaeinheiten auf diesen Plattformen.
2.2. ALGLIB bei Interpolationsproblemen
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.
Das ALGLIB-Paket implementiert beide Arten von RBFs: die globale Gaußsche Funktion und die kompakt unterstützte. Die klassische Gaußsche Funktion nimmt bereits in einem Abstand von etwa 3R0 vom Zentrum kleine Werte an und kann leicht so modifiziert werden, dass sie kompakt unterstützt wird.
In dieser Arbeit wurde der im ALGLIB-Paket implementierte RBF-ML-Algorithmus verwendet. Er hat drei Parameter: den Ausgangsradius R0, die Anzahl der Schichten NL und den Regularisierungskoeffizienten l. Dieser Algorithmus baut eine Hierarchie von Modellen mit abnehmenden Radien auf [13]. In der ersten (optionalen) Iteration erstellt der Algorithmus ein lineares Modell der kleinsten Quadrate. Die durch das lineare Modell vorhergesagten Werte werden von den Funktionswerten an den Knoten subtrahiert, und der Restvektor wird an die nächste Iteration weitergegeben. In der ersten Iteration wird ein traditionelles RBF-Modell mit einem Radius von R0 erstellt. Es verwendet jedoch keinen dichten Solver und versucht nicht, das Problem exakt zu lösen. Es löst das Problem der kleinsten Quadrate, indem es eine feste Anzahl (etwa 50) von LSQR [22] Iterationen durchführt. In der Regel ist die erste Iteration ausreichend. Weitere Iterationen werden die Situation nicht verbessern, da das lineare System mit einem so großen Radius schlecht konditioniert ist. Die von der ersten Schicht des RBF-Modells vorhergesagten Werte werden von den Funktionswerten an den Knoten subtrahiert, und der Restvektor wird wiederum an die nächste Iteration weitergegeben. Bei jeder weiteren Iteration wird der Radius halbiert, indem dieselbe konstante Anzahl von LSQR-Iterationen durchgeführt wird, und die Prognosen der neuen Modelle werden vom Residualvektor subtrahiert.In allen nachfolgenden Iterationen kann eine feine Regularisierung angewendet werden, um die Konvergenz des LSQR-Solvers zu verbessern. Größere Werte für den Regularisierungsfaktor können helfen, das Datenrauschen zu reduzieren. Eine weitere Möglichkeit der kontrollierten Glättung besteht darin, die entsprechende Anzahl von Ebenen zu wählen. Abbildung 2 zeigt ein Beispiel eines B-Scans und eine Methode der Annäherung durch ein hierarchisches Modell. Nachfolgende Schichten haben einen doppelt so kleinen Radius und erklären die Rückstände nach der vorherigen Schicht. Mit abnehmendem Radius werden die feineren Details des B-Scans wiedergegeben.
Der hierarchische Algorithmus hat mehrere wesentliche Vorteile:
- Gaußsche CS-RBFs erzeugen lineare Systeme mit dünn besetzten Matrizen, was die Verwendung des dünn besetzt LSQR-Solvers ermöglicht, der mit der Rangdefektmatrix arbeiten kann;
Der vorgestellte hierarchische RBF-Approximationsalgorithmus ist einer der effizientesten Algorithmen zur Verarbeitung großer, verstreuter Datensätze. Seine Implementierung in der ALGLIB-Bibliothek ermöglicht eine einfache Softwareentwicklung, die erfolgreich zur Analyse von GPR-Bildern eingesetzt werden kann.
- Die Zeit der Modellbildung hängt von der Anzahl der Punkte, N, als N logN ab, im Gegensatz zu einfachen RBF-Implementierungen mit O(N3) Effizienz;
- Ein iterativer Algorithmus (aufeinanderfolgende Schichten korrigieren die Fehler der vorhergehenden) schafft ein robustes Modell, selbst bei einem sehr großen Anfangsradius. Aufeinanderfolgende Schichten haben kleinere Radien und korrigieren die Ungenauigkeit, die durch die vorhergehende Schicht eingeführt wurde;
- Das Mehrschichtenmodell ermöglicht eine Kontrollglättung sowohl durch Änderung des Regularisierungskoeffizienten als auch durch eine unterschiedliche Anzahl von Schichten.
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 ist eine numerische Bibliothek, die sich auf das Lösen allgemeiner numerischer Probleme konzentriert. Sie kann mit verschiedenen Programmiersprachen wie C++, C# und Delphi verwendet werden. Sie bietet eine große Vielfalt an Funktionen für verschiedene Wissenschaftsbereiche. In dieser speziellen Anwendung ist es erforderlich, die 2D-Datenfelder zu interpolieren, die gleichmäßig verteilt sein können oder auch nicht (ungleichmäßig verteilt). Die Entwicklung der Funktion, die das Äquivalent zu griddata implementiert, erfordert die Verwendung von ALGLIB 2D-Interpolationsfunktionen für spärliche/uneinheitliche Daten. Für den Anpassungsteil wird die Funktion der kleinsten Quadrate verwendet, für die zwei Optionen zur Verfügung stehen: BlockLLS oder FastDDDM. Die Option FastDDDM wurde gewählt, um die bestmögliche Leistung zu erzielen.
Während die meisten Codes und Funktionen des Algorithmus in MATLAB in C++ übersetzt und optimiert wurden, konnten andere nicht direkt übersetzt werden. Der Grund dafür ist, dass es keine Informationen über die internen Berechnungen einiger Funktionen in MATLAB gibt. Dies bedeutet, dass die Ergebnisse der beiden Implementierungen leicht unterschiedlich sind. Diese Unterschiede zeigen sich vor allem bei der Implementierung der Funktion griddata. Für diese Anwendung wurde die Interpolationsmethode „bikubische Splines“ verwendet, die in den FastDDM-Solver der ALGLIB-Bibliothek integriert ist.
ArrayFire bietet eine vollständige API, die die gängigsten Funktionen, die mit MATLAB implementiert werden, löst. Daher kann man davon ausgehen, dass die Portierung von MATLAB nach C++ unter Verwendung der ArrayFire API relativ einfach ist und einige Teile des Codes sogar Zeile für Zeile gleichwertig sind. Allerdings fehlen in ArrayFire einige leistungsfähige Funktionen, die in MATLAB verfügbar sind. Die Funktion „griddata“ ermöglicht beispielsweise verschiedene Arten von Interpolationen mit gleichmäßiger und ungleichmäßiger Verteilung der Eingangsdaten. Bei dieser Funktion in MATLAB sind einige Teile des internen Codes für den Nutzer sichtbar, andere Teile sind jedoch nicht verfügbar, sodass es unmöglich ist, die Berechnungen zu reproduzieren. Obwohl ArrayFire Version 3.8.0 eine Funktion zur Interpolation enthält, erwartet es, dass die Eingabedaten einheitlich organisiert sind. Um dieses Problem zu lösen, haben wir uns für die Open-Source-Bibliothek ALGLIB entschieden, die eine Reihe von Funktionen für die 2D-Interpolation bietet, mit denen sich das Problem umgehen lässt.
2.3. ALGLIB-Algorithmen als Benchmark für den Vergleich
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. implementierten einen iterativen Jacobi-Solver auf einer physikalischen Hardware-Emulationsplattform, um den Finite-Elemente-Solver eines EM-Simulators zu beschleunigen [5]. Sie demonstrierten die Effizienz ihrer Lösung durch die Implementierung eines zweidimensionalen (2D) Kantenelement-Codes zur Lösung der Maxwell-Gleichungen für Metamaterialien mittels FEM. Ihr Entwurf war 101 Mal schneller als die gleiche reine Software-Implementierung in MATLAB [13] und eine 35-fache Beschleunigung gegenüber dem besten iterativen Software-Solver aus der ALGLIB C++ Bibliothek [14] bei derLösung von 2 Millionen Gleichungen.
In diesem Beitrag stellen wir eine skalierbare Architektur vor, die den Solver-Kern eines EM-Simulators effizient beschleunigen kann. Die Architektur ist auf einer physikalischen Hardware-Emulationsplattform implementiert und wird mit den modernsten Solvern verglichen. Experimentelle Ergebnisse zeigen, dass der vorgeschlagene Solver in der Lage ist, eine 522-fache Beschleunigung gegenüber der gleichen reinen Software-Implementierung auf Matlab, eine 184-fache Beschleunigung gegenüber dem besten iterativen Software-Solver aus der ALGLIB C++ Bibliothek und eine 5-fache Beschleunigung gegenüber einer anderen emulationsbasierten Hardware-Implementierung aus der Literatur zu erzielen, wobei 2 Millionen Gleichungen gelöst werden.
2016: Liu, Yongchao & Pan, Tony & Aluru, Srinivas (2016), Parallel Pairwise Correlation Computation On Intel Xeon Phi Clusters.
Anhand von künstlichen und realen Genexpressionsdatensätzen haben wir LightPCC mit zwei CPU-basierten Gegenstücken verglichen: einer sequenziellen C++-Implementierung in ALGLIB (http://www.alglib.net) und einer Implementierung, die auf einer parallelen GEMM-Routine in der Intel Math Kernel Library (MKL) basiert. Unsere experimentellen Ergebnisse zeigen, dass LightPCC bei Verwendung eines 5110P Phi und 16 Phis bis zu 20,6× und 218,2× schneller als ALGLIB und bis zu 6,8× und 71,4× schneller als Single-Threaded MKL laufen kann.
2.4. ALGLIB-Algorithmen als Teil einer spezialisierten Software
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
Methoden: Die PK-Populationsparameter von Paclitaxel wurden einem veröffentlichten PK-Modell entnommen. Ein Alglib-VBA-Code wurde in Excel 2007 implementiert, um die Differentialgleichungen für das Paclitaxel-PK-Modell zu berechnen. Maximale a posteriori Bayes'sche Schätzungen der PK-Parameter wurden mit dem Excel Solver unter Verwendung einzelner Arzneimittelkonzentrationen ermittelt. Es wurden die Konzentrationen von 250 Patienten simuliert, die einen Zyklus einer Paclitaxel-Chemotherapie erhielten. Die mit dem Excel-Tool berechneten Vorhersagen von Paclitaxel-Tc > 0,05 μmol/L wurden mit NONMEM verglichen, wobei mit der POSTHOC-Funktion maximale a-posteriori-Bayesian-Schätzungen ermittelt wurden.
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.
Während die statistischen und maschinellen Lerntransformationen zum Aufbau von Oberflächen und zur Berechnung von Datensätzen innerhalb eines Tabellenfeldes verwendet werden können, definieren sie an sich nicht die Beziehungen zwischen Antwort- und erklärenden Variablen wie ein prädiktives Modell. Um diese Beziehungen zu definieren, haben wir eine Reihe von Klassen entwickelt, die eine Vielzahl von statistischen Tests und Vorhersagemodellen durchführen und dabei viele der Optimierungsalgorithmen und mathematischen Verfahren verwenden, die in ALGLIB und Accord.net zu finden sind [15,16].
Darüber hinaus stellen wir eine neue Kodierungsbibliothek vor, die die numerischen Bibliotheken von Accord.NET und ALGLIB integriert und mit Hilfe von Lazy Evaluation eine breite Palette von räumlichen, statistischen und maschinellen Lernverfahren innerhalb eines neuen GIS-Modellierungsrahmens, der Funktionsmodellierung, ermöglicht. Die Ergebnisse der Simulationen zeigen eine Verringerung der Verarbeitungszeit um 64,3 % und eine Verringerung des Speicherplatzes um 84,4 %, die auf die Funktionsmodellierung zurückzuführen sind. In einer angewandten Fallstudie führte dies zu einer Verkürzung der Verarbeitungszeit von 2247 Stunden auf 488 Stunden und zu einer Verringerung des Speicherplatzes von 152 Terabyte auf 913 Gigabyte.
3. ALGLIB-Bibliothek für die Finanzmarktanalyse
Die erste Version der Bibliothek für MQL5 (ALGLIB 3.5) ist in der Analyse von Finanzdaten weit verbreitet und löst verschiedene Probleme mit modernen Algorithmen.
Im Folgenden finden Sie eine Liste von Artikeln, in denen Klassen und Funktionen aus der ALGLIB-Bibliothek aktiv angewendet werden:
- Gescheites "Marktgedächtnis" durch Differentiation und Entropieuntersuchung
Algorithmus der logistischen Regression (Klasse CLogitModel) - Statistik-Cookbook für Händler: Hypothesen
Prüfung der Hypothesen:
Wilcoxon signierter Rangtest (Klasse CWilcoxonSignedRank)
Mann-Whitney-U-Test(CMannWhitneyU-Klasse)
Signifikanztest des Spearman-Rangkorrelationskoeffizienten (SpearmanRankCorrelationSignificance) - Die Rolle von statistischen Verteilungen für die Arbeit eines Händlers
Hypothesentests: Jarque-Bera-Test (Klasse CJarqueBera) - Neuronales Netz: Selbst-optimierender Expert Advisor
Algorithmen für die Arbeit mit neuronalen Netzen:
CMLPBase-Klasse — Mehrschicht-Perzeptron
CMLPTrain-Klasse — Mehrschicht-Perzeptron-Training
CMLPE-Klasse — Neuronale Netzsätze - Optimieren einer Strategie unter Verwendung einer Kurve der Salden und dem Vergleich der Ergebnisse mit dem Kriterium "Balance + max Sharpe Ratio"
Die Klassen CLinReg, CLinearModel und CLRReport für die Arbeit mit der linearer Regression. - R² als Gütemaß der Saldenkurve einer Strategie
Die Klasse CLinReg für die Arbeit mit der linearer Regression.
Berechnung der linearen Pearson-Korrelation und der Rangkorrelationskoeffizienten nach Spearman. - Visuelle Auswertung der Optimierungsergebnisse
Lineares Regressionsmodell;
Berechnung des linearen Korrelationskoeffizienten nach Pearson. - Ein Beispiel für die Entwicklung einer Spread-Strategie für Moskauer Börsentermingeschäfte
Lineares Regressionsmodell. - Anleitung zum Schreiben einer DLL für MQL5 in Delphi
Lineares Regressionsmodell. - Studieren der Klasse CCanvas, Anti-Aliasing und Schatten.
- Grafiken in der Bibliothek DoEasy (Teil 77): Objektklasse der Schatten
- DoEasy. Steuerung (Teil 27): Arbeiten am Objekt WinForms der ProgressBar,
Gaußsche Schattenformung und Unschärfe. - Portfoliohandel im MetaTrader 4
Methode der Hauptkomponentenanalyse (Funktionen LRBuildZ, LSFitLinearC und PCABuildBasis). - Kontrollierte Optimierung: Simuliertes Abkühlen
Zufallszahlengenerator (die Klasse CHighQualityRandStateShell und die Funktionen HQRndRandomize, HQRndNormal, HQRndNormal2 und HQRndUniformR). - Praktische Anwendung von Kohonen Neural Networks im algorithmischen Handel. Teil I. Werkzeuge
Der Clusteralgorithmus k-means. - MQL5 Kochbuch - Erstellen eines Ringpuffers zur schnellen Berechnung von Indikatoren in einem gleitenden Fenster
Berechnung der grundlegenden statistischen Parameter:
- Mittelwert,
- Standardabweichung (StdDev),
- Asymmetrie der glockenförmigen Verteilung (Schiefe),
- Kurtosis. - MQL5 Wizard-Techniken, die Sie kennen sollten (Teil 06): Fourier-Transformation
Fast Fourier Transformation (FFTR1D). - Frequenzbereichsdarstellungen von Zeitreihen: Das Leistungsspektrum
Fast Fourier Transformation (FFTR1D). - Random Decision Forest beim verstärkenden Lernen
Der Algorithmus Random Decision Forest (RDF). - MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 5): Markov-Ketten
Markov-Ketten (Klasse CMarkovCPD). - Prognose von Zeitreihen (Teil 2): Kleinste-Quadrat-Vektor-Maschine (LS-SVM);
Lineare „Solver“ der ALGLIB-Bibliothek. - MQL5 Wizard-Techniken, die Sie kennen sollten (Teil 04): Lineare Diskriminanzanalyse.
Lineare Diskriminanzanalyse (CLDA-Klasse) - Prognose von Marktbewegungen mit Hilfe der Bayes'schen Klassifizierung und von Indikatoren auf der Grundlage der Singular Spectrum Analysis
ALGLIB-Matrixfunktionen
Die Funktionsweise der mathematischen Bibliothek ALGLIB erwies sich somit als nützliches Werkzeug für die Analyse von Finanzdaten.
4. Singuläre Spektralanalyse in ALGLIB
Wir laden Sie ein, sich mit der Funktionsweise dieser Methode in der Praxis vertraut zu machen und Ihre Erfahrungen bei der Entwicklung von Handelsstrategien zu teilen.
Nachfolgend finden Sie ein Testskript mit Beispielen für die Verwendung der SSA-Methode. Weitere Informationen über Beispiele und Details zur Verwendung der SSA-Methode in der ALGLIB-Bibliothek finden Sie im Abschnitt Singular Spectrum Analysis (Singuläre Spektralanalyse) der offiziellen Hilfe zur Bibliothek.
//+------------------------------------------------------------------+ //| 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(); } //+------------------------------------------------------------------+
Schlussfolgerung
ALGLIB ist ein leistungsfähiges Werkzeug für die Analyse von Daten auf den Finanzmärkten. Die Mehrsprachigkeit, die plattformübergreifende Natur, die reichhaltige Funktionalität und der offene Quellcode machen es zu einer attraktiven Wahl für Forscher und Entwickler im Bereich der Finanzanalyse und -modellierung. Es besteht ein ständiger Bedarf an zuverlässigen Datenanalysewerkzeugen, und ALGLIB erfüllt diese Herausforderung erfolgreich, indem es die kontinuierliche Entwicklung und Verbesserung unterstützt.
Die Entwickler der MetaTrader 5-Plattform bieten den Händlern ihrerseits die besten Lösungen an:
- MQL5, eine Sprache, die in Bezug auf die Geschwindigkeit mit C++ vergleichbar ist;
- eine integrierte Verarbeitung von SQLite-Datenbanken, die Möglichkeit zur Durchführung von Berechnungen mit OpenCL, eine DirectX-Unterstützung, die Verwendung von ONNX-Modellen und die Integration von Python;
- mathematische Bibliotheken, einschließlich Fuzzy-Logik, Statistik und der aktualisierten ALGLIB-Version.
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/13289
ONNX meistern: Der Game-Changer für MQL5-Händler
Datenkennzeichnung für die Zeitreihenanalyse (Teil 3)：Beispiel für die Verwendung von Datenkennzeichnungen
Kategorientheorie in MQL5 (Teil 23): Ein anderer Blick auf den doppelten exponentiellen gleitenden Durchschnitt
Fertige Vorlagen für die Verwendung von Indikatoren in Expert Advisors (Teil 1): Oszillatoren
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.