Referência MQL5Séries Temporais e Acesso a Indicadores 

Acesso a séries de tempo e indicadores

Estas são funções para trabalhar com séries de tempo e indicadores. Uma série de tempo difere de um array de dados usual pela sua ordenação reversa - elementos de séries de tempo são indexados do final de um array para seu início (a partir do mais recente para o mais antigo). Para copiar valores de séries de tempo e dados de indicadores, é recomendável usar somente arrays dinâmicos, porque as funções de cópia estão projetadas para alocar o tamanho necessário dos arrays que recebem valores.

Existe uma importante exceção a esta regra: se valores de séries de tempo e indicadores precisam ser copiados com freqüência, por exemplo, a cada chamada de OnTick() em Expert Advisors ou a cada chamada de OnCalculate() em indicadores, neste caso seria melhor usar arrays alocados estaticamente, porque operações de alocação de memória para arrays dinâmicos requerem um tempo adicional, e isso terá efeitos durante os processos de teste e otimização.

Ao usar funções de acesso a valores de séries de tempo e indicadores, a direção de indexação deve ser leva em consideração. Isso é descrito na seção Direção de indexação em arrays e séries de tempo.

O acesso a dados de indicadores e séries de tempo é implementado independentemente do fato dos dados solicitados estarem prontos ou não (o chamado acesso assíncrono). Isso é extremamente importante para os cálculos de um indicador customizado, porque se não houver dados, as funções de tipo Copy...() retornam imediatamente um erro. Contudo, ao acessar dados a partir de Expert Advisors e scripts, as várias tentativas para receber dados são feitos com uma pausa pequena, cujo objetivo é fornecer algum tempo necessário para baixar a série de tempo requerida para calcular valores de um indicador.

A seção Organizando Acesso a Dados descreve detalhes de recebimento, armazenamento e solicitação de dados de preço no terminal cliente MetaTrader 5.

Direção de indexação em uma série de tempo e em um array comum

É historicamente aceito que um acesso a dados de preço em um array é realizado a partir do final dos dados. Fisicamente, os novos dados são sempre escritos no final do array, mas o índice do array é sempre igual a zero. O índice 0 no array de série de tempo denota dados da barra corrente, isto é, a barra que correspondente ao intervalo de tempo não terminado nesta janela de tempo.

Uma janela de tempo é o período de tempo, durante o qual uma única barra de preço é formada. Existem 21 janelas de tempo padrão predefinidas.

Função

Ação

SeriesInfoInteger

Retorna informação sobre o estado dos dados históricos

Bars

Retorna o número de barras do histórico para um ativo e período especificados

BarsCalculated

Retorna o número de dados calculados em um buffer de indicador ou -1 em caso de erro (os dados não foram calculados ainda)

IndicatorCreate

Retorna o handle para o indicador técnico especificado criado por um array de parâmetros de tipo MqlParam

IndicatorParameters

Baseado no handle especificado, retorna o número de parâmetros de entrada do indicador, bem como os valores e tipos dos parâmetros

IndicatorRelease

Remove um handle de indicador e libera o bloco de cálculo do indicador, se ele não for usado por ninguém mais

CopyBuffer

Copia dados de um buffer especificado de um indicador especificado em um array

CopyRates

Obtém dados históricos da estrutura Rates para um ativo e período especificados em um array

CopyTime

Obtém dados históricos sobre hora de abertura de barras para um ativo e período especificados em um array

CopyOpen

Obtém dados históricos sobre preço de abertura de barras para um ativo e período especificados em um array

CopyHigh

Obtém histórico de dados sobre preço de barra máximo para um ativo e período especificados em um array

CopyLow

Obtém histórico de dados sobre preço de barra minimo para um ativo e período especificados em um array

CopyClose

Obtém histórico de dados sobre preço de fechamento de barra para um ativo e período especificados em um array

CopyTickVolume

Obtém histórico de dados sobre volumes de tick para um ativo e período especificados em um array

CopyRealVolume

Obtém dados históricos sobre volumes de negociação para um ativo e período especificados em um array

CopySpread

Obtém histórico de dados sobre spreads para um ativo e período especificados em um array

CopyTicks

Obtém, dentro da matriz ticks_array, ticks no formato MqlTick

CopyTicksRange

Obtém, na matriz ticks_array, ticks em formato MqlTick

iBars

Retorna o número de barras - no histórico - do símbolo e do período correspondentes

iBarShift

Retorna o índice da barra na qual o tempo especificado coincide

iClose

Retorna o valor do preço de fechamento da barra (indicado pelo parâmetro shift) do gráfico correspondente

iHigh

