ArrayCopy

Copia um array em um outro array.

int  ArrayCopy(
   void&        dst_array[],         // array de destino
   const void&  src_array[],         // array de origem
   int          dst_start=0,         // índice de início do array destino a partir do qual se escreve
   int          src_start=0,         // primeiro índice de um array de origem
   int          count=WHOLE_ARRAY    // número de elementos
   );

Parâmetros

dst_array[]

[out]  Array destino

src_array[]

[in]  Array fonte

dst_start=0

[in]  Índice de início do array destino. Por padrão, o índice de início é 0.

src_start=0

[in]  Índice de início para o array fonte. Por padrão, o índice de início é 0.

count=WHOLE_ARRAY

[in]  Número de elementos que devem ser copiados. Por padrão, todo conjunto array é copiado (count=WHOLE_ARRAY).

Valor do Retorno

Retorna o número de elementos copiados.

Observação

Se count<0 ou count>src_size-src_start, toda a parte restante do array é copiada. Arrays são copiados da esquerda para direita. Para arrays de série, a posição de início é corretamente ajustada para copiar da esquerda para direita.

Se os arrays são de tipos diferentes, durante a cópia a função tenta transformar cada elemento do array fonte para o tipo do array destino. Um array de string pode ser copiado somente em um array de string. Arrays de classes e estruturas contendo objetos que requerem inicialização não são copiados. Um array de estruturas pode ser copiado somente em um array do mesmo tipo.

For dynamic arrays with indexing as in timeseries, the size of a destination array is automatically increased to the amount of copied data (if the latter exceeds the array size). The destination array size is not decreased automatically.

Exemplo:

#property description "O indicador destaca os candlesticks que são local"
#property description "altos e baixos. Comprimento do intervalo para encontrar"
#property description "valores extremos usando parâmetros de entrada."
//--- configurações do indicador
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   1
//---- plotar
#property indicator_label1  "Extremums"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrLightSteelBlue,clrRed,clrBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- constante pré-definida
#define INDICATOR_EMPTY_VALUE 0.0
//--- parâmetros de entrada
input int InpNum=4; // Meio intervalo de comprimento
//--- buffers do indicador
double ExtOpen[];
double ExtHigh[];
double ExtLow[];
double ExtClose[];
double ExtColor[];
//--- variáveis globais
int    ExtStart=0; // índice do primeiro candlestick que não é um extremo
int    ExtCount=0; // número de não extremos no intervalo
//+------------------------------------------------------------------+
//| Preenchimento dos candlesticks não extremos                      |
//+------------------------------------------------------------------+
void FillCandles(const double &open[],const double &high[],
                 const double &low[],const double &close[])
  {
//--- preencher os candlesticks
   ArrayCopy(ExtOpen,open,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtHigh,high,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtLow,low,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtClose,close,ExtStart,ExtStart,ExtCount);
  }
//+------------------------------------------------------------------+
//| Função de inicialização do indicador customizado                 |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- mapeamento de buffers do indicador
   SetIndexBuffer(0,ExtOpen);
   SetIndexBuffer(1,ExtHigh);
   SetIndexBuffer(2,ExtLow);
   SetIndexBuffer(3,ExtClose);
   SetIndexBuffer(4,ExtColor,INDICATOR_COLOR_INDEX);
//--- especificar o valor que não é apresentado
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,INDICATOR_EMPTY_VALUE);
//--- especificar os nomes dos buffers do indicador para exibir na janela de dados
   PlotIndexSetString(0,PLOT_LABEL,"Open;High;Low;Close");
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Função de iteração do indicador customizado                      |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- definir a indexação direta em séries de tempo
   ArraySetAsSeries(open,false);
   ArraySetAsSeries(high,false);
   ArraySetAsSeries(low,false);
   ArraySetAsSeries(close,false);
//--- variável da barra para iniciar cálculo
   int start=prev_calculated;
//--- cálculo não é realizado pela primeira InpNum*2 barras
   if(start==0)
     {
      start+=InpNum*2;
      ExtStart=0;
      ExtCount=0;
     }
//--- se a barra acabou de se formar, verifique o seguinte extremo potencial
   if(rates_total-start==1)
      start--;
//--- índice da barra a ser verificado para o extremo
   int ext;
//--- valor do indicador para cálculo do loop
   for(int i=start;i<rates_total-1;i++)
     {
      //--- inicialmente num bar sem desenhar
      ExtOpen[i]=0;
      ExtHigh[i]=0;
      ExtLow[i]=0;
      ExtClose[i]=0;
      //--- índice extremo para verificação
      ext=i-InpNum;
      //--- verificar o máximo local
      if(IsMax(high,ext))
        {
         //--- destacar um candlestick extremo
         ExtOpen[ext]=open[ext];
         ExtHigh[ext]=high[ext];
         ExtLow[ext]=low[ext];
         ExtClose[ext]=close[ext];
         ExtColor[ext]=1;
         //--- destacar outros candles até o extremo com uma cor neutra
         FillCandles(open,high,low,close);
         //--- alterar as cores variáveis
         ExtStart=ext+1;
         ExtCount=0;
         //--- passar para a próxima iteração
         continue;
        }
      //--- verifique o mínimo local
      if(IsMin(low,ext))
        {
         //--- destacar um candlestick extremo
         ExtOpen[ext]=open[ext];
         ExtHigh[ext]=high[ext];
         ExtLow[ext]=low[ext];
         ExtClose[ext]=close[ext];
         ExtColor[ext]=2;
         //--- destacar outros candles até o extremo com uma cor neutra
         FillCandles(open,high,low,close);
         //--- alterar os valores das variáveis
         ExtStart=ext+1;
         ExtCount=0;
         //--- passar para a próxima iteração
         continue;
        }
      //--- aumentar o número de não extremos no intervalo
      ExtCount++;
     }
//--- valor retorno de prev_calculated para a próxima chamada
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Verificar se o atual elemento array é um local máximo (high)     |
//+------------------------------------------------------------------+
bool IsMax(const double &price[],const int ind)
  {
//--- variável do início do intervalo
   int i=ind-InpNum;
//--- final do período do intervalo
   int finish=ind+InpNum+1;
//--- verificar a primeiro metade do intervalo
   for(;i<ind;i++)
     {
      if(price[ind]<=price[i])
         return(false);
     }
//--- verificar a segunda metade do intervalo
   for(i=ind+1;i<finish;i++)
     {
      if(price[ind]<=price[i])
         return(false);
     }
//--- este é um extremo
   return(true);
  }
//+------------------------------------------------------------------+
//| Verificar se o atual elemento array é um local mínimo (low)     |
//+------------------------------------------------------------------+
bool IsMin(const double &price[],const int ind)
  {
//--- variável do início do intervalo
   int i=ind-InpNum;
//--- variável do final do intervalo
   int finish=ind+InpNum+1;
//--- verificar a primeiro metade do intervalo
   for(;i<ind;i++)
     {
      if(price[ind]>=price[i])
         return(false);
     }
//--- verificar a segunda metade do intervalo
   for(i=ind+1;i<finish;i++)
     {
      if(price[ind]>=price[i])
         return(false);
     }
//--- este é um extremo
   return(true);
  }