ALGLIB - Bibliothèque d'Analyse Numérique - bibliothèque pour MetaTrader 5

Véritable auteur :

Sergey Bochkanov. Site Web du projet ALGLIB - http://www.alglib.net/. La bibliothèque date de 1999.

ALGLIB est l'une des bibliothèques mathématiques les plus importantes et les plus complètes

Avez-vous besoin de faire une transformée de Fourier rapide ou de résoudre un système d'équation différentielle ? Effectuez-vous une analyse de données complexe en essayant de rassembler toutes les méthodes en un seul endroit en tant que code source ? Alors la bibliothèque de méthodes numériques ALGLIB est faite pour vous !

ALGLIB est actuellement l'une des meilleures bibliothèques d'algorithmes multi-langages. Vous trouverez ci-dessous les fonctionnalités d'ALGLIB mentionnées sur le site officiel :

La bibliothèque ALGLIB est constamment enrichie, de nouvelles fonctions et améliorations en fonction des commentaires des utilisateurs sont régulièrement mises en œuvre. La dernière version est la 4.0.

En outre, la bibliothèque contient une grande collection de cas de test couvrant la majeure partie des fonctionnalités des méthodes proposées. Cela vous permettra de réaliser les tests et de signaler les erreurs détectées aux auteurs du projet.

Les fonctions statiques de la classe CAlglib doivent être utilisées pour travailler avec la bibliothèque - toutes les fonctions de la bibliothèque sont déplacées vers la classe système CAlglib en tant que fonctions statiques.

Les scripts de cas de test testclasses.mq5 et testinterfaces.mq5 sont joints avec un simple script de démonstration usealglib.mq5. Les fichiers d'include du même nom (testclasses.mqh et testinterfaces.mqh) sont utilisés pour lancer les cas de test. Ils doivent être placés dans \MQL5\Scripts\Alglib\Testcases\.

Vous trouverez ci-dessous des informations plus détaillées sur les packages de bibliothèque portés par ALGLIB MQL5 :

Code :

Les fonctions de la bibliothèque ont des commentaires détaillés sur leur utilisation.

//+-------------------------------------------- ----------------------+
//| Calcul des moments de distribution : moyenne, variance,           |
//| asymétrie, aplatissement.                                         |
//| PARAMÈTRES D'ENTRÉE :                                             |
//|   X     - échantillon                                             |
//|   N     - N>=0, taille de l'échantillon :                         |
//|          * si donné, seuls les N éléments principaux de X sont    |
//|            traités                                                |
//|          * si non fourni, déterminé automatiquement à partir de   |
//|            la taille de X                                         |
//| PARAMÈTRES DE SORTIE                                              |
//|   Moyenne   - moyenne.                                            |
//|   Variance  - variance.                                           |
//|   Asymétrie -   asymétrie (si variance<>0 ; zéro sinon).          |
//|   Kurtosis  -   aplatissement (si variance<>0 ; zéro sinon).      |
//+-------------------------------------------------------------------+
static bool CBaseStat::SampleMoments(const double &cx[],const int n,double &mean,
                                     double &variance,double &skewness,double &kurtosis)
  {
//--- vérification
   if(!CAp::Assert(n>=0,__FUNCTION__+": the error variable"))
      return(false);
//--- vérification
   if(!CAp::Assert(CAp::Len(cx)>=n,__FUNCTION__+": length(x)<n"))
      return(false);
//--- vérification
   if(!CAp::Assert(CApServ::IsFiniteVector(cx,n),__FUNCTION__+": x is not finite vector"))
      return(false);
//--- crée les variables
   double v=0;
   double v1=0;
   double v2=0;
   double stddev=0;
//--- Initialisation, cas spécial 'N=0'
   mean=0;
   variance=0;
   skewness=0;
   kurtosis=0;
//--- vérification
   if(n<=0)
      return(true);
//--- Moyenne
   for(int i=0;i<n;i++)
      mean+=cx[i];
   mean/=n;
//--- Variance (utilisant l'algorithme corrigé en deux passes)
   if(n!=1)
     {
      //--- calcul
      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);
      //--- calcul
      stddev=MathSqrt(variance);
     }
   else
      variance=EMPTY_VALUE;
//--- Asymétrie et aplatissement
   if(stddev!=0)
     {
      //--- calculn
      for(int i=0;i<n;i++)
        {
         v=(cx[i]-mean)/stddev;
         v2=CMath::Sqr(v);
         skewness+=v2*v;
         kurtosis+=CMath::Sqr(v2);
        }
      //--- modification des valeurs
      skewness=skewness/n;
      kurtosis=kurtosis/n-3;
     }
//--- exécution réussie
   return(true);
  }

Les fonctions statiques de la classe CAlgalib doivent être utilisées pour travailler avec la bibliothèque. Vous trouverez ci-dessous le code source du script de fonction usealglib.mq5 pour le calcul de certains paramètres de notation statistiques :