Retorna o valor do preço máximo da barra (especificado pelo parâmetro shift) do gráfico correspondente

iHighest

Retorna o índice do maior valor encontrado (deslocamento relativo à barra atual) do gráfico correspondente

iLow

Retorna o valor do preço mínimo da barra (indicado pelo parâmetro shift) do gráfico correspondente

iLowest

Retorna o índice do menor valor encontrado (deslocamento relativo à barra atual) do gráfico correspondente

iOpen

Retorna o valor do preço de abertura da barra (indicado pelo parâmetro shift) do gráfico correspondente

iTime

Retorna o valor do tempo de abertura da barra (indicado pelo parâmetro shift) do gráfico correspondente

iTickVolume

Retorna o valor do volume de tick (especificado pelo parâmetro shift) do gráfico correspondente

iRealVolume

Retorna o valor do volume real da barra (indicado pelo parâmetro shift) do gráfico correspondente

iVolume

Retorna o valor do volume de tick (especificado pelo parâmetro shift) do gráfico correspondente

iSpread

Retorna o valor do spread da barra (indicado pelo parâmetro shift) do gráfico correspondente

Apesar do fato de que pelo uso da função ArraySetAsSeries() é possível definir em arrays acesso aos elementos como em séries de tempo, deve ser lembrado que os elementos de arrays são fisicamente armazenados na mesma e única ordem - somente a direção de indexação muda. Para demonstrar este fato, vamos apresentar um exemplo:

   datetime TimeAsSeries[];
//--- define acesso ao array como uma série de tempo
   ArraySetAsSeries(TimeAsSeries,true);
   ResetLastError();
   int copied=CopyTime(NULL,0,0,10,TimeAsSeries);
   if(copied<=0)
     {
      Print("A operação de cópia dos valores do tempo de abertura para as últimas 10 barras falhou");
      return;
     }
   Print("TimeCurrent =",TimeCurrent());
   Print("ArraySize(Time) =",ArraySize(TimeAsSeries));
   int size=ArraySize(TimeAsSeries);
   for(int i=0;i<size;i++)
     {
      Print("TimeAsSeries["+i+"] =",TimeAsSeries[i]);
     }
 
   datetime ArrayNotSeries[];
   ArraySetAsSeries(ArrayNotSeries,false);
   ResetLastError();
   copied=CopyTime(NULL,0,0,10,ArrayNotSeries);
   if(copied<=0)
     {
      Print("A operação de cópia dos valores do tempo de abertura para as últimas 10 barras falhou");
      return;
     }   
   size=ArraySize(ArrayNotSeries);
   for(int i=size-1;i>=0;i--)
     {
      Print("ArrayNotSeries["+i+"] =",ArrayNotSeries[i]);
     }

Como resultado nós conseguimos a seguinte saída:

TimeCurrent = 2009.06.11 14:16:23
ArraySize(Time) = 10
TimeAsSeries[0] = 2009.06.11 14:00:00
TimeAsSeries[1] = 2009.06.11 13:00:00
TimeAsSeries[2] = 2009.06.11 12:00:00
TimeAsSeries[3] = 2009.06.11 11:00:00
TimeAsSeries[4] = 2009.06.11 10:00:00
TimeAsSeries[5] = 2009.06.11 09:00:00
TimeAsSeries[6] = 2009.06.11 08:00:00
TimeAsSeries[7] = 2009.06.11 07:00:00
TimeAsSeries[8] = 2009.06.11 06:00:00
TimeAsSeries[9] = 2009.06.11 05:00:00
 
ArrayNotSeries[9] = 2009.06.11 14:00:00
ArrayNotSeries[8] = 2009.06.11 13:00:00
ArrayNotSeries[7] = 2009.06.11 12:00:00
ArrayNotSeries[6] = 2009.06.11 11:00:00
ArrayNotSeries[5] = 2009.06.11 10:00:00
ArrayNotSeries[4] = 2009.06.11 09:00:00
ArrayNotSeries[3] = 2009.06.11 08:00:00
ArrayNotSeries[2] = 2009.06.11 07:00:00
ArrayNotSeries[1] = 2009.06.11 06:00:00
ArrayNotSeries[0] = 2009.06.11 05:00:00

Como vemos a partir da saída, a medida que o índice do array TimeAsSeries aumenta, o valor da hora do índice diminui, isto é, nós nos movemos do presente para o passado. Para o array comum ArrayNotSeries o resultado é diferente - a medida que o índice cresce, nós nos movemos do passado para o presente.

Veja também

ArrayIsDynamic, ArrayGetAsSeries, ArraySetAsSeries, ArrayIsSeries