OnCalculate

É chamada em indicadores quando ocorre o evento Calculate para processar alterações nos dados de preço. Existem duas versões da função, você não pode usar as duas dentro do mesmo indicador.

Cálculo baseado numa matriz de dados

int  OnCalculate(
   const int        rates_total,       // tamanho da matriz price[]
   const int        prev_calculated,   // número de barras processadas na chamada anterior
   const int        begin,             // número do índice na matriz price[] a partir do qual começam os dados significativos
   const double&    price[]            // matriz de valores para cálculo
   );

Cálculos baseados nas séries temporais do timeframe atual

int  OnCalculate(
   const int        rates_total,       // tamanho das séries temporais de entrada
   const int        prev_calculated,   // número de barras processadas na chamada anterior
   const datetime&  time{},            // matriz Time
   const double&    open[],            // matriz Open
   const double&    high[],            // matriz High
   const double&    low[],             // matriz Low
   const double&    close[],           // matriz Close
   const long&      tick_volume[],     // matriz Tick Volume
   const long&      volume[],          // matriz Real Volume
   const int&       spread[]           // matriz Spread
   );

Parâmetros

rates_total

[in]  Tamanho da matriz price[] ou das séries temporais de entrada disponíveis para o indicador para cálculo. Na segunda versão da função, o valor do parâmetro corresponde ao número de barras no gráfico em que está sendo executado.

prev_calculated

[in]  Contém o valor retornado pela função OnCalculate() na chamada anterior. Ele é usado para ignorar nos cálculos as barras que não mudaram desde a última inicialização desta função.

begin

[in]  valor do índice na matriz price[] a partir do qual começam os dados significativos. Permite ignorar nos cálculos os dados ausentes ou iniciais, para os quais não há valores corretos.

price[]

[in]  Matriz de valores para executar cálculos. Como matriz price[] pode ser transferida uma das séries temporais de preços ou o buffer calculado de qualquer indicador. O tipo de dados que foi transferido para o cálculo pode ser determinado usando a variável predefinida _AppliedTo.

time{}

[in]  Matriz com os valores de tempo da abertura das barras.

open[]

[in]  Matriz com os valores dos preços de abertura.

high[]

[in]  Matriz com os valores dos preços máximos.

low[]

[in]  Matriz com os valores dos preços mínimos.

close[]

[in]  Matriz com os valores dos preços de fechamento.

tick_volume[]

[in]  Matriz com valores dos volumes de ticks.

volume[]

[in]  Matriz com valores dos volumes de negociação.

spread[]

[in]  Matriz com os valores de spread para barras.

Valor retornado

Valor de tipo int que será transferido como parâmetro prev_calculated, da próxima vez que a função for chamada.

Observação

Se a função OnCalculate() retornar um valor zero, a janela DataWindow do terminal do cliente não exibirá os valores do indicador.

Se os dados de preço foram alterados desde a última chamada da função OnCalculate() (um histórico mais profundo foi carregado ou o histórico estava ausente), o valor do parâmetro de entrada prev_calculated será definido como zero pelo próprio terminal.

Para determinar a direção da indexação nas matrizes time[], open[], high[], low[], close[], tick_volume[], volume[] e spread[], é necessário chamar a função ArrayGetAsSeries(). Para não depender dos padrões, é absolutamente necessário chamar a função ArraySetAsSeries() para aquelas matrizes com as quais se deve trabalhar.

Ao usar a primeira versão da função, a séries temporais ou o indicador necessário como uma matriz price[] é selecionado pelo usuário na guia Parameters quando o indicador é iniciado. Para fazer isso, você deve especificar o elemento desejado na lista suspensa do campo "Apply to".

Para obter os valores do indicador personalizado a partir de outros programas MQL5, é usada a função iCustom() que retorna o identificador do indicador para as operações subsequentes. Neste caso, você pode especificar a matriz necessária price[] ou o identificador da outro indicador. Este parâmetro deve ser o último a ser passado na lista de variáveis de entrada do indicador personalizado.

É necessário usar o relacionamento entre o valor retornado pela função OnCalculate() e o segundo parâmetro de entrada prev_calculated. O parâmetro prev_calculated, ao chamar a função, contém o valor retornado pela função OnCalculate() na chamada anterior. Isso possibilita a implementação de algoritmos econômicos para o cálculo do indicador personalizado, a fim de evitar cálculos repetitivos para as barras que não foram alteradas desde a última inicialização desta função.

 

Exemplo de indicador

//+------------------------------------------------------------------+
//|                                           OnCalculate_Sample.mq5 |
//|                        Copyright 2018, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property description "Exemplo de cálculo do indicador Momentum"
 
//---- indicator settings
#property indicator_separate_window
#property indicator_buffers 1
#property indicator_plots   1
#property indicator_type1   DRAW_LINE
#property indicator_color1  Blue
//---- parâmetros de entrada
input int MomentumPeriod=14; // Período para cálculo
//---- buffer de indicador
double    MomentumBuffer[];
//--- variável global para armazenar o período de cálculos
int       IntPeriod;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
void OnInit()
  {
//--- verificamos o parâmetro de entrada
   if(MomentumPeriod<0)
     {
      IntPeriod=14;
      Print("parâmetro Período possui um valor inválido. Para cálculos, será usado o valor ",IntPeriod);
     }
   else
      IntPeriod=MomentumPeriod;
//---- buffers  
   SetIndexBuffer(0,MomentumBuffer,INDICATOR_DATA);
//---- o nome do indicador a ser exibido na DataWindow e na subjanela
   IndicatorSetString(INDICATOR_SHORTNAME,"Momentum"+"("+string(IntPeriod)+")");
//--- definimos o número da barra a partir da qual começa a plotagem
   PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,IntPeriod-1);
//--- definimos 0.0 como um valor vazio que não é plotado
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
//--- precisão para mostrar os valores do indicador
   IndicatorSetInteger(INDICATOR_DIGITS,2);
  }
//+------------------------------------------------------------------+
//|  Cálculo do indicador Momentum                                   |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,     // tamanho da matriz price[] 
                const int prev_calculated, // número de barras processadas anteriormente
                const int begin,           // começo dos valores significativos
                const double &price[])     // matriz para o valor a ser processado
  {
//--- posição inicial para cálculos
   int StartCalcPosition=(IntPeriod-1)+begin;
//---- se não houver suficientes dados para cálculo
   if(rates_total<StartCalcPosition)
      return(0);  // saímos com valor nulo - indicador não é calculado
//--- correct draw begin
   if(begin>0)
      PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,StartCalcPosition+(IntPeriod-1));
//--- começamos os cálculos, calculamos a posição do início
   int pos=prev_calculated-1;
   if(pos<StartCalcPosition)
      pos=begin+IntPeriod;
//--- ciclo principal de cálculos
   for(int i=pos;i<rates_total && !IsStopped();i++)
      MomentumBuffer[i]=price[i]*100/price[i-IntPeriod];
//--- execução da OnCalculate concluída. Retornamos o novo valor de prev_calculated para a chamada subsequente
   return(rates_total);
  }

Veja também

ArrayGetAsSeries, ArraySetAsSeries, iCustom, Funções de processamento de eventos, Execução de programas, Eventos do terminal do cliente, Acesso a séries temporais e indicadores