//+------------------------------------------------------------------+
//|                                                    UseAlglib.mq5 |
//|                         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"
//+------------------------------------------------------------------+
//| Connecter les bibliothèques                                      |
//+------------------------------------------------------------------+
#include <Math\Alglib\alglib.mqh>
#include <Trade\DealInfo.mqh>
#include <Arrays\ArrayDouble.mqh>
//+------------------------------------------------------------------+
//| Fonction de démarrage du programme de script                     |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- objet d'accès aux données sur les ordres
   CDealInfo     deal;
//--- objet pour stocker le profit/la perte de chaque transaction
   CArrayDouble *profit=new CArrayDouble;
//--- objets pour stocker le solde
   CArrayDouble *balance_total=new CArrayDouble;
//--- solde initial
   double        balance=0;
//--- récupération de l'historique
   HistorySelect(0,TimeCurrent());
//--- nombre total de transactions
   int deals_total=HistoryDealsTotal();
//--- récupération des données des profit et solde des transactions
   for(int i=0;i<deals_total;i++)
     {
      //--- se rend à la i-ème transaction
      deal.SelectByIndex(i);
      //--- récupère le solde initial
      if(deal.DealType()==DEAL_TYPE_BALANCE)
        {
         if(NormalizeDouble(deal.Profit()+deal.Swap(),2)>=0.0)
            if(balance==0.0)
               balance=deal.Profit();
        }
      //--- récupère le profit et le solde
      if(deal.DealType()==DEAL_TYPE_BUY || deal.DealType()==DEAL_TYPE_SELL)
         if(deal.Entry()==DEAL_ENTRY_OUT || deal.Entry()==DEAL_ENTRY_INOUT)
           {
            profit.Add(NormalizeDouble(deal.Profit()+deal.Swap()+deal.Commission(),2));
            balance_total.Add(balance);
            balance=balance+NormalizeDouble(deal.Profit()+deal.Swap()+deal.Commission(),2);
           }
     }
   balance_total.Add(balance_total.At(balance_total.Total()-1)+profit.At(balance_total.Total()-1));
//--- copie les données du solde dans le tableau de types double
   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);
//--- copie les données du profit dans le tableau de type double
   double arr_profit[];
   ArrayResize(arr_profit,profit.Total());
   for(int i=0;i<profit.Total();i++)
      arr_profit[i]=profit.At(i);
//--- régression linéaire
//--- nombre de variables indépendantes
   int nvars=1;
//--- échantillon de volume
   int npoints=balance_total.Total();
//--- crée la matrice des paramètres pour la régression linéaire
   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 pour détecter les résultats des calculs (réussi, échoué)
   int info;
//--- objets de classe nécessaires pour stocker les données des calculs
   CLinearModelShell lm;
   CLRReportShell    ar;
//--- tableaux pour stocker les résultats de la régression
   double lr_coeff[];
   double lr_values[];
   ArrayResize(lr_values,npoints);
//--- calcule les ratios de la régression linéaire
   CAlglib::LRBuild(xy,npoints,nvars,info,lm,ar);
//--- récupère les ratios de régression linéaire
   CAlglib::LRUnpack(lm,lr_coeff,nvars);
//--- récupère les valeurs de la régression linéaire calculée
   for(int i=0;i<npoints;i++)
      lr_values[i]=lr_coeff[0]*i+lr_coeff[1];
//--- calcule le Rendement Attendu
   double exp_payoff,tmp1,tmp2,tmp3;
   CAlglib::SampleMoments(arr_profit,exp_payoff,tmp1,tmp2,tmp3);
//--- calcule le tableau HPR
   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);
//--- calcule l'écart type et les attendus mathématiques depuis HPR
   double AHPR,SD;
   CAlglib::SampleMoments(HPR,AHPR,SD,tmp2,tmp3);
   SD=MathSqrt(SD);
//--- calcule la corrélation LR
   double lr_corr=CAlglib::PearsonCorr2(arr_balance,lr_values);
//--- récupère l'erreur standard LR
   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));
//--- calcule la Ratio de Sharpe
   double sharpe_ratio=(AHPR-1)/SD;
//--- affichage
   PrintFormat("-----------------------------------------------");
   PrintFormat("Fonction de corrélation : y = %.2fx + %.2f",lr_coeff[0],lr_coeff[1]);
//--- parameters
   PrintFormat("Rendement Attendu = %.2f",exp_payoff);
   PrintFormat("AHPR = %.4f",AHPR);
   PrintFormat("Ratio de Sharpe = %.2f",sharpe_ratio);
   PrintFormat("Corrélation LR = %.2f",lr_corr);
   PrintFormat("Erreur Standard LR = %.2f",lr_stand_err);
   PrintFormat("-----------------------------------------------");
//--- supprime les objets
   delete profit;
   delete balance_total;
  }
//+------------------------------------------------------------------+

On obtient le résultat suivant :