Em 2015, houve alterações no procedimento para criar bibliotecas DLL no MATLAB. Quanto à integração com programas em MQL5, agora o MATLAB Compiler está focado na geração de arquivos executáveis independentes, e não na criação de bibliotecas, como antigamente. Desde 2015, a criação de bibliotecas de DLLs foi transferida para o MATLAB Compiler SDK. O MATLAB Compiler SDK expandiu a funcionalidade do MATLAB Compiler, permitindo criar bibliotecas compartilhadas C/C ++, assemblies Microsoft.NET e classes Java a partir de programas MATLAB.

Como no passado, os aplicativos criados usando os componentes de software do pacote MATLAB Compiler SDK podem ser distribuídos gratuitamente entre usuários que podem dispensar o MATLAB. Esses aplicativos usam o MATLAB Runtime e um conjunto de bibliotecas compartilhadas que usam aplicativos compilados ou componentes do MATLAB.

A tarefa que era conferida ao aplicativo MATLAB Compiler é delegada ao programa Library Compiler. Para completar, consideramos o procedimento para criar uma biblioteca compartilhada C/C++ a partir do MATLAB. O arquivo zip anexado ao artigo contém arquivos com a extensão .m usados para criar a biblioteca. No MATLAB (na guia APPS), é iniciado o aplicativo Library Compiler, é aberto o projeto LibSARIMA.prj e é formada uma estrutura semelhante à mostrada na imagem.

Fig. 1. Interface do Library Compiler.

Aqui é importante prestar atenção às posições destacadas na fig. 1 com linhas e números 1-4. 

1. Criada uma biblioteca compartilhada padrão em C++.
2. Exportada uma função apresentada no arquivo ForecastSARIMA.m, além disso, outras funções não são para exportação e acesso a programas externos.
3. Gerados arquivos para ligação com a interface padrão (matlabsarima.dll, matlabsarima.h, matlabsarima.lib). 
4. Utilizada a interface de acesso à matriz de memória do MATLAB através de estruturas mwArray.

Depois de clicar no botão «Package», é gerada a biblioteca. Pode-se selecionar o modo de geração de biblioteca com o usuário solicitando o download do pacote MATLAB Engine da Internet, ou pode-se incluir inicialmente os componentes necessários do MATLAB Engine no conteúdo do pacote. 

Nesta etapa, é criada uma biblioteca com um programa projetado para filtrar as séries temporais, para construir o modelo SARIMA e a previsão. O arquivo MatlabSArima.zip contém um conjunto de fontes e o resultado da montagem da biblioteca.

2. Criando uma biblioteca intermediária em Microsoft Visual C ++

Depois de criar a biblioteca principal, a próxima tarefa é conectar-se a ela, transferir dados e coletar resultados após os cálculos. Trata-se de criar uma biblioteca adaptador fornecendo tradução de dados entre o MQL5, com memória usada em estilo C/C++ e o MATLAB com memória em forma de matriz.

Para iniciar a programação direta do adaptador para dados, é bom preparar e registrar três variáveis de ambiente do sistema no sistema operacional. Isto pode ser feito, por exemplo, com a ajuda do Explorador de Arquivos através das «propriedades do computador», indo para os «parâmetros adicionais do sistema» e «variáveis de ambiente».

1. Primeira variável — MATLAB_2018 deve apontar para um diretório com MATLAB ou MATLAB Runtime instalado; 
2. Segunda variável — MATLAB_2018_LIB64 deve apontar para um diretório com bibliotecas externas: <MATLAB_2018>\extern\lib\win64;
3. Terceira variável — MATLIB_USER deve apontar para o diretório em que as bibliotecas originais devem ser colocadas. Esse diretório também deve ser adicionado à variável de sistema Path para resolver o problema de localizar as bibliotecas originais de usuários.  

Para reduzir a influência dos fatores de ruído nas cotações de ações recebidas, é bom providenciar uma filtragem adicional e uma limpeza de dados. Quanto mais ruido tiverem os dados, mais difícil será processá-los. O filtro de kalman é um algoritmo de filtragem recursiva eficaz usado em vários campos. O algoritmo consiste em duas fases repetidas: previsão e ajuste. No primeiro passo, calcula-se a previsão do estado no momento seguinte (tendo em conta a imprecisão da sua medição). Além disso, o valor previsto é ajustado tendo em conta a nova informação (também tendo em conta a imprecisão e o ruído desta informação). 

3.2 Programa do indicador em MQL5

As bibliotecas AdapterSArima.dll e matlabsarima.dll necessárias para o indicador devem ser colocadas no diretório Libraries do diretório de trabalho do MetaTrader 5.

Há alguma especificidade de depuração e de teste. Neste modo, o MetaEditor executa a biblioteca a partir dos diretórios auxiliares <MetaQuotes\Tester\....\Agent-127.0.0.1-300x>, onde 300х assumem os valores 3000, 3001, 3002, etc. Nesse caso, a biblioteca AdapterSArima.dll é copiada automaticamente, enquanto a matlabsarima.dll, não. Para que isso não afete a operação do indicador, a biblioteca matlabsarima.dll deve estar no diretório de pesquisa do sistema. Foi recomendado designar um diretório como $(MATLIB_USER)e indicar na lista de caminhos de pesquisa do sistema ou copiar para Windows ou Windows\System32. Em seguida, a biblioteca é detectada, conectada e o indicador é iniciado. 

O programa do indicador, que usa a previsão do modelo considerado, está contido no arquivo ISArimaForecast.mq5 e no arquivo anexado.

//+------------------------------------------------------------------+
//|                                              ISArimaForecast.mq5 |
//|                                                Roman Korotchenko |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright   "Roman Korotchenko"
#property link        "https://login.mql5.com/pt/users/Solitonic"
#property description "This indicator demonstrates forecast by model SARIMA(2,1,2)."
#property description "The program actively uses MATLAB with professionally developed toolboxes and the ability to scale."
#property version   "1.00"
#property indicator_chart_window 

#import "AdapterSArima.dll"
int  prepareSARIMA(void);
int  goSarima(double &Res[],double &DataArray[],int idx0,int nLoad,int iSeasonPeriod,int npredict,int filterOn,int PlotOn);
void closeSARIMA(void);
#import

#property indicator_buffers 2    //---- Buffers for calculating and drawing the indicator
#property indicator_plots   1    //---- graphic constructions
#property indicator_type1  DRAW_COLOR_LINE   
#property indicator_color1  clrChocolate, clrBlue // clrWhite, clrBlue
#property indicator_width1  3 
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum ENUM_TIMERECALC
  {
   TimeRecalc05 = 5,   // 5 sec
   TimeRecalc10 = 10,  // 10 sec
   TimeRecalc15 = 15,  // 15 sec
   TimeRecalc30 = 30,  // 30 sec
   TimeRecalc60 = 60   // 60 sec
  };
//--- input parameters
input ENUM_TIMERECALC RefreshPeriod=TimeRecalc30;         // Recalculate period
input int      SegmentLength  = 450; // N: Data fragment
input int      BackwardShift  = 0;   // Backward shift (testing)
input int      ForecastPoints = 25;  // Point to forecast
input int      SeasonLag=32;         // Season lag of SARIMA(2,1,2)
input bool     DoFilter=true;        // Do Kalman filtering of Data Series

                                     // input string   _INTERFACE_   = "* INTERFACE *"; 
//input long     magic_numb=19661021777;       // Magic Number 

//--- indicator buffers
double   DataBuffer[],ColorBuffer[];
//double   LastTrend[],LastData[];

double   wrkResult[],wrkSegment[];
static int wRKLength;

uint CalcCounter;
//
uint calc_data;
uint start_data;    // Start time to build the chart
uint now_data;      // Current time

static int libReady=0,ErrorHFRange,ErrorDataLength;
static bool   IsCalcFinished;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
static int LengthWithPrediction;

static int PlotOn;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnDeinit()
  {
   closeSARIMA();
   Alert("SARIMA DLL - DeInit");
   Print("SARIMA DLL - DeInit");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!TerminalInfoInteger(TERMINAL_DLLS_ALLOWED))
      Alert("Check the connection permission in the terminal settings DLL!");
   else
     {
      libReady=prepareSARIMA();
      if(libReady<0)
        {
         Alert("Dll DOES NOT CONNECTED!");
         return(INIT_FAILED);
        }

     }

   LengthWithPrediction=SegmentLength+ForecastPoints;
//--- indicator buffers mapping
   SetIndexBuffer(0,DataBuffer,INDICATOR_DATA);            ArraySetAsSeries(DataBuffer,true);
   SetIndexBuffer(1,ColorBuffer,INDICATOR_COLOR_INDEX);    ArraySetAsSeries(ColorBuffer,true);
