ALGLIB - Biblioteca de análisis numérico - librería para MetaTrader 5

Autor real:

Sergey Bochkanov. Sitio web del proyecto ALGLIB - http://www.alglib.net/. Las fechas de la librería se remontan a 1999.

ALGLIB es una de las bibliotecas matemáticas más completas e importantes

¿Necesitas hacer una transformada rápida de Fourier para resolver un sistema de ecuaciones diferenciales? ¿Quieres realizar un análisis de datos complejos tratando de reunir todos los métodos en un solo lugar como un código fuente? Then ALGLIB la biblioteca de métodos numéricos es para ti!!

ALGLIB es actualmente una de las mejores bibliotecas de los algoritmos multi-lenguaje. A continuación se mencionan las características de ALGLIB del sitio web oficial:

La librería ALGLIB se está mejorando constantemente, se implementan regularmente nuevas funciones y mejoras de acuerdo con los comentarios de los usuarios. La última versión es 4.0.

Además, la librería contiene una gran colección de casos de prueba que cubre la mayor parte de la funcionalidad de los métodos propuestos. Eso le permitirá llevar las pruebas y los informes de los errores detectados a los autores del proyecto.

Las funciones estáticas de la clase CAlglib deben utilizarse para trabajar con la librería - todas las funciones de la librería se trasladaron a la clase del sistema CAlglib como funciones estáticas.

Los scripts de prueba testclasses.mq5 y testinterfaces.mq5 se adjuntan junto con un simple script de demostración usealglib. Los archivos incluidos del mismo nombre (testclasses.mqh y testinterfaces.mqh) se utilizan para poner en marcha los casos de prueba. Deben ser colocados en \MQL5\Scripts\Alglib\Testcases\.

A continuación se muestra información más detallada sobre los paquetes de la libreria ALGLIB MQL5:

Code:

Funciones de la librería con comentarios detallados sobre su uso.

//+------------------------------------------------------------------+
//| Cálculo de los momentos de distribución: mean, variance,         |
//| skewness, kurtosis.                                              |
//| PARAMETROS DE ENTRADA:                                           |
//|     X       -   sample                                           |
//|     N       -   N>=0, sample size:                               |
//|                 * si se da, sólo se procesan los elementos       |
//|                   principales de N de X                          |
//|                 * si no se da, se determina automáticamente      |
//|                   a partir del tamaño de X                       |
//| PARAMETROS DE SALIDA:                                            |
//|     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)
  {
//--- comprueba
   if(!CAp::Assert(n>=0,__FUNCTION__+": variable de error"))
      return(false);
//--- comprueba
   if(!CAp::Assert(CAp::Len(cx)>=n,__FUNCTION__+": length(x)<n"))
      return(false);
//--- comprueba
   if(!CAp::Assert(CApServ::IsFiniteVector(cx,n),__FUNCTION__+": x no es un vector finito"))
      return(false);
//--- crear 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;
//--- comprueba
   if(n<=0)
      return(true);
//--- Mean
   for(int i=0;i<n;i++)
      mean+=cx[i];
   mean/=n;
//--- Variación (utilizando el algoritmo de dos pasos corregido)
   if(n!=1)
     {
      //--- cálculo
      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);
      //--- cálculo
      stddev=MathSqrt(variance);
     }
   else
      variance=EMPTY_VALUE;
//--- Skewness y kurtosis
   if(stddev!=0)
     {
      //--- cálculo
      for(int i=0;i<n;i++)
        {
         v=(cx[i]-mean)/stddev;
         v2=CMath::Sqr(v);
         skewness+=v2*v;
         kurtosis+=CMath::Sqr(v2);
        }
      //--- cambia los valores
      skewness=skewness/n;
      kurtosis=kurtosis/n-3;
     }
//--- ejecución exitosa
   return(true);
  }

Deben utilizarse las funciones estáticas de la clase CAlglib para trabajar con la librería. A continuación se muestra el código fuente del script de funciones usealglib.mq5 para el cálculo de algunos parámetros estadísticos de comercio:

//+------------------------------------------------------------------+
//|                                                    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"
//+------------------------------------------------------------------+
//| Conexión de las librerias                                        |
//+------------------------------------------------------------------+
#include <Math\Alglib\alglib.mqh>
#include <Trade\DealInfo.mqh>
#include <Arrays\ArrayDouble.mqh>
//+------------------------------------------------------------------+
//| Función de inicio del programa de secuencias de comandos         |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- object to access data on deals
   CDealInfo     deal;
//--- objeto para el almacenamiento de beneficio / pérdida de cada transacción 
   CArrayDouble *profit=new CArrayDouble;
//--- objetos para almacenar el balance
   CArrayDouble *balance_total=new CArrayDouble;
//--- balance inicial
   double        balance=0;
//--- recibe el historial
   HistorySelect(0,TimeCurrent());
//--- importe total de las transacciones
   int deals_total=HistoryDealsTotal();
//--- recibe datos sobre las ganancias y el balance de las transacciones
   for(int i=0;i<deals_total;i++)
     {
      //--- mover la transacción con el índice i
      deal.SelectByIndex(i);
      //--- recibe el saldo inicial
      if(deal.DealType()==DEAL_TYPE_BALANCE)
        {
         if(NormalizeDouble(deal.Profit()+deal.Swap(),2)>=0.0)
            if(balance==0.0)
               balance=deal.Profit();
        }
      //--- recibe el beneficio y el balance
      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));
//--- copia los datos del balance al array del tipo de 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);
//--- copia los datos en beneficio al array tipo double
   double arr_profit[];
   ArrayResize(arr_profit,profit.Total());
   for(int i=0;i<profit.Total();i++)
      arr_profit[i]=profit.At(i);
//--- regresión lineal
//--- número de variables independientes
   int nvars=1;
//--- volumen de la muestra
   int npoints=balance_total.Total();
//--- crea el array de parámetros para la regresión lineal
   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 para detectar los resultados de los cálculos (éxito, sin éxito)
   int info;
//--- objetos de la clase necesarios para almacenar los datos en cálculos
   CLinearModelShell lm;
   CLRReportShell    ar;
//--- arrays para almacenar los resultados de la regresión
   double lr_coeff[];
   double lr_values[];
   ArrayResize(lr_values,npoints);
//--- calcular los coeficientes de la regresión lineal
   CAlglib::LRBuild(xy,npoints,nvars,info,lm,ar);
//--- recibe los coeficientes de la regresión lineal
   CAlglib::LRUnpack(lm,lr_coeff,nvars);
//--- recibe los valores recuperados de la regresión lineal
   for(int i=0;i<npoints;i++)
      lr_values[i]=lr_coeff[0]*i+lr_coeff[1];
//--- calcula el Payoff esperado
   double exp_payoff,tmp1,tmp2,tmp3;
   CAlglib::SampleMoments(arr_profit,exp_payoff,tmp1,tmp2,tmp3);
//--- calcula el array 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);
//--- calcula la desviación estándar y la expectativa matemática de HPR
   double AHPR,SD;
   CAlglib::SampleMoments(HPR,AHPR,SD,tmp2,tmp3);
   SD=MathSqrt(SD);
//--- calcula la LR Correlation
   double lr_corr=CAlglib::PearsonCorr2(arr_balance,lr_values);
//--- recibe el error LR Standard
   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));
//--- calcula el ratio Sharpe
   double sharpe_ratio=(AHPR-1)/SD;
//--- imprime
   PrintFormat("-----------------------------------------------");
   PrintFormat("Correlation function: y = %.2fx + %.2f",lr_coeff[0],lr_coeff[1]);
//--- parámetros
   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("-----------------------------------------------");
//--- elimina los objetos
   delete profit;
   delete balance_total;
  }
//+------------------------------------------------------------------+

Recibimos el siguiente resultado: