• Introdução
• Criação e exclusão de símbolos personalizados
• Geração de ticks e barras
• Modelando a tendência
• Modelagem de padrões gráficos
• Fim do artigo

O artigo mostra como criar símbolos personalizados na janela "Símbolos" do MetaTrader 5, com base nos símbolos já existentes. 

Sugerimos automatizar esse processo usando um script simples com configurações mínimas.

O script tem 4 parâmetros de entrada:

• nome do símbolo personalizado
• nome abreviado do par de moedas ou do instrumento financeiro
• nome completo do par de moedas ou do instrumento financeiro
• nome abreviado da moeda base ou do instrumento financeiro, se o símbolo for criado com base no símbolo base.
  

//+------------------------------------------------------------------+
//|                                                 CreateSymbol.mq5 |
//|                                                  Aleksey Zinovik |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Aleksey Zinovik"
#property script_show_inputs 
#property version   "1.00"
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
input string SName="ExampleCurrency";
input string CurrencyName="UCR";
input string CurrencyFullName="UserCurrency";
input string BaseName="EURUSD";
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   ResetLastError();
//crie o símbolo
   if(!CustomSymbolCreate(SName,"\\Forex"))
     {
      if(SymbolInfoInteger(SName,SYMBOL_CUSTOM))
         Print("O símbolo ",SName," já existe!");
      else
         Print("Erro ao criar símbolo. Código de erro: ",GetLastError());
     }
   else
     {
      if(BaseName=="")//crie um novo
        {
         //propriedade do tipo String
         if((SetProperty(SName,SYMBOL_CURRENCY_BASE,CurrencyName,"")) && //unidade monetária base
            (SetProperty(SName,SYMBOL_CURRENCY_PROFIT,"USD",""))&&                         //moeda de lucro
            (SetProperty(SName,SYMBOL_CURRENCY_MARGIN,"USD",""))&&                         //moeda de margem
            (SetProperty(SName,SYMBOL_DESCRIPTION,CurrencyName,""))&&                      //descrição do caractere de string (nome completo)
            (SetProperty(SName,SYMBOL_BASIS,"","")) &&                                     //nome do ativo subjacente para o instrumento derivado
            (SetProperty(SName,SYMBOL_FORMULA,"","")) &&                                   //fórmula para construir o preço de um símbolo personalizado
            (SetProperty(SName,SYMBOL_ISIN,"","")) &&                                      //nome do símbolo de negociação no sistema ISIN
            (SetProperty(SName,SYMBOL_PAGE,"","")) &&                                      //endereço da página da web com informações sobre o símbolo
            //propriedades do tipo Integer
            (SetProperty(SName,SYMBOL_CHART_MODE,SYMBOL_CHART_MODE_BID,"")) &&             //plotagem do grafico segundo o preço Bid
            (SetProperty(SName,SYMBOL_SPREAD,3,"")) &&                                     //spread
            (SetProperty(SName,SYMBOL_SPREAD_FLOAT,true,"")) &&                            //spread flutuante
            (SetProperty(SName,SYMBOL_DIGITS,5,"")) &&                                     //precisão (número de casas decimais)
            (SetProperty(SName,SYMBOL_TICKS_BOOKDEPTH,10,"")) &&                           //tamanho do livro de ofertas
            (SetProperty(SName,SYMBOL_BACKGROUND_COLOR,White,""))&&                        //cor de fundo em que é destacado o símbolo na Observação do mercado
            (SetProperty(SName,SYMBOL_TRADE_MODE,SYMBOL_TRADE_MODE_FULL,""))&&             //tipo de execução de ordens: acesso completo
            (SetProperty(SName,SYMBOL_TRADE_EXEMODE,SYMBOL_TRADE_EXECUTION_INSTANT,""))&&  //modo de transações: execução imediata
            (SetProperty(SName,SYMBOL_ORDER_GTC_MODE,SYMBOL_ORDERS_GTC,""))&&              //validade das ordens StopLoss e TakeProfit: validas até serem canceladas
            (SetProperty(SName,SYMBOL_FILLING_MODE,SYMBOL_FILLING_FOK,""))&&               //modo de execução da ordem: tudo ou nada
            (SetProperty(SName,SYMBOL_EXPIRATION_MODE,SYMBOL_EXPIRATION_GTC,""))&&         //modo de expiração da ordem: ilimitado no tempo, até o cancelamento explícito
            (SetProperty(SName,SYMBOL_ORDER_MODE,127,"")) &&                               //tipos de ordens: todos os tipos de ordens
            (SetProperty(SName,SYMBOL_TRADE_CALC_MODE,SYMBOL_CALC_MODE_FOREX,""))&&        //método de cálculo do valor do contrato
            (SetProperty(SName,SYMBOL_MARGIN_HEDGED_USE_LEG,false,""))&&                   //modo de cálculo da margem coberta pelo maior lado
            (SetProperty(SName,SYMBOL_SWAP_MODE,SYMBOL_SWAP_MODE_POINTS,""))&&             //modelo de cálculo de swap: cálculo de swap em pontos
            (SetProperty(SName,SYMBOL_SWAP_ROLLOVER3DAYS,WEDNESDAY,"")) &&                 //dia da semana para o swap triplo
            (SetProperty(SName,SYMBOL_OPTION_MODE,0,"")) &&                                //tipo de opção
            (SetProperty(SName,SYMBOL_OPTION_RIGHT,0,"")) &&                               //direito de opção
            (SetProperty(SName,SYMBOL_TRADE_STOPS_LEVEL,0,"")) &&                          //recuo mínimo em pontos a partir do preço atual de fechamento para posicionamento de ordens Stop
            (SetProperty(SName,SYMBOL_TRADE_FREEZE_LEVEL,0,"")) &&                         //distância de congelamento de operações de negociação (em pontos)
            (SetProperty(SName,SYMBOL_START_TIME,0,"")) &&                                 //data de início da negociação do instrumento (geralmente usado para futuros)
            (SetProperty(SName,SYMBOL_EXPIRATION_TIME,0,"")) &&                            //data do final da negociação do instrumento (geralmente usado para futuros)
            //propriedades do tipo Double
            (SetProperty(SName,SYMBOL_OPTION_STRIKE,0,"")) &&                              //preço de exercício da opção
            (SetProperty(SName,SYMBOL_SESSION_PRICE_LIMIT_MAX,0,"")) &&                    //preço mínimo permitido para a sessão 
            (SetProperty(SName,SYMBOL_SESSION_PRICE_LIMIT_MIN,0,"")) &&                    //preço máximo permitido para a sessão
            (SetProperty(SName,SYMBOL_SESSION_PRICE_SETTLEMENT,0,"")) &&                   //preço de entrega para a sessão atual
            (SetProperty(SName,SYMBOL_TRADE_ACCRUED_INTEREST,0,"")) &&                     //juros acumulados (para títulos)
            (SetProperty(SName,SYMBOL_TRADE_FACE_VALUE,0,"")) &&                           //valor nominal (para títulos)
            (SetProperty(SName,SYMBOL_TRADE_LIQUIDITY_RATE,0,"")) &&                       //índice de liquidez (usado para instrumentos colaterais)
            (SetProperty(SName,SYMBOL_TRADE_TICK_SIZE,0.00001,"")) &&                      //mudança mínima do preço 
            (SetProperty(SName,SYMBOL_TRADE_TICK_VALUE,1,"")) &&                           //valor do tick
            (SetProperty(SName,SYMBOL_TRADE_CONTRACT_SIZE,100000,"")) &&                   //tamanho do contrato
            (SetProperty(SName,SYMBOL_POINT,0.00001,"")) &&                                //valor de um ponto
            (SetProperty(SName,SYMBOL_VOLUME_MIN,0.01,"")) &&                              //volume mínimo para realização da transação
            (SetProperty(SName,SYMBOL_VOLUME_MAX,500.00,"")) &&                            //volume máximo para realizar a transação
            (SetProperty(SName,SYMBOL_VOLUME_STEP,0.01,"")) &&                             //incremento mínimo de alteração do volume para realizar a transação
            (SetProperty(SName,SYMBOL_VOLUME_LIMIT,0,"")) &&                               //volume total máximo da posição aberta e das ordens pendentes segundo um único símbolo numa só direção (compra ou venda).
            (SetProperty(SName,SYMBOL_MARGIN_INITIAL,0,"")) &&                             //margem inicial
            (SetProperty(SName,SYMBOL_MARGIN_MAINTENANCE,0,"")) &&                         //margem de manutenção
            (SetProperty(SName,SYMBOL_MARGIN_HEDGED,100000,"")) &&                         //tamanho do contrato ou da margem para um lote de posições multidirecionais segundo um único símbolo 
            (SetProperty(SName,SYMBOL_SWAP_LONG,-0.7,"")) &&                               //valor do swap na compra
            (SetProperty(SName,SYMBOL_SWAP_SHORT,-1,"")))                                  //valor do swap na venda
            Print("Símbolo ",SName," criado com sucesso");
         else
            Print("Erro ao definir as propriedades do símbolo. Código de erro: ",GetLastError());
        }
      else//criamos com base no ativo base
        {
         if((SetProperty(SName,SYMBOL_CURRENCY_BASE,CurrencyName,"")) && 
            (SetProperty(SName,SYMBOL_CURRENCY_PROFIT,"",BaseName)) && 
            (SetProperty(SName,SYMBOL_CURRENCY_MARGIN,"",BaseName)) && 
            (SetProperty(SName,SYMBOL_DESCRIPTION,CurrencyFullName,"")) && 
            (SetProperty(SName,SYMBOL_BASIS,"",BaseName)) && 
            (SetProperty(SName,SYMBOL_FORMULA,"",BaseName)) && 
            (SetProperty(SName,SYMBOL_ISIN,"",BaseName)) && 
            (SetProperty(SName,SYMBOL_PAGE,"",BaseName)) && 

            (SetProperty(SName,SYMBOL_CHART_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SPREAD,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SPREAD_FLOAT,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_DIGITS,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TICKS_BOOKDEPTH,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_BACKGROUND_COLOR,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_EXEMODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_ORDER_GTC_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_FILLING_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_EXPIRATION_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_ORDER_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_CALC_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_MARGIN_HEDGED_USE_LEG,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SWAP_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SWAP_ROLLOVER3DAYS,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_OPTION_MODE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_OPTION_RIGHT,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_STOPS_LEVEL,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_FREEZE_LEVEL,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_START_TIME,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_EXPIRATION_TIME,0,BaseName)) && 

            (SetProperty(SName,SYMBOL_OPTION_STRIKE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SESSION_PRICE_LIMIT_MAX,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SESSION_PRICE_LIMIT_MIN,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SESSION_PRICE_SETTLEMENT,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_ACCRUED_INTEREST,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_POINT,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_CONTRACT_SIZE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_FACE_VALUE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_LIQUIDITY_RATE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_TICK_SIZE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_TRADE_TICK_VALUE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_VOLUME_MIN,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_VOLUME_MAX,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_VOLUME_STEP,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_VOLUME_LIMIT,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_MARGIN_INITIAL,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_MARGIN_MAINTENANCE,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_MARGIN_HEDGED,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SWAP_LONG,0,BaseName)) && 
            (SetProperty(SName,SYMBOL_SWAP_SHORT,0,BaseName)))
            Print("Símbolo ",SName," criado com sucesso");
         else
            Print("Erro ao definir as propriedades do símbolo. Código de erro: ",GetLastError());
        }
      if(SymbolSelect(SName,true))
         Print("Símbolo ",SName," selecionado na Observação do Mercado");
      else
         Print("Erro ao selecionar o símbolo na Observação do Mercado. Código de erro: ",GetLastError());
     }
  }
//função para definir as propriedades do símbolo
bool SetProperty(string SymName,ENUM_SYMBOL_INFO_STRING SProp,string PropValue,string BaseSymName)
  {
   ResetLastError();
   if(BaseSymName=="")
     {
      if(CustomSymbolSetString(SymName,SProp,PropValue))
         return true;
      else
         Print("Erro ao definir a propriedade do símbolo: ",SProp," .Código de erro: ",GetLastError());
     }
   else
     {
      string SValue=SymbolInfoString(BaseSymName,SProp);
      if(CustomSymbolSetString(SymName,SProp,SValue))
         return true;
      else
         Print("Erro ao definir a propriedade do símbolo: ",SProp," .Código de erro: ",GetLastError());
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool SetProperty(string SymName,ENUM_SYMBOL_INFO_INTEGER IProp,long PropValue,string BaseSymName)
  {
   ResetLastError();
   if(BaseSymName=="")
     {
      if(CustomSymbolSetInteger(SymName,IProp,PropValue))
         return true;
      else
         Print("Erro ao definir a propriedade do símbolo: ",IProp," .Código de erro: ",GetLastError());
     }
   else
     {
      long IValue=SymbolInfoInteger(BaseSymName,IProp);
      if(CustomSymbolSetInteger(SymName,IProp,IValue))
         return true;
      else
         Print("Erro ao definir a propriedade do símbolo: ",IProp," .Código de erro: ",GetLastError());
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool SetProperty(string SymName,ENUM_SYMBOL_INFO_DOUBLE DProp,double PropValue,string BaseSymName)
  {
   ResetLastError();
   if(BaseSymName=="")
     {
      if(CustomSymbolSetDouble(SymName,DProp,PropValue))
         return true;
      else
         Print("Erro ao definir a propriedade do símbolo: ",DProp," .Código de erro: ",GetLastError());
     }
   else
     {
      double DValue=SymbolInfoDouble(BaseSymName,DProp);
      if(CustomSymbolSetDouble(SymName,DProp,DValue))
         return true;
      else
         Print("Erro ao definir a propriedade do símbolo: ",DProp," .Código de erro: ",GetLastError());
     }
   return false;
  }
//+------------------------------------------------------------------+

Considere o código do script em mais detalhes. Primeiro, é feita uma tentativa de criar um símbolo usando a função CustomSymbolCreate:

if(!CustomSymbolCreate(SName,"\\Forex"))
     {
      if(SymbolInfoInteger(SName,SYMBOL_CUSTOM))
         Print("O símbolo ",SName," já existe!");
      else
         Print("Erro ao criar símbolo. Código de erro: ",GetLastError());
     }

O símbolo é criado na pasta Custom/Forex. Se você criar sua própria subpasta (grupo personalizado) na pasta Custom, especifique seu nome no segundo parâmetro da função CustomSymbolCreate.

Em seguida, são definidas as propriedades do símbolo criado. Quando não definido o parâmetro BaseName, é executada a definição dos parâmetros do símbolo estabelecidos pelo usuário. Por exemplo, vejas propriedades definidas do par de moedas EURUSD:

    //propriedade do tipo String
         if((SetProperty(SName,SYMBOL_CURRENCY_BASE,CurrencyName,"")) && //unidade monetária base
            (SetProperty(SName,SYMBOL_CURRENCY_PROFIT,"USD",""))&&                         //moeda de lucro
            (SetProperty(SName,SYMBOL_CURRENCY_MARGIN,"UCR",""))&&                         //moeda da margem
...

Por conveniência, as propriedades são divididas em grupos, primeiro são definidas as propriedades do tipo String, Integer e, finalmente, Double. No caso de configuração bem-sucedida de propriedades, no log é registrada uma mensagem sobre a criação bem-sucedida do símbolo, caso contrário, no log é registrado o código de erro ao definir as propriedades do símbolo. 

Se o valor do parâmetro BaseName não estiver vazio, as propriedades do símbolo que está sendo criado são copiadas das propriedades do símbolo base cujo nome é especificado pelo parâmetro BaseName, por exemplo, podem ser os pares de moedas EURUSD, USDCAD, GBPUSD e outros.

A função SetProperty, descrita após o código da função base do script, é responsável por definir as propriedades dos símbolos. Esta função não é usada em outros scripts, portanto, não a coloque numa classe plug-in separada.

Para propriedades do tipo String, Integer e Double, são criadas instâncias separadas da função SetProperty. Para definir as propriedades do símbolo personalizado, são usadas as funções CustomSymbolSetString, CustomSymbolSetInteger, CustomSymbolSetDouble. Para obter as propriedades do símbolo base, são usadas as funções SymbolInfoString, SymbolInfoInteger, SymbolInfoDouble. 

Após a configuração bem-sucedida das propriedades, o símbolo personalizado criado é selecionado na Observação do mercado usando a função SymbolSelect:

  if(SymbolSelect(SName,true))
         Print("Símbolo ",SName," selecionado na Observação do Mercado");
      else
         Print("Erro ao selecionar o símbolo na Observação do Mercado. Código de erro: ",GetLastError());

Para abrir o gráfico do símbolo criado, você precisa carregar no símbolo ticks ou barras. O script para gerar ticks e barras será discutido abaixo. 

Agora, considere o processo para excluir um símbolo personalizado. Se você quiser excluir um símbolo personalizado selecionando-o na guia Símbolos, nem sempre será possível conseguir isso:

Fig. 1. Tentando excluir um símbolo quando selecionado na Observação do mercado.

Para excluir um símbolo, é necessário removê-lo da Observação do mercado clicando no símbolo duas vezes na janela Símbolos. O símbolo que você deseja desabilitar não deve ter gráficos abertos e posições, portanto, é necessário fechar todos os gráficos e posições para este símbolo manualmente. Este processo não é muito rápido, especialmente se você tiver muitos gráficos nesse símbolo. Mostraremos como implementar a exclusão de símbolo usando um script pequeno (o script está anexado ao artigo no arquivo DeleteSymbol.mq5):

//+------------------------------------------------------------------+
//|                                                 DeleteSymbol.mq5 |
//|                                                  Aleksey Zinovik |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Aleksey Zinovik"
#property script_show_inputs 
#property version   "1.00"
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
input string SName="ExampleCurrency";
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   ResetLastError();
   if(SymbolInfoInteger(SName,SYMBOL_CUSTOM))//se o símbolo existir
     {
      if(!CustomSymbolDelete(SName))//tentamos remover
        {
         if(SymbolInfoInteger(SName,SYMBOL_SELECT))//se estiver selecionado na Observação do mercado
           {
            if(SymbolSelect(SName,false))//Tentamos desativar e remover
              {
               if(!CustomSymbolDelete(SName))
                  Print("Erro ao remover o símbolo ",SName," Código de erro: ",GetLastError());
               else
                  Print("Símbolo ",SName," removido com sucesso");
              }
            else
              {
               //tentamos fechar gráficos com um símbolo
               int i=0;
               long CurrChart=ChartFirst();
               int i_id=0;
               long ChartIDArray[];
               while(CurrChart!=-1)
                 {
                  //iteramos a lista de gráficos e salvamos os identificadores de gráficos abertos do símbolo SName
                  if(ChartSymbol(CurrChart)==SName)
                    {
                     ArrayResize(ChartIDArray,ArraySize(ChartIDArray)+1);
                     ChartIDArray[i_id]=CurrChart;
                     i_id++;
                    }
                  CurrChart=ChartNext(CurrChart);
                 }
               //fechamos todos os gráficos do símbolo SName
               for(i=0;i<i_id;i++)
                 {
                  if(!ChartClose(ChartIDArray[i]))
                    {
                     Print("Erro ao fechar o gráfico do símbolo ",SName,". Código de erro: ",GetLastError());
                     return;
                    }
                 }
               //desativamos e removemos o símbolo 
               if(SymbolSelect(SName,false))
                 {
                  if(!CustomSymbolDelete(SName))
                     Print("Erro ao remover o símbolo ",SName," Código de erro: ",GetLastError());
                  else
                     Print("Símbolo ",SName," removido com sucesso");
                 }
               else
                  Print("Erro ao desativar o símbolo ",SName," na Observação do mercado. Código de erro: ",GetLastError());
              }//end else SymbolSelect 
           } //end if(SymbolSelect(SName,false))
         else
            Print("Erro ao remover o símbolo ",SName," Código de erro: ",GetLastError());
        }
      else
         Print("Símbolo ",SName," removido com sucesso");
     }
   else
      Print("O símbolo ",SName," não existe");
  }
//+------------------------------------------------------------------+

Considere o funcionamento do script:

• primeiro, é verificada a presença de um símbolo com o nome SName,
• se o símbolo for encontrado, é feita uma tentativa para removê-lo usando a função CustomSymbolDelete,
• se o símbolo não puder ser excluído, tente desativá-lo na Observação do mercado usando a função SimbolSelect,
• se não for possível desabilitar o símbolo na Observação do mercado, feche todos os gráficos abertos para este símbolo.
  

Para fazer isso, passe por todos os gráficos abertos e salve os identificadores dos gráficos abertos no símbolo com o nome SName:

               while(CurrChart!=-1)
                 {
                  //iteramos a lista de gráficos e salvamos os identificadores de gráficos abertos do símbolo SName
                  if(ChartSymbol(CurrChart)==SName)
                    {
                     ArrayResize(ChartIDArray,ArraySize(ChartIDArray)+1);
                     ChartIDArray[i_id]=CurrChart;
                     i_id++;
                    }
                  CurrChart=ChartNext(CurrChart);
                 }

              for(i=0;i<i_id;i++)
                 {
                  if(!ChartClose(ChartIDArray[i]))
                    {
                     Print("Erro ao fechar o gráfico do símbolo ",SName,". Código de erro: ",GetLastError());
                     return;
                    }
                 }

• depois que todos os gráficos são fechados, tente desabilitar o símbolo novamente na Observação do mercado e exclui-lo, caso contrário, uma mensagem de erro será registrada no log.

Para substituir barras, é criada a função ReplaceHistory cujo código é dado no final do script. A substituição de barras é realizada pela função CustomRatesReplace. Após a substituição de barras, é zerado o contador de barras e é liberado o buffer da matriz dinâmica MRatesMin que armazena as barras criadas. 

3) O script permite gerar velas de vários tipos

A geração de vários tipos de velas é implementada da seguinte forma (parâmetro DiffCande = true):

 if(DiffCandle)
           {
            i=MathRand()%5;
            switch(i)
              {
               case 0://Doji
                 {
                  MRatesMin[i_bar].close=MRatesMin[i_bar].open;
                  break;
                 }
               case 1://Hammer
                 {
                  if(MRatesMin[i_bar].open>MRatesMin[i_bar].close)
                     MRatesMin[i_bar].high=MRatesMin[i_bar].open;
                  else
                    {
                     if(MRatesMin[i_bar].open<MRatesMin[i_bar].close)
                        MRatesMin[i_bar].high=MRatesMin[i_bar].close;
                    }
                  break;
                 }
               case 2://Star
                 {
                  if(MRatesMin[i_bar].open>MRatesMin[i_bar].close)
                     MRatesMin[i_bar].low=MRatesMin[i_bar].close;
                  else
                    {
                     if(MRatesMin[i_bar].open<MRatesMin[i_bar].close)
                        MRatesMin[i_bar].low=MRatesMin[i_bar].open;
                    }
                  break;
                 }
               case 3://Maribozu
                 {
                  if(MRatesMin[i_bar].open>MRatesMin[i_bar].close)
                    {
                     MRatesMin[i_bar].high=MRatesMin[i_bar].open;
                     MRatesMin[i_bar].low=MRatesMin[i_bar].close;
                    }
                  else
                    {
                     if(MRatesMin[i_bar].open<MRatesMin[i_bar].close)
                       {
                        MRatesMin[i_bar].high=MRatesMin[i_bar].close;
                        MRatesMin[i_bar].low=MRatesMin[i_bar].open;
                       }
                    }
                  break;
                 }
               default: break;
              }
           }

Assim, o script permite gerar as habituais velas longas ou curtas "doji", "hammer", "star" e "mariboza" com a mesma probabilidade.

Vamos mostrar o trabalho do script, para isso, inicie o script com os seguintes parâmetros de entrada:

Fig. 1. Parâmetros de entrada do script

Como resultado, aparece um novo símbolo ExampleCurrency. Durante a operação do script, são geradas 33 121 barras de minutos. A Figura 2 mostra um fragmento do gráfico de minutos do símbolo ExampleCurrency.

Fig. 2. Gráfico de minutos do símbolo ExampleCurrency

Às vezes, as barras de minutos podem não ser suficientes para testar um EA ou indicador, e o teste é realizado em ticks reais ou modelados. 

Considere um script que simula ticks e formula barras de minutos com base em ticks modelados. O código completo do script é fornecido no arquivo GetTick.mq5 anexado ao artigo. Aqui está o código da função OnStart():

void OnStart()
  {
   if(SymbolInfoInteger(SName,SYMBOL_CUSTOM))//se o símbolo existir
     {
      MqlDateTime  StructCTime;
      long TBeginMSec=(long)TBegin*1000;      //tempo de início da geração de ticks em ms
      long TEndMSec=(long)TEnd*1000;          //hora de término da geração de ticks em ms
      int ValMsec=0;                          //variável para gerar um deslocamento de tempo aleatório em ms
      int SumSec=0;                           //contador de segundos
      int SumMSec=0;                          //contador de milissegundos
      int PrevTickCount=0;                    //variável para armazenar os ticks anteriores num minuto
      datetime TCurrent=TBegin;
      bool   NewMinute=false;
       //copiamos o valor do preço no qual começará a geração de ticks
      if(CopyClose(SName,PERIOD_M1,TCurrent-60,1,BValue)==-1)
         BValue[0]=Base;
      //preenchemos a estrutura LastTick
      LastTick.ask=BValue[0];
      LastTick.bid=BValue[0];
      LastTick.last=BValue[0];
      LastTick.volume=baseVol;

      while(TBeginMSec<=TEndMSec)
        {
         if(FiveDayOfWeek)
           {
            TimeToStruct(TCurrent,StructCTime);
            if((StructCTime.day_of_week==0) || (StructCTime.day_of_week==6))
              {
               if(StructCTime.day_of_week==0)
                 {
                  TCurrent=TCurrent+86400;
                  TBeginMSec=TBeginMSec+86400000;
                 }
               else
                 {
                  TCurrent=TCurrent+2*86400;
                  TBeginMSec=TBeginMSec+2*86400000;
                 }
               if(TBeginMSec>=TEndMSec)
                  break;
              }
           }
         GetTick(TCurrent,TBeginMSec);
         if(IsErrCheck(DistErr)) return;
         i_tick++;

         if(RandomTickTime)
           {
            //geramos o deslocamento aleatório de tempo
            
            ValMsec=(int)((MathRand()%30000)/(MaxTickInMinute*0.25)+1);
            SumSec=SumSec+ValMsec;
            SumMSec=SumMSec+ValMsec;
            if(i_tick-PrevTickCount>=MaxTickInMinute)
              {
               TimeToStruct(TCurrent,StructCTime);
               StructCTime.sec=0;
               TCurrent=StructToTime(StructCTime)+60;
               TBeginMSec=TBeginMSec+60000-SumSec+ValMsec;
               SumSec=0;
               SumMSec=0;
               NewMinute=true;
              }
            else
              {
               if(SumSec>=60000)
                 {
                  //redefinimos o contador de ticks por minuto
                  SumSec=SumSec-60000*(SumSec/60000);
                  NewMinute=true;
                 }
               //formação de um novo tempo de tick    
               TBeginMSec=TBeginMSec+ValMsec;
               if(SumMSec>=1000)
                 {
                  TCurrent=TCurrent+SumMSec/1000;
                  SumMSec=SumMSec-1000*(SumMSec/1000);
                 }
              }
           }
         else
           {
            TBeginMSec=TBeginMSec+60000/MaxTickInMinute;
            SumSec=SumSec+60000/MaxTickInMinute;
            SumMSec=SumMSec+60000/MaxTickInMinute;
            if(SumMSec>=1000)
              {
               TCurrent=TCurrent+SumMSec/1000;
               SumMSec=SumMSec-1000*(SumMSec/1000);
              }
            if(SumSec>=60000)
              {
               SumSec=SumSec-60000*(SumSec/60000);
               NewMinute=true;
              }
           }
         if(NewMinute)
           {
            //adicionamos a nova barra à matriz 
            ArrayResize(MRatesMin,ArraySize(MRatesMin)+1);
            if(ArraySize(MRatesMin)==1)//se o primeiro minuto
              {
               MRatesMin[i_bar].open=NormalizeDouble(LastTick.bid,_Digits);
               MRatesMin[i_bar].tick_volume=(long)i_tick;
              }
            else
              {
               MRatesMin[i_bar].open=NormalizeDouble(MTick[PrevTickCount-1].bid,_Digits);
               MRatesMin[i_bar].tick_volume=(long)i_tick-PrevTickCount;
              }
            MRatesMin[i_bar].close=NormalizeDouble(MTick[i_tick-1].bid,_Digits);
            if(ValHigh>MRatesMin[i_bar].open)
               MRatesMin[i_bar].high=NormalizeDouble(ValHigh,_Digits);
            else
               MRatesMin[i_bar].high=MRatesMin[i_bar].open;
            if(ValLow<MRatesMin[i_bar].open)
               MRatesMin[i_bar].low=NormalizeDouble(ValLow,_Digits);
            else
               MRatesMin[i_bar].low=MRatesMin[i_bar].open;
            MRatesMin[i_bar].real_volume=(long)MTick[i_tick-1].volume;
            MRatesMin[i_bar].spread=(int)MathRound(MathAbs(MTick[i_tick-1].bid-MTick[i_tick-1].ask)/_Point);
            TimeToStruct(MTick[i_tick-1].time,StructCTime);
            StructCTime.sec=0;
            MRatesMin[i_bar].time=StructToTime(StructCTime);
            i_bar++;
            PrevTickCount=i_tick;
            ValHigh=2.2250738585072014e-308;
            ValLow=1.7976931348623158e+308;
            NewMinute=false;
            if(i_bar>=BarForReplace)
              {
               ReplaceHistory(MRatesMin[0].time,MRatesMin[i_bar-1].time);
               LastTick.bid=MTick[i_tick-1].bid;
               LastTick.ask=MTick[i_tick-1].ask;
               LastTick.last=MTick[i_tick-1].last;
               LastTick.volume=MTick[i_tick-1].volume;
               i_tick=0;
               i_bar=0;
               PrevTickCount=0;
               ArrayFree(MRatesMin);
               ArrayFree(MTick);
              }
           }
        }//end while
      if(i_bar>0)
         ReplaceHistory(MRatesMin[0].time,MRatesMin[i_bar-1].time);
     }
   else
      Print("O símbolo ",SName," não existe");
  }

No início da função OnStart(), ​​são inicializadas as variáveis. Geração de ticks e barras é executada no ciclo principal do script:

while(TBeginMSec<=TEndMSec)
{
...
}

No início do ciclo, caso o parâmetro FiveDayOfWeek = true, é desativada a geração de ticks nos fins de semana, adicionalmente, a hora do tick é alterado em 1 dia (se o horário do tick corresponder ao domingo) ou 2 dias (se o horário do tick corresponder ao sábado):

if(FiveDayOfWeek)
{
...
}

Em seguida, um tick é gerado usando a função GetTick:

 GetTick(TCurrent,TBeginMSec);
	if(IsErrCheck(DistErr)) return;
 	i_tick++;

Se ocorrer um erro durante a geração do tick (o valor da função IsErrCheck = true), o script será finalizado. A função IsErrCheck é descrita acima no código do script GetCandle.

Considere a função GetTick:

void GetTick(datetime TDate,long TLong)
  {
   ArrayResize(MTick,ArraySize(MTick)+1);
//preenchemos o novo tempo  
   MTick[i_tick].time=TDate;
   MTick[i_tick].time_msc=TLong;
//preenchemos o tick atual com o valor do anterior
   if(ArraySize(MTick)>1)
     {
      MTick[i_tick].ask=MTick[i_tick-1].ask;
      MTick[i_tick].bid=MTick[i_tick-1].bid;
      MTick[i_tick].volume=MTick[i_tick-1].volume;
      MTick[i_tick].last=MTick[i_tick-1].last;
     }
   else
     {
      MTick[i_tick].ask=LastTick.ask;
      MTick[i_tick].bid=LastTick.bid;
      MTick[i_tick].last=LastTick.last;
      MTick[i_tick].volume=LastTick.volume;
     }
//preenchemos o tick atual  
   if(RandomTickValue)
     {
      double RBid=MathRandomUniform(0,1,DistErr);
      double RAsk=MathRandomUniform(0,1,DistErr);
      double RVolume=MathRandomUniform(0,1,DistErr);
      if(RBid>=0.5)
        {
         if(i_tick>0)
            MTick[i_tick].bid=Base+GetDist(DistOCHL,DistOCHLParam1,DistOCHLParam2,DistOCHLParam3)*dStep;
         MTick[i_tick].last=MTick[i_tick].bid;
         MTick[i_tick].flags=10;
         if(RAsk>=0.5)
           {
            MTick[i_tick].ask=Base+GetDist(DistOCHL,DistOCHLParam1,DistOCHLParam2,DistOCHLParam3)*dStep;
            MTick[i_tick].flags=MTick[i_tick].flags+4;
           }
         if(RVolume>=0.5)
           {
            MTick[i_tick].volume=(ulong)(baseVol+GetDist(DistVolume,DistVolumeParam1,DistVolumeParam2,DistVolumeParam3)*dStepVol);
            MTick[i_tick].flags=MTick[i_tick].flags+16;
           }
        }
      else
        {
         if(RAsk>=0.5)
           {
            MTick[i_tick].ask=Base+GetDist(DistOCHL,DistOCHLParam1,DistOCHLParam2,DistOCHLParam3)*dStep;
            MTick[i_tick].flags=4;
            if(RVolume>=0.5)
              {
               MTick[i_tick].volume=(ulong)(baseVol+GetDist(DistVolume,DistVolumeParam1,DistVolumeParam2,DistVolumeParam3)*dStepVol);
               MTick[i_tick].flags=MTick[i_tick].flags+16;
              }
           }
        }
     }//end if(RandomTickValue)
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   else
     {
      MTick[i_tick].bid=Base+GetDist(DistOCHL,DistOCHLParam1,DistOCHLParam2,DistOCHLParam3)*dStep;
      MTick[i_tick].ask=Base+GetDist(DistOCHL,DistOCHLParam1,DistOCHLParam2,DistOCHLParam3)*dStep;
      MTick[i_tick].last=MTick[i_tick].bid;
      MTick[i_tick].volume=(ulong)(baseVol+GetDist(DistVolume,DistVolumeParam1,DistVolumeParam2,DistVolumeParam3)*dStepVol);
      MTick[i_tick].flags=30;
     }//end if(RandomTickValue)  
  //armazenamos os valores mais altos e mais baixos para a formação de barras de minutos  
   if(MTick[i_tick].bid>ValHigh)
      ValHigh=MTick[i_tick].bid;
   if(MTick[i_tick].bid<ValLow)
      ValLow=MTick[i_tick].bid;
  }//end 

A entrada da função recebe o tempo do tick no formato datetime e em milissegundos. Primeiro, o tick atual é preenchido com os valores do anterior, depois, os valores do tick atual são alterados da seguinte forma:

1) Se o valor do parâmetro RandomTickValue = true, cada um dos parâmetros Ask, Bid e Volume será alterado com uma probabilidade de 0.5. Para isso, são geradas 3 variáveis aleatórias uniformemente distribuídas :

      double RBid=MathRandomUniform(0,1,DistErr);
      double RAsk=MathRandomUniform(0,1,DistErr);
      double RVolume=MathRandomUniform(0,1,DistErr);

Se RBid>0.5, RAsk>0.5 - os preços Bid e/ou Ask são alterados de acordo com a fórmula (1), descrita acima para o script GetCandle. O volume é alterado de acordo com a fórmula (1), caso mude o preço Ask ou Bid e o parâmetro RVolume > 0.5. O valor do preço Bid é atribuído ao preço Last quando ele muda.

2) Se o valor do parâmetro RandomTickValue = false, os valores dos parâmetros Ask, Bid e Volume são calculados de acordo com a fórmula (1). 

O valor do sinalizador dos ticks (flags) é definido da seguinte maneira:

• alteração no preço Bid - flags=flags+2
• alteração no preço Ask - flags=flags+4
• alteração no preço Last - flags=flags+8
• alteração no preço Volume - flags=flags+16

ValMsec=(int)((MathRand()%30000)/(MaxTickInMinute*0.25)+1);

 ArrayResize(MRatesMin,ArraySize(MRatesMin)+1);

            if(ArraySize(MRatesMin)==1)//se o primeiro minuto
              {
               MRatesMin[i_bar].open=NormalizeDouble(LastTick.bid,_Digits);
               MRatesMin[i_bar].tick_volume=(long)i_tick;
              }
            else
              {
               MRatesMin[i_bar].open=NormalizeDouble(MTick[PrevTickCount-1].bid,_Digits);
               MRatesMin[i_bar].tick_volume=(long)i_tick-PrevTickCount;
              }

Ao formar a primeira barra de minutos, ao preço de abertura é atribuído o preço Bid do último tick da substituição de tick anterior (ticks e barras são substituídos usando a função ReplaceHistory) ou o valor base do preço Bid (parâmetro Base), se a substituição de ticks e barras não tiver sido realizada anteriormente. Ao formar as seguintes barras de minutos, o preço de abertura é atribuído ao valor normalizado do preço Bid do último tick (preço de fechamento) do minuto anterior. A normalização é entendida como arredondamento conforme ao preço do símbolo do gráfico atual no qual o script está sendo executado. 

• preço Close formado - preço Bid normalizado do último tick:

MRatesMin[i_bar].close=NormalizeDouble(MTick[i_tick-1].bid,_Digits);

• valores dos preços High e Low formados. Isso leva em conta que o valor do preço de abertura pode ser maior que o maior (Valhigh) ou menor que o menor (Vallow) preço Bid dos ticks gerados:

 if(ValHigh>MRatesMin[i_bar].open)
     MRatesMin[i_bar].high=NormalizeDouble(ValHigh,_Digits);
 else
     MRatesMin[i_bar].high=MRatesMin[i_bar].open;
 if(ValLow<MRatesMin[i_bar].open)
     MRatesMin[i_bar].low=NormalizeDouble(ValLow,_Digits);
 else
     MRatesMin[i_bar].low=MRatesMin[i_bar].open;

Para gerar o padrão "Topo Duplo", defina as seguintes configurações de script:

• Hora de início da geração das barras: 00:00 02.01.2018
• Hora final da geração de barras: 12:00 02.01.2018
• Modelo de tendência: LinearAndStochastic
• Tipo de tendência: Random
• Coeficiente de tendência: 0.15 
• Coeficiente k1 do modelo de tendência: 0.15
• Coeficiente k2 do modelo de tendência: 1 
• Coeficiente k3 do modelo de tendência: 1 
• Intervalo de mudança aleatória da direção da tendência: 60

Inicialização №2:

Os símbolos personalizados são uma ferramenta conveniente e útil para testar EAs e indicadores. No artigo, criamos e revisamos scripts com os seguintes recursos:

Foi mostrado como criar um símbolo personalizado com base num existente ou novo com propriedades especificadas manualmente. O script que implementa a remoção de símbolo permite fechar todos os gráficos contendo um símbolo e desativá-lo na "Observação do mercado".

Os scripts permitem gerar barras de minutos num determinado intervalo de tempo, com a capacidade de desativar a geração de barras nos fins de semana dias. Foram implementadas a geração de várias velas (longas ou curtas, doji, martelo, estrela e mariboza) e a substituição de barras e ticks por partes para economizar memória ao gerar grandes matrizes de barras e ticks.

Os scripts permitem modelar uma tendência usando vários modelos: linear, hiperbólico, exponencial, de potência, parabólico, linear-periódico e linear-estocástico. Também é possível modelar uma tendência para diferentes períodos.

Foi exemplificado o uso do script GetCandleTrend para criar os padrões "Topo Duplo" e "Fundo Duplo".

Os scripts apresentados podem ser usados para criar seu próprio histórico de preços, a partir de barras de minutos e ticks, para testes e para otimização de EAs e indicadores.