// SetIndexBuffer(2,LastTrend,   INDICATOR_CALCULATIONS);   ArraySetAsSeries(LastTrend,true);      //for Expert
// SetIndexBuffer(3,LastData,    INDICATOR_CALCULATIONS);   ArraySetAsSeries(LastData,true);       //for Expert

   PlotIndexSetInteger(0,PLOT_SHIFT,ForecastPoints-BackwardShift);

   wRKLength = ForecastPoints+ SegmentLength; // The number of elements in the array with the results
   ArrayResize(wrkResult,wRKLength,0);        // Allocates memory for function results
   ArrayResize(wrkSegment,SegmentLength,0);   // Allocates memory for input data.

//---   
   string shortname;
   StringConcatenate(shortname,"SARIMA(2,1,2). Season Lag: ",SeasonLag,"  // ");
//--- The label to display in DataWindow
   PlotIndexSetString(0,PLOT_LABEL,shortname);
   IndicatorSetString(INDICATOR_SHORTNAME,shortname);

   now_data  = 0.001*GetTickCount();
   start_data= 0.001*GetTickCount();
   calc_data = 0;

   CalcCounter    = 1;
   IsCalcFinished = true;

   ErrorHFRange   = 0;
   ErrorDataLength= 0;

   PlotOn=0; // Auxiliary drawing, executed by MATLAB (for testing)

   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[]
                )
  {
//---
   int ShiftIdx=rates_total-SegmentLength-BackwardShift; // The starting index for the work segment data 

   if(ShiftIdx<0)
     {
      if(!ErrorDataLength)
        {
         PrintFormat("SARIMA INDI FAULT: there are not enough data.");
         ErrorDataLength=1;
        }
      return(0);
     }

   ErrorDataLength=0;

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

   now_data=0.001*GetTickCount();

   if(now_data-calc_data<RefreshPeriod || !IsCalcFinished) // calculation is not needed or not completed
     {
      // ReloadBuffers(prev_calculated,rates_total);
      return(prev_calculated);
     }
   if(prev_calculated!=0 && !IsCalcFinished)
     {
      return(prev_calculated);  // New data comes faster than current calculation finished 
     }
//---------------------------------------------------------------------------     

   IsCalcFinished=false; // Block the request a new calculation until the current one is executed

   int idx=0,iBnd2=ShiftIdx+SegmentLength;
   for(int icnt=ShiftIdx; icnt<iBnd2; icnt++)
     {
      wrkSegment[idx++]=price[icnt];
     }

   ErrorHFRange=0;
// MATLAB SUBROUTINE   
   goSarima(wrkResult,wrkSegment,0,SegmentLength,SeasonLag,ForecastPoints,DoFilter,PlotOn);

   ReloadBuffers(LengthWithPrediction,rates_total);

   ++CalcCounter;
   IsCalcFinished=true; // Ready to make new calculation 

   calc_data=0.001*GetTickCount();

   return(rates_total);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void EmptyBuffers(int n)
  {
   for(int i=0; i<n; i++)
     {
      DataBuffer[i] = EMPTY_VALUE;
      ColorBuffer[i]= EMPTY_VALUE;
     }
  }
//+------------------------------------------------------------------+ 

void ReloadBuffers(int npoint,int ntotal)
  {
   ResetLastError();
   EmptyBuffers(ntotal); // ntotal = rates_total

   if(npoint== 0) return;
   int k=0;//BackwardShift;
   for(int i=0; i<npoint; i++) // npoint = LengthWithPrediction
     {
      if(i>=ntotal) break;
      DataBuffer [k]=wrkResult[LengthWithPrediction-1-i];
      ColorBuffer[k]=(i<ForecastPoints)? 1:0;
      k++;
     }
  }
//=============================================================================

Os resultados da simulação mostram uma boa probabilidade de correspondência entre valores previstos nas primeiras 10-12 contagens e valores observados em tempo real. Além disso, é interessante que o trader precisa apenas de fazer um pequeno esforço para configurar o modelo. O modelo requer dois parâmetros, isto é, o comprimento do segmento e o período de sazonalidade, que podem ser selecionados pelo método de varredura nos dados do histórico mais recente. O restante da carga calculada vai para o MATLAB. No futuro, pode-se analisar o conjunto ideal de parâmetros para o comprimento do segmento e para o período de sazonalidade, a fim de modernizar o indicador.