ArraySort

Classifica os valores na primeira dimensão de um array numérico multidimensional na ordem crescente.

bool  ArraySort(
   void&  array[]      // array para ordenação
   );

Parâmetros

array[]

[in][out]  Array numérico para ordenação.

Valor do Retorno

A função retorna true para sucesso, caso contrário - false.

Observação

Um array é sempre classificado em ordem crescente, independentemente do valor da flag AS_SERIES.

Funções ArraySort e ArrayBSearch aceitam arrays de qualquer dimensão como um parâmetro. No entanto, a pesquisa e a classificação são sempre aplicadas à primeira dimensão (zero).

Exemplo:

#property description "O indicador analisa os dados para o último mês e pinta todos os candlesticks com pequenos"
#property description "e grandes volumes de tick. A volume de tick do array é ordenado"
#property description "para definir estes candlesticks. Os candlesticks que tem os volumes compreendendo o primeiro InpSmallVolume"
#property description "por cento do array, são consideradas pequenos. Os candlesticks que tem os volumes compreendendo o último InpBigVolume "
#property description "por cento do array, são consideradas grandes."
//--- configurações do indicador
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   1
//--- plotar
#property indicator_label1  "VolumeFactor"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrDodgerBlue,clrOrange
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2
//--- constante pré-definida
#define INDICATOR_EMPTY_VALUE 0.0
//--- parâmetros de entrada
input int InpSmallVolume=15; // Valor percentual de pequenos volumes (<50)
input int InpBigVolume=20;   // Valor percentual de grandes volumes (<50)
//--- início do tempo para análise (será deslocado)
datetime ExtStartTime;
//--- buffers do indicador
double   ExtOpenBuff[];
double   ExtHighBuff[];
double   ExtLowBuff[];
double   ExtCloseBuff[];
double   ExtColorBuff[];
//--- valores de limite do volume para exibir os candlesticks
long     ExtLeftBorder=0;
long     ExtRightBorder=0;
//+------------------------------------------------------------------+
//| Receber valores das bordas para volumes de tick                  |
//+------------------------------------------------------------------+
bool GetVolumeBorders(void)
  {
//--- variáveis
   datetime stop_time;  // copiar tempo final
   long     buff[];     // buffer para copiar
//--- tempo final é o atual
   stop_time=TimeCurrent();
//--- tempo de início é de um mês antes do atual
   ExtStartTime=GetStartTime(stop_time);
//--- receber os valores de volume do tick
   ResetLastError();
   if(CopyTickVolume(Symbol(),Period(),ExtStartTime,stop_time,buff)==-1)
     {
      //--- falhou para receber os dados, retornar falso para lançar o comando de recálculo
      PrintFormat("Falha ao receber os valores de volume do tick. Código de erro = %d",GetLastError());
      return(false);
     }
//--- calcule tamanho de array
   int size=ArraySize(buff);
//--- classificar o array
   ArraySort(buff);
//--- definir os valores das bordas esquerda e direita para volumes do tick
   ExtLeftBorder=buff[size*InpSmallVolume/100];
   ExtRightBorder=buff[(size-1)*(100-InpBigVolume)/100];
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| Receber os dados do mês menor do que o mês anterior              |
//+------------------------------------------------------------------+
datetime GetStartTime(const datetime stop_time)
  {
//--- converter o tempo final da variável de estrutura do tipo MqlDateTime
   MqlDateTime temp;
   TimeToStruct(stop_time,temp);
//--- receber os dados que é do mês menor
   if(temp.mon>1)
      temp.mon-=1;  // o mês corrente não é o primeiro no ano, por conseguinte, o número do anterior é menor
   else
     {
      temp.mon=12;  // o mês corrente é o primeiro no ano, por conseguinte, o número do anterior é 12,
      temp.year-=1; // enquanto o número do ano é um a menos
     }
//--- número do dia não será superior a 28
   if(temp.day>28)
      temp.day=28;
//--- retornar a data obtida
   return(StructToTime(temp));
  }
//+------------------------------------------------------------------+
//| Função de inicialização do indicador customizado                 |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- verificar se os parâmetros de entrada satisfazem as condições
   if(InpSmallVolume<0 || InpSmallVolume>=50 || InpBigVolume<0 || InpBigVolume>=50)
     {
      Print("Parâmetros de entrada incorreto");
      return(INIT_PARAMETERS_INCORRECT);
     }
//--- mapeamento de buffers do indicador
   SetIndexBuffer(0,ExtOpenBuff);
   SetIndexBuffer(1,ExtHighBuff);
   SetIndexBuffer(2,ExtLowBuff);
   SetIndexBuffer(3,ExtCloseBuff);
   SetIndexBuffer(4,ExtColorBuff,INDICATOR_COLOR_INDEX);
//--- definir o valor que não será exibido
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,INDICATOR_EMPTY_VALUE);
//--- definir etiquetas para buffers do indicador
   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[])
  {
//--- verificar se barras não manipuladas ainda estão presentes
   if(prev_calculated<rates_total)
     {
      //--- receber novos valores das bordas direita e esquerda para volumes
      if(!GetVolumeBorders())
         return(0);
     }
//--- iniciar variável para cálculo da barra
   int start=prev_calculated;
//--- trabalho na última barra se os valores do indicador já foram calculados no tick anterior
   if(start>0)
      start--;
//--- definir indexação direta em séries temporais
   ArraySetAsSeries(time,false);
   ArraySetAsSeries(open,false);
   ArraySetAsSeries(high,false);
   ArraySetAsSeries(low,false);
   ArraySetAsSeries(close,false);
   ArraySetAsSeries(tick_volume,false);
//--- o loop de cálculo dos valores do indicador
   for(int i=start;i<rates_total;i++)
     {
      //--- preencher os candlesticks a partir da data inicial
      if(ExtStartTime<=time[i])
        {
         //--- se o valor não é inferior a borda direita, preencher clandlestick
         if(tick_volume[i]>=ExtRightBorder)
           {
            //--- receber dados para desenhar o candlestick
            ExtOpenBuff[i]=open[i];
            ExtHighBuff[i]=high[i];
            ExtLowBuff[i]=low[i];
            ExtCloseBuff[i]=close[i];
            //--- cor de DodgerBlue
            ExtColorBuff[i]=0;
            //--- continuar o loop
            continue;
           }
         //--- preencher o candlestick, se o valor não exceder o limite esquerdo
         if(tick_volume[i]<=ExtLeftBorder)
           {
            //--- receber dados para desenhar o candlestick
            ExtOpenBuff[i]=open[i];
            ExtHighBuff[i]=high[i];
            ExtLowBuff[i]=low[i];
            ExtCloseBuff[i]=close[i];
            //--- Cor laranja
            ExtColorBuff[i]=1;
            //--- continuar o loop
            continue;
           }
        }
      //--- definir valores vazios para as barras que não foram incluídas no cálculo
      ExtOpenBuff[i]=INDICATOR_EMPTY_VALUE;
      ExtHighBuff[i]=INDICATOR_EMPTY_VALUE;
      ExtLowBuff[i]=INDICATOR_EMPTY_VALUE;
      ExtCloseBuff[i]=INDICATOR_EMPTY_VALUE;
     }
//--- valor retorno de prev_calculated para a próxima chamada
   return(rates_total);
  }

Também Veja

ArrayBsearch