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

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 3.6.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.mq4 et testinterfaces.mq5 sont joints avec un simple script de démonstration usealglib.mq4. 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 \MQL4\Scripts\Alglib\Testcases\.

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

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 trading statistiques :

//+------------------------------------------------------------------+
//|                                                    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
//+------------------------------------------------------------------+
//| Fichiers include                                                 |
//+------------------------------------------------------------------+
#include <Math\Alglib\alglib.mqh>
#include <Arrays\ArrayDouble.mqh>
//+------------------------------------------------------------------+
//| Fonction de démarrage du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- objet pour le stockage des données de profit/perte pour chaque ordre
   CArrayDouble *profit=new CArrayDouble;
//--- objet pour le stockage des données du solde
   CArrayDouble *balance_total=new CArrayDouble;
//--- solde initial
   double        balance=0;
//--- requête des données historiques
//--- obtient la quantité totale d'ordres
   int orders_total=OrdersHistoryTotal();
//--- obtient le profit
   for(int i=0;i<orders_total;i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false)
        {
         Print("Erreur dans OrderSelect (",GetLastError(),")");
         return;
        }
      int order_type=OrderType();
      //--- solde initial
      if(order_type==6) // OP_BALANCE=6
        {
         if(NormalizeDouble(OrderProfit()+OrderSwap(),2)>=0.0)
            if(balance==0.0)
               balance=OrderProfit();
        }
      //--- ajoute le profit de l'ordre
      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));
//--- copie les données du solde dans le tableau de doubles
   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 doubles
   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;
//--- nombre de points
   int npoints=balance_total.Total();
//--- création d'une matrice de paramètres, utilisée 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 de détection du résultat des calculs (succès, échec)
   int info;
//--- objets de classe nécessaires au stockage des données sur les calculs
   CLinearModelShell lm;
   CLRReportShell    ar;
//--- tableaux pour stocker les résultats de régression
   double lr_coeff[];
   double lr_values[];
   ArrayResize(lr_values,npoints);
//--- calcule les coefficients de régression linéaire
   CAlglib::LRBuild(xy,npoints,nvars,info,lm,ar);
//--- récupère les coefficients de régression linéaire
   CAlglib::LRUnpack(lm,lr_coeff,nvars);
//--- obtient les valeurs de régression linéaire récupérées
   for(int i=0;i<npoints;i++)
      lr_values[i]=lr_coeff[0]*i+lr_coeff[1];
//--- calcul du gain attendu
   double exp_payoff,tmp1,tmp2,tmp3;
   CAlglib::SampleMoments(arr_profit,exp_payoff,tmp1,tmp2,tmp3);
//--- calcul du 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);
//--- calcul de l'écart type et de la moyenne de HPR
   double AHPR,SD;
   CAlglib::SampleMoments(HPR,AHPR,SD,tmp2,tmp3);
   SD=MathSqrt(SD);
//--- calcul de la corrélgation LR
   double lr_corr=CAlglib::PearsonCorr2(arr_balance,lr_values);
//--- calcul de 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));
//--- calcul du ration Sharpe
   double sharpe_ratio=(AHPR-1)/SD;
//--- print
   PrintFormat("-----------------------------------------------");
   PrintFormat("Régrssion linéaire : y = %.2fx + %.2f",lr_coeff[0],lr_coeff[1]);
//--- paramètres
   PrintFormat("Gain 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("-----------------------------------------------");
//--- delete objects
   delete profit;
   delete balance_total;
  }
//+------------------------------------------------------------------+

Nous recevrons le résultat suivant (en fonction des résultats de votre trading) :