Schau, wie man Roboter kostenlos herunterladen kann

Interessantes Skript?
Veröffentliche einen Link auf das Skript, damit die anderen ihn auch nutzen können

Hat Ihnen das Skript gefallen?
Bewerten Sie es im Terminal MetaTrader 5

Bibliotheken

ALGLIB - Numerische Analyse Bibliothek - Bibliothek für den MetaTrader 4

MetaQuotes Software Corp. | German English Русский 中文 Español 日本語 Português

Ansichten:
1106
Rating:
Stimmen: 47
Veröffentlicht:
2016.04.15 14:03
Aktualisiert:
2019.09.03 15:46
\MQL4\mql4\Include\Math\Alglib\
alglib.mqh (1372.18 KB)ansehen
ap.mqh (75.68 KB)ansehen
complex.mqh (14.07 KB)ansehen
linalg.mqh (712.14 KB)ansehen
matrix.mqh (23.83 KB)ansehen
solvers.mqh (149.25 KB)ansehen
\MQL4\mql4\Scripts\Alglib\
TestClasses.mqh (1380.85 KB)ansehen

Wirklicher Autor:

Sergey Bochkanov. ALGLIB Projekt Website - http://www.alglib.net/. Die Bibliothek datiert zurück auf 1999.

Anmerkung: Der Expert Advisor arbeitet mit MetaTrader 4 build 555 und später.

Das Archive muss ausgepackt werden in die: terminal_data_folder.
Die Codes der Bibliothek sind im Verzeichnis terminal_data_folder\Math\Alglib\
Beispiele der Test-Skripts sind im Verzeichnis terminal_data_folder\MQL4\Scripts\Alglib\

ALGLIB ist eine der größten und komplettesten mathematischen Bibliotheken

Benötigen Se eine Fast Fourier Transformation oder die Lösung einer Differentialgleichung? Führen Sie eine komplexe Datenanalyse durch und versuchen alle notwendigen Methoden mit dem Source-Code an einem Platz zu sammeln? Dann ist die ALGLIB Bibliothek zur numerischen Analyse die Deine!

ALGLIB ist aktuell eine der besten Bibliotheken für "multi-language" Algorithmen. Weiter unten sind die ALGLIB Merkmale der offiziellen Website:

ALGLIB ist eine "cross-platform" Bibliothek für numerische Analyse und Datenverarbeitung. Sie unterstützt mehrere Programmiersprachen (C++, C#, Pascal, VBA) und mehrere Betriebssysteme (Windows, Linux, Solaris). ALGLIB Merkmale beinhalten:

  • Lineare Algebra (direkte Algorithmen, EVD/SVD)
  • Gleichungslöser (linear und nichtlinear)
  • Interpolation
  • Optimierung
  • Fast Fourier Transformation
  • Numerische Integration
  • Linear und nichtlineare Kleinste-Quadrat-Approximation
  • Gewöhnliche Differentialgleichung
  • Spezial Funktionen
  • Statistik (deskriptive Statistik, hypothetisches Testen)
  • Datenanalyse (Klassifikation/Regression, einschließlich Neuronale Netzwerke)
  • Hochgenaue Versionen von linearer Algebra, Interpolation Optimierung und andere Algorithmeen (verwendet MPFR für "floating point" Berechnungen)

Warum ALGLIB? Weil es:

  • portable. Es kann fast überall compiliert werden mit fast jedem Compiler (Siehe Kompatibilitäts Matrix für weitere Information).
  • einfach zu verwenden. Es unterstützt viele Programmiersprachen. Wenn Sie eine verwenden, brauchen Sie andere nicht zu lernen (FORTRAN, z.B.), um zu kompilieren und eine externe Bibliothek zu laden.
  • "open source". Es kann frei unter GPL 2+ verwendet werden.
  • Geeignet auch für kommerzielle Verwendung. Die, welche ALGLIB in kommerziellen Anwendungen verwenden wollen, können eine kommerzielle Lizenz erstehen.

Die ALGLIB Bibliothek wird ständig erweitert, neue Funktionen und Verbesserungen nach Nutzer-Kommentaren werden hinzugefügt. Die letzte Version ist 3.6.0.

Daneben enthält die Bibliothek eine große Menge von Testdaten, die den Hauptteil der Funktionalität der vorgeschlagenen Methoden abdecken. Das erlaubt Ihnen selber Tests auszuführen und entdeckte Fehler dem Autor des Projektes zu melden.


CAlglib-Klasse statische Funktionen sollten mit der Bibliothek verwendet werden, arbeiten - alle Bibliotheksfunktionen sind jetzt Teil der CAlglib System-Klasse als statische Funktionen.

Die Test-Skripte testclasses.mq4 und testinterfaces.mq5 sind zusammen mit einem einfachen Demo-Skript usealglib.mq4 beigefügt. Die Include-Dateien mit gleichem Namen (testclasses.mqh und testinterfaces.mqh) werden verwendet, um die Tests zu starten. Sie müssen in \MQL4\Scripts\Alglib\Testcases\ kopiert werden.

Hinweis: Die Skriptausführung von testclasses.mq4 dauert ziemlich lange (ca. 30 Minuten).

Nachfolgend finden Sie detaillierte Informationen über die portierte Bibliothek ALGLIB MQL4:

Pakete
Beschreibung
alglib.mqh
Das Hauptbibliotheks-Paket enthält benutzerdefinierte Funktionen. Diese Funktionen sollten für Arbeiten mit der Bibliothek verwendet werden.
alglibinternal.mqh
Zusätzliche Klassen für die Verwendung der anderen Bibliotheks-Pakete.
alglibmisc.mqh

Das Paket enthält die folgenden Klassen:

  1. CHighQualityRand - hochwertiger Zufallszahlengenerator.
  2. CNearestNeighbor - KD-Bäume-Generation und Lösung.
ap.mqh Das Paket enthält auch zusätzliche Klassen, die für andere Pakete notwendig sind.
bitconvert.mqh С ++ grundlegenden Klassen und Funktionen, die fehlen in MQL4 als Built-in:
  1. BitConverter - Klasse für die Umwandlung von int- und double-Zahlen in Bit-Arrays und umgekehrt.
  2. CInfOrNaN - NaNs und Plus/Minus Unendlich-Prüfung und Erstellung der Klasse.
  3. ArrayReverse - Arrayelemente Umkehr-Funktion.
  4. GetSelectionString - Funktion um aus einem char-Array eine string-Variable zu erzeugen.
  5. MathSign - Vorzeichen-Funktion für Zahlen.
  6. MathSinh - Sinus Hyperbolicus Funktion.
  7. MathCosh - Kosinus Hyperbolicus Funktion.
  8. MathTanh - Tangens Hyperbolicus Funktion.
complex.mqh Definiert die komplexen Strukturen zur Arbeit mit komplexen Zahlen.
dataanalysis.mqh Klassen zur Datenanalyse:
  1. CBdSS - Funktion für Fehlerberechnungen.
  2. CDForest - arbeiten mit den Wäldern der Entscheidungsbäume.
  3. CKMeans - Clusteranalyse mittels des k-Means-Algorithmus.
  4. CLDA - linearen Diskriminanzanalyse.
  5. CLinReg - lineare Regression.
  6. CMLPBase - Multilayer Perceptron (Neuronale Netzwerke).
  7. CLogit - multinomialen Logit Regression.
  8. CMarkovCPD - Markovketten für Bevölkerungsdaten.
  9. CMLPTrain - Trainieren von Multilayer Perceptrons.
  10. CMLPE - Gruppen von Neuronalen Netzwerken
  11. CPCAnalysis - Hauptkomponenten der Methoden.
delegatefunctions.mqh Das Paket enthält die Ersatzklassen für Delegate. Die Objekte dieser Klassen sind durch mehrere Bibliotheksmethoden optimierte Funktionen.
diffequations.mqh Die Klasse zur Lösung gewöhnlicher Differentialgleichungen:
  1. CODESolver - Lösung gewöhnlicher Differentialgleichungen.
fasttransforms.mqh Fast Transformation Klassen:
  1. CFastFourierTransform - Fast Fourier Transformation.
  2. CConv - Konvolution (Faltung).
  3. CCorr - Kreuz-Korrelationen.
  4. CFastHartleyTransform - Fast Hartley Transformation.
integration.mqh Klassen für numerische Integration:
  1. CGaussQ - Gauß-Quadratur.
  2. CGaussKronrodQ - Gauß–Kronrod Quadratur Formeln.
  3. CAutoGK - adaptive Integration.
interpolation.mqh Interpolation, Näherung und numerische Ableitungsklassen:
  1. CIDWInt - Interpolation und Näherung durch Inverse Distanzwichtung.
  2. CRatInt - rational Interpolation.
  3. CPolInt - Polynominterpolation.
  4. CSpline1D - Eindimensionale Spline-Interpolation.
  5. CLSFit - Approximation mittels linearer oder nichtlinearer kleinste Quadrate Methode.
  6. CPSpline - parametrische Spline Interpolation.
  7. CSpline2D - zweidimensionale Spline Interpolation.
linalg.mqh Klassen zur Berechnung einiger linearer Algebra Operationen:
  1. COrtFac - QR/LQ Zerlegung, Zerlegung nach Hessenberg, wie auch bi- und tridiagonalen Matrizen.
  2. CEigenVDetect - Auffinden der Eigenwerte und Eigenvektoren.
  3. CMatGen - Zufallsmatrizen Erzeugung.
  4. CTrFac - LU und Cholesky Zerlegung.
  5. CRCond - Schätzung einer Abhängigkeitsmatrix.
  6. CMatInv - Matrixinversion.
  7. CBdSingValueDecompose - Singulärwertzerlegung einer bidiagonalen Matrix.
  8. CSingValueDecompose - Singulärwertzerlegung einer Matrix.
  9. CFbls - schnelle, einfache lineare Lösung.
  10. CMatDet - Berechnung der Determinanten einer Matrix.
  11. CSpdGEVD - Auffinden der Eigenwerte und Eigenvektoren in generalisierten, symmetrischen Matrizen.
  12. CInverseUpdate - Matrixinversion und update.
  13. CSchur - Issai Schur Zerlegung.
matrix.mqh Matrix-Klassen: ganze, rationale und komplexe Zahlen.
optimization.mqh Klassen zur ein- und mehrdimensionale Optimierung:
  1. CMinCG - Optimierung mittels konjugierter Gradienten Methode.
  2. CMinBLEIC - Optimierung mittels linearen Nebenbedingungen in Form von Gleichungen und Ungleichungen.
  3. CMinLBFGS - Optimierung mittels sukzessiver Entwicklung und Klassifikation des quadratischen Modells einer Funktion.
  4. CMinQP - quadratische Programmierung mittels linearen Nebenbedingungen in Form von Gleichungen und Ungleichungen.
  5. CMinLM - Optimierung mittels des Levenberg-Marquardt Algorithmus.
  6. CMinComp - rückwärts Kompatibilitätsfunktion.
solvers.mqh Klassen zur Lösung linearer und nichtlinearer Gleichungssysteme:
  1. CDenseSolver - Lösung linearer Gleichungssysteme.
  2. CNlEq - Lösung nichtlinearer Gleichungssysteme.
specialfunctions.mqh Klassen zu Verteilungsfunktionen, Integrale und Polynomen:
  1. CGammaFunc - Gamma-Funktion.
  2. CIncGammaF - unvollständige Gamma-Funktion.
  3. CBetaF - Beta-Funktion.
  4. CIncBetaF - unvollständige Beta-Funktion.
  5. CPsiF - psi-Funktion.
  6. CAiryF - Airy Funktion.
  7. CBessel - Besselsche Funktion ganzzahliger Ordnung.
  8. CJacobianElliptic - Jacobische elliptische Funktion.
  9. CDawson - Dawson Integral.
  10. CTrigIntegrals - trigonometrisches Integral
  11. CElliptic - elliptisches Integral erster und zweiter Ordnung.
  12. CExpIntegrals - exponentielles Integral.
  13. CFresnel - Fresnel-Integral.
  14. CHermite - Hermitesches Polynom.
  15. CChebyshev - Chebyshev-Polynom.
  16. CLaguerre - Laguerre-Polynom.
  17. CLegendre - Legendre-Polynom.
  18. CChiSquareDistr - Chi-Quadrat-Verteilung.
  19. CBinomialDistr - Binominalverteilung.
  20. CNormalDistr - Normalverteilung.
  21. CPoissonDistr - Poisson-Verteilung.
  22. CStudenttDistr - Studentsche t-Verteilung.
  23. CFDistr - F-Verteilung.
statistics.mqh Klassen zur statistischen Datenanalyse:
  1. CBaseStat - grundlegende statistische Methoden.
  2. CCorrTests - Signifikanztest von Korrelationen.
  3. CJarqueBera - Jarque Bera Kriterium.
  4. CMannWhitneyU - Mann-Whitney-U-Kriterium.
  5. CSignTest - Sign-Test.
  6. CStudentTests - Studentsche t-Tests.
  7. CVarianceTests - F-test and chi-square test.
  8. CWilcoxonSignedRank - Wilcoxon-W-Kriterium.


Code:

Die Bibliotheksfunktionen habe detaillierte Beschreibungen zur Verwendung.

//+------------------------------------------------------------------+
//| Berechnung der Verteilungswerte: Mittelwert, Varianz,         |
//| Schiefe, Kurtosis.                                              |
//| Eingabe  Parameter:                                                |
//|     X       -   Beispiel                                           |
//|     N       -   N>=0, Beispiel Anzahl:                               |
//|                 * falls angegeben, nur die ersten N Elemente aus X werden     |
//|                   berechnet                                      |
//|                 * falls nicht angegeben, automatisch bestimmt  durch    |
//|                   Anzahl von X                                      |
//| AUSGABE PARAMETER                                                |
//|     Mean    -   Mittelwert.                                            |
//|     Variance-   Varianz.                                        |
//|     Skewness-   Schiefe (wenn Varianz<>0; sonst Null).       |
//|     Kurtosis-   Kurtosis (wenn Varianz<>0; sonst Null).       |
//+------------------------------------------------------------------+
static bool CBaseStat::SampleMoments(const double &cx[],const int n,double &mean,
                                     double &variance,double &skewness,double &kurtosis)
  {
//--- check
   if(!CAp::Assert(n>=0,__FUNCTION__+": the error variable"))
      return(false);
//--- check
   if(!CAp::Assert(CAp::Len(cx)>=n,__FUNCTION__+": length(x)<n"))
      return(false);
//--- check
   if(!CAp::Assert(CApServ::IsFiniteVector(cx,n),__FUNCTION__+": x is not finite vector"))
      return(false);
//--- create variables
   double v=0;
   double v1=0;
   double v2=0;
   double stddev=0;
//--- Init, special case 'N=0'
   mean=0;
   variance=0;
   skewness=0;
   kurtosis=0;
//--- check
   if(n<=0)
      return(true);
//--- Mean
   for(int i=0;i<n;i++)
      mean+=cx[i];
   mean/=n;
//--- Variance (using corrected two-pass algorithm)
   if(n!=1)
     {
      //--- calculation
      for(int i=0;i<n;i++)
         v1+=CMath::Sqr(cx[i]-mean);
      for(int i=0;i<n;i++)
         v2+=cx[i]-mean;
      v2=CMath::Sqr(v2)/n;
      variance=(v1-v2)/(n-1);
      //--- calculation
      stddev=MathSqrt(variance);
     }
   else
      variance=EMPTY_VALUE;
//--- Skewness and kurtosis
   if(stddev!=0)
     {
      //--- calculation
      for(int i=0;i<n;i++)
        {
         v=(cx[i]-mean)/stddev;
         v2=CMath::Sqr(v);
         skewness+=v2*v;
         kurtosis+=CMath::Sqr(v2);
        }
      //--- change values
      skewness=skewness/n;
      kurtosis=kurtosis/n-3;
     }
//--- successful execution
   return(true);
  }

Um mit den statistischen Funktionen zu arbeiten, verwenden Sie die Klassen aus CAlglib. Unten finden Sie usealglib.mq4, das einige statistische Parameter des Handels berechnet:

//+------------------------------------------------------------------+
//|                                                    UseAlglib.mq4 |
//|                        Copyright 2012, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
//+------------------------------------------------------------------+
//| Include libraries                                                |
//+------------------------------------------------------------------+
#include <Math\Alglib\alglib.mqh>
#include <Arrays\ArrayDouble.mqh>
//+------------------------------------------------------------------+
//| Script Programm Start Funktion                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Objekt zum Speichern von Gewinn/Verlust jeder Position
   CArrayDouble *profit=new CArrayDouble;
//--- Objekt zum Speichern des Kontostands
   CArrayDouble *balance_total=new CArrayDouble;
//--- Anfangssaldo
   double        balance=0;
//--- historischer Datenabruf
//--- Anzahl aller geschlossenen Positionen
   int orders_total=OrdersHistoryTotal();
//--- lies Gewinn/Verlust
   for(int i=0;i<orders_total;i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false)
        {
         Print("Error in OrderSelect (",GetLastError(),")");
         return;
        }
      int order_type=OrderType();
      //--- Anfangssaldo
      if(order_type==6) // OP_BALANCE=6
        {
         if(NormalizeDouble(OrderProfit()+OrderSwap(),2)>=0.0)
            if(balance==0.0)
               balance=OrderProfit();
        }
      //--- addiere Gewinn/Verlust
      if(order_type==OP_BUY || order_type==OP_SELL)
        {
         double order_profit=OrderProfit()+OrderSwap()+OrderCommission();
         profit.Add(NormalizeDouble(order_profit,2));
         balance_total.Add(balance);
         balance=balance+NormalizeDouble(order_profit,2);
        }
     }
//---
   balance_total.Add(balance_total.At(balance_total.Total()-1)+profit.At(balance_total.Total()-1));
//--- kopiere die Kontensaldi in ein "double-Array"
   double arr_balance[];
   ArrayResize(arr_balance,balance_total.Total());
   for(int i=0;i<balance_total.Total();i++)
      arr_balance[i]=balance_total.At(i);
//--- kopiere die Gewinn/Verlust in ein "double-Array"
   double arr_profit[];
   ArrayResize(arr_profit,profit.Total());
   for(int i=0;i<profit.Total();i++)
      arr_profit[i]=profit.At(i);
//--- lineare Regression
//--- Anzahl unabhängiger Variablen
   int nvars=1;
//--- Anzahl Positionen
   int npoints=balance_total.Total();
//--- erzeuge Parameter-Matrix, für die lineare Regression
   CMatrixDouble xy(npoints,nvars+1);
   for(int i=0;i<npoints;i++)
     {
      xy[i].Set(0,i);
      xy[i].Set(1,arr_balance[i]);
     }
//--- Variable der Ergebnisberechnung (erfolgreich, erfolglos)
   int info;
//--- notwendige Objektklasse zum Speichern der Daten
   CLinearModelShell lm;
   CLRReportShell    ar;
//--- Arrays zum Speichern der Ergebnisse der Regression
   double lr_coeff[];
   double lr_values[];
   ArrayResize(lr_values,npoints);
//--- Berechnung der Koeffizienten der lineare Regression
   CAlglib::LRBuild(xy,npoints,nvars,info,lm,ar);
//--- erhalten der Koeffizienten der lineare Regression
   CAlglib::LRUnpack(lm,lr_coeff,nvars);
//--- erhalte die Werte der lineare Regression
   for(int i=0;i<npoints;i++)
      lr_values[i]=lr_coeff[0]*i+lr_coeff[1];
//--- Berechnung des erwarteten Payoffs
   double exp_payoff,tmp1,tmp2,tmp3;
   CAlglib::SampleMoments(arr_profit,exp_payoff,tmp1,tmp2,tmp3);
//--- Berechnung des HPR Arrays
   double HPR[];
   ArrayResize(HPR,balance_total.Total()-1);
   for(int i=0;i<balance_total.Total()-1;i++)
      HPR[i]=balance_total.At(i+1)/balance_total.At(i);
//--- Berechnung der Standardabweichung und des Mittelwerts der HPR
   double AHPR,SD;
   CAlglib::SampleMoments(HPR,AHPR,SD,tmp2,tmp3);
   SD=MathSqrt(SD);
//--- Berechnung der LR-Korrelation
   double lr_corr=CAlglib::PearsonCorr2(arr_balance,lr_values);
//--- Berechnung der LR-Standard-Fehlers
   double lr_stand_err=0;
   for(int i=0;i<npoints;i++)
     {
      double delta=MathAbs(arr_balance[i]-lr_values[i]);
      lr_stand_err=lr_stand_err+delta*delta;
     }
   lr_stand_err=MathSqrt(lr_stand_err/(npoints-2));
//--- Berechnung des Sharpe Ratio
   double sharpe_ratio=(AHPR-1)/SD;
//--- Ausgabe
   PrintFormat("-----------------------------------------------");
   PrintFormat("Linear regression: y = %.2fx + %.2f",lr_coeff[0],lr_coeff[1]);
//--- Parameter
   PrintFormat("Expected Payoff = %.2f",exp_payoff);
   PrintFormat("AHPR = %.4f",AHPR);
   PrintFormat("Sharpe Ratio = %.2f",sharpe_ratio);
   PrintFormat("LR Correlation = %.2f",lr_corr);
   PrintFormat("LR Standard Error = %.2f",lr_stand_err);
   PrintFormat("-----------------------------------------------");
//--- Lösche Objekte
   delete profit;
   delete balance_total;
  }
//+------------------------------------------------------------------+

Wir erhalten folgendes Ergebnis (abhängig von den Ergebnissen Ihres Handelns):

Alglib Test Ergebnis

Die Übersetzung aus dem Russischen wurde durch die MetaQuotes Software Corp. ausgeführt
Originalpublikation: https://www.mql5.com/ru/code/11077

Ideal ZigZag Ideal ZigZag

Sehr schneller ZigZag. Keine abgehängten Spitzen. Keine falschen Spitzen. Zur Verwendung durch EAs. Optimierter Spitzen-Abruf

FiboPivotCandleBar FiboPivotCandleBar

Dieser Indikator ist eine Kombination mehrerer Indikatoren: Fibonacci, Pivot Point, ZigZag und MACD, die dieser Indikator vereint.

Skype Control Library Skype Control Library

Bibliothek für Skype.

FMOneEA FMOneEA

FMOneEA ist ein Scalping Expert Advisor basierend auf den MA und MACD-Indikatoren.