ALGLIB - Libreria di Analisi Numerica - libreria per MetaTrader 4

Autore:

Sergey Bochkanov. Sito web progetto ALGLIB - http://www.alglib.net/. La libreria risale a prima del 1999.

ALGLIB è una delle maggiori e complete librerie matematiche

Hai bisogno di fare velocemente una trasformata di Fourier o di risolvere un sistema di equazioni differenziali? Vuoi performare una complessa analisi di dati provando a raccogliere tutti i metodi in un unico posto come codice sorgente? Allora la libreria di funzioni numeriche ALGLIB è per te!

ALGLIB è al momento una delle migliori librerie di algoritmi multi lingua. Di seguito sono riportate le funzionalità di ALGLIB menzionate sul sito Web ufficiale:

La libreria ALGLIB viene costantemente migliorata, nuove funzioni e miglioramenti in base ai commenti degli utenti vengono implementati regolarmente. L'ultima versione è la 3.6.0.

Inoltre, la libreria contiene un'ampia raccolta di casi di test che coprono la maggior parte delle funzionalità dei metodi proposti. Ciò ti consentirà di portare i test e segnalare gli errori rilevati agli autori del progetto.

Le funzioni statiche della classe CAlglib dovrebbero essere utilizzate per lavorare con la libreria - tutte le funzioni della libreria vengono spostate nella classe di sistema CAlglib come funzioni statiche.

testclasses.mq4 e testinterfaces.mq4 script test sono allegati insieme ad un semplice script di prova usealglib.mq4. I file inclusi con lo stesso nome (testclasses.mqh e testinterfaces.mqh) sono utilizzati per avviare i test. Dovranno essere collocati in \MQL5\Scripts\Alglib\Testcases\.

Di seguito maggiori informazioni dettagliate circa il pacchetto della libreria ALGLIB portato in MQL4:

Codice

Le fuzioni della libreria sono commentate in modo dettagliato per il loro uso.

//+------------------------------------------------------------------+
//| Calculation of the distribution moments: mean, variance,         |
//| skewness, kurtosis.                                              |
//| INPUT PARAMETERS:                                                |
//|     X       -   sample                                           |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only leading N elements of X are     |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   size of X                                      |
//| OUTPUT PARAMETERS                                                |
//|     Mean    -   mean.                                            |
//|     Variance-   variance.                                        |
//|     Skewness-   skewness (if variance<>0; zero otherwise).       |
//|     Kurtosis-   kurtosis (if variance<>0; zero otherwise).       |
//+------------------------------------------------------------------+
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);
  }

Le funzioni statiche della classe CAlglib dovrebbero essere usate per lavorare con la libreria. Di seguito il codice sorgente della funzione dello script usealglib.mq4 per il calcolo di alcuni parametri statistici del trading:

//+------------------------------------------------------------------+
//|                                                    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 program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- object for storage of profit/loss data for each order
   CArrayDouble *profit=new CArrayDouble;
//--- object for storage of balance data
   CArrayDouble *balance_total=new CArrayDouble;
//--- initial balance
   double        balance=0;
//--- historical data request
//--- get total amount ot orders
   int orders_total=OrdersHistoryTotal();
//--- get profit data
   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();
      //--- initial balance
      if(order_type==6) // OP_BALANCE=6
        {
         if(NormalizeDouble(OrderProfit()+OrderSwap(),2)>=0.0)
            if(balance==0.0)
               balance=OrderProfit();
        }
      //--- add order profit
      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));
//--- copy balance data to the array of double type
   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);
//--- copy profit data to the array of double type
   double arr_profit[];
   ArrayResize(arr_profit,profit.Total());
   for(int i=0;i<profit.Total();i++)
      arr_profit[i]=profit.At(i);
//--- linear regression
//--- number of independent variables
   int nvars=1;
//--- number of points
   int npoints=balance_total.Total();
//--- creating parameters matrix, used for linear 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 for detecting calculations result (successful, unsuccessful)
   int info;
//--- class objects necessary for storing data on calculations
   CLinearModelShell lm;
   CLRReportShell    ar;
//--- arrays for storing regression results
   double lr_coeff[];
   double lr_values[];
   ArrayResize(lr_values,npoints);
//--- calculate linear regression coefficients
   CAlglib::LRBuild(xy,npoints,nvars,info,lm,ar);
//--- get linear regression coefficients
   CAlglib::LRUnpack(lm,lr_coeff,nvars);
//--- get the recovered linear regression values
   for(int i=0;i<npoints;i++)
      lr_values[i]=lr_coeff[0]*i+lr_coeff[1];
//--- calculation of Expected Payoff
   double exp_payoff,tmp1,tmp2,tmp3;
   CAlglib::SampleMoments(arr_profit,exp_payoff,tmp1,tmp2,tmp3);
//--- calculation of HPR array
   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);
//--- calculation of the standard deviation and mean of the HPR
   double AHPR,SD;
   CAlglib::SampleMoments(HPR,AHPR,SD,tmp2,tmp3);
   SD=MathSqrt(SD);
//--- calculation of LR Correlation
   double lr_corr=CAlglib::PearsonCorr2(arr_balance,lr_values);
//--- calculation of LR Standard Error
   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));
//--- calculation of Sharpe Ratio
   double sharpe_ratio=(AHPR-1)/SD;
//--- print
   PrintFormat("-----------------------------------------------");
   PrintFormat("Linear regression: y = %.2fx + %.2f",lr_coeff[0],lr_coeff[1]);
//--- parameters
   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("-----------------------------------------------");
//--- delete objects
   delete profit;
   delete balance_total;
  }
//+------------------------------------------------------------------+

Ricevendo i risultati seguenti: