O que há de novo no MetaTrader 5?

1. Adicionada a capacidade de colocar ordens stop e stop-limit no gráfico.
   
   Agora você não está limitado apenas a colocar ordens restritas. Selecione o tipo de ordem pendente desejada pressionando logo o botão correspondente no painel inferior do gráfico.

   
   

   
   
2. Adicionada a capacidade de fechar posições e excluir ordens pendentes do gráfico. Selecione o ícone de posição ou nível de ordem no gráfico e o comando correspondente aparecerá no painel de negociação inferior:
   

   
   

   
   
3. Melhorada a função de deslocamento da borda direita do gráfico de preços. Agora, para alterar o deslocamento, basta rolar o gráfico até o último preço até que apareça um separador vertical. Em seguida, é necessário arrastar o triângulo na escala inferior do gráfico:

   
   

   
   
4. Adicionada a capacidade de copiar objetos analíticos no gráfico, para facilitar a marcação. Chame o menu do objeto pressionando-o longamente e selecione "Copiar":
   
   

   

   
   
5. Adicionada a capacidade de controlar a exibição de indicadores em diferentes períodos gráficos. Se o indicador não for adequado para determinados períodos gráfico, ele pode ser ocultado para liberar espaço na tela para outras ferramentas analíticas.

   
   
   

   
   
6. Adicionada exibição de comissões do instrumento na janela de especificação.

   
   

   
   
7. Adicionado um link para redefinir a senha da sua conta. O acesso só pode ser restaurado através da corretora com o qual a conta foi aberta. O link mostra detalhes de contato onde você pode obter ajuda.

   
   

   
   
8. Adicionada a capacidade de compartilhar links para o canal na MQL5.community.
   

   
   

   
   
9. Aprimorada a experiência do usuário ao se conectar a uma conta de negociação restrita.
   
   A negociação na conta pode ser limitada por diversos motivos, como a conexão com a conta no modo investidor, falta de aceitação de acordos, verificação pendente com a corretora, entre outros. Isso pode levar o usuário a não compreender por que as funções de negociação não estão disponíveis no aplicativo.
   
   Agora, nesses casos, um botão cinza para fazer um novo pedido será exibido na seção "Negociação". Ao clicar nele, o usuário verá informações e recomendações relevantes.

   
   

   
   
10. Aprimorado o manuseio de certificados SSL usados na autenticação estendida.
    
    Agora, ao se conectar a uma conta que utiliza autenticação avançada, o usuário recebe uma breve descrição das ações necessárias.

    
    

    
    Também é possível importar um certificado de um arquivo PFX. Para isso, salve-o no aplicativo e, em seguida, utilize a função de importação disponível na caixa de diálogo inicial.
    
    Além disso, agora é possível exportar certificados para arquivos e usá-los em outros dispositivos. Para isso, acesse "Configurações > Certificados" e clique em "Exportar" no menu de certificados.
    
    
11. A construção de tabelas de preços foi adaptada para Metal, a última geração da API gráfica usada em dispositivos Apple. Isso trará um significativo aumento de desempenho ao exibir gráficos, indicadores e objetos.
12. Corrigida a substituição dos níveis de Stop Loss e Take Profit no livro de ofertas. A partir de agora, em contas que operam no modo FIFO, os níveis de stop serão automaticamente definidos de acordo com os níveis de stop das posições já abertas para o mesmo instrumento. Isso é necessário para cumprir a regra FIFO.
13. Corrigida a recotação. Agora, ao receber uma nova cotação, o usuário terá um breve período de tempo para decidir se aceita ou não os novos preços. Se não houver solução, a solicitação é automaticamente rejeitada e a janela de nova cotação é fechada.
14. Corrigida exibição de tempo na seção "Gráfico" ao usar o tema de interface escura.

Terminal

1. Terminal: atualizadas traduções da interface do usuário.
2. Correções de crash-logs.
   

WebTerminal

• Correção de bugs da autenticação 2FA/TOTP.

WebTerminal

1. Adicionado suporte para autenticação 2FA/TOTP usando o Google Authenticator e aplicativos similares.
   
   A utilização de autenticação de dois fatores lhe permite proteger ainda mais sua conta de negociação contra o acesso não autorizado, mesmo que seu nome de utilizador e palavra-passe permanente sejam divulgados. Existem muitos aplicativos móveis que permitem a autenticação em duas etapas usando o algoritmo Time-based One-time Password Algorithm (TOTP) Entre os mais conhecidos estão Google Authenticator, Microsoft Authenticator, LastPass Authenticator e Authy. Agora, o terminal cliente MetaTrader 5 permite logar usando senhas únicas obtidas desse tipo de aplicativos Authenticator.
   
   Para ativar a autenticação em duas etapas, primeiro faça login no terminal cliente MetaTrader 5 da forma habitual. Em seguida, clique na sua conta no menu e selecione "Ativar 2FA/TOTP" na caixa de diálogo que se abre. Inicie o Authenticator em seu telefone celular, pressione o botão "+" nele para adicionar sua conta de negociação e ler o código QR a partir do terminal. Digite o código recebido no campo "Senha única" e clique em "Ativar 2FA", assim o sigilo de sua conta será adicionado ao servidor de negociação da corretora.
   

   
   
   

   
   O código salvo agora será usado no aplicativo Authenticator para gerar uma senha OTP para cada conexão posterior. Cada senha é válida durante 30 segundos, depois é gerada uma nova.
   

   
   
   

   
   Um código de backup também é exibido na caixa de diálogo com o código QR para vincular ao gerador, mantenha-o em um local seguro. Se você perder o acesso ao seu dispositivo vinculado, isso permitirá que você adicione novamente sua conta ao aplicativo Authenticator.
   
   Se você decidir remover o código guardado do aplicativo Authenticator, primeiro desabilite o uso da autenticação 2FA/TOTP usando o devido comando no menu de contexto de conta. Se a autenticação 2FA/TOTP não estiver disponível na sua conta, peça à sua corretora para ativar esta opção.
   
   
2. Expandida a quantidade de informações exibidas na Observação do Mercado. Agora, além dos preços Bid/Ask atuais e a porcentagem de variação de preço, você pode ver:
   
   
   • Preço Bid/Ask máximo e mínimo para o pregão atual
   • Preços de abertura dos preços atuais e de fechamento do pregão anterior
   
   Para personalizar as informações exibidas, use o menu de contexto:

   
   
   

   
   
3. Adicionada exibição de uma notificação de risco quando a configuração correspondente é habilitada no lado da corretora. Alguns reguladores exigem que o comerciante leia e aceite a notificação antes de negociar.
4. Corrigida a exibição da barra de ferramentas superior nos modelos de iPhone com um entalhe na parte superior da tela. Em alguns casos, ela podia cobrir os botões do painel.
5. Corrigida a exibição dos indicadores financeiros finais da conta (lucro, patrimônio, etc.) no navegador Google Chrome. Em alguns casos, os valores podiam não ser atualizados.
   
   

Terminal

1. Ootimizada e acelerada a abertura da caixa de diálogo para criar contas demo.
2. Atualizadas traduções da interface do usuário.
3. Correções de crash-logs.

1. Adicionados novos métodos à classe COpenCL da biblioteca padrão:
   
   
   • BufferFromMatrix - preenchimento do buffer do dispositivo com dados da matriz
   • BufferToMatrix - leitura de dados desde o buffer do dispositivo em uma matriz
   • ContextCreate - criação do contexto do dispositivo (primeira parte do método Initialize)
   • ProgramCreate - criação de um programa baseado em código-fonte OpenCL (segunda parte do método Initialize)
   • ContextClean - liberação de todos os dados pertencentes ao contexto do dispositivo (semelhante ao método Shutdown, mas sem remover o contexto)
   • GetDeviceInfoInteger - recepção de uma propriedade inteira do dispositivo
   • GetKernelInfoInteger — recepção de uma propriedade inteira do kernel
   • GetDeviceInfo - recepção de qualquer propriedade inteira única do dispositivo não presente na enumeração ENUM_OPENCL_PROPERTY_INTEGER
   
   Exemplo de uso de GetDeviceInfo:
   

   longo preferido_workgroup_size_multiple=OpenCL.GetDeviceInfo(0x1067);

2. Adicionados os valores TERMINAL_CPU_NAME e TERMINAL_OS_VERSION à enumeração ENUM_TERMINAL_INFO_STRING. Eles permitem que você obtenha o nome do processador e sistema operacional do usuário.
   

   void OnStart()
     {
      string cpu,os;
   //---
      cpu=TerminalInfoString(TERMINAL_CPU_NAME);
      os=TerminalInfoString(TERMINAL_OS_VERSION);
      PrintFormat("CPU: %s, OS: %s",cpu,os);
     }
   

   Resultado:
   
   CPU: Intel Xeon E5-2630 v4 @ 2,20 GHz, SO: Windows 10 build 19045
   
3. Corrigido o parâmetro "table_or_sql" nas funções DatabasePrint e DatabaseExport. Agora você pode passar nele o nome da tabela e não apenas a consulta SQL.

1. Corrigida a verificação do número máximo de colunas no banco de dados que podem ser exibidas. Agora você pode exibir até 64 colunas.
2. Corrigido o trabalho de pontos de interrupção em construções curtas como IF[ if(cond) break; ].

Terminal

1. Adicionado suporte para autenticação 2FA/TOTP usando o Google Authenticator e aplicações similares.
   
   A utilização de autenticação de dois fatores lhe permite proteger ainda mais a sua conta de negociação contra o acesso não autorizado, mesmo que o seu nome de utilizador e palavra-passe permanente sejam divulgados. Existem muitos aplicativos móveis que permitem a autenticação em duas etapas usando o algoritmo time-based one-time password. Entre os mais conhecidos estão Google Authenticator, Microsoft Authenticator, LastPass Authenticator e Authy. Agora, o terminal cliente MetaTrader 5 permite logar usando senhas únicas obtidas desse tipo de aplicativos Authenticator.
   
   Para ativar a autenticação em duas etapas, primeiro faça login no terminal cliente MetaTrader 5 da forma habitual. Em seguida, clique com o botão direito do mouse na conta de negociação para abrir o menu e selecione "Permitir 2FA/TOTP". Inicie o Authenticator em seu telefone celular, pressione o botão "+" nele para adicionar sua conta de negociação e escanear o código QR a partir do terminal. Digite o código recebido no campo "One-time password" e clique em "Enable 2FA" - o sigilo de sua conta será adicionado ao servidor de negociação da corretora.

   
   
   
   

   O código salvo agora será usado no aplicativo Authenticator para gerar uma senha OTP para cada conexão posterior. Cada senha é válida durante 30 segundos, depois é gerada uma nova.

   
   
   

   Se você decidir remover o código guardado do aplicativo Authenticator, primeiro desabilite o uso da autenticação 2FA/TOTP usando o devido comando do menu de contexto de conta. Se a autenticação 2FA/TOTP não estiver disponível na sua conta, peça à sua corretora para ativar esta opção.
   
   

