ALGLIB - Librería de Análisis Numérico - librería para MetaTrader 4

Autor real:

Sergey Bochkanov. Sitio web del proyecto ALGLIB - http://www.alglib.net/. La librería se remonta a 1999.

ALGLIB es una de las librerias matemáticas más grandes y más completas

¿Necesita hacer una transformada rápida de Fourier o de resolver un sistema de ecuación diferencial? ¿Realizar un análisis de datos complejos tratando de reunir todos los métodos en un mismo lugar como un código fuente? ¡Entonces la librería de métodos numéricosALGLIB es para usted!

ALGLIB es actualmente una de las mejores librerías de algoritmos en varios lenguajes. A continuación se mencionan características de ALGLIB en la web oficial:

Las librerías ALGLIB están siendo constantemente mejoradas, se aplican regularmente nuevas funciones y mejoras según los comentarios de los usuarios. La versión más reciente es 3.6.0.

Además, la libreria contiene una colección grande de casos de prueba que cubren la mayor parte de la funcionalidad de los métodos propuestos. Permitirá realizar pruebas e Informe detectó errores a los autores del proyecto.

Funciones estáticas de la clase CAlglib puede usarse para trabajar con la librería - todas las funciones se mueven de la clase del sistema de CAlglib como funciones estáticas.

los scripts de casos de prueba TestClasses.MQ4 y testinterfaces.mq5 se unen junto con un script de demostración de usealglib.mq4 simple. Incluir archivos del mismo nombre (testclasses.mqh y testinterfaces.mqh) que se utilizan para ejecutar casos de prueba. Se colocarán en \MQL4\Scripts\Alglib\Testcases\.

A continuación, información más detallada acerca de los paquetes portados de la librería de MQL4 ALGLIB:

Código:

Las funciones de la libreria han detallados comentarios sobre su uso.

//+------------------------------------------------------------------+
//| Cálculo de los momentos de la distribución: media, varianza, |
//| asimetría, curtosis.                                             |
//| PARÁMETROS DE ENTRADA:                                           |
//|     X       -   muestra                                          |
//|     N       -   N>=0, tamaño de la muestra::                     |
//|                 * Si da, únicos N destacados elementos de X son  |
//|                   procesado                                      |
//|                 * Si no está dado, determinado automáticamente a partir de    |
//|                   tamaño de X                                    |
//| PARÁMETROS DE SALIDA                                             |
//|     Mean    -   promedio.                                        |
//|     Variance-   variancia.                                       |
//|     Skewness-   skewness (si variancia<>0; sino cero).           |
//|     Kurtosis-   kurtosis (i variancia<>0; sino cero).            |
//+------------------------------------------------------------------+
static bool CBaseStat::SampleMoments(const double &cx[],const int n,double &mean,
                                     double &variance,double &skewness,double &kurtosis)
  {
//--- comprobación
   if(!CAp::Assert(n>=0,__FUNCTION__+": variable erronea"))
      return(false);
//--- comprobación
   if(!CAp::Assert(CAp::Len(cx)>=n,__FUNCTION__+": length(x)<n"))
      return(false);
//--- comprobación
   if(!CAp::Assert(CApServ::IsFiniteVector(cx,n),__FUNCTION__+": x no es un vector finito"))
      return(false);
//--- crear las variables
   double v=0;
   double v1=0;
   double v2=0;
   double stddev=0;
//--- Inicio, caso especial n = 0'
   mean=0;
   variance=0;
   skewness=0;
   kurtosis=0;
//--- comprobación
   if(n<=0)
      return(true);
//--- Mean
   for(int i=0;i<n;i++)
      mean+=cx[i];
   mean/=n;
//--- Variance (usando algoritmo corregido de paso de dos)
   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;
//--- La asimetría 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);
        }
      //--- cambio de valores
      skewness=skewness/n;
      kurtosis=kurtosis/n-3;
     }
//--- ejecución exitosa
   return(true);
  }

Funciones estáticas de la clase CAlglib deben ser utilizadas para trabajar con la librería. A continuación es código fuente del script de la función usealglib.mq5 para el cálculo de algunos parámetros estadísticos 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
//+------------------------------------------------------------------+
//| Incluyen librerías                                               |
//+------------------------------------------------------------------+
#include <Math\Alglib\alglib.mqh>
#include <Arrays\ArrayDouble.mqh>
//+------------------------------------------------------------------+
//| Script de la función de inicio de programa                       |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- objeto para el almacenamiento de datos de pérdidas y ganancias de cada orden de
   CArrayDouble *profit=new CArrayDouble;
//--- objeto para almacenar los datos del balance
   CArrayDouble *balance_total=new CArrayDouble;
//--- balance inicial
   double        balance=0;
//--- solicitud de datos históricos
//--- obtener cantidad total de órdenes
   int orders_total=OrdersHistoryTotal();
//--- datos de ganancias
   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();
      //--- balance inicial
      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));
//--- copiar los datos del balance en la matriz de tipo 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);
//--- copiar datos del beneficio en lka matriz del 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;
//--- número de puntos
   int npoints=balance_total.Total();
//--- crear matriz de parámetros, utilizado 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 el resultado de los cálculos (exitosos, fracasados)
   int info;
//--- clase de objetos necesarios para almacenar los datos en los cálculos
   CLinearModelShell lm;
   CLRReportShell    ar;
//--- matrices para almacenar los resultados de la regresión
   double lr_coeff[];
   double lr_values[];
   ArrayResize(lr_values,npoints);
//--- calcular coeficientes de regresión lineal
   CAlglib::LRBuild(xy,npoints,nvars,info,lm,ar);
//--- obtener coeficientes de regresión lineal
   CAlglib::LRUnpack(lm,lr_coeff,nvars);
//--- obtener los valores de la regresión lineal recuperados
   for(int i=0;i<npoints;i++)
      lr_values[i]=lr_coeff[0]*i+lr_coeff[1];
//--- cálculo del pago esperado
   double exp_payoff,tmp1,tmp2,tmp3;
   CAlglib::SampleMoments(arr_profit,exp_payoff,tmp1,tmp2,tmp3);
//--- cálculo de la matriz 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);
//--- cálculo de la desviación estándar y media del HPR
   double AHPR,SD;
   CAlglib::SampleMoments(HPR,AHPR,SD,tmp2,tmp3);
   SD=MathSqrt(SD);
//--- cálculo de correlación LR
   double lr_corr=CAlglib::PearsonCorr2(arr_balance,lr_values);
//--- cálculo del Error estándar de 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));
//--- cálculo de Ratio de Sharpe
   double sharpe_ratio=(AHPR-1)/SD;
//--- print
   PrintFormat("-----------------------------------------------");
   PrintFormat("Linear regression: y = %.2fx + %.2f",lr_coeff[0],lr_coeff[1]);
//--- parametros
   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("-----------------------------------------------");
//--- eliminar objetos
   delete profit;
   delete balance_total;
  }
//+------------------------------------------------------------------+

Recibiremos el siguiente resultado (dependiendo de los resultados de sus operaciones):