ALGLIB - Biblioteca de Análise Numérica - biblioteca para MetaTrader 4

Real autor:

Sergey Bochkanov. Website do projeto ALGLIB - http://www.alglib.net/. A data da biblioteca é de 1999.

ALGLIB é uma das maiores e mais completas bibliotecas matemáticas.

Você precisa fazer uma transformação rápida de Fourier ou resolver um sistema de equações diferenciais? Você executa uma análise de dados complexos tentando reunir todos os métodos num lugar como um código-fonte? Então a biblioteca ALGLIB de métodos numéricos é para você!!

ALGLIB é atualmente uma das melhores bibliotecas de algoritmos de multilinguagem. A seguir estão os recursos da bilbioteca ALGLIB mencionados no site oficial:

A biblioteca ALGLIB está sendo constantemente aprimorada, novas funções e melhorias de acordo com comentários dos usuários são implementados regularmente. A última versão é a 3.6.0.

Além disso, a biblioteca contém uma grande coleção de casos de testes que cobrem a maior parte da funcionalidade dos métodos propostos. Isto lhe permitirá realizar os testes e reportar erros detectados aos autores do projeto.

Funções estáticas da classe CAglib devem ser usadas para trabalhar com a biblioteca - todas as funções da biblioteca são movidas para classe de sistema CAlglib como funções estáticas.

Os testes de casos dos scripts testclasses.mq4 e testinterfaces.mq5 são ligados em conjunto com um simples script de demonstração alglib.mq4. Inclusão de arquivos com o mesmo nome (testclasses.mqh e testinterfaces.mqh) são usados para lançar casos de testes. Devem ser colocados no diretório: \MQL4\Scripts\Alglib\Testcases\.

Abaixo está informações mais detalhadas sobre os pacotes da biblioteca portada ALGLIB MQL4:

Código:

As funções da biblioteca tem comentários detalhados sobre a sua utilização.

//+------------------------------------------------------------------+
//| Cálculo dos momentos de distribuição: média, variânção,          |
//| skewness, kurtosis.                                              |
//| PARÂMETROS DE ENTRADA:                                           |
/|     X        -   amostra                                          |
//|     N       -   N>=0, tamanho da amostra:                        | 
//|                 * Se dados, só os principais N elementos de X são|
//|                   processados                                    |
//|                 * se não for dado, determinar automaticamente do |
//|                   tamanho de X                                   |
//| PARÂMETROS DE SAÍDA                                              |
//|     Mean    -   significa                                        |
//|     Variance-   VARIAÇÃO.                                        |
//|     Skewness-   assimetria(se a variação<>0; do contrário zero). |
//|     Kurtosis-   curtose (se a variação<>0; do contrário zero).   |
//+------------------------------------------------------------------+
static bool CBaseStat::SampleMoments(const double &cx[],const int n,double &mean,
                                     double &variance,double &skewness,double &kurtosis)
  {
//--- Verificação
   if(!CAp::Assert(n>=0,__FUNCTION__+": the error variable"))
      return(false);
//--- Verificação
   if(!CAp::Assert(CAp::Len(cx)>=n,__FUNCTION__+": length(x)<n"))
      return(false);
//--- Verificação
   if(!CAp::Assert(CApServ::IsFiniteVector(cx,n),__FUNCTION__+": x is not finite vector"))
      return(false);
//--- criar variáveis
   double v=0;
   double v1=0;
   double v2=0;
   double stddev=0;
//--- Init, caso especial 'N=0'
   mean=0;
   variance=0;
   skewness=0;
   kurtosis=0;
//--- Verificação
   if(n<=0)
      return(true);
//--- Significa
   for(int i=0;i<n;i++)
      mean+=cx[i];
   mean/=n;
//--- Variação (usando duas passagens corrigidas de algoritmo)
   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;
//--- Assimetria e curtose
   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);
        }
      //--- mudar valores
      skewness=skewness/n;
      kurtosis=kurtosis/n-3;
     }
//--- execução bem-sucedida
   return(true);
  }

Funções de classe estática CAglib deve ser usada para trabalhar com a biblioteca. Abaixo a função usealglib.mq5 de código fonte do script para cálculo de alguns parâmetros estatísticos de negociação:

//+------------------------------------------------------------------+
//|                                                    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
//+------------------------------------------------------------------+
//| Bibliotecas incluídas                                            |
//+------------------------------------------------------------------+
#include <Math\Alglib\alglib.mqh>
#include <Arrays\ArrayDouble.mqh>
//+------------------------------------------------------------------+
//| função de início do programa Script                              |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- objeto para o armazenamento dos dados de lucro/perda para cada ordem
   CArrayDouble *profit=new CArrayDouble;
//--- objeto para o armazenamento dos dados do balanço
   CArrayDouble *balance_total=new CArrayDouble;
//--- balanço inicial
   double        balance=0;
//--- solicitação de dados históricos
//--- obter a quantidade total das ordens
   int orders_total=OrdersHistoryTotal();
//--- obter dados de lucro
   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();
      //--- balanço inicial
      if(order_type==6) // OP_BALANCE=6
        {
         if(NormalizeDouble(OrderProfit()+OrderSwap(),2)>=0.0)
            if(balance==0.0)
               balance=OrderProfit();
        }
      //--- adicionar o lucro da ordem
      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 os dados do balanço para o array do 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 dados de lucro para o array do tipo double
   double arr_profit[];
   ArrayResize(arr_profit,profit.Total());
   for(int i=0;i<profit.Total();i++)
      arr_profit[i]=profit.At(i);
//--- regressão linear
//--- número de variáveis independentes
   int nvars=1;
//--- número de pontos
   int npoints=balance_total.Total();
//--- criação de matriz dos parâmetros, utilizado na regressão linear
   CMatrixDouble xy(npoints,nvars+1);
   for(int i=0;i<npoints;i++)
     {
      xy[i].Set(0,i);
      xy[i].Set(1,arr_balance[i]);
     }
//--- variável para a detecção de resultado dos cálculos (bem sucedido, sem sucesso)
   int info;
//--- classe de objetos necessários para armazenar dados calculados
   CLinearModelShell lm;
   CLRReportShell    ar;
//--- arrays para armazenar os resultados da regressão
   double lr_coeff[];
   double lr_values[];
   ArrayResize(lr_values,npoints);
//--- calcula os coeficientes de regressão linear
   CAlglib::LRBuild(xy,npoints,nvars,info,lm,ar);
//--- obtem coeficientes de regressão linear
   CAlglib::LRUnpack(lm,lr_coeff,nvars);
//--- obtem os valores de regressão linear recuperados
   for(int i=0;i<npoints;i++)
      lr_values[i]=lr_coeff[0]*i+lr_coeff[1];
//--- cálculo do Resultado Esperado
   double exp_payoff,tmp1,tmp2,tmp3;
   CAlglib::SampleMoments(arr_profit,exp_payoff,tmp1,tmp2,tmp3);
//--- cálculo do 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);
//--- cálculo do desvio padrão e a média de HPR
   double AHPR,SD;
   CAlglib::SampleMoments(HPR,AHPR,SD,tmp2,tmp3);
   SD=MathSqrt(SD);
//--- cálculo de correlação LR
   double lr_corr=CAlglib::PearsonCorr2(arr_balance,lr_values);
//--- cálculo do 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));
//--- cálculo do Índice Sharpe
   double sharpe_ratio=(AHPR-1)/SD;
//--- impressão
   PrintFormat("-----------------------------------------------");
   PrintFormat("Linear regression: 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("-----------------------------------------------");
//--- excluir objetos
   delete profit;
   delete balance_total;
  }
//+------------------------------------------------------------------+

Nós receberemos o seguinte resultado (dependendo dos resultados de sua negociação):