1. Corrigido o funcionamento da função CopyTicks para instrumentos de negociação personalizados. Em alguns casos, ao trabalhar com símbolos personalizados, os ticks iniciais do pregão anterior eram devolvidos em vez dos dados solicitados.
   
   
2. Adicionados novos valores à enumeração para obter informações sobre o último erro OpenCL, tais valores permitem obter o código de erro e a respectiva descrição.
   
1. adicionado CL_LAST_ERROR (código 4094) à enumeração ENUM_OPENCL_PROPERTY_INTEGER 
   
   Para obter o último erro OpenCL através de CLGetInfoInteger, o parâmetro handle é ignorado, ou seja, não tem valor. Descrição de erros: https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_API.html#CL_SUCCESS.
   No caso de um código de erro desconhecido, a string "unknown OpenCL error N" será retornada, sendo N o código de erro.
   
   Por exemplo:

   //--- primeiro parâmetro handle é ignorado quando o último código de erro é recebido
   int code = (int)CLGetInfoInteger(0,CL_LAST_ERROR);

   
   
2. adicionado o valor CL_ERROR_DESCRIPTION (4093) à enumeração ENUM_OPENCL_PROPERTY_STRING.
   Uma descrição do erro OpenCL pode ser obtida usando CLGetInfoString. Descrição de erros: https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_API.html#CL_SUCCESS.
   
   Ao utilizar CL_ERROR_DESCRIPTION como parâmetro handle, o código de erro deve ser passado para CLGetInfoString. Se CL_LAST_ERROR for passado em vez do código de erro, a função devolverá uma descrição do último erro.
   
   Por exemplo:

   //--- obter o código para o último erro OpenCL
   int    code = (int)CLGetInfoInteger(0,CL_LAST_ERROR);
   string desc; // для получения текстового описания ошибки
   
   //--- usamos o código de erro para obter uma descrição textual do erro
   if(!CLGetInfoString(code,CL_ERROR_DESCRIPTION,desc))
      desc = "cannot get OpenCL error description, " + (string)GetLastError();
   Print(desc);
   
   
   //--- para obter uma descrição do último erro OpenCL sem primeiro obter o código, passamos CL_LAST_ERROR  
   if(!CLGetInfoString(CL_LAST_ERROR,CL_ERROR_DESCRIPTION, desc))
      desc = "cannot get OpenCL error description, " + (string)GetLastError();
   Print(desc);

   Por enquanto, o nome da enumeração interna é dado como a descrição do erro, cuja decifração pode ser encontrada na página https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_API.html#CL_SUCCESS. Por exemplo, se CL_INVALID_KERNEL_ARGS for recebido, a descrição para ele será "Returned when enqueuing a kernel when some kernel arguments have not been set or are invalid."
   
   
3. Corrigido o funcionamento do método matrix::MatMul. Quando se trabalha com matrizes grandes, o terminal colidiria dependendo de determinados tamanhos.

MetaTrader 5 WebTerminal

1. Na versão móvel, as operações de classificação e filtragem por profundidade foram adicionadas à seção de histórico de negociação. Para personalizar a exibição do histórico, use os comandos no painel superior:
   

   
   
   

   
   As operações podem ser ordenadas por parâmetros básicos: data, bilhete, símbolo, volume, etc.
   
   
2. Acesso aprimorado às informações sobre suas contas de negociação.
   
   
   • Na versão desktop, os dados da conta atual no menu flutuante agora são clicáveis. Ao clicar na conta, você acessa seus detalhes.
   • Na versão móvel, a exibição da conta atual foi adicionada na seção "Configurações". Ao clicar na conta, você acessa seus detalhes.

   
   
   

3. Corrigida a exibição do tipo de conta na janela de gerenciamento de contas.
4. Corrigida a exibição de patrimônio e margem livre após atualizar a página do terminal web em navegadores móveis.
   
5. Corrigida a exibição da barra inferior no navegador móvel Firefox.
   
   

Terminal

1. Corrigido um bug no cálculo dos gráficos de saldo e capital líquido no relatório de negociação.

1. Modificado o comportamento de typename(expr). Agora a função retorna o tipo completo com modificadores e dimensões (para arrays):
   

   classe A
     {
     };
   
   void OnStart(void)
     {
      const A *const arr[][2][3]={};
      Print(typename(arr));
     }
   

   Resultado:
   

   "class A const * const [][2][3]"

1. Adicionado um novo comando para acessar o novo relatório de negociação ao menu de contexto das seções "Negociação" e "Histórico":
   

   

   
   O relatório de negociação inclui:
   
   • Indicadores de crescimento mensais na forma de gráfico e tabela
   • Gráfico de capital líquido
   • Gráfico de radar que permite avaliar rapidamente o estado da conta
   • Estatísticas de negociação por instrumento
   • Muitos indicadores complementares para análise de negociação
   
   
2. Corrigido o cálculo do depósito inicial no relatório de negociação.
3. Corrigida a configuração dos níveis "Stop Loss" e "Take Profit" ao usar painéis de negociação rápida no gráfico e no "Market Watch". Os níveis podem ser herdados erroneamente de posições abertas anteriormente, mesmo que não seja necessário (a funcionalidade é destinada a contas FIFO).
4. Atualizadas traduções da interface do usuário.

1. Corrigido um erro do compilador que permitia acessar um campo de estrutura por uma string constante cujo valor era o nome do campo.
2. MQL5: corrigida a verificação do estado de tecla com TerminalInfoInteger(TERMINAL_KEYSTATE_*).

Correções de crash-logs.

MetaTrader 5 WebTerminal build 3500

1. Corrigido fechamento de posições ao receber uma recotação.
2. Corrigida a reconexão com o servidor após maximizar uma janela do navegador que estava inativa há muito tempo.
3. Corrigida exibição de fundos de crédito na conta.
4. Muitas outras melhorias e correções.

Versão móvel do terminal web

A nova versão do terminal web possui suporte total para dispositivos móveis. Agora sua interface se adapta automaticamente ao tamanho da tela, permitindo que os usuários trabalhem convenientemente na plataforma por meio de telefones e tablets com iOS e Android:

Além disso, muitas correções e melhorias foram feitas no terminal web.

Novo terminal web MetaTrader 5 suporta todos os recursos que um trader moderno precisa. O aplicativo permite:

• Trabalhar com contas demo e reais
• Receber cotações de quaisquer instrumentos financeiros
• Negociar em qualquer mercado
• Realizar análises técnicas de cotações usando mais de 30 indicadores e 20 objetos gráficos
  
• Analisar dados do Calendário Econômico

Terminal

1. As funções do gerenciador de tarefas foram expandidas. Agora ele facilita o rastreio de recursos consumidos com ainda mais precisão.
   
   • Adicionada exibição do tamanho da pilha para fluxos
   • Adicionada a exibição de quantidade de chaveamentos
   • Adicionado reconhecimento de threads do sistema e threads em DLLs de terceiros
   • Adicionada exibição do tempo de operação no modo kernel. Um aumento neste indicador em relação ao tempo gasto no modo de usuário pode indicar problemas no sistema: problemas nos drivers, erros de hardware, hardware lento. Leia mais na documentação da Microsoft.
   • Adicionada exibição do tempo de operação no modo de usuário.
   
   

   
   
   
   

2. A guia OpenCL foi adicionada às configurações do terminal para gerenciar os dispositivos disponíveis. O novo gerenciador OpenCL permite especificar explicitamente os dispositivos que serão usados para cálculos.
   
   

   

3. Adicionada a substituição dos níveis de Stop Loss e Take Profit no livro de ofertas para contas que operam no modo FIFO (pode ser ativado no lado da corretora).
   
   O modo FIFO implica que as posições de cada instrumento devem ser fechadas na ordem em que foram abertas. Para garantir que as posições de fechamento por meio de níveis de stop estejam sempre em conformidade com a regra FIFO, no lado do terminal do cliente é implementada a seguinte lógica:
   
   Se houver várias posições para o mesmo instrumento, o posicionamento de níveis de stop para qualquer um deles resultará no posicionamento de níveis de stop similares para todos os outros. Assim, quando o nível for acionado, todas as posições serão fechadas em ordem de acordo com a regra FIFO.
   
   Agora, ao abrir o livro de ofertas para um instrumento que já possui posições, os níveis das posições existentes (se houver) serão inseridos automaticamente nos campos Stop Loss e Take Profit.
   
   
4. Corrigida a exclusão dos níveis Stop Loss e Take Profit usando os botões "X" na seção "Caixa de Ferramentas\Negociação". O erro ocorria quando a função de negociação rápida era desativada. Agora, quando o botão for pressionado, uma caixa de diálogo de negociação será aberta com o valor vazio do nível correspondente.
   
   
5. Feitas alterações no relatório de negociaçãorelatório de negociação - as legendas nos gráficos e o cálculo da comissão final foram corrigidos. Além disso, em alguns casos, o Profit incorreto era mostrado nas estatísticas do relatório, bem como valores incorretos nas dicas de ferramentas ao passar o mouse sobre os gráficos de patrimônio liquido e saldo.
   
   

1. Adicionados métodos vetoriais e matriciais CopyTicks e CopyTicksRange. Eles facilitam a cópia de matrizes de dados de ticks para vetores e matrizes.
   

   bool matrix::CopyTicks(string symbol,uint flags,ulong from_msc,uint count);
   bool vector::CopyTicks(string symbol,uint flags,ulong from_msc,uint count);
   
   bool matrix::CopyTicksRange(string symbol,uint flags,ulong from_msc,ulong to_msc);
   bool matrix::CopyTicksRange(string symbol,uint flags,ulong from_msc,ulong to_msc);

   O tipo de dados a ser copiado é especificado no parâmetro flags usando a enumeração ENUM_COPY_TICKS. Estão disponíveis os seguintes valores:
   

   COPY_TICKS_INFO    = 1,       // ticks causados por mudanças em Bid e/ou Ask
   COPY_TICKS_TRADE   = 2,       // ticks causados por mudanças em Last e Volume
   COPY_TICKS_ALL     = 3,       // ticks com alterações
   COPY_TICKS_TIME_MS = 1<<8,    // tempo em milissegundos
   COPY_TICKS_BID     = 1<<9,    // preço Bid
   COPY_TICKS_ASK     = 1<<10,   // preço Ask
   COPY_TICKS_LAST    = 1<<11,   // preço Last
   COPY_TICKS_VOLUME  = 1<<12,   // volume
   COPY_TICKS_FLAGS   = 1<<13,   // sinalizadores de tick

   Quando vários tipos de dados são selecionados (disponível apenas para matrizes), a ordem das linhas na matriz corresponderá à ordem dos valores na enumeração.
   
   
2. Expandidos os recursos dos métodos matrix::Assign e vector::Assign.
   
   Agora, um array ou vetor unidimensional pode ser atribuído à matriz:
   

   bool matrix::Assign(const vector &vec);

   O resultado será uma matriz de uma linha.
   
   Além disso, uma matriz agora pode ser atribuída a um vetor (com suavização da matriz):
   

   bool vector::Assign(const matrix &mat);

3. Adicionados métodos de Swap para vetores e matrizes.
   

   bool vector::Swap(vector &vec);
   bool vector::Swap(matrix &vec);
   bool vector::Swap(double &arr[]);
   bool matrix::Swap(vector &vec);
   bool matrix::Swap(matrix &vec);
   bool matrix::Swap(double &arr[]);

   Cada array, vetor ou matriz aponta para um buffer de memória que contém os elementos de dado objeto. O método Swap realmente troca de lugar os ponteiros para esses buffers sem gravar os elementos na memória. Desse modo, a matriz continua sendo uma matriz e o vetor continua sendo um vetor. Quando você troca uma matriz e um vetor, obtém uma matriz de uma linha com elementos vetoriais e um vetor com elementos de matriz em uma representação plana (consulte o método Flat).
   

   //+------------------------------------------------------------------+
   //| Script program start function                                    |
   //+------------------------------------------------------------------+
   void OnStart()
    {
   //---
     matrix a= {{1, 2, 3}, {4, 5, 6}};
     Print("a before Swap: \n", a);
     matrix b= {{5, 10, 15, 20}, {25, 30, 35, 40}, {45, 50, 55, 60}};
     Print("b before Swap: \n", b);  
   //--- swap matrix pointers
     a.Swap(b);
     Print("a after Swap: \n", a);
     Print("b after Swap: \n", b);
     /*
     a before Swap:
     [[1,2,3]
     [4,5,6]]
     b before Swap:
     [[5,10,15,20]
     [25,30,35,40]
     [45,50,55,60]]
     
     a after Swap:
     [[5,10,15,20]
     [25,30,35,40]
     [45,50,55,60]]
     b after Swap:
     [[1,2,3]
     [4,5,6]]
     */
     vector v=vector::Full(10, 7);
     Print("v before Swap: \n", v);
     Print("b before Swap: \n", b);
     v.Swap(b);
     Print("v after Swap: \n", v);
     Print("b after Swap: \n", b);
     /*
     v before Swap:
     [7,7,7,7,7,7,7,7,7,7]
     b before Swap:
     [[1,2,3]
     [4,5,6]]
     
     v after Swap:
     [1,2,3,4,5,6]
     b after Swap:
     [[7,7,7,7,7,7,7,7,7,7]]
     */
    }

   O método Swap também permite trabalhar com arrays dinâmicos (um array de tamanho fixo que não pode ser passado como parâmetro). Neste caso, a matriz pode ser de qualquer dimensão, mas de um tamanho acordado. Isso significa que o tamanho total de uma matriz ou vetor deve ser um múltiplo da dimensão zero da matriz. A dimensão zero de uma matriz é o número de elementos contidos no primeiro índice da matriz. Por exemplo, para um array tridimensional dinâmico double array[][2][3], a dimensão zero será o produto dos tamanhos da segunda e da terceira dimensão, ou seja, 2x3=6. Isso significa que tal array só pode ser usado no método Swap com matrizes e vetores cujo tamanho total seja múltiplo de 6: 6, 12, 18, 24, etc.
   
   Vamos mostrar isso com um exemplo:
   

   //+------------------------------------------------------------------+
   //| Script program start function                                    |
   //+------------------------------------------------------------------+
   void OnStart()
    {
   //--- preenchemos a matriz 1x10 com o valor 7,0
     matrix m= matrix::Full(1, 10, 7.0);
     Print("matrix before Swap:\n", m);
   //--- tentamos realizar um intercâmbio entre uma matriz e um array
     double array_small[2][5]= {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
     Print("array_small before Swap:");
     ArrayPrint(array_small);
     if(m.Swap(array_small))
      {
       Print("array_small after Swap:");
       ArrayPrint(array_small);
       Print("matrix after Swap: \n", m);
      }
     else // o tamanho da matriz não é um múltiplo do tamanho da primeira dimensão do array
      {
       Print("m.Swap(array_small) failed. Error ", GetLastError());
      }
     /*
     matrix before Swap:
     [[7,7,7,7,7,7,7,7,7,7]]
     array_small before Swap:
              [,0]     [,1]     [,2]     [,3]     [,4]
     [0,]  1.00000  2.00000  3.00000  4.00000  5.00000
     [1,]  6.00000  7.00000  8.00000  9.00000 10.00000
     m.Swap(array_small) failed. Error 4006
     */
   //--- pegamos uma matriz maior e tentamos a realizar o intercâmbio novamente
     double array_static[3][10]= {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
        {2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
        {3, 6, 9, 12, 15, 18, 21, 24, 27, 30}
      };
     Print("array_static before Swap:");
     ArrayPrint(array_static);
     if(m.Swap(array_static))
      {
       Print("array_static after Swap:");
       ArrayPrint(array_static);
       Print("matrix after Swap: \n", m);
      }
     else // um array estático não pode ser usado para troca com uma matriz
      {
       Print("m.Swap(array_static) failed. Error ", GetLastError());
      }
     /*
     array_static before Swap:
            [,0]     [,1]     [,2]     [,3]     [,4]     [,5]     [,6]     [,7]     [,8]     [,9]
     [0,]  1.00000  2.00000  3.00000  4.00000  5.00000  6.00000  7.00000  8.00000  9.00000 10.00000
     [1,]  2.00000  4.00000  6.00000  8.00000 10.00000 12.00000 14.00000 16.00000 18.00000 20.00000
     [2,]  3.00000  6.00000  9.00000 12.00000 15.00000 18.00000 21.00000 24.00000 27.00000 30.00000
     m.Swap(array_static) failed. Error 4006
     */
   //--- outra tentativa de trocar um array e uma matriz
     double array_dynamic[][10];    // array dinâmico
     ArrayResize(array_dynamic, 3); // colocamos o tamanho da primeira dimensão
     ArrayCopy(array_dynamic, array_static);
   //--- agora usamos um array dinâmico para realizar o intercâmbio
     if(m.Swap(array_dynamic))
      {
       Print("array_dynamic after Swap:");
       ArrayPrint(array_dynamic);
       Print("matrix after Swap: \n", m);
      }
     else //  não há erros
      {
       Print("m.Swap(array_dynamic) failed. Error ", GetLastError());
      }
     /*
     array_dynamic after Swap:
           [,0]    [,1]    [,2]    [,3]    [,4]    [,5]    [,6]    [,7]    [,8]    [,9]
     [0,] 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000 7.00000
     matrix after Swap:
     [[1,2,3,4,5,6,7,8,9,10,2,4,6,8,10,12,14,16,18,20,3,6,9,12,15,18,21,24,27,30]]
     */
    }

4. Adicionados métodos LossGradient para vetores e matrizes. Este método calcula um vetor ou matriz de derivadas parciais da função de perda em relação aos valores previstos. Na álgebra linear, esse vetor é chamado de gradiente e é usado no aprendizado de máquina.
   

   vector vector::LossGradient(const vector &expected,ENUM_LOSS_FUNCTION loss) const;
   matrix matrix::LossGradient(const matrix &expected,ENUM_LOSS_FUNCTION loss) const;

5. Habilitado o uso de FOREIGN KEYS no SQLite, o que permite construir relacionamentos entre tabelas em consultas SQL.   Por exemplo:
   

   CREATE TABLE artist(
     artistid    INTEGER PRIMARY KEY, 
     artistname  TEXT
   );
   
   CREATE TABLE track(
     trackid     INTEGER, 
     trackname   TEXT, 
     trackartist INTEGER,
     FOREIGN KEY(trackartist) REFERENCES artist(artistid)
   );

   
   
6. Corrigida a seleção do método de classe necessário dependendo da constância do método e do objeto.
   
   

1. O tamanho do comentário com suporte foi aumentado para commits para MQL5 Storage.  Comentários detalhados ao enviar alterações ao repositório são considerados uma boa prática ao trabalhar em grandes projetos, mas essas mensagens eram anteriormente limitadas a 128 caracteres. O limite agora está definido para 260 caracteres.

1. Maior sensibilidade do interruptor de velocidade de teste no modo visual.

Correções de crash-logs.

1. Adicionado um novo relatório de histórico de negociação de conta. Em termos de parâmetros e apresentação de informações, é semelhante aos já conhecidos relatórios de Sinais. Agora na própria plataforma você terá acesso a:
   
   • Indicadores de crescimento mensais na forma de gráfico e tabela
     
   • Gráfico de capital líquido
   • Gráfico de radar que permite avaliar rapidamente o estado da conta
   • Estatísticas de negociação por instrumento
     
   • Muitos indicadores adicionais para análise de negociação
     
   
   O relatório agora pode ser visualizado diretamente na plataforma sem antes exportá-lo para um arquivo. Para abri-lo, clique em "Relatórios" no menu "Exibir".

   
   
   

   
   
2. Corrigido o preenchimento do quadro de opções quando o número ou tipo de instrumento não coincide entre os contratos Call e Put.
   
3. Corrigida a seleção de posição na caixa de diálogo de negociação ao fechar uma posição com uma oposta. Ocorria um erro ao classificar ordens opostas disponíveis por qualquer coluna que não seja o ticket.
   
4. Acelerada a exibição de entradas para o log da plataforma.
5. Corrigida a exibição de comentários em gráficos de símbolos personalizados.

1. Corrigido o trabalho da função CArrayList::LastIndexOf. Anteriormente, sempre retornava -1 em vez do índice do último elemento encontrado.
2. Adicionado método de atribuição de vetores e matrizes. Ele permite que você substitua o conteúdo de uma matriz/vetor pelos dados da matriz/vetor ou array passado.
   

   bool vector<TDst>::Assign(const vector<TSrc> &assign);
   bool matrix<TDst>::Assign(const matrix<TSrc> &assign);
   

   Por exemplo:
   

     //--- copying matrices
     matrix b={};
     matrix a=b;
     a.Assign(b);
     
     //--- copying an array to a matrix
     double arr[5][5]={{1,2},{3,4},{5,6}};
     Print("array arr");
     ArrayPrint(arr);
     b.Assign(arr);
     Print("matrix b \n",b);
   /*
   array arr
           [,0]    [,1]    [,2]    [,3]    [,4]
   [0,] 1.00000 2.00000 0.00000 0.00000 0.00000
   [1,] 3.00000 4.00000 0.00000 0.00000 0.00000
   [2,] 5.00000 6.00000 0.00000 0.00000 0.00000
   [3,] 0.00000 0.00000 0.00000 0.00000 0.00000
   [4,] 0.00000 0.00000 0.00000 0.00000 0.00000
   matrix b 
   [[1,2,0,0,0]
    [3,4,0,0,0]
    [5,6,0,0,0]
    [0,0,0,0,0]
    [0,0,0,0,0]]
   
   */

3. Adicionado método de vetores e matrizes CopyRates. Ele permite que você copie facilmente matrizes de dados de preços em vetores e matrizes.
   

   bool matrix::CopyRates(string symbol,ENUM_TIMEFRAMES period,ulong rates_mask,ulong from,ulong count);
   bool vector::CopyRates(string symbol,ENUM_TIMEFRAMES period,ulong rates_mask,ulong from,ulong count);

   O tipo de dados a ser copiado é especificado no parâmetro rates_mask usando a enumeração ENUM_COPY_RATES. Estão disponíveis os seguintes valores:
   
   COPY_RATES_OPEN
   COPY_RATES_HIGH
   COPY_RATES_LOW
   COPY_RATES_CLOSE
   COPY_RATES_TIME
   COPY_RATES_VOLUME_TICK
   COPY_RATES_VOLUME_REAL
   COPY_RATES_SPREAD
   COPY_RATES_OHLC
   COPY_RATES_OHLCT
   
   Os dois últimos valores se destinam à seleção conveniente de vários parâmetros da barra principal de uma só vez - preços Open, High, Low, Close e horário.
   
   Quando vários tipos de dados são selecionados (disponível apenas para matrizes), a ordem das linhas na matriz corresponderá à ordem dos valores na enumeração.
   
   
4. Corrigida a exibição de objetos "Rótulo de texto". Ao usar as propriedades OBJPROP_XOFFSET e OBJPROP_YOFFSET, um fragmento de imagem incorreto pode ser exibido no gráfico.
   
   

5. Corrigido o erro de alteração em um parâmetro constante passado para uma função como referência a um ponteiro de objeto.

   Lembre-se de que o especificador const declara variável constante e não permite alterar o valor desta variável durante a execução do programa. Apenas uma vez permitida a inicialização da variável quando ela é declarada. Exemplo de variáveis constantes na função OnCalculate:

   int OnCalculate (const int rates_total,      // price[] array size
                    const int prev_calculated,  // bars processed on previous call
                    const int begin,            // meaningful data starts at
                    const double& price[]       // array for calculation
      );
   

   Mas no exemplo abaixo, houve um erro do compilador que permitia a conversão implícita de ponteiro para parâmetros de referência:
   

   class A {};
   const A *a = new A;
   
   void foo( const A*& b )
     {
      b = a;
     }
   
   void OnStart()
     {
           A *b; 
           foo(b);  // não permitido
           Print( a,":",b );
     }

   Agora esta operação ilegal será detectada pelo compilador e gerará um erro.
   
   

1. Corrigida a exibição de referências a números complexos no depurador.
2. Aprimorado desempenho do MQL5 Cloud Protector. Anteriormente, a proteção de arquivos podia falhar em casos raros.
   
3. Correções de crash-logs.
   
   

Novo terminal web MetaTrader 5

Apresentamos um novo terminal web para o MetaTrader 5. Nós o fizemos moderno e rápido, atualizando não apenas o visual, mas também reescrevendo completamente o núcleo. Em termos de interface, o terminal web evoluiu de forma similar à já familiar versão iPad da plataforma:

Comparado com a versão antiga, tem muitos recursos novos:

• Pedido de contas reais, preenchendo um formulário de registro detalhado e fornecendo documentos comprobatórios
• Suporte para assinaturas de dados de preços e recepção de cotações com atraso
• Mais objetos analíticos, gerenciamento mais conveniente
• Exibição de entradas e saídas de mercado no gráfico
• Visualização de eventos de calendário econômico
• Configuração conveniente de instrumentos no Market Watch, visualização de alterações diárias de preços
• A interface foi significativamente simplificada: o menu de contexto do gráfico e o menu superior foram removidos; todos os comandos para gerenciar o gráfico, objetos e indicadores sobrepostos foram colocados nos painéis à esquerda e superior; o resto dos comandos estão em um menu de hambúrguer
• Tema da interface noturna

Terminal

1. Adicionada a abertura automática de tutorial ao se conectar a uma conta de negociação pela primeira vez. Isso permite que os iniciantes dominem rapidamente os fundamentos da negociação e se familiarizem com os recursos da plataforma diretamente no terminal. O tutorial é dividido em várias seções, cada uma das quais fornece informações breves. O progresso de cada tópico a aprender é mostrado com uma linha azul.
   
   

   

2. Corrigido o erro das operações em massa "Fechar posições lucrativas/não lucrativas". Anteriormente, a plataforma usava posições opostas, se houvesse, para fechar as posições correspondentes. Por exemplo, se você tivesse duas posições de compra não lucrativas em EURUSD e uma posição de venda lucrativa em EURUSD, todas as três posições existentes seriam encerradas durante o fechamento em massa de posições não lucrativas. A compra e a venda seriam fechadas com uma operação de fechamento com a posição oposta, e a compra restante seria fechada com uma operação de fechamento normal. Agora as equipes trabalham conforme o planejado, fechando apenas posições selecionadas - lucrativas ou não lucrativas.
   
3. Corrigida a exibição do histórico de preços para preços negativos em gráficos com período D1. Agora os gráficos com preços negativos são exibidos corretamente em todos os períodos gráficos.
   
4. Otimizado e reduzido significativamente o consumo de recursos do sistema pelo terminal.
   
5. O número de agregadores disponíveis para visualização de um instrumento de mercado foi ampliado para 15, o que permite encontrar informações sobre o número máximo de tickers nos agregadores econômicos mais populares.
   

   

   Existem pelo menos 7.000 ações líquidas e mais de 2.000 ETFs listados no mercado global. Além disso, existem muitos futuros e outros derivativos. A plataforma MetaTrader 5 contém um enorme banco de dados de instrumentos bolsistas e também permite que você acesse o site do agregador em um clique e, assim, obtenha dados fundamentais diretamente do Market Watch. Para conforto dos investidores, oferecemos uma variedade de fontes de informação para cada título.
   
   
6. Corrigida a substituição dos níveis de Stop Loss e Take Profit na janela para posicionar uma nova ordem. Agora, para contas operando no modo FIFO, os níveis de stop serão definidos automaticamente de acordo com os níveis de stop das posições já abertas para o mesmo instrumento. Isso é necessário para cumprir a regra FIFO.

1. : As funções matemáticas agora podem trabalhar com matrizes e vetores.
   
   Continuamos a expandir os recursos da plataforma MetaTrader 5 para negociação algorítmica e aprendizado de máquina. Anteriormente, adicionamos um novo tipo de dados, isto é, matrizes e vetores, que permitem abandonar o uso de matrizes para processamento de dados. Para trabalhar com ele, adicionamos mais de 70 métodos à linguagem MQL5 que permitem realizar cálculos de álgebra linear e estatística na forma de uma única operação. Agora multiplicação, transformação e solução de sistema de equações são feitas de forma simples e sem programação desnecessária. A adição de novos tipos não deixou de lado as funções matemáticas.
   
   As funções matemáticas foram originalmente projetadas para operações matemáticas em valores escalares. Agora, a maioria dessas funções pode ser usada com novos tipos de dados - matrizes e vetores - MathAbs, MathArccos, MathArcsin, MathArctan, MathCeil, MathCos, MathExp, MathFloor, MathLog, MathLog10, MathMod, MathPow, MathRound, MathSin, MathSqrt, MathTan, MathExpm1 , MathLog1p, MathArccosh, MathArcsinh, MathArctanh, MathCosh, MathSinh, MathTanh. Neste caso, a matriz ou vetor é processado termo a termo, por exemplo:
   

   //---
     matrix a= {{1, 4}, {9, 16}};
     Print("matrix a=\n",a);
   
     a=MathSqrt(a);
     Print("MatrSqrt(a)=\n",a);
     /*
      matrix a=
      [[1,4]
       [9,16]]
      MatrSqrt(a)=
      [[1,2]
       [3,4]]
     */

   No caso de MathMod e MathPow, um escalar, uma matriz ou um vetor de tamanho apropriado pode ser usado como segundo parâmetro.
   
   Vamos usar um exemplo para mostrar como calcular o desvio padrão usando funções matemáticas sobre um vetor.
   

   //+------------------------------------------------------------------+
   //| Script program start function                                    |
   //+------------------------------------------------------------------+
   void OnStart()
    {
   //--- используем инициализирующую функцию для заполнения вектора
     vector r(10, ArrayRandom); // массив случайных чисел от 0 до 1
   //--- вычислим среднее значение
     double avr=r.Mean();       // среднее значение массива
     vector d=r-avr;            // вычислим массив отклонений от среднего значения
     Print("avr(r)=", avr);
     Print("r=", r);
     Print("d=", d);
     vector s2=MathPow(d, 2);   // массив квадратов отклонений
     double sum=s2.Sum();       // сумма квадратов отклонений
   //--- вычислим стандартное отклонение 2-мя способами
     double std=MathSqrt(sum/r.Size());
     Print(" std(r)=", std);
     Print("r.Std()=", r.Std());    
    }
   /*
     avr(r)=0.5300302133243813
     r=[0.8346201971495713,0.8031556138798182,0.6696676534318063,0.05386516922513505,0.5491195410016175,0.8224433118686484,...
     d=[0.30458998382519,0.2731254005554369,0.1396374401074251,-0.4761650440992462,0.01908932767723626,0.2924130985442671, ...
      std(r)=0.2838269732183663
     r.Std()=0.2838269732183663
   */ 
   //+------------------------------------------------------------------+
   //| Заполняет вектор случайными значениями                           |
   //+------------------------------------------------------------------+
   void ArrayRandom(vector& v)
    {
     for(ulong i=0; i<v.Size(); i++)
       v[i]=double(MathRand())/32767.;
    }
   



2. As funções de modelo agora podem usar as entradas matrix<double>, matrix<float>, vector<double>, vector<float> em vez dos tipos matrix, matrixf, vector, vectorf correspondentes.
   

3. Aprimoradas as funções matemáticas para trabalhar com o tipo float. Devido ao surgimento da aplicação de funções matemáticas a matrizes e vetores flutuantes, as funções correspondentes aplicadas a escalares flutuantes também foram melhoradas. Anteriormente, os parâmetros dessas funções eram convertidos incondicionalmente no tipo double, a implementação correspondente da função matemática era chamada e, em seguida, o resultado era convertido no tipo float. Agora, no caso do tipo float, os parâmetros e resultados não são convertidos, pois são chamadas as implementações das funções matemáticas correspondentes ao tipo float.
   
   A diferença nos cálculos usando o exemplo de um seno matemático:
   

   //+------------------------------------------------------------------+
   //| Script program start function                                    |
   //+------------------------------------------------------------------+
   void OnStart()
    {
   //---  массив случайных чисел от 0 до 1
     vector d(10, ArrayRandom);
     for(ulong i=0; i<d.Size(); i++)
      {
       double delta=MathSin(d[i])-MathSin((float)d[i]);
       Print(i,". delta=",delta);
      }
    }
   /*
      0. delta=5.198186103783087e-09
      1. delta=8.927621308885136e-09
      2. delta=2.131878673594656e-09
      3. delta=1.0228555918923021e-09
      4. delta=2.0585739779477308e-09
      5. delta=-4.199390279957527e-09
      6. delta=-1.3221741035351897e-08
      7. delta=-1.742922250969059e-09
      8. delta=-8.770715820283215e-10
      9. delta=-1.2543186267421902e-08
   */
   //+------------------------------------------------------------------+
   //| Заполняет вектор случайными значениями                           |
   //+------------------------------------------------------------------+
   void ArrayRandom(vector& v)
    {
     for(ulong i=0; i<v.Size(); i++)
       v[i]=double(MathRand())/32767.;
    }

   
   
4. Adicionados métodos de matrizes e vetores Ativation (função de ativação) e Derivative (derivada da função de ativação) com parâmetros:
   

   AF_ELU	Exponential Linear Unit
   AF_EXP	Exponencial
   AF_GELU	Gaussian Error Linear Unit
   AF_HARD_SIGMOID	Hard Sigmoid
   AF_LINEAR	Linear
   AF_LRELU	Leaky REctified Linear Unit
   AF_RELU	REctified Linear Unit
   AF_SELU	Scaled Exponential Linear Unit
   AF_SIGMOID	Sigmoid
   AF_SOFTMAX	Softmax
   AF_SOFTPLUS	Softplus
   AF_SOFTSIGN	Softsign
   AF_SWISH	Swish
   AF_TANH	Hyperbolic Tangent
   AF_TRELU	Thresholded REctified Linear Unit

   Uma função de ativação em uma rede neural determina como a soma ponderada de um sinal de entrada é convertida no sinal de saída de um nó ou nós a nível da rede. A escolha da função de ativação tem um grande impacto nas capacidades e no desempenho da rede neural. Diferentes partes do modelo podem usar diferentes funções de ativação. A linguagem MQL5 implementa não apenas todas as funções de ativação conhecidas, mas também derivações da função de ativação. Funções derivadas são necessárias para calcular rapidamente a correção com base no erro recebido durante o treinamento da rede neural.
   
5. Adicionado método de matrizes e vetores Loss (função de perda) com os seguintes parâmetros:
   

   LOSS_MSE	Mean Squared Error
   LOSS_MAE	Mean Absolute Error
   LOSS_CCE	Categorical Crossentropy
   LOSS_BCE	Binary Crossentropy
   LOSS_MAPE	Mean Absolute Percentage Error
   LOSS_MSLE	Mean Squared Logarithmic Error
   LOSS_KLD	Kullback-Leibler Divergence
   LOSS_COSINE	Cosine similarity/proximity
   LOSS_POISSON	Poisson
   LOSS_HINGE	Hinge
   LOSS_SQ_HINGE	Squared Hinge
   LOSS_CAT_HINGE	Categorical Hinge
   LOSS_LOG_COSH	Logarithm of the Hyperbolic Cosine
   LOSS_HUBER	Huber

   
   A função de perda é responsável por avaliar quão bem o modelo prevê o valor real. Construir um modelo é basicamente resolver o problema de minimizar o valor dessa função em cada estágio. Dependendo do tipo de dados, você precisa usar abordagens diferentes, ou seja, funções diferentes. A função de perda também pode depender de pesos e tendências variáveis. A função de perda é unidimensional e não é um vetor porque avalia o desempenho da rede neural como um todo.
   
6. Adicionados métodos de matrizes e vetores matrix::CompareByDigits e vector::CompareByDigits. Eles comparam se dígitos significativos dos elementos de duas matrizes/vetores coincidem.
   
   
7. Adicionado suporte a funções MathMin e MathMax para strings. Nesse caso, as funções usarão comparação lexicográfica, isto é, as letras são comparadas alfabeticamente e diferenciam maiúsculas de minúsculas.
   
   
8. Aumentado o número máximo de objetos OpenCL de 256 para 65536. As CLContextCreate, CLBufferCreate e CLProgramCreate ajudam a criar identificadores para objetos OpenCL em programas MQL5. O limite anterior de 256 identificadores não permitia que você trabalhasse efetivamente em métodos de aprendizado de máquina.
   
   
9. Permitido usar OpenCL em placas sem suporte para double. Anteriormente, os programas MQL5 usavam apenas GPUs com suporte para double, embora muitas tarefas permitissem e fossem projetadas para cálculos usando floats. O tipo float é inicialmente considerado nativo para computação paralela, pois ocupa menos espaço. Este requisito já foi removido.
   
   Se uma tarefa precisar usar apenas uma GPU com suporte para double, isso poderá ser especificado explicitamente ao chamar CLContextCreate usando o novo valor CL_USE_GPU_DOUBLE_ONLY (somente dispositivos que suportam cálculos com o tipo double podem ser usados).
   

      int cl_ctx;
   //--- инициализация OpenCL контекста
      if((cl_ctx=CLContextCreate(CL_USE_GPU_DOUBLE_ONLY))==INVALID_HANDLE)
        {
         Print("OpenCL not found");
         return;
        }

   
   
10. Corrigido o trabalho da função CustomBookAdd. Anteriormente, se um valor zero fosse especificado no campo MqlBookInfo::volume_real, o devido instantâneo do livro de ofertas não era criado. Agora a verificação é feita assim:
    
    A exatidão dos dados transmitidos é verificada, sendo que o tipo, o preço e o volume devem ser indicados para cada elemento. Ao mesmo tempo, MqlBookInfo.volume e MqlBookInfo.volume_real não devem ser zero ou negativos: se ambos os volumes forem negativos, isso será considerado um erro. Você pode especificar qualquer um dos volumes ou ambos, pois é tomado o que é indicado ou positivo:
    
       volume=-1 && volume_real=2 — será usado volume_real=2,
    
       volume=3 && volume_real=0 — será usado volume=3.
    
    Volume com maior precisão MqlBookInfo.volume_real tem uma prioridade mais alta do que MqlBookInfo.volume normal. Se ambos os valores forem especificados para o elemento do livro de ofertas, será utilizado volume_real.
    
    Se pelo menos um elemento do livro de ofertas for descrito incorretamente, o sistema descartará completamente o estado transferido.
    
    
    
11. Corrigida a operação da função CalendarValueLast. O bug era que, em alguns casos, chamadas sucessivas para a função após alterações no calendário econômico (o parâmetro de alteração recebia um novo valor após a chamada) podiam ignorar eventos ao usar o filtro de moeda.
    

    CalendarValueLast(change, result, "", "EUR")

12. Corrigido o comportamento da função ArrayBSearch. Se houver vários elementos idênticos, será retornada uma referência ao primeiro e não, a um aleatório, como era antes.
13. Corrigida a visibilidade de função de modelo em uma classe. O erro era que as funções do modelo de classe declaradas como private/protected acabavam sendo de fato public (public).

1. Corrigidos bugs e comportamento ambíguo MetaAssist.
2. Adicionado suporte para a macro %terminal%, que significa o caminho para o diretório de dados da plataforma onde este terminal está instalado. Por exemplo, %terminal%\MQL5\Experts. 
   

   
   
   

3. Aprimorada a exibição de matrizes no depurador.
4. Aumento do buffer para copiar valores a partir do depurador.
   
5. Aprimoradas dicas de erro.
6. Caminhos relativos agora são escritos no arquivo de projeto *.mproj. Anteriormente, os caminhos eram absolutos, o que resultava em erros de compilação ao mover um projeto.
   
7. Adicionada incorporação automática de recursos BMP como matrizes de bitmap de 32 bits disponíveis globalmente quando incluídas em projetos. Isso elimina a necessidade de chamar ResourceReadImage no código para ler o recurso gráfico.
   

   'levels.bmp' as 'uint levels[18990]'
   

8. Aprimorada a leitura de formatos de arquivos BMP estendidos.
   
9. Traduções de IU atualizadas.
10. Correções de crash-logs.

Terminal

1. Aprimoradas as dicas de ferramentas para objetos de negociação exibidos em gráficos.
   
   • A exibição de lucro foi adicionada para negociações de saída do mercado.
     
   • Para as transações realizadas como resultado de um acionamento de Take Profit ou Stop Loss, foi adicionada a indicação correspondente - TP/SL.
     
   
   Dicas semelhantes foram adicionadas às linhas que conectam as negociações de entrada e saída.

   
   
   

   
   
2. Acelerado o trabalho do sistema gráfico.
3. Adicionado o registo em log de operações em massa sobre ordens e posições abertas. Ao executar esse comando, uma mensagem do tipo "bulk closing of XXX positions started" é registada no log.
4. Corrigido o fechamento de posições em massa por meio de posições contrárias.
5. Corrigida a atualização dos objetos que representam o histórico de negociação no gráfico. Esse erro ocorria quando o instrumento de negociação era alterado no gráfico.

MQL5

1. Continuamos a trabalhar nas funções para matrizes e vetores: adicionada o suporte a float e complex.
2. O operador "!" (LNOT) para ponteiros verifica agora se ele é válido através de uma chamada implícita da função CheckPointer. O operador "==" deve ser utilizado para verificar rapidamente se ele é NULL, assim: ptr==NULL ou ptr!=NULL.

MetaTester

1. Corrigida a exibição de objetos de transações no gráfico de teste.
2. Acelerado o funcionamento do sistema gráfico.

MetaEditor

• Atualizadas traduções da interface.

Correções de crash-logs.

1. Adicionada a capacidade de redimensionar o objeto gráfico "Rectângulo" arrastando qualquer um dos quatro cantos.
   

   
   

   
   
2. Acelerada a renderização da GUI.
   
3. Melhorado o suporte a endereços IPv6.
   
4. Corrigido o cálculo da altura do campo de data e a largura do campo de preço logo na primeira inicialização da plataforma.

1. Adicionada a função para manusear matrizes e vetores —  RegressionMetric. Ela especifica o cálculo para avaliar a regressão.
   

    double vector.RegressionError(const enum lr_error);
    double matrix.RegressionError(const enum lr_error);
    vector matrix.RegressionError(const enum lr_error,const int axis);

   Os cálculos que podem ser utilizados são:
   

   enum REGRESSION_ERROR
     {
      REGRESSION_MAE,     // Erro médio absoluto
      REGRESSION_MSE,     // Erro médio quadrático
      REGRESSION_RMSE,    // Raiz do erro médio quadrático
      REGRESSION_R2,      // R ao quadrado
      REGRESSION_MAPE,    // Erro médio absoluto em porcentagem
      REGRESSION_MSPE,    // Erro médio quadrático em porcentagem
      REGRESSION_RMSLE    // Erro médio logarítmico quadrático
     };

2. Adicionado o recurso para escrever matrizes com um tamanho de dados maior que INT_MAX (matrizes de estruturas).

1. Redesenhado o painel de guias:
   
   
   • O painel não fica oculto mesmo que apenas uma janela esteja aberta. Assim, os comandos do menu de contexto da guia estão sempre disponíveis.
   • Um botão "X" foi adicionado a cada guia para fechamento. Além disso, as guias podem ser fechadas com o botão do meio do mouse ou através do menu de contexto.
   
   
2. Adicionado o comando para a rápida compilação de programas. Nenhuma otimização de código é realizada neste modo, o que reduz significativamente o tempo necessário para criar um arquivo EX5 executável. Use este modo quando você estiver em um estágio ativo de desenvolvimento e precisar verificar o código escrito rapidamente. Já ao compilar o programa, mude para o modo de otimização máxima para obter o melhor desempenho.
   

   

   O parâmetro "Otimização máxima" nas configurações do projeto desempenha a mesma função.
   Todas as operações relacionadas à compilação foram colocadas no menu "Compilação".
   
   
3. Melhorado o gerenciamento de código:
   
   • Foram separados os comandos para acessar a declaração e a implementação. Anteriormente, era usado um comando que exibia um menu de seleção. Agora você pode pular imediatamente para a parte necessária do código.
     
   • Acrescentada a substituição de palavra-chave atribuída, pressionando "Tab", além de "Enter".
     

   

   
   
4. Adicionada a exibição automática de variáveis locais na lista de monitoramento do depurador. Para fazer isso, ative a opção "Locais" no menu de contexto. Durante a depuração, conforme você navega pelo código, as variáveis do escopo atual serão exibidas automaticamente na lista.
   

   
   
   

5. Melhorado o funcionamento da lista de monitoramento para vetores e matriz no depurador.
   
6. Corrigidos os caminhos para os arquivos de projeto. O erro podia acarretar o desaparecimento de arquivos.

1. Melhorada o desligamento de agentes de teste ao encerrar a plataforma.
2. Adicionado um quinto nó para a MQL5 Cloud Network, está localizado em Hong Kong. Isso acelerará a otimização dos robôs que utilizam a rede nas regiões mais próximas.

1. Corrigido o preenchimento dos níveis de Trailing Stop padrão no menu de contexto de ordens e posições abertas.
   

   
   
   

2. Atualizadas as traduções da interface do usuário.

1. Bate-papo embutido melhorado:
   
   • O design foi atualizado e as mensagens agora aparecem sem "nuvens", liberando a conversa de detalhes desnecessários. Adicionados avatares e separadores de datas.
   • Comandos de cópia e exclusão foram adicionados ao menu de mensagens.
   • Corrigidos erros e melhorada a estabilidade.

   
   

   
   
2. Corrigido o funcionamento do comando para o fechamento de posições em massa. O erro ocorria em contas com um sistema de registro de posições com cobertura.
3. Corrigido o cálculo de alguns tipos de negócios ao gerar o histórico de posições.

Terminal

1. Adicionados comandos para fechamento de posições e remoção de ordens pendentes em massa.
   
   No menu de contexto da seção de negociação, foi acrescentada uma nova seção, "Operações em massa". A lista de comandos disponíveis é gerada de forma inteligente, dependendo da operação selecionada e do seu tipo de conta.
   

   
   

   
   Os comandos estão sempre disponíveis no menu:
   
   • Fechamento de todas as posições. Para as contas de cobertura, o sistema primeiro tenta fechar posições com posições contrárias, e depois fecha as posições restantes de acordo com o procedimento normal.
   • Fechamento de todas as posições lucrativas e todas as posições desfavoráveis
   • Remoção de todas as ordens pendentes
   • Remoção de todas as ordens pendentes separadamente por tipo: Limit, Stop, Stop Limit
     
   
   Se uma posição for selecionada, comandos adicionais aparecem no menu:
   
   • Fechamento de todas as posições com o mesmo símbolo
   • Fechamento de todas as posições na mesma direção (para contas de cobertura)
   • Fechamento de posições contrárias com o mesmo símbolo (para contas de cobertura)
   • Reversão de posição (para contas de compensação)
     
   
   Se uma ordem pendente for selecionada, comandos adicionais aparecem no menu:
   
   • Remoção de todas as ordens pendentes com o mesmo símbolo
   • Remoção de todas as ordens pendentes com o mesmos tipo e símbolo
     
   
   
   Para que estes comandos funcionem, o usuário deve habilitar a negociação com um clique nas configurações da plataforma: Serviço \ Configurações \ Negociação.
   
2. Expandidas as funções de bate-papo embutidas:
   
   • Adicionada a opção de responder a mensagens. O texto da mensagem original será incluído na resposta como uma citação.
     
   • Adicionada a criação de mensagens com diferentes tipos de conteúdo: imagens com texto, texto com anexos, etc.
   • Corrigida a exibição do separador de mensagens lidas e não lidas.
     
   • Corrigidos vários erros e alcançada uma maior estabilidade.
     

   
   

   
   
3. Otimizada e significativamente acelerada a operação do sistema gráfico do terminal. Menos recursos serão gastos na exibição da interface.
4. Corrigido o cálculo da variação diária do preço de futuros. Se a corretora transmitir o preço de compensação, o cálculo será feito a partir dele.
   ((Last - preço de compensação)/preço de compensação)*100
   
   Você pode saber mais sobre o cálculo para cada tipo de instrumento na documentação.
   
   
5. Corrigidos erros ao adquirir serviços MQL5:
   
   • Em alguns casos, os sistemas de pagamento podiam exibir mensagens de erro incorretas relativas a operações bem sucedidas.
   • Em estágios intermediários de aluguel de produtos no Mercado, a página podia apresentar um preço incorreto.
     
   
   
6. Corrigido o funcionamento do botão "Iniciar" na página do produto comprado/descarregado via Mercado. Agora ele executa o aplicativo corretamente no primeiro dos gráficos abertos.
7. Corrigido o cálculo de alguns tipos de negócios ao gerar o histórico de posições.
   

1. Adicionadas novas funções para trabalhar usando matrizes e vetores:
   
   • Median — retorna a mediana dos elementos da matriz ou vetor
   • Quantile — retorna o q-ésimo quantil de elementos da matriz/vetor ou elementos ao longo do eixo matricial especificado
     
   • Percentile — retorna o q-ésimo percentil dos elementos da matriz/vetor ou elementos ao longo do eixo matricial especificado
   • Std — calcula o desvio padrão dos elementos de uma matriz ou vetor
   • Var — calcula a variância dos elementos de uma matriz ou vetor
   • CorrCoef — calcula o coeficiente de correlação de uma matriz ou vetor
     
   • Correlate — calcula a correlação cruzada dos dois vetores
     
   • Convolve — retorna uma convolução linear discreta de dois vetores
     
   • Cov — calcula a matriz de covariância
     
   
   
2. Continuam os trabalhos para adicionar métodos embutidos para matrizes numéricas. Isto ampliará a facilidade de escrita do código, o tornará mais compacto e melhorará a compatibilidade com outras linguagens.
   
   Atualmente, há três métodos disponíveis:
   
   • ArgSort — classifica a matriz por uma dada dimensão, por padrão pela mais recente (axis=-1).
     
   • Range — retorna o número de elementos na dimensão especificada da matriz. Análogo a ArrayRange.
     
   • Size — retorna o número de elementos da matriz. Análogo a ArraySize.
     
   
   Exemplo:
   

   void OnStart()
     {
      int arr[4][5]=
        {
           {22, 34, 11, 20,  1},
           {10, 36,  2, 12,  5},
           {33, 37, 25, 13,  4},
           {14,  9, 26, 21, 59}
        };
      ulong indexes[4][5];
   //--- Classificamos a matriz
      arr.ArgSort(indexes,-1,0);
      Print("indexes");  
      ArrayPrint(indexes);
     }
   
   // Resultado no log:
   // indexes
   //     [,0][,1][,2][,3][,4]
   // [0,]   4   2   3   0   1
   // [1,]   2   4   0   3   1
   // [2,]   4   3   2   0   1
   // [3,]   1   0   3   2   4

   
   
3. Em andamento esforços para acrescentar métodos embutidos para strings.
   
   Os seguintes métodos estão atualmente disponíveis:
   
   • BufferSize — retorna o tamanho do buffer alocado para a cadeia.
     
   • Compare — compara duas strings e retorna o resultado como um inteiro.
     
   • Length — retorna o número de caracteres na string.
   • Find — procura uma substring na string.
     
   • Upper — converte a string em maiúsculas.
     
   • Lower — Upper — converte a string em minúsculas.
     
   • Replace — substitui a substring.
     
   • Reserve — reserva um buffer para a string.
   
   Todos os métodos funcionam da mesma maneira que as funções de string.
   
   
   Exemplo:
   

   void OnStart()
     {
      string test="some string";
      PrintFormat("String length is %d",test.Length());
     }
   
   // Resultado no log:
   // String length is 11

4. Adicionado o valor SYMBOL_SUBSCRIPTION_DELAY à enumeração ENUM_SYMBOL_INFO_INTEGER — tamanho do atraso nas cotações transmitidas pelo símbolo.
   
   Usado somente para instrumentos baseados em assinaturas, geralmente, ao transmitir dados em modo de teste gratuito.
   
   A propriedade só pode ser consultada para símbolos selecionados na Observação do Mercado. Caso contrário, você receberá o erro ERR_MARKET_NOT_SELECTED (4302).
   
   
5. Adicionada a propriedade ACCOUNT_HEDGE_ALLOWED à propriedade ENUM_ACCOUNT_INFO_INTEGER — permissão para abrir posições opostas e ordens pendentes. Usado somente para contas de cobertura, permitindo a implementação das exigências de alguns reguladores quando a conta é proibida de ter posições opostas, mas permitido ter múltiplas posições do mesmo símbolo na mesma direção.
   
   Se esta opção for desativada, não é permitido que as contas tenham posições e ordens opostas para o mesmo instrumento ao mesmo tempo. Por exemplo, se houver uma posição Buy na conta, o usuário não poderá abrir uma posição Sell ou colocar uma ordem de venda pendente. Se o usuário tentar fazer isso, ele receberá o erro TRADE_RETCODE_HEDGE_PROHIBITED.
   
   
6. Acrescentadas novas propriedades à enumeração ENUM_SYMBOL_INFO_DOUBLE:
   
   • SYMBOL_SWAP_SUNDAY
   • SYMBOL_SWAP_MONDAY
   • SYMBOL_SWAP_TUESDAY
   • SYMBOL_SWAP_WEDNESDAY
   • SYMBOL_SWAP_THURSDAY
   • SYMBOL_SWAP_FRIDAY
   • SYMBOL_SWAP_SATURDAY
   
   Elas permitem que você obtenha a taxa de acumulação de swaps para cada dia da semana. 1 — único swap acumulado, 3 — triplo, 0 — sem acumulação.
   
   
7. Corrigido um bug, ao usar CopyTicks e CopyTicksRange, que fazia com que os dados desatualizados fossem dados à meia-noite. Ocorria quando não eram recebidos ticks do instrumento.
8. Correções de crash-logs.
   

1. Adicionadas as funções Min, Max, ArgMin, ArgMax e Sum para vetores e matrizes, que permitem encontrar valores mínimos e máximos, índices e soma correspondentes.
   
2. Adicionado suporte para métodos Flat para matrizes. Isto permite que um elemento matricial seja endereçado através de um único índice, e não através de dois.
   

   double matrix::Flat(ulong index) const;      // getter
   void matrix::Flat(ulong index,double value); // setter

   Pseudocódigo para calcular o endereço de um elemento da matriz:
   

   ulong row=index / mat.Cols();
   ulong col=index % mat.Cols();
   
   mat[row,col]

   Por exemplo, para uma matriz matrix mat(3,3) o acesso aos elementos pode ser registrado assim:
   

     para leitura —  x=mat.Flat(4), o que corresponde à expressão x=mat[1][1]
     para registro —  mat.Flat(5, 42), o que corresponde à expressão mat[1][2]=42
   
   Caso seja chamada uma função com um índice de matriz inválido, será gerado um erro crítico de
   execução - OutOfRange.
   
3. Melhorada a formatação de números fracionários nos parâmetros de entrada MQL5 do programa. Quando eram lidos alguns números reais, nos parâmetros de entrada eram substituídos números com mais zeros, por exemplo, 0,4 era representado como 0.400000000002.
   
4. Corrigidos bugs da biblioteca matemática Math\Stat\Math.mqh. Além disso, foi modificada a função MathSample desta biblioteca para corresponder ao comportamento clássico do mesmo tipo de bibliotecas matemáticas quando da amostragem com retorno.
   
5. Corrigido um bug ao usar CopyTicks/CopyTicksRange, este erro fazia com que os dados desatualizados fossem dados à meia-noite para aqueles casos em que não eram recebidos ticks do instrumento.
6. Acrescentados os novos valores INDICADOR_FIXED_MINIMUM e INDICADOR_FIXED_MAXIMUM à enumeração ENUM_CUSTOMIND_PROPERTY_INTEGER.
   Estas propriedades são utilizadas para habilitar/desabilitar a fixação dos valores mínimos e máximos do indicador através da função IndicatorSetInteger. Ao chamar IndicatorSetInteger(INDICATOR_FIXED_MINIMUM/INDICATOR_FIXED_MAXIMUM, true) é usado o valor mínimo/máximo atual, respectivamente.
   

   
   

   
   

Tester

1. Alterado o algoritmo de cálculo Sharpe Ratio, agora é calculado da maneira clássica e seu valor é reduzido ao intervalo anual. O algoritmo anterior se baseava no PnL (spread of profits and losses), mas não levava em conta as flutuações do capital líquido em posições abertas. Agora são levados em conta os altos e baixos do capital líquido, e o valor do próprio índice de Sharpe é tratado classicamente:
•  Sharpe Ratio < 0              Estratégia não lucrativa, não é boa.  Ruim.
  
•  0 < Sharpe Ratio  < 1.0    Risco não compensa. Tais estratégias podem ser tomadas para operar se não houver alternativas.  Incerto.
  
• Sharpe Ratio ≥ 1.0            Caso o índice de Sharpe seja maior que um, o risco está compensando, a carteira/estratégia está funcionando. Bom.
  
• Sharpe Ratio ≥ 3.0            Um número alto indica que a probabilidade de ocorrência de uma perda em qualquer negócio em particular é muito baixa. Muito bom
  
  

1. Otimizado o consumo de memória do terminal.
   
2. Aprimorado o funcionamento do subsistema de rede para melhorar o desempenho e reduzir a latência da rede.
   
3. Removida a exibição do zero da grade no indicador quando a renderização da grade estiver desativada.

1. Adicionada a ativação da janela do gráfico ao soltar nela quer seja um símbolo desde a "Observação do mercado" ou uma operação de negociação desde o histórico da conta.
   
   Ambas as ações alteram o símbolo do gráfico para o selecionado. Anteriormente, isso não causava que a janela do gráfico ficasse ativa. Assim, algumas ações adicionais, como chamar a caixa de diálogo de negociação (F9) ou alterar a escala (+/-) usando teclas de atalho, podem ser aplicadas inesperadamente a outro gráfico para o usuário. Agora, após arrastar o gráfico do símbolo alterado, este fica imediatamente selecionado.
   
   
2. Adicionada a abertura de uma nova janela de ordem ao clicar duas vezes em uma operação no histórico da conta. O instrumento financeiro da operação em que você clicou é imediatamente substituído na caixa de diálogo, permitindo negociar mais rapidamente. Um comando semelhante foi adicionado ao menu de contexto.
   

   
   
   

   
   
3. Adicionada a inclusão inteligente de volumes reais ou de ticks ao abrir novos gráficos. Esses dados são importantes na hora de analisar o mercado, porém, nem todos os traders estão cientes de sua disponibilidade na plataforma.
   
   A prioridade é dada aos volumes reais de negociação. Se forem fornecidos por uma corretora, sua exibição será habilitada no gráfico. Caso contrário, será habilitada a exibição de volumes de ticks.
   
   O mecanismo é usado apenas se o gráfico for aberto como modelo default.tpl. Se o usuário desabilitar manualmente a exibição de volumes nas configurações do gráfico, ele não será habilitado novamente quando for reaberto. Os modelos personalizados não são afetados.
   
   
4. Corrigida e significativamente acelerada a exibição da interface do usuário.
5. Aprimorada a função de impressão de gráfico, chamada através do menu "Arquivo":
   
   • Corrigido o salvamento das configurações de impressão
   • Melhorada a aparência da página impressa: ampliadas linhas de grade, escondido nome do programa, atualizada fonte do cabeçalho
     
   • Aumentada a caixa de diálogo de impressão para exibir a interface corretamente
     
   
   
6. Corrigido o funcionamento do campo de volume no painel de negociação rápida no gráfico. Anteriormente, após inserir um novo valor e pressionar a tecla Tab, o valor era redefinido para o valor anterior.
7. Corrigida a exibição de histórico de negociação no gráfico. Anteriormente, ao alternar entre contas, as operações da conta anterior não eram removidas dos gráficos.
8. Corrigido o pagamento de serviços da MQL5.com via PayPal.
9. Corrigido o congelamento da plataforma ao exibir o gráfico de volatilidade de opções.
10. Corrigida a verificação de número de telefone na janela de registro da conta real. Em alguns casos, após inserir o número certo, a plataforma não permitia avançar para a próxima etapa do registro.
11. Corrigida a verificação de direitos ao entrar em um bate-papo em grupo com membros da comunidade MQL5.com. Anteriormente, um usuário recém-conectado só podia ler, mas não escrever mensagens.
12. Substituído o rótulo no gráfico na ausência de dados. Agora, o nome, o timeframe e a descrição do instrumento são exibidos em vez de "Waiting for update".
13. Melhorado o suporte de preços negativos, adicionado no build 2450. Para os respectivos instrumentos, a "Observação do mercado" agora também pode exibir valores zero.
14. Corrigida a exibição de logotipos de produtos no Mercado ao trabalhar no Wine.

1. Continuamos a trabalhar o suporte para vetores e matrizes. As novas funções ampliam significativamente as possibilidades para desenvolvedores de soluções baseadas em redes neurais.
   
   Já existem muitas funcionalidades neste momento:
   
   • Eye — cria uma matriz com uns na diagonal especificada e zeros nos outros lugares.
   • Identity — cria uma matriz com o tamanho especificado com uns na diagonal principal e zeros nos outros lugares.
   • Ones — cria uma matriz com o tamanho especificado, preenchida com uns.
   • Zeroes — cria uma matriz com o tamanho especificado, preenchida com zeros.
   • Full — cria uma matriz com o tamanho especificado, preenchida com os valores especificados.
   • Copy — cria uma cópia de uma matriz ou de um vetor.
   • Diag — extrai uma diagonal de uma matriz, e preenche a diagonal especificada com valores provenientes de um vetor.
   • Tri — cria uma matriz com uns na diagonal especificada e sob ela e zeros nos outros lugares.
   • Row — retorna uma linha de matriz como um vetor, e preenche a linha especificada com valores provenientes de um vetor.
   • Col — retorna uma coluna de matriz como um vetor, e preenche a coluna especificada com valores provenientes de um vetor.
   • Rows — retorna o número de linhas em uma matriz.
   • Cols — retorna o número de colunas em uma matriz.
   • Transpose — transposição da matriz.
   • * — produto de matrizes, de vetores e de escalares — produto dot.
   • Power — exponenciação de matriz.
   • Kron — produto de Kronecker.
   • Cholesky — decomposição de Cholesky.
   • QR — fatoração QR.
   • SVD — decomposição SVD.
   • LU — decomposição LU.
   • LUP — decomposição LUP.
   • Norm — cálculo de norma de matriz.
   • Cond — cálculo de número de condição de matriz.
   • Spectrum — cálculo de espetro de matriz.
   • Det — cálculo de determinante de matriz.
   • Rank — cálculo de posto de matriz.
   • SLogDet — obtém o sinal e o logaritmo de um determinante de matriz
   • Trace — cálculo de traço de matriz.
   • Solve — solução de sistemas de equações lineares.
   • LstSq — solução de sistemas de equações lineares pelo método dos mínimos quadrados.
   • Inv — cálculo de inversa de matriz.
   • PInv — cálculo de pseudoinverso pelo método Moore-Penrose
   • Compare — comparação de duas matrizes pelo método Épsilon.
   
   Informações detalhadas sobre a formatação estão disponíveis na documentação MQL5:
   
   
2. Corrigidos erros ao trabalhar usando arquivos e bancos de dados relacionados à restrição de comprimento de caminho. Em particular, a função DatabaseOpen permitia definir um caminho maior que o permitido, causando a criação incorreta do banco de dados. A função agora retornará corretamente o código de erro ERR_TOO_LONG_FILE_NAME.
   
3. Corrigido o controle de constância de variáveis. Em alguns casos, o compilador podia não gerar o erro "constant variable cannot be passed as reference".
4. Corrigidos avisos errôneos do compilador sobre o uso de uma variável não inicializada.
   
5. Corrigido o funcionamento da função ChartWindowOnDropped para indicadores. Anteriormente, sempre retornava valor zero.
   
6. Adicionado ao módulo de integração com Python o suporte para Python 3.10.

1. Corrigida a exibição do item VPS no Navegador. Em alguns casos, desaparecia ao alternar entre contas.

MetaEditor

1. Corrigida expansão de expressões complexas na janela de visualização durante a depuração.
   

1. Corrigida a exportação de relatórios de teste para um arquivo. Alguns valores eram arredondados incorretamente quando uma moeda com 0 casas decimais era usada como moeda de depósito. Por exemplo, o JPY.
   

1. Corrigida a transição para uma página em branco após a compra de serviços MQL5. Os usuários agora serão diretamente reencaminhados para os resultados da operação.
2. Corrigida a compressão excessiva de imagens de documentos carregadas ao solicitar contas reais. Isso melhorou a qualidade das verificações KYC automatizadas e a velocidade de tomada de decisão.
3. Corrigido o funcionamento do gráfico aberto quando o teste é concluído.

1. Adicionado suporte para SQLite 3.36.0.

1. Adicionado destaque de fundo para parêntesis emparelhados. Para habilitar vá para as configurações gerais do MetaEditor.
2. Aprimorado o desempenho do depurador de programas MQL5.

1. Corrigido um bug que em alguns casos acabava por fazer desaparecer ferramentas de negociação personalizadas.
2. Aprimorados ícones de menu e de barra de ferramentas.
3. Adicionados três novos idiomas no MQL5.com: francês, italiano e turco.
   
   Já é o decimo primeiro idioma disponível na maior comunidade de traders - MQL5.community. Traduzimos completamente a interface e a documentação do site, bem como várias dezenas de tópicos importantes do fórum. A tradução de artigos e calendário econômico estará disponível em breve.
   
   
4. Correções de crash-logs.
   

1. Corrigidos bugs que causavam problemas com a função StringConcatenate.
2. Corrigida a configuração do valor _LastError ao usar a função FileSave. Em alguns casos, em vez de descrever o erro ocorrido na função, a variável acabava por conter um valor nulo.
3. Corrigida a importação de dados desde recursos em matrizes de tipo double.

1. Corrigido um erro que fazia com que a janela do gráfico travasse durante o teste visual.

Terminal

Terminal

1. Adicionada a possibilidade de receber notificações Push sobre operações a partir do servidor de negociação - funcionam mesmo quando o terminal está desligado.
   

   
   

   
   Anteriormente, você só podia receber notificações em dispositivos móveis a partir de seu próprio terminal desktop. Assim que uma operação comercial era realizada, o terminal enviava uma mensagem para a MetaQuotes ID especificada nas configurações. Consequentemente, isso só funcionava enquanto permanecia ligado. Agora não existem tais restrições. Se um Take Profit for acionado no servidor e seu computador estiver desligado, você receberá uma notificação sobre o fechamento da posição em seu dispositivo móvel.
   
   Para receber notificações do servidor, você deve:
   
   • Ter uma conta real, uma vez que as notificações vindas do servidor não funcionam para contas de demonstração
     
   • Instalar o terminal móvel MetaTrader 5 em seu smartphone para iOS ou Android
   • Abrir a seção de mensagens, encontrar sua MetaQuotes ID e especificá-la nas configurações do terminal desktop
   • Habilitar as notificações do servidor nas configurações do terminal desktop
     
   
   A disponibilidade e os detalhes das notificações dependem da sua corretora
   
   São suportados três tipos de notificações: sobre ordens, sobre operações e sobre operações de balanço. Se esta opção estiver ativada, os tipos de notificações disponíveis serão exibidos no log do terminal:
   '1222': subscribed to deals, orders, balance notifications from trade server
   
   
   
2. Atualizamos o mostruário do VPS MetaTrader, tornando-o mais moderno e conveniente:
   
   • A interface se adapta a qualquer largura de tela.
   • O mostruário ocupa menos espaço em altura para caber sempre na janela de trabalho.
   • As informações necessárias aparecem apenas no momento em que são requeridas. Até que você tenha escolhido uma tarifa, não serão mostrados detalhes adicionais de pagamento.
     

   
   

   
   
3. Comandos para mudança rápida para serviços MQL5 e a janela "Ferramentas" foram adicionados ao painel do Testador de Estratégia. Eles são exibidos apenas na seção "Visão Geral"; nas outras guias, o painel é usado para gerenciar os testes.
   

   
   

   
   
4. Adicionado o estado salvo de janela para serviços MQL5. Se você deixar o Mercado aberto antes de desligar o terminal, irá encontrá-lo no mesmo estado na próxima vez que o ligar.
   
5. Corrigida a sincronização periódica do estado de uma conta MQL5. Em alguns casos, o erro podia impedir a cópia de sinais.
6. Corrigida a exibição de uma seleção de produtos recomendados no Mercado.
7. Corrigido o funcionamento do menu de contexto de sinais no Navegador. Usando-o, você pode ir para ver o sinal ao qual você está inscrito, bem como cancelar a inscrição.
   

1. Corrigido erro no funcionamento do operador "-" durante a implementação de números complexos na biblioteca padrão (arquivo MQL5\Include\Math\Alglib\complex.mqh).
2. Agora você pode usar qualquer expressão na inicialização de seqüências, não apenas constantes. Isto melhorará a usabilidade e a compatibilidade com o código C++.
   

   struct POINT
     {
      int x,y;
     };
   
   int GetYFunc(y)
     {
      return(y * y);
     }
   
   void SomeFunction(int x1,int x2,int y)
     {
      POINT pt={ x1+x2, GetYFunc(y) };
      ProcessPoint(pt);
     };

3. Corrigido um erro que ocorria durante a compilação union ao manipular grandes quantidades de dados.
4. Corrigida a operação da função StringToCharArray. Agora ela converte toda a string passada numa matriz Char, em vez de parar no primeiro caractere nulo de término.
   
5. Adicionado controle sobre a presença explícita de uma chamada de construtor no código para classes/estruturas cuja a classe pai não tem um construtor padrão.
   

1. Adicionada exibição do local de chamada para funções inline no relatório do criador de perfil.
   No exemplo abaixo, a chamada de func(); agora é destacada:
   

   
   
   

   
   A função func em si não é destacada, pois seu código está completamente colocado em OnStart.
   
   
2. Adicionada a capacidade de criar um projeto em branco. Isso será útil para o desenvolvimento fora do padrão com sua própria estrutura de arquivo, quando os modelos padrão não são adequados.
   

   
   

   
   Quando você cria um projeto desta forma, apenas um arquivo de configurações vazio "mqproj" é criado. Os arquivos para o código fonte devem ser criados por você mesmo depois.
   
   
3. Acelerada a inicialização do MetaEditor.
4. Corrigido um erro de exibição de dados na lista de expressões observadas durante a depuração. Em alguns casos, podia mostrar valores das variáveis de maneira incorreta.
5. Corrigida a adição automática da extensão ".py" aos arquivos de scripts em Python criados usando o MQL Wizard.