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

Wirklicher Autor:

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

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:

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.

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

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):