O que há de novo no MetaTrader 5?
Histórico de atualizações das plataformas desktop, móvel e web
21 fevereiro 2019
MetaTrader 5 build 2005: calendário econômico, programas MQL5 como serviços e APIs para linguagem R
Terminal
- Calendário econômico embutido totalmente atualizado.
O Calendário econômico foi desenvolvido propriamente por nós. Mais de 600 indicadores e indicadores das 13 principais economias do mundo estão disponíveis: os EUA, a União Europeia, o Japão, a Grã-Bretanha, o Canadá, a Austrália, a China, etc. Todos os dados são coletados em tempo real a partir de fontes abertas.
Além de atualizar o conteúdo, filtros de eventos avançados estão disponíveis no calendário: por hora, por prioridade, por moeda e por país.
Além disso, os dados do calendário agora podem ser consultados em programas MQL5. Mais informações sobre isso são fornecidas abaixo.
- Adicionado um novo tipo de programa MQL5, Serviços. Eles permitem que você crie suas próprias fontes de preços para o terminal, transferindo preços vindos de sistemas externos em tempo real, como fazem os servidores de negociação das corretoras.
Ao contrário de EAs, de indicadores e de scripts, os serviços não estão vinculados a um gráfico específico. Eles correm em segundo plano e começam a trabalhar automaticamente quando é iniciado o terminal (se eles não foram forçados a parar).
Para gerenciar serviços, ao Navegador foi adicionada uma subseção:
Criação de serviços
Para criar um modelo de serviço, use o item correspondente em Assistente MQL5. Serviços têm um ponto de entrada OnStart semelhante a scripts. Nele, você pode organizar um loop interminável de recebimento e processamento de dados usando funções de rede.
Inicialização de serviços
Para iniciar várias cópias de um EA ou indicador com parâmetros diferentes, basta colocá-lo em gráficos diferentes. Isso cria instâncias separadas do programa, que operam independentemente umas das outras. Os serviços não estão vinculados a gráficos, portanto, é fornecido um mecanismo separado para criar suas instâncias.
Selecione serviço no navegador e clique em "Adicionar serviço" em seu menu de contexto. Uma caixa de diálogo padrão do programa MQL5 é aberta, nela você pode ativar/desativar a negociação e o acesso a sinais, bem como definir parâmetros.
Para iniciar e parar a instância do serviço, use seu menu. Para gerenciar todas as instâncias, use o menu do próprio serviço.
- Adicionado sistema de educação.
Agora os iniciantes podem aprender facilmente como trabalhar com a plataforma. Nós adicionamos mais de 100 dicas interativas nas principais funções.
- As dicas não distraem do trabalho com a plataforma, pois elas são incorporadas na barra de ferramentas na forma de uma barra de progresso.
- As dicas são exibidas apenas para ações que você ainda não realizou na plataforma.
- Links interativos são incorporados nas dicas para ir a elementos específicos da interface da plataforma. Por exemplo, diretamente do EA, você pode abrir um diálogo de negociação ou um menu com o comando desejado.
- O histórico da conta de negociação pode ser representado como posições — a plataforma coleta dados sobre transações relacionadas à posição (abertura, aumento, fechamento parcial e total) e agrupa esses dados em um único registro. Isso facilita a visualização do horário de abertura e fechamento de posições, seu volume, preço e resultado total. Essa exibição agora também está disponível em relatórios de histórico exportados para arquivos.
- Adicionada uma API para solicitar dados do terminal MetaTrader 5 através de aplicativos usando linguagem R.
Nós preparamos um pacote MetaTrader especial. Ele contém uma DLL para interação entre o terminal R e o terminal MetaTrader 5, bem como documentação e arquivos auxiliares-r. O pacote está atualmente no processo de registro no repositório CRAN e, em breve, estará disponível para download e instalação.
Para instalar um pacote, use o seguinte comando:
R CMD INSTALL --build MetaTrader
Atualmente, os seguintes comandos estão disponíveis para consulta de dados:
- MT5Initialize — inicializa e estabelece uma conexão com o terminal MetaTrader 5. Quando o comando é executado, o terminal é iniciado, se necessário.
- MT5Shutdown — desinicialização e desconexão do terminal MetaTrader 5.
- MT5Version — obtém a versão do terminal MetaTrader 5.
- MT5TerminalInfo — obtém o status e os parâmetros de conexão do terminal ao servidor da corretora (número da conta e endereço do servidor).
- MT5WaitTerminal — aguarda a conexão do terminal MetaTrader 5 com o servidor da corretora.
- MT5CopyTicksFrom(symbol, from, count, flags) — copia os ticks com a data especificada no valor especificado. A data é especificada em milissegundos desde 1970.01.01.
- MT5CopyTicksRange(symbol, from, to, flags) — copia ticks a partir do período de data especificado. A data é especificada em milissegundos desde 1970.01.01.
- MT5CopyRatesFrom(symbol, timeframe, from, count) — copia as barras de minuto de uma data especificada no valor especificado. A data é indicada em segundos desde 1970.01.01.
- MT5CopyRatesFromPos(symbol, timeframe, start_pos, count) — copia as barras de minuto de uma posição especificada começando com última barra.
- MT5CopyRatesFromRange(symbol, timeframe, date_from, date_to) — copia barras do período de data especificado. As datas são especificadas em segundos desde 1970.01.01.
No futuro, a lista de comandos suportados será expandida.
- Otimizado o diálogo fechar posição de negociação usando outra oposta. Agora seu trabalho não diminui com um grande número de posições abertas.
- Corrigidos erros de cálculo de instrumentos sintéticos, o que levava à formação de omissão de dados.
- Agora, ao excluir instrumentos personalizados, são excluídos os arquivos com seu histórico de ticks e de barras. Isso evita o acúmulo de dados não utilizados no disco rígido.
- Corrigida a exibição de resultados de pesquisa em monitores de alta DPI.
MQL5
- Adicionado acesso a dados do calendário econômico através de programas MQL5.
Novos recursos
CalendarCountryById — obtém a descrição do país por identificador.
bool CalendarCountryById( const long country_id, // identificador do país MqlCalendarCountry& country // descrição do país );
CalendarEventById — obtém a descrição do evento por identificador.
bool CalendarEventById( const long event_id, // identificador do evento MqlCalendarEvent& event // descrição do evento );
CalendarValueById — obtém a descrição do valor do evento por identificador.
bool CalendarValueById( const long value_id, // identificador do valor MqlCalendarValue& value // descrição do valor );
CalendarEventByCountry — obtém um array de notícias disponíveis por país.
bool CalendarEventByCountry( string country_code, // código do país MqlCalendarEvent& events[] // matriz do evento );
CalendarEventByCurrency — obtém um array contendo as notícias disponíveis da moeda, que elas afetam.
bool CalendarEventByCurrency( string currency, // moeda MqlCalendarEvent& events[] // matriz de eventos );
CalendarValueHistoryByEvent — obtém um array de valores para o período especificado de acordo com o identificador do evento.
bool CalendarValueHistoryByEvent( ulong event_id, // identificador do evento MqlCalendarValue& values[], // matriz de valores datetime datetime_from, // data inicial datetime datetime_to=0 // data final );
CalendarValueHistory — obtém um array de valores de todos os pelo período definido com filtragem por país e/ou moeda.
bool CalendarValueHistory( MqlCalendarValue& values[], // matriz de valores datetime datetime_from, // início do período datetime datetime_to=0, // fim do período string country_code=NULL, // código do país string currency=NULL // moeda );
CalendarValueLastByEvent — obtém o array dos últimos valores de evento por identificador. Esse recurso permite consultar apenas os valores que foram alterados desde a última consulta. Para fazer isso, é usado seu in/out parâmetro "change_id".
Toda vez que o banco de dados do calendário é alterado, a propriedade "change_id" é alterada — identificador da última alteração. Ao solicitar dados, você especifica "change_id" e o terminal retorna os eventos que aparecem no calendário a partir desse momento, bem como o valor atual de "change_id", que pode ser usado para a próxima solicitação. Ao chamar a função pela primeira vez, especifique um zero "change_id", assim, a função não retorna nenhum evento, mas fornece o "change_id" atual para as próximas solicitações.
bool CalendarValueHistory( ulong event_id, // identificador do evento ulong& change_id, // identificador do último valor do calendário MqlCalendarValue& values[] // matriz de valores );
CalendarValueLast — obtém o array dos últimos valores de todos os eventos com filtragem por país e/ou moeda. Esse recurso permite consultar apenas os valores que foram alterados desde a última consulta. Semelhante a CalendarValueLastByEvent, a propriedade "change_id" é usada para a consulta.
bool CalendarValueHistory( ulong event_id, // identificador do evento ulong& change_id, // ID da última alteração do calendário MqlCalendarValue& values[], // matriz de valores string country_code=NULL, // código do país string currency=NULL // moeda );
Novas estruturas
MqlCalendarCountry — descrição do país.
struct MqlCalendarCountry { ulong id; // identificador do país ISO 3166-1 string name; // nome do país string code; // código do país ISO 3166-1 alpha-2 string currency; // código da moeda do país string currency_symbol; // símbolo da moeda do país string url_name; // nome do país usado no URL no site mql5.com };
MqlCalendarEvent — descrição do evento.
struct MqlCalendarEvent { ulong id; // identificador do evento ENUM_CALENDAR_EVENT_TYPE type; // tipo de evento ENUM_CALENDAR_EVENT_SECTOR sector; // setor ao qual está relacionado o evento ENUM_CALENDAR_EVENT_FREQUENCY frequency; // frequência de publicação de eventos ENUM_CALENDAR_EVENT_TIMEMODE time_mode; // modo de publicação de eventos por horário ulong country_id; // identificador do país ENUM_CALENDAR_EVENT_UNIT unit; // medida do valor do evento ENUM_CALENDAR_EVENT_IMPORTANCE importance; // importância do evento ENUM_CALENDAR_EVENT_MULTIPLIER multiplier; // multiplicador do valor do evento uint digits; // número de casas decimais no valor do evento string source_url; // URL da fonte string event_code; // código do evento string name; // nome do evento na linguagem do terminal };
MqlCalendarValue — descrição do valor do evento.
struct MqlCalendarValue { ulong id; // identificador do valor ulong event_id; // identificador do evento datetime time; // hora e data do evento datetime period; // período de relatório do evento int revision; // revisão do indicador publicado em relação ao período de relatório long actual_value; // valor atual do evento long prev_value; // valor anterior do evento long revised_prev_value; // valor anterior revisado para o evento long forecast_value; // valor previsto do evento ENUM_CALENDAR_EVENT_IMPACRT impact_type; // impacto potencial na taxa de câmbio };
Novas enumerações
enum ENUM_CALENDAR_EVENT_FREQUENCY { CALENDAR_FREQUENCY_NONE =0, // não é usado CALENDAR_FREQUENCY_WEEK =1, // semana CALENDAR_FREQUENCY_MONTH =2, // mês CALENDAR_FREQUENCY_QUARTER =3, // trimestre CALENDAR_FREQUENCY_YEAR =4, // ano CALENDAR_FREQUENCY_DAY =5, // dia }; enum ENUM_CALENDAR_EVENT_TYPE { CALENDAR_TYPE_EVENT =0, // evento (reunião, discurso, etc.) CALENDAR_TYPE_INDICATOR =1, // indicador CALENDAR_TYPE_HOLIDAY =2, // feriado }; enum ENUM_CALENDAR_EVENT_SECTOR { CALENDAR_SECTOR_NONE =0, // não CALENDAR_SECTOR_MARKET =1, // mercado CALENDAR_SECTOR_GDP =2, // PIB CALENDAR_SECTOR_JOBS =3, // trabalho CALENDAR_SECTOR_PRICES =4, // preços CALENDAR_SECTOR_MONEY =5, // dinheiro CALENDAR_SECTOR_TRADE =6, // negociação CALENDAR_SECTOR_GOVERNMENT =7, // governo CALENDAR_SECTOR_BUSINESS =8, // negócio CALENDAR_SECTOR_CONSUMER =9, // usuário CALENDAR_SECTOR_HOUSING =10, // habitação CALENDAR_SECTOR_TAXES =11, // impostos CALENDAR_SECTOR_HOLIDAYS =12, // feriados }; enum ENUM_CALENDAR_EVENT_IMPORTANCE { CALENDAR_IMPORTANCE_NONE =0, // não CALENDAR_IMPORTANCE_LOW =1, // baixo CALENDAR_IMPORTANCE_MODERATE =2, // médio CALENDAR_IMPORTANCE_HIGH =3, // alto }; enum ENUM_CALENDAR_EVENT_UNIT { CALENDAR_UNIT_NONE =0, // não CALENDAR_UNIT_PERCENT =1, // porcentagem CALENDAR_UNIT_CURRENCY =2, // moeda nacional CALENDAR_UNIT_HOUR =3, // quantidade de horas CALENDAR_UNIT_JOB =4, // número de empregos CALENDAR_UNIT_RIG =5, // número de torres CALENDAR_UNIT_USD =6, // dólares estadunidenses CALENDAR_UNIT_PEOPLE =7, // número de pessoas CALENDAR_UNIT_MORTGAGE =8, // número de empréstimos hipotecários CALENDAR_UNIT_VOTE =9, // número de votos CALENDAR_UNIT_BARREL =10, // número de barreis CALENDAR_UNIT_CUBICFEET =11, // pés cúbicos CALENDAR_UNIT_POSITION =12, // número de empregos CALENDAR_UNIT_BUILDING =13 // número de edifícios }; enum ENUM_CALENDAR_EVENT_MULTIPLIER { CALENDAR_MULTIPLIER_NONE =0, // não CALENDAR_MULTIPLIER_THOUSANDS =1, // miles CALENDAR_MULTIPLIER_MILLIONS =2, // milhões CALENDAR_MULTIPLIER_BILLIONS =3, // bilhões CALENDAR_MULTIPLIER_TRILLIONS =4, // trilhões }; enum ENUM_CALENDAR_EVENT_IMPACRT { CALENDAR_IMPACT_NA =0, // desconhecido CALENDAR_IMPACT_POSITIVE =1, // positivo CALENDAR_IMPACT_NEGATIVE =2, // negativo }; enum ENUM_CALENDAR_EVENT_TIMEMODE { CALENDAR_TIMEMODE_DATETIME =0, // a fonte publica o tempo exato CALENDAR_TIMEMODE_DATE =1, // evento acontece durante todo o dia CALENDAR_TIMEMODE_NOTIME =2, // fonte não publica a hora do evento CALENDAR_TIMEMODE_TENTATIVE =3, // fonte não publica com antecedência o tempo exato do evento, apenas notifica o dia, o tempo é confirmado após a ocorrência do evento };
Novos códigos de erro
ERR_CALENDAR_MORE_DATA =5400, // matriz é pequena para o resultado inteiro (dados os valores que se ajustam na matriz) ERR_CALENDAR_TIMEOUT =5401, // expirado tempo de resposta da consulta de dados a partir do calendário ERR_CALENDAR_NO_DATA =5402, // dados não encontrados
- Corrigido e significativamente acelerado o trabalho com histórico de ticks e de barras.
- Corrigidas e significativamente aceleradas funções para alterar o histórico de ticks e de barras nos instrumentos de negociação personalizados CustomTicks* e CustomRates*.
- Adicionadas novas funções de conversão de dados.
CharArrayToStruct — copia um array de tipo uchar para uma estrutura POD.
bool CharArrayToStruct( void& struct_object, // estrutura const uchar& char_array[], // matriz uint start_pos=0 // posição inicial na matriz );
StructToCharArray — copia uma estrutura POD para um array de tipo uchar.
bool StructToCharArray( const void& struct_object, // estrutura uchar& char_array[], // matriz uint start_pos=0 // posição inicial na matriz );
- Adicionada a função MathSwap para alterar a ordem dos bytes no valor ushort, uint e ulong.
ushort MathSwap(ushort value); uint MathSwap(uint value); ulong MathSwap(ulong value);
- Adicionadas funções de rede para criar conexões TCP para hosts remotos por meio de soquetes de sistema:
- SocketCreate — cria um soquete com os sinalizadores especificados e retorna seu identificador
- SocketClose — fecha o soquete
- SocketConnect — conecta-se a um servidor com controle de tempo limite
- SocketIsConnected — verifica se o soquete está conectado no momento
- SocketIsReadable — obtém o número de bytes que podem ser lidos no soquete
- SocketIsWritable — verifica se os dados podem ser gravados no soquete no momento atual
- SocketTimeouts — define os tempos limite para receber e enviar dados para o objeto do sistema de soquete
- SocketRead — lê dados do soquete
- SocketSend — grava dados em um soquete
- SocketTlsHandshake — inicia uma conexão TLS (SSL) segura com o host especificado usando o protocolo TLS Handshake
- SocketTlsCertificate — obtém informações sobre o certificado usado para proteger a conexão de rede.
- SocketTlsRead — lê dados de uma conexão TLS segura
- SocketTlsReadAvailable — lê todos os dados disponíveis a partir de uma conexão TLS segura
- SocketTlsSend — envia dados por meio de uma conexão TLS segura
O endereço do host ao qual você está se conectando - usando funções de rede - deve ser explicitamente da lista permitida nas configurações do terminal.
Para trabalhar com funções de rede, adicionados novos códigos de erro:
- ERR_NETSOCKET_INVALIDHANDLE (5270) — identificador de soquete inválido passado para a função
- ERR_NETSOCKET_TOO_MANY_OPENED (5271) — muitos soquetes abertos (máximo de 128)
- ERR_NETSOCKET_CANNOT_CONNECT (5272) — erro de conexão com host remoto
- ERR_NETSOCKET_IO_ERROR (5273) — erro ao enviar/receber dados para/de um soquete
- ERR_NETSOCKET_HANDSHAKE_FAILED (5274) — erro de estabelecimento de conexão segura (handshake TLS)
- ERR_NETSOCKET_NO_CERTIFICATE (5275) — não há informações sobre o certificado que protege a conexão
- Adicionadas novas funções para trabalhar com strings:
StringReserve — reserva na memória para o string o buffer do tamanho especificado.
bool StringReserve( string& string_var, // string uint new_capacity // tamanho do buffer para armazenar a string );
StringSetLength — define para a string o comprimento especificado nos símbolos.
bool StringSetLength( string& string_var, // strings uint new_length // novo comprimento da string );
- Adicionadas novas funções para trabalhar com arrays:
ArrayRemove — remove o número especificado de elementos da matriz, iniciando no índice especificado.
bool ArrayRemove( void& array[], // matriz de qualquer tipo uint start, // índice para começar a excluir uint count=WHOLE_ARRAY // número de elementos );
ArrayInsert — insere o número especificado de elementos do array de origem no array de destino, iniciando no índice especificado.
bool ArrayInsert( void& dst_array[], // array de destino const void& src_array[], // array de origem uint dst_start, // índice no array de destino para inserir uint src_start=0, // índice no array de origem para copiar uint count=WHOLE_ARRAY // número de elementos a serem inseridos );
ArrayReverse — inverte o número especificado de elementos no array, iniciando no índice especificado.
bool ArrayReverse( void& array[], // array de qualquer tipo uint start=0, // índice para começar a inverter o array uint count=WHOLE_ARRAY // número de elementos );
- Às funções CustomRatesUpdate, CustomRatesReplace, CustomTicksAdd e CustomTicksReplace adicionado o parâmetro "uint count" para especificar o número de elementos do array transmitido a ser usado. Por padrão, para o parâmetro, é usado o valor WHOLE_ARRAY. Isso significa que será usado todo o array.
- Adicionada a função CustomBookAdd — transmite o estado do livro de ofertas para o instrumento personalizado. A função permite transmitir um livro de ofertas como se viesse do servidor de uma corretora.
int CustomBookAdd( const string symbol, // nome do símbolo const MqlBookInfo& books[] // array com descrições de elementos do livro de ofertas uint count=WHOLE_ARRAY // número de elementos a serem usados );
- Adicionada a sobrecarga da função CustomSymbolCreate, permitindo que você crie um instrumento de negociação personalizado com base em um existente. Após a criação, qualquer propriedade de símbolo pode ser alterada para o valor desejado pelas funções correspondentes.
bool CustomSymbolCreate( const string symbol_name, // nome do símbolo personalizado const string symbol_path="", // nome do grupo em que é criado o símbolo const string symbol_origin=NULL // nome do símbolo em cuja base é criado o símbolo personalizado );
O nome do símbolo - do qual serão copiadas as propriedades do símbolo personalizado criado - é especificado no parâmetro "symbol_origin".
- Atualizada a função StringToTime que converte uma string de data/hora em um valor de data e hora. Agora suporta os seguintes formatos de data:
- yyyy.mm.dd [hh:mi]
- yyyy.mm.dd [hh:mi:ss]
- yyyymmdd [hh:mi:ss]
- yyyymmdd [hhmiss]
- yyyy/mm/dd [hh:mi:ss]
- yyyy-mm-dd [hh:mi:ss]
- À enumeração ENUM_TERMINAL_INFO_INTEGER adicionada a propriedade TERMINAL_VPS — sinal de que o terminal está sendo executado em um servidor virtual Hospedagem Virtual MetaTrader (VPS MetaTrader). Se o programa estiver sendo executado em um serviço de hospedagem, você poderá desabilitar todas as suas funções visuais, já que o servidor virtual não possui uma interface gráfica de usuário.
- À enumeração ENUM_SYMBOL_INFO_INTEGER adicionada a nova propriedade SYMBOL_EXIST — sinal de que existe um símbolo com o mesmo nome.
- Corrigida tipificação ao usar declaração preliminar de uma função de template.
- Adicionada a reinicialização de indicadores ao alterar uma conta de negociação.
- Otimizado o trabalho da função StringSplit.
- Corrigidos erros na biblioteca padrão.
Tester
- Adicionada a função TesterStop — término antecipado do trabalho um EA em um agente de teste. Agora você pode forçar a interrupção do teste quando for atingido um determinado número de negociações perdedoras, um determinado nível de rebaixamento ou qualquer outro critério.
O teste concluído com essa função é considerado bem-sucedido. Depois de ser chamado, o terminal recebe o histórico de negociação obtido como resultado de testes, bem como todas as estatísticas de negociação.
- Desativado o recurso para testar e otimizar EAs via MQL5 Cloud Network no modo de uso de ticks reais. Este modo pode ser usado somente em agentes locais e farms na rede local.
- Aprimorado o trabalho com indicadores para testes visuais. Agora, o gráfico de preços e as linhas de indicadores são desenhados em sincronia, mesmo na velocidade máxima de renderização.
- Otimizados e significativamente acelerados teste e otimização.
- Corrigida a depuração de indicadores em dados históricos. Agora a função OnInit e OnDeinit dos indicadores podem ser depuradas corretamente.
- Acelerado o acesso a dados históricos ao testar EAs em várias moedas.
- Corrigidos erros que faziam o testador visual congelar ao depurar dados históricos.
- Acelerado início de passagens quando o agente processa o pacote de tarefas.
- Alterada a política de distribuição de pacotes de tarefas para agentes de teste. O tamanho do pacote foi aumentado, o que levava a uma redução significativa nos custos indiretos das operações de rede.
- Alterado o comportamento da opção de usar agentes locais, de rede e de nuvem. Agora, quando essas opções estão desativadas, as tarefas já emitidas são processadas no final e as novas não são mais emitidas. Anteriormente, essas opções funcionavam de forma semelhante ao comando "Desativar", impedindo o trabalho dos agentes imediatamente.
MetaEditor
- Adicionado suporte para símbolos não-ANSI no depurador. Agora as expressões observadas são exibidas corretamente, mesmo se o nome da variável for especificado em cirílico.
- Corrigida a exibição de resultados de pesquisa em monitores de alta DPI.
Adicionada tradução da interface do usuário para o idioma croata.
Documentação atualizada.
26 outubro 2018
MetaTrader 5 build 1930: Gráficos flutuantes e bibliotecas .Net em MQL5
Terminal
- agora você pode exibir gráficos de instrumentos financeiros fora da janela do terminal de negociação.
Isso é conveniente quando se trabalha com vários monitores. Por exemplo, em um deles, você pode colocar a janela principal da plataforma e monitorar o status da conta, enquanto, em outro, você pode botar os gráficos para avaliar a situação no mercado. Para separar o gráfico do terminal, desative a opção "Encaixar" em seu menu de contexto. Depois disso, coloque o gráfico no monitor desejado.
Para que você não precise alternar entre monitores para aplicar objetos ou indicadores analíticos, os gráficos desafixados têm uma barra de ferramentas separada. A fim de alterar um conjunto de comandos ou ocultar a barra de ferramentas, use seu menu de contexto.
- bate-papos incorporados totalmente atualizados. Agora eles suportam diálogos e canais de grupo. Você pode iniciar discussões privadas com grupos de pessoas em um único espaço - sem alternar entre diferentes diálogos -, criar canais temáticos por interesse e idioma. Você pode se comunicar com colegas e amigos na MQL5.community sem visitar o site.
Cada bate-papo e canal em grupo pode ser público ou privado. O próprio autor decide se eles podem se juntar livremente ou apenas por convite. Você também pode atribuir moderadores a canais e bate-papos, providenciando controle adicional de comunicação.
- adicionado suporte para maior precisão na negociação de criptomoedas. Agora, o volume mínimo possível de operações de negociação é de 0,00000001 lotes. Ao livro de ofertas, ao feed de transações e a outros itens de interface foi adicionado um recurso para exibir volumes com uma precisão de até 8 casas decimais.
Seu valor mínimo, 'step' e alteração dependem das configurações do instrumento financeiro no lado da corretora.
- à janela "Caixa de Ferramentas" foi adicionada uma guia de artigos publicados na MQL5.community. Mais de 600 materiais detalhados sobre o desenvolvimento de estratégias de negociação em MQL5 estão agora disponíveis diretamente no terminal. Novos artigos são publicados a cada semana.
- adicionado o suporte a autorização estendida usando certificados ao trabalhar com o Wine.
- corrigida a exibição do livro de ofertas quando sua profundidade é limitada a um nível.
- adicionado o comando "Salvar como imagem" à barra de ferramentas "Padrão". Agora é mais fácil tirar capturas de tela dos gráficos e compartilhá-los na comunidade.
- corrigida a implementação do deslocamento temporal ao importar barras e ticks. Anteriormente, em alguns casos, o deslocamento não era aplicado.
- corrigido o bloqueio do terminal com uma grande quantidade de notícias do calendário econômico.
MQL5
- adicionada suporte nativo a bibliotecas .NET com funções de importação inteligentes. Agora, as bibliotecas .NET podem ser usadas sem escrever 'wrappers' especiais — o MetaEditor toma conta disso por conta própria.
Para trabalhar com as funções da biblioteca .NET, basta importar a própria DLL sem especificar funções específicas. O MetaEditor importa automaticamente todas as funções com as quais é possível o trabalho:
- Estruturas simples (POD, plain old data), isto é, estruturas que contêm apenas tipos de dados simples.
- Funções estáticas públicas cujos parâmetros usam apenas tipos simples e estruturas de POD ou seus arrays
Para chamar funções da biblioteca, basta importá-la:
#import "TestLib.dll" //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { int x=41; TestClass::Inc(x); Print(x); }
O código C# para a função Inc da classe TestClass é semelhante ao seguinte:
public class TestClass { public static void Inc(ref int x) { x++; } }
Como resultado, o script retornará o valor 42.
O melhoramento do suporte a bibliotecas .NET continua, em versões futuras, planeja-se expandir suas possibilidades de uso.
- à biblioteca padrão foi adicionado o suporte para trabalhar com funções WinAPI. Agora, para usar as funções do sistema operacional no programa MQL5, não há necessidade de importar manualmente as bibliotecas e descrever as assinaturas de funções. Basta conectar o arquivo de cabeçalho do diretório MQL5\Include\WinAPI.
As funções WinAPI são agrupadas em arquivos separados por finalidade:- libloaderapi.mqh — trabalho com recursos
- memoryapi.mqh — trabalho com memória
- processenv.mqh — trabalho com ambiente
- processthreadsapi.mqh — trabalho com processos
- securitybaseapi.mqh — trabalho com o sistema de segurança do sistema operacional
- sysinfoapi.mqh — obtenção de informações do sistema
- winbase.mqh — funções comuns
- windef.mqh — constantes, estruturas e enumerações
- wingdi.mqh — trabalho com objetos gráficos
- winnt.mqh — trabalho com exceções
- winreg.mqh — trabalho com o registro
- winuser.mqh — gerenciamento de janelas e interface
- errhandlingapi.mqh — processamento de erros
- fileapi.mqh — trabalho com arquivos
- handleapi.mqh — trabalho com identificadores
- winapi.mqh — conexão de todas as funções (arquivos de cabeçalho WinAPI)
A ligação funciona apenas com arquitetura de 64 bits. - libloaderapi.mqh — trabalho com recursos
- adicionado o suporte a qualificadores inline, __inline, __forceinline ao analisar o código. A presença desses qualificadores no código não causará erros e não afetará a compilação. No momento, isso torna mais fácil transferir código C++ para MQL5.
Mais informações sobre qualificadores estão disponíveis no MSDN.
- realizada uma otimização substancial da execução de programas MQL5. Em alguns casos, o ganho de desempenho pode chegar a 10%. Para obter um aumento de velocidade, recompile seus programas na nova versão do MetaEditor.
Infelizmente, otimização adicional levou à perda de compatibilidade de novos programas com versões anteriores do terminal. Todos os programas compilados no MetaEditor versão 1910 e superior não serão inicializados em terminais de versão inferior a 1880. Ao mesmo tempo, programas compilados anteriormente em versões anteriores do MetaEditor funcionarão em novos terminais.
- realizado trabalho de otimização de conjuntos de funções MQL5.
- adicionadas novas propriedades para ajustar/separar gráficos da janela principal do terminal e controlar sua posição.
À enumeração ENUM_CHART_PROPERTY_INTEGER adicionados:
- CHART_IS_DOCKED — janela do gráfico encaixada. Se definido como false, o gráfico pode ser arrastado para fora do terminal.
- CHART_FLOAT_LEFT — coordenada esquerda do gráfico desencaixado em relação à tela virtual.
- CHART_FLOAT_TOP — coordenada superior do gráfico desencaixado em relação à tela virtual.
- CHART_FLOAT_RIGHT — coordenada direita do gráfico desencaixado em relação à tela virtual.
- CHART_FLOAT_BOTTOM — coordenada inferior do gráfico desencaixado em relação à tela virtual.
À enumeração ENUM_TERMINAL_INFO_INTEGER foram adicionados:
- TERMINAL_SCREEN_LEFT — coordenada esquerda da tela virtual. A tela virtual é o retângulo que cobre todos os monitores. Se o sistema tiver dois monitores e sua ordem for definida da direita para a esquerda, a coordenada esquerda da tela virtual poderá estar na borda de dois monitores.
- TERMINAL_SCREEN_TOP — coordenada superior da tela virtual.
- TERMINAL_SCREEN_WIDTH — largura do terminal.
- TERMINAL_SCREEN_HEIGHT — altura do terminal.
- TERMINAL_LEFT — coordenada esquerda do terminal em relação à tela virtual.
- TERMINAL_TOP — coordenada superior do terminal em relação à tela virtual.
- TERMINAL_RIGHT — coordenada direita do terminal em relação à tela virtual.
- TERMINAL_BOTTOM — coordenada inferior do terminal em relação à tela virtual.
- adicionado o campo volume_real às estruturas MqlTick e MqlBookInfo. Ele é projetado para funcionar com maior precisão. O valor volume_real tem uma precedência mais alta do que o volume. O servidor usará esse valor, se especificado.
struct MqlTick
{
datetime time; // Hora da última atualização de preço
double bid; // Preço Bid atual
double ask; // Preço Ask atual
double last; // Preço atual da última transação (Last)
ulong volume; // Volume para o preço Last atual
long time_msc; // Hora da última atualização de preço em milissegundos
uint flags; // Sinalizadores de ticks
double volume_real; // Volume para o preço Last atual com alta precisão
};struct MqlBookInfo { ENUM_BOOK_TYPE type; // tipo de boleta a partir da enumeração ENUM_BOOK_TYPE double price; // preço long volume; // volume double volume_real; // volume com alta precisão };
- à enumeração ENUM_SYMBOL_INFO_DOUBLE foram adicionadas novas propriedades:
- SYMBOL_VOLUME_REAL — volume da última transação concluída;
- SYMBOL_VOLUMEHIGH_REAL — valor máximo do volume da transação concluída para o dia atual;
- SYMBOL_VOLUMELOW_REAL — valor mínimo do volume da transação concluída para o dia atual.
Para obter essas propriedades, use a função SymbolInfoDouble.
- SYMBOL_VOLUME_REAL — volume da última transação concluída;
- à enumeração ENUM_MQL_INFO_INTEGER foi adicionada a propriedade MQL_FORWARD — um sinal de que o programa está no modo teste para frente.
- adicionada a propriedade pack( integer_value ) para estruturas. Permite definir o alinhamento da localização dos campos dentro da estrutura, é necessário quando se trabalha com uma DLL. Para integer_value, são possíveis os valores 1, 2 ,4 ,8 e 16.
Se a propriedade não estiver definida, por padrão é usado o alinhamento de 1 byte — pack(1).
Exemplo de uso://+------------------------------------------------------------------+ //| Default packing | //+------------------------------------------------------------------+ struct A { char a; int b; }; //+------------------------------------------------------------------+ //| Specified packing | //+------------------------------------------------------------------+ struct B pack(4) { char a; int b; }; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { Print("sizeof(A)=",sizeof(A)); Print("sizeof(B)=",sizeof(B)); } //+------------------------------------------------------------------+
Conclusão:sizeof(A)=5 sizeof(B)=8
Mais informações sobre o alinhamento em estruturas estão disponíveis no MSDN. - flexibilização dos requisitos para coerção de enumerações. Quando implicitamente convertido, o compilador substituirá automaticamente pelo valor da enumeração correta e exibirá um aviso.
Para o seguinte código:
enum Main { PRICE_CLOSE_, PRICE_OPEN_ }; input Main Inp=PRICE_CLOSE; //+------------------------------------------------------------------+ //| Start function | //+------------------------------------------------------------------+ void OnStart() { }
O compilador emitirá um aviso:
implicit conversion from 'enum ENUM_APPLIED_PRICE' to 'enum Main'Anteriormente, neste caso, era gerado o erro:
'Main::PRICE_OPEN_' instead of 'ENUM_APPLIED_PRICE::PRICE_CLOSE' will be used
'PRICE_CLOSE' - cannot convert enumSe enumerações são usadas incorretamente nos parâmetros de funções, o compilador ainda produzirá um erro.
- corrigidos erros de compilação de funções de modelo. Agora, ao usar funções de modelo sobrecarregadas, apenas a sobrecarga necessária é instanciada e não todas as existentes.
class X { }; void f(int) { } template<typename T> void a(T*) { new T(2); } // anteriormente neste lugar o compilador dava um erro template<typename T> void a() { f(0); } void OnInit() { a<X>(); }
- otimizados alguns casos de acesso ao histórico de ticks através da função CopyTicks*.
- adicionada a nova função TesterStop que permite concluir o teste/otimização antes do planejado. Ao ser chamada, todo o histórico de negociação e o resultado do OnTester são transferidos para o terminal do cliente como durante a conclusão geral do teste/otimização.
- adicionada uma nova propriedade para indicadores personalizados #property tester_everytick_calculate. Ela é usada no testador de estratégias e permite ativar o cálculo de indicadores em cada tick.
Tester
- agora, com testes/otimização não visuais, todos os indicadores usados (padrão e personalizados) são calculados apenas por solicitação de dados. Os indicadores que contêm chamadas da função EventChartCustom e que usam o manipulador Ontimer são exceções. Anteriormente no testador de estratégias, após a chegada de qualquer tick (mesmo do instrumento de outra pessoa), todos os indicadores eram calculados incondicionalmente. Essa inovação acelerou significativamente os testes e a otimização.
Para forçar o cálculo de indicadores em cada tick, adicione a propriedade #property tester_everytick_calculate para o programa.
Os indicadores compilados por versões anteriores do compilador serão calculados como antes — em cada tick. - corrigida a precisão da moeda de depósito ao testar/otimizar e gerar relatórios relevantes.
- otimizado e acelerado o funcionamento do testeador de estratégias.
- corrigidos vários erros de teste e otimização.
MetaEditor
- corrigida a busca de palavras inteiras. Agora, ao pesquisar, o sublinhado é contado como um caractere regular, não como um delimitador de palavras.
Documentação atualizada.
6 julho 2018
MetaTrader 5 build 1880: cálculo do histórico completo de instrumentos sintéticos
Terminal
- Adicionado o cálculo do histórico de preços de instrumentos sintéticos, para toda a profundidade de dados disponível.
Para instrumentos sintéticos, a plataforma calcula o histórico de barras de minutos, com base nas barras de minutos dos instrumentos que compõem sua fórmula. Anteriormente, por padrão, o cálculo era feito apenas para os últimos dois meses do histórico. Um histórico mais profundo podia ser criado com uma solicitação explícita (ao rolar o gráfico para a esquerda ou chamar funções Copy). Agora o histórico é calculado em todos os dados disponíveis incondicionalmente.
O histórico de preços de cada instrumento incluído na fórmula pode ter diferentes profundidades. É por isso que o cálculo é feito para o período mais curto. Por exemplo, a fórmula usa três instrumentos:
- EURUSD com histórico até 2009.01.01
- USDJPY com histórico até 2012.06.01
- EURJPY com histórico até 2014.06.01
Nesse caso, o histórico do instrumento sintético será calculado apenas de 2014.06.01 até o presente. Além dessa data, serão descartados outros 100 minutos para garantir a integridade do cálculo (na ausência de uma barra de minutos separada no histórico, no cálculo é usada a barra do minuto anterior).
Se houver um histórico profundo, o cálculo do instrumento sintético pode levar muito tempo. Para que você possa ver imediatamente o seu gráfico, sem esperar todos os cálculos serem concluídos, primeiro é calculado o histórico dos últimos dois meses (semelhante ao que acontecia nas versões anteriores). Só depois disso começa o cálculo de um histórico anterior.
MQL5
- Adicionada a propriedade ACCOUNT_CURRENCY_DIGITS, isto é, o número de casas decimais para a moeda de depósito da conta. Para recebê-la, use a função AccountInfoInteger. A propriedade pode ser usada no cálculo independente do lucro para normalizar os valores obtidos.
- Corrigido o atraso de execução das funções Copy e funções i ao trabalhar com o timeframe semanal.
- Corrigidos erros na função WebRequest.
Tester
- Adicionada a possibilidade de teste único de EA após os resultados de otimização do arquivo de cache serem carregados.
- Acelerado o carregamento inicial do histórico de preços por agentes de teste locais.
Documentação atualizada.
26 junho 2018
MetaTrader 5 build 1870: adição de símbolos à Observação do mercado de acordo com o ISIN
Terminal
- A janela Observação do mercado foi adicionada a pesquisa
de instrumentos de acordo com o "International Securities Identification
Number" (ISIN). Agora você pode adicionar instrumentos de três
maneiras: por nome, por descrição e por ISIN.
- Corrigida a degradação do desempenho da interface do usuário ao alterar a senha da conta de negociação.
- Corrigido o erro que em alguns casos causava o aumento da utilização da CPU pelo terminal do cliente.
MQL5
- Corrigida a transferência de cabeçalhos HTTP personalizados para funções WebRequest.
- Corrigido o comportamento da função Bars ao especificar a mesma data como o início e o fim do intervalo. Agora, se houver uma barra, ela retornará 1. Anteriormente, neste caso, a função retornava incondicionalmente 0.
Tester
- Corrigida a inicialização do teste em modo visual após a otimização para frente.
- Corrigida a classificação de resultados de otimização. Agora, ela leva em conta corridas com parâmetros de entrada incorretos (INIT_INCORRECT_PARAMETERS) e com um fator de lucro ausente.
- Corrigido o recálculo do gráfico de otimização genética após alterar o critério de otimização.
Documentação atualizada.
15 junho 2018
MetaTrader 5 build 1860: funções para trabalhar com barras em MQL5 e melhorias no testador de estratégias
Terminal
- Completamente redesenhado a caixa de diálogo de
abertura de conta. Agora você primeiro seleciona a corretora de
interesse e, em seguida, o tipo de conta que deseja abrir. Graças a
isso, a lista de corretores se tornou mais compacta, uma vez que agora
exibe nomes de empresas, em vez de mostrar todos os servidores
disponíveis.
Também para facilitar a busca, à lista foram adicionados logotipos de empresas. Se a corretora desejada não estiver na lista, basta digitar o nome da empresa ou o endereço do servidor na caixa de pesquisa e clicar em "Encontrar sua corretora".
Para ajudar traders inexperientes, à caixa de diálogo foram adicionadas as descrições dos tipos de conta. Além disso, devido à atualização da General Data Protection Regulation (GDPR), ao abrir uma conta, agora podem ser exibidos os links para vários contratos e políticas de empresas corretagem:
As possibilidades de abertura de contas reais foram significativamente expandidas. A função de upload documentos para confirmar a identidade e o endereço, anteriormente existente em terminais móveis, agora está disponível na versão desktop. Corretoras regulamentadas pelo MiFID podem agora solicitar todas as informações necessárias para a identificação do cliente, incluindo dados sobre emprego, renda, experiência comercial, etc. Tudo isso facilitará e agilizará a obtenção de contas reais, além de livrá-lo de burocracia desnecessária.
- Adicionada a exibição de valores de
Stop Loss e Take Profit ao histórico de transações. Para as transações
de entrada e reversão, elas são definidas de acordo com os valores das
ordens Stop Loss e Take Profit, como resultado de que foram executadas.
Para transações de saída, os valores de Stop Loss e Take Profit das
respectivas posições são usados no momento de seu fechamento. O último
permite que você salve e exiba informações sobre o valor do Stop Loss e
Take Profit na posição no momento em que foi fechada. Antes disso, tais
informações não eram armazenadas em nenhum lugar, uma vez que a posição
após o fechamento desaparece e o histórico de posições no terminal é
formado com base em transações.
- Adicionada a exibição de valores de Stop Loss e Take Profit ao
histórico de posições. Eles são preenchidos de acordo com o valor das
transações Stop Loss e Take Profit que abrem e fecham as posições
correspondentes.
- Agora, ao exibir ordens pendentes no gráfico, é usado o volume atual da
ordem, em vez de implementar o solicitado inicialmente.
- Otimizada e significativamente acelerada a exibição do livro de ofertas no modo avançado com exibição de spread ativada.
- Otimizado o processamento de resultados de execução de pedidos de negociação. Em alguns casos, isso pode dar uma aceleração significativa de processamento.
- Corrigido o erro de funcionamento do Trailing Stop, em alguns casos levando ao envio de várias solicitações para alterações no nível de Stop Loss numa posição.
- Corrigida a colocação de volume mínimo e volume máximo, bem como o passo do volume nas propriedades de instrumentos personalizadas.
- Corrigido um erro devido ao qual a opção "Fixar a escala" não era levada em conta ao aplicar a escala ao gráfico do instrumento de negociação.
- Corrigido um erro que, em alguns casos, levava à coleta incorreta do histórico de ticks.
MQL5
- Aumentada a velocidade de trabalho de programas MQL5, graças à
otimização adicional do código-fonte durante a compilação. Para
aumentar a velocidade, recompile seus programas na nova versão do
MetaEditor.Infelizmente, a otimização adicional levou à perda de compatibilidade dos novos programas com versões anteriores do terminal. Todos os programas compilados no MetaEditor versão 1860 e superior não serão iniciados nos terminais anteriores à versão 1860. Neste caso, os programas compilados nas versões anteriores do MetaEditor funcionarão nos novos terminais.
- Adicionadas as funções iTime, iOpen, iHigh, iLow, iClose, iVolume,
iBars, iBarShift, iLowest, iHighest, iRealVolume, iTickVolume, iSpread.
Essas funções são semelhantes àquelas usadas em MQL4. Assim, será mais
fácil para os usuários transferir o código de programas de negociação
para a plataforma de quinta geração.
Anteriormente, a maioria das tarefas resolvidas por essas funções podiam ser executada facilmente usando as funções Copy *. No entanto, para encontrar os valores máximo/mínimo no gráfico e para procurar as barras segundo o tempo, o usuário tinha que implementar suas próprias funções. Agora pode ser facilmente executado usando as funções iHighest, iLowest e iBarShift.
iTime
Retorna o valor do tempo de abertura da barra (indicado pelo parâmetro shift) do gráfico correspondente.datetime iTime( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
iOpen
Retorna o valor do preço de abertura da barra (indicado pelo parâmetro shift) do gráfico correspondente.double iOpen( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
iHigh
Retorna o valor do preço máximo da barra (especificado pelo parâmetro shift) do gráfico correspondente.double iHigh( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
iLow
Retorna o valor do preço mínimo da barra (indicado pelo parâmetro shift) do gráfico correspondente.double iLow( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
iClose
Retorna o valor do preço de fechamento da barra (indicado pelo parâmetro shift) do gráfico correspondente.double iClose( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
iVolume
Retorna o valor do volume do tick (especificado pelo parâmetro shift) do gráfico correspondente.long iVolume( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
iBars
Retorna o número de barras - no histórico - do símbolo e do período correspondentes.int iBars( string symbol, // símbolo ENUM_TIMEFRAMES timeframe // período );
iBarShift
Busca de barra pelo tempo. A função retorna o índice da barra na qual coincide o tempo especificado.int iBarShift( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período datetime time, // tempo bool exact=false // modo );
iLowest
Retorna o índice do menor valor encontrado (deslocamento em relação à barra atual) do gráfico correspondente.int iLowest( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int type, // identificador de timeseries int count, // número de elementos int start // índice );
iHighest
Retorna o índice do maior valor encontrado (deslocamento em relação à barra atual) do gráfico correspondente.int iHighest( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int type, // identificador de timeseries int count, // número de elementos int start // índice );
iRealVolume
Retorna o valor do volume real da barra (indicado pelo parâmetro shift) do gráfico correspondente.long iRealVolume( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
iTickVolume
Retorna o valor do volume do tick (especificado pelo parâmetro shift) do gráfico correspondente.long iTickVolume( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
iSpread
Retorna o valor do spread da barra (indicado pelo parâmetro shift) do gráfico correspondente.long iSpread( string symbol, // símbolo ENUM_TIMEFRAMES timeframe, // período int shift // deslocamento );
- Adicionada a função TesterHideIndicators.
Especifica o modo de exibir/ocultar os indicadores usados no EA. A
função se destina a controlar a visibilidade dos indicadores utilizados
apenas durante o teste. Especifique o sinalizador true se você quiser
ocultar os indicadores que estão sendo criados, caso contrário, false.
void TesterHideIndicators( bool hide // sinalizador );
- Adicionada a geração do evento CHARTEVENT_CLICK so clicar nos níveis de negociação do gráfico.
- Corrigido e otimizado o trabalho das funções CopyTicks.
- Corrigido o valor dado pelas funções SymbolInfoDouble para a propriedade SYMBOL_TRADE_LIQUIDITY_RATE.
- Corrigido o erro ao copiar matrizes de string com uma área de memória sobreposta.
- Corrigido o erro de alocação de matriz de string na função FileReadArray.
- Corrigidos vários erros na biblioteca MQL5 padrão.
Tester
- Completamente atualizado o sistema para trabalhar com o cache de
otimização. O cache é os dados sobre as passagens de otimização
calculados anteriormente. O testador de estratégias os armazena para
retomar a otimização após uma pausa e para não recalcular as passagens
de teste já calculadas.
Mudanças no formato de armazenamento em cache
Anteriormente, o cache de otimização era armazenado como um único arquivo XML, que incluía todas as passagens de otimização do EA com as configurações de teste especificadas. No mesmo arquivo os resultados da otimização eram obtidos com diferentes parâmetros de entrada.
Agora, o cache de otimização é armazenado como arquivos binários separadamente para cada conjunto de parâmetros otimizados. Alterando o formato e reduzindo o tamanho dos arquivos, foi significativamente acelerado o trabalho do testador com o cache de otimização. Essa aceleração será especialmente notável com a continuação da otimização suspensa anteriormente.
Visualização dos resultados das otimizações realizadas anteriormente
Agora você pode ver os resultados de otimizações anteriores diretamente no testador de estratégias, sem analisar enormes arquivos XML em programas de terceiros. Clique na guia "Resultados de otimização", selecione o EA e o arquivo com o cache de otimização:
A lista exibe todos os arquivos de cache de otimização que estão no disco para o Expert Advisor selecionado. Para cada arquivo são mostrados a data de otimização, configurações de teste (símbolo, timeframe, datas), bem como informações sobre os parâmetros de entrada. Além disso, você pode filtrar os resultados da otimização no servidor de negociação no qual eles são recebidos.
Recálculo do critério de otimização em tempo real
O critério de otimização é um determinado indicador cujo valor determina a qualidade de um conjunto testado de parâmetros de entrada. Quanto maior o valor do critério de otimização, melhor será avaliado o resultado do teste com tal conjunto de parâmetros.
Anteriormente, ao otimizar, era calculado apenas um critério selecionado antes da otimização. Agora, ao visualizar os resultados, você pode alterar o critério de otimização em tempo real, o testador de estratégia recalculará automaticamente todos os valores.
Como usar o cache de otimização manualmente
Anteriormente, o cache de otimização era armazenado como um arquivo XML que podia ser aberto e analisado em programas de terceiros. Agora ele é armazenado em arquivos binários fechados. Para obter dados no formato XML, exporte-os por meio do menu de contexto da guia "Resultados de otimização". - Adicionado a capacidade de especificar manualmente a moeda de depósito e
o tamanho da alavancagem para teste e otimização. Anteriormente, a
moeda de depósito era definida de acordo com a conta atual conectada.
Assim, para alterá-lo, o usuário tinha que mudar para outras contas. O
tamanho da alavancagem só podia ser selecionada numa lista predefinida,
agora você pode especificar qualquer valor.
Observe que, para testes corretos, na conta devem estar disponíveis os pares de moedas para conversão de lucros e margens na moeda de depósito especificada.
- Removido o banimento do uso de OpenCL em agentes de teste. Anteriormente, os dispositivos OpenCL só podiam ser usados ao testar em agentes locais. Agora, os agentes podem usar todos os dispositivos OpenCL disponíveis (processador, placa de vídeo) ao trabalhar na rede local e na MQL5 Cloud Network.
MetaEditor
- Otimizado e acelerado o trabalho com o repositório de dados MQL5 Storage.
- Corrigido a retomada de depuração após a suspensão no arquivo MQH.
- Corrigidos erros no destaque do código-fonte no editor.
- Corrigido o erro de transição nos resultados de pesquisa.
- Corrigida a substituição massiva de texto. Em alguns casos, era
substituída apenas a primeira ocorrência da sequência substituída, em
vez de todas.
Documentação atualizada.
18 janeiro 2018
MetaTrader 5 build 1755
Terminal
- Corrigido erro, devido ao qual o terminal e MetaEditor bloqueava o desligamento e reinicialização do Windows.
- Corrigida a colocação do recuo do gráfico, ao implementar o modelo.
MQL5
- Corrigidos erros que levavam à degradação do desempenho de compilação sob determinadas condições.
Correções de crash-logs.
12 janeiro 2018
MetaTrader 5 build 1745
MetaTrader 5 build 1745 é a versão mais recente da plataforma de negociação, ela suporta o Microsoft Windows XP/2003/Vista.
Alguns meses atrás, nós anunciamos o fim do suporte a versões mais antigas dos sistemas operacionais.
Windows 2003, Windows Vista e, em particular, Microsoft Windows XP
estão desatualizados. Há um ano, a Microsoft deixou de dar suporte ao
Windows XP 3, uma vez que limitações técnicas não permitiam implementar
todo o potencial do hardware.
MetaTrader 5 build 1745, bem como versões liberadas anteriormente
continuarão a trabalhar nesses sistemas operacionais, mas sem
atualizações. Além disso, nesses sistemas operacionais, não serão
executados instaladores.
A versão mínima para trabalhar com o
MetaTrader 5 é o Windows 7, no entanto recomendamos que você use a
versão de 64 bits do Windows 10.
Terminal
- No instalador, adicionada a chave /auto. Ela permite
instalar o programa automaticamente, sem quaisquer ações adicionais por
parte do usuário. Ao executar o instalador com esta chave, não são
mostradas configurações de instalação, o terminal é instalado
imediatamente no menu "Iniciar". Exemplo de inicialização:
C:\mt5setup.exe /auto
- Corrigido o trabalho quando o usuário do sistema operativo não tem permissões suficientes.
- Corrigido o consumo desnecessário de CPU quando o
terminal não realiza nenhuma ação ativa (sem gráficos em andamento nem
ações por parte do utilizador).
- Ativada a compressão automática de arquivos *.log, no nível do sistema de arquivos. Isso reduz a quantidade de espaço em disco para logs.
- Aumentado o volume de cache com testes individuais, o que acelera o funcionamento em sistemas operativos de 64 bits.
Tester
- Corrigida a otimização de robôs de negociação através da rede de computação em nuvem MQL5 Cloud Network. Podiam ocorrer problemas em produtos adquiridos na loja MetaTrader Market.
- Corrigida a formação de spreads nas barras geradas no modo de teste "Todos os ticks".
- Corrigida a seleção do dispositivo OpenCL no testador de estratégias. O testador visual agora tem acesso a todos os dispositivos OpenCL disponíveis.
- Habilitada a compressão automática de arquivos *.log, no nível do sistema de arquivos. Isso reduz a quantidade de espaço em disco para logs.
MQL5
- Corrigida a remoção de barras do instrumento personalizado usando o método CustomRatesDelete.
Correções de crash-logs.
Documentação atualizada.
20 dezembro 2017
MetaTrader 5 build 1730: projetos no MetaEditor e instrumentos sintéticos
Fim do suporte a versões antigas dos terminais!
Na nova versão da plataforma será descontinuado o suporte a terminais desktop e móveis das versões mais antigas:
- Terminal do cliente: versões inferiores à 730 de 23 de setembro 2012
- Terminal móvel para iPhone: versões inferiores à 1171 de 11 de novembro de 2015
- Terminal móvel para Android: versões inferiores à 1334 de 5 agosto de 2016
Modificado o protocolo de trabalho com o MQL5 Storage
Para dar suporte a novos projetos de grupo, foi modificado o protocolo
de trabalho com o armazenamento online MQL5 Storage. Infelizmente, após a
atualização para uma nova versão da plataforma, você terá que
re-extrair todos os dados a partir do repositório. Os dados armazenados
nele não serão nem afetados nem perdidos.
Antes de atualizar
para uma nova versão da plataforma, recomendamos que você envie todas as
alterações locais para o repositório (executar Commit).
Terminal
- Adicionado recurso para criar instrumentos financeiros
sintéticos, isto é, instrumentos com base em um ou mais dos que temos
disponíveis. Basta especificar a fórmula para calcular as cotações, e a
plataforma em tempo real gera os ticks do instrumento sintético, bem
como cria seu histórico de minuto.Como isso acontece?
- Você cria um instrumento sintético, especificando uma fórmula para ele.
- A plataforma contará seus ticks a uma frequência de 10 vezes por segundo (só se o preço de pelo menos um dos instrumentos incluídos na fórmula mudar).
- A plataforma computa o histórico de barras de minutos -
durante os últimos dois meses - com base nas barras de minutos dos
instrumentos incluídos na fórmula. Todas as barras novas (atuais e
ulteriores) serão construídas em tempo real com base nos ticks gerados
do instrumento sintético.
Por exemplo, você pode criar uma ferramenta que mostrará o índice do dólar (USDX). Sua fórmula é a seguinte:
50.14348112 * pow(ask(EURUSD),-0.576) * pow(USDJPY,0.136) * pow(ask(GBPUSD),-0.119) * pow(USDCAD,0.091) * pow(USDSEK,0.042) * pow(USDCHF,0.036)
Nota: na fórmula original do índice do dólar, são usados os pares USDEUR e USDGBP. Como na plataforma há apenas pares invertidos, na fórmula do instrumento sintético para eles é usada uma potência negativa e o preço Ask, em vez do Bid.
A plataforma calculará em tempo real o preço do novo instrumento com base nas cotações de outros seis instrumentos diferentes fornecidos pela sua corretora. Na Observação do mercado e no gráfico, você pode ver como se altera seu preço:
Crie um novo instrumento personalizado, abra sua especificação e insira a fórmula:
Por conveniência, o editor de fórmulas exibe uma lista de opções enquanto você digita os nomes dos instrumentos e funções.
Cálculo de ticks e de barras de minuto do instrumento sintético começará quando ele é adicionado à "Observação do mercado". Além disso, todos os símbolos necessários para seu cálculo são adicionados automaticamente à "Observação do mercado". Ao diário da plataforma será adicionado o registro sobre o início do cálculo: Synthetic Symbol USDX: processing started.- Cálculo do instrumento sintético é interrompido quando ele é oculto na "Observação do mercado".
- Os símbolos que estão sendo utilizados para o cálculo dos instrumentos sintéticos não podem ser ocultos da "Observação do mercado".
Cálculo de cotações em tempo real
A cada 100 ms (dez vezes por segundo) é verificado se o preço de pelo menos um dos instrumentos envolvidos na fórmula mudou. Se assim for, ocorrerá o cálculo do preço do instrumento sintético e será gerado um tick. O cálculo é realizado paralelamente em três fluxos para os preços Bid, Ask e Last. Por exemplo, se, na fórmula, for especificado EURUSD*GBPUSD, o cálculo do instrumento sintético será como se segue:
- Bid - bid(EURUSD)*bid(GBPUSD)
- Ask - ask(EURUSD)*ask(GBPUSD)
- Last - last(EURUSD)*last(GBPUSD)
A presença de alterações é verificada para cada preço separadamente. Por exemplo, como, durante o cálculo, no instrumento-fonte só foi o preço Bid que se alterou, então, para o tick do instrumento sintético foi calculado apenas o preço onde houve mudanças.
Traçado do histórico de barras de minuto
Além da coleta de ticks em tempo real, a plataforma cria um histórico de minuto para o instrumento sintético. Assim, o trader pode, da mesma maneira como o faria com instrumentos convencionais, ver seus gráficos, realizar a análise técnica usando os objetos e indicadores.
Assim que o trader adiciona um instrumento sintético à Observação do mercado, a plataforma verifica se exite algum histórico de minuto reservado para ele. Se não for assim, ele será criado para os últimos 60 dias, o que é cerca de 50 000 barras. Se, nas configurações da plataforma, no parâmetro "Máx. de barras na janela", for definido um valor menor, será usada essa restrição.
Quando uma parte das barras em este período já está construída, a plataforma criar as que estão em falta. É só quando se tenta consultar o período correspondente no gráfico que se cria um histórico mais em profundidade, caso esse período for rolado para cima ou consultado a partir de programas em linguagem MQL5).
O histórico de barras de minuto, do instrumento sintético, é calculado com base nas barras de minuto (e não de ticks) dos instrumentos incluídos na fórmula. Por exemplo, para calcular o preço Open da barra de minuto do instrumento sintético, a plataforma toma os preços Open dos instrumentos incluídos na fórmula. Da mesma forma, é realizado o cálculo para os preços High, Low e Close.
Se qualquer um dos instrumentos da fórmula não tiver a barra de minuto necessária, a plataforma será obrigada a calcular usando o preço Close da barra anterior. Vamos supor que estamos usando três instrumentos: EURUSD, USDJPY e GBPUSD. Se não for encontrada a barra correspondente ao minuto 12:00 durante seu cálculo, serão usados os seguintes preços:
- Para Open - EURUSD Open 12:00, USDJPY Close 11:59, GBPUSD Open 12:00
- Para High - EURUSD High 12:00, USDJPY Close 11:59, GBPUSD High 12:00
- Para Low - EURUSD Low 12:00, USDJPY Close 11:59, GBPUSD Low 12:00
- Para Close - EURUSD Close 12:00, USDJPY Close 11:59, GBPUSD Close 12:00
Se nenhum dos instrumentos da fórmula tiver certa barra de minuto, a barra correspondente no instrumento sintético também não não será calculada.
Traçado de novas barras de minuto
Todas as barras novas (atuais e ulteriores) do instrumento sintético são construídas com base nos ticks gerados. O preço segundo o qual são construídas as barras depende do parâmetro "Plotagem de gráficos" na especificação:
Operações a serem usadas na fórmula do instrumento
Na fórmula, podem-se usar dados de preços, bem como algumas propriedades dos símbolos (fornecidas pela corretora). Para fazer isso, insira:
- Nome do símbolo - dependendo de qual o preço do instrumento sintético é calculado, na fórmula será usado o preço Bid, Ask ou Last do instrumento especificado. Por exemplo, especificado EURUSD*GBPUSD, o Вid é calculado como bid(EURUSD)*bid(GBPUSD), enquanto o preço Ask - como ask(EURUSD)*ask(GBPUSD).
- bid(nome do símbolo) - para o cálculo do preço Bid do instrumento sintético será usado - incondicionalmente - o preço Bid do símbolo especificado. Na verdade, esta variação coincide com a anterior (sem especificar o tipo de preço).
- ask(nome do símbolo) - para o cálculo do preço Bid do instrumento sintético será usado - incondicionalmente - o preço Ask do símbolo especificado. Para o cálculo do preço Ask será usado o preço Bid do instrumento especificado. Para o cálculo do preço Last será usado o preço Last do instrumento especificado. Por exemplo, se você especificar ask(EURUSD)*GBPUSD, o cálculo é o seguinte:
- Вid = ask(EURUSD)*bid(GBPUSD)
- Ask = bid(EURUSD)*ask(GBPUSD)
- Last = last(EURUSD)*last(GBPUSD)
- last(nome do símbolo) - preço Last do símbolo especificado será usado durante o cálculo de todos os preços do instrumento sintético (Bid, Ask e Last). Por exemplo, se você definir last(EURUSD)*GBPUSD, o cálculo é o seguinte:
- Вid = last(EURUSD)*bid(GBPUSD)
- Ask = last(EURUSD)*ask(GBPUSD)
- Last = last(EURUSD)*last(GBPUSD)
- volume(nome do símbolo) - na fórmula será usado o volume do tick do instrumento especificado. Verifique que as informações dos volumes são transmitidas para o instrumento especificado.
- point(nome do símbolo) - na fórmula será colocado em seu lugar o tamanho da alteração mínima do preço do instrumento especificado.
- digits(nome do símbolo) - na fórmula será colocado em seu lugar o número de casas decimais no preço do instrumento especificado.
Se o personagem tem um nome complexo (contendo hífens, pontos, etc.), deve estar entre aspas. Por exemplo, "RTS-6.17".Na fórmula, pode-se utilizar operações aritméticas tais como a adição (+), a subtração (-), multiplicação (*), divisão (/) e o resto da divisão (%). Por exemplo, EURUSD+GBPUSD indica que o preço é calculado como a soma dos preços EURUSD e GBPUSD. Também na fórmula pode ser usado o menos unário para alterar o sinal, por exemplo: -10*EURUSD.
É dada prioridade à execução de operações aritméticas:
- As operações de multiplicação, divisão e resto da divisão são executadas primeiro, logo, a adição e a subtração.
- Operações são realizadas da esquerda para a direita. Se, na fórmula, forem utilizadas várias operações com a mesma prioridade (por exemplo, multiplicação e divisão), a primeira operação realizada é a do lado esquerdo.
- Para alterar a prioridade das operações, pode-se usar parênteses (e). As expressões entre parênteses têm a maior prioridade durante o cálculo. Para elas também se aplica o princípio da esquerda para a direita, isto é, primeiro, são avaliadas as expressões entre parênteses, mais à esquerda, na fórmula.
Além disso, na fórmula, é possível usar as constantes:
- Numéricas (inteiros e reais com ponto). Por exemplo, EURUSD*2+GBPUSD*0.7.
- Propriedades do símbolo _Digits e _Point. Eles adicionam à fórmula as propriedades do símbolo personalizado a partir da especificação. _Digits é o número de dígitos após o ponto decimal no preço do instrumento, _Point é o tamanho da variação mínima no preço do instrumento.
Além disso, na fórmula é possível utilizar todas as funções matemáticas habilitadas para linguagem MQL5, exceto MathSrand, MathRand e MathIsValidNumber: Para todas as funções apenas são usados nomes curtos: fabs(), acos(), asin(), etc.
- Adicionado o recurso que permite adicionar cotações para
instrumentos personalizados em tempo real. Agora, em MQL5, pode-se
programar um expert que adiciona quaisquer cotações de acordo com o
instrumento personalizado definido. Para fazer isso, usa-se a nova
função CustomTicksAdd.
int CustomTicksAdd( const string symbol, // nome do símbolo const MqlTick& ticks[] // matriz com dados de ticks que é necessário aplicar ao instrumento personalizado );
A função CustomTicksAdd permite enviar ticks, como se viessem do servidor da corretora. Os dados não são gravados diretamente no banco de ticks, em vez disso, são enviados para a janela "Observação do mercado". Em seguida, a partir dela, o terminal armazena ticks em seu banco de dados. Quando o volume de dados enviados numa única chamada é muito grande, a função muda o seu comportamento para economizar recursos. Ao carregar mais de 256 ticks, os dados são divididos em duas partes. A primeira parte (a maior) é imediatamente gravada no banco de ticks (como o faz CustomTicksReplace). A segunda parte, que consiste nos últimos 128 ticks, é enviada através da janela "Observação do mercado" e, em seguida, é armazenada na base do terminal.
- Adicionada a exibição de preços High e Low na Observação
do mercado. Por padrão, essas colunas estão desabilitadas. Elas podem
ser ativadas através do menu de contexto:
Para instrumentos cujos gráficos são construídos nos preços Bid (indicado na especificação) são mostrados os preços Bid High e Bid Low. Para instrumentos cujos gráficos são construídos nos preços Last são mostrados os preços Last High e Last Low.
Juntamente com as colunas High/Low é ativada automaticamente a coluna Last, se, na Observação do mercado, há pelo menos um instrumento cujos gráficos são construídos nos preços Last.
- Adicionado recurso para editar o histórico de ticks de
instrumentos financeiros personalizados. Clique em "Símbolos" no menu de
contexto da Observação do mercado, selecione o instrumento
personalizado e solicite o intervalo de dados necessário na guia
"Ticks".
- Para alterar o valor, clique duas vezes sobre ele.
- Para adicionar ou apagar entradas, use o menu de contexto.
- Para excluir várias barras/ticks, selecione-os com o mouse, mantenha pressionada a tecla Shift ou Ctrl+Shift.
Por conveniência, as entradas modificadas são destacadas:
- fundo verde — entrada alterada
- fundo cinza — entrada excluída
- fundo amarelo — entrada adicionada
Para salvar as alterações, clique em "Aplicar alterações" na parte inferior da janela.
- Adicionada a exibição de contas prévias na árvore do Navegador.
Traders podem enviar a corretoras pedidos para abrir contas reais diretamente a partir de terminais desktop. Para fazer isso, basta preencher um formulário simples com informações de contato, como ao abrir uma conta de demonstração. Após isso, para o trader, é criada uma conta prévia especial. Em seguida, a corretora entre em contato com o trader para formalizar relacionamento com o cliente e transformá-la em conta real.
- Adicionada a exibição do tempo em milissegundos na Janela de cotações:
- Rastreamento mais rápido de servidores disponíveis na caixa de diálogo da nova conta.
- Corrigida a exibição do objeto gráfico "Linha de tendência" com as opções "Raio para esquerda" e "Raio para a direita" ativadas.
- Otimizado o trabalho com muitas mensagens no correio interno (centenas de milhares).
- Otimizado o funcionamento do terminal com muitos instrumentos financeiros (50 mil ou mais).
- Adicionado recurso para otimização do histórico de ticks
de instrumentos personalizados realizada após a edição do histórico.
MetaEditor
Projetos com recursos completos estão agora disponíveis no MetaEditor. O processo de desenvolvimento de programas se tornou muito mais conveniente.
Agora o arquivo de programa principal MQ5 não é apresentado como projeto. O projeto é um arquivo separado "MQPROJ", em que são armazenadas as configurações do programa, os parâmetros de compilação e informações sobre todos os arquivos utilizados. O acesso às principais configurações do projeto é organizado através de uma caixa de diálogo separada, não há mais necessidade de especificá-las no código fonte através de #property.Para o trabalhar facilmente com o projeto, existe uma guia separada no Navegador. Ela mostra todos os arquivos usados por categorias: incluídos, de recurso, de cabeçalhos, etc. Além disso, os arquivos são adicionados ao navegador do projeto automaticamente. Por exemplo, se você habilitar um novo arquivo MQH no código, ele será exibido automaticamente na seção "Dependencies" do navegador.
Ao mesmo tempo, nós tornamos possível trabalhar com novos projetos no repositório online MQL5 Storage. Agora, o desenvolvimento de grandes projetos pode ser realizado conjuntamente com outros participantes da MQL5.community.Para trabalhar com projetos em grupo, foi adicionada a nova seção Shared Projects. O projeto criado nesta seção é imediatamente enviado para o repositório: você pode distribuir rapidamente permissões de acesso a ele a outros participantes e começar o desenvolvimento conjunto.
Quando você compila o projeto no Shared Project, o executável EX5 é automaticamente copiado no catálogo local Experts, Indicators ou Scripts, dependendo do tipo de programa. Você pode imediatamente executar o programa dentro do gráfico, sem ter que copiar os arquivos manualmente de cada vez.
Alterações no trabalho com o repositório MQL5 StoragePara uma experiência completa com projetos em grupo, foi refeito o protocolo de trabalho com o repositório MQL5 Storage. Infelizmente, após a atualização para uma nova versão da plataforma, você terá que re-extrair todos os dados a partir do repositório. Os dados armazenados nele não serão nem afetados nem perdidos.
Antes de atualizar para uma nova versão da plataforma, recomendamos que você envie todas as alterações locais para o repositório (executar Commit).
Agora o comando "Extrair dados do repositório" (Checkout from Storage) está indisponível. Para extrair dados, são usados os comandos "Ativar MQL5 Storage" e "Obter arquivo do repositório":
- Se, na cópia atual do MetaEditor, você ainda não tiver usado o repositório, clique no botão "Ativar MQL5 Storage" no menu contextual da janela "Navegador". Todos os diretórios e arquivos em seu repositório serão transferidos para um computador local.
- Se você já estiver trabalhando com o repositório, para extrair
dados, clique em "Obter arquivos do repositório" no menu contextual do
elemento raiz MQL5 na janela "Navegador".
Novos projetos: exemplo de criação e detalhes de trabalho
Ao MetaEditor foi adicionado o projeto. Trata-se de um arquivo com extensão mqproj, em que são armazenadas as propriedades gerais do programa, bem como informações sobre todos os arquivo utilizados. Agora é possível gerenciar facilmente as propriedades do programa numa caixa de diálogo separada do MetaEditor, em vez de alterá-las manualmente no código-fonte (diretiva #property).
Se você já tiver um projeto, a maneira mais fácil de experimentar novos projetos é usar o comando "Novo projeto a partir do arquivo-fonte."
No diretório em que o arquivo selecionado está localizado, será criado um novo arquivo de projeto com o mesmo nome e a extensão mqproj. As principais propriedades do programa especificadas no código-fonte via #property serão automaticamente adicionadas ao projeto, incluindo o nome, direitos de autor, versão, link para o site e programa de descrição do desenvolvedor.
Ao conjunto de propriedades do programa no arquivo de projeto é dada uma prioridade mais elevada do que às propriedades especificadas no código do programa. Se propriedades são especificadas tanto no projeto quanto no arquivo de origem, serão usadas as propriedades do projeto.
Foram adicionadas duas novas opções para compilar programas MQL5:
- Ativar otimização adicional: aplicativo com otimização desativada são compilados mais rápido, mas trabalham mais devagar.
- Verificar separadores de ponto flutuante: aplicativos com teste desativado correm ligeiramente mais rápido, porque a divisão por zero não é verificada durante a execução do código.
Para trabalhar com o projeto, use a guia separada "Projeto" na janela "Navegador". Todos os arquivos usados no projeto são exibidos nesta guia convenientemente. Quando um projeto é gerado a partir de um arquivo de origem, todos os arquivos anexados (especificados usando a diretiva #include no arquivo MQ5 principal e em todos os arquivos incluídos no mesmo) são automaticamente adicionados à seção "Dependencies".
Quando você adiciona novos arquivos no código fonte, eles também aparecerão no Navegador do projeto. Os arquivos de cabeçalho usados serão adicionados à seção Headers, enquanto as imagens, sons e outros programas MQL5 são adicionados ao projeto como recursos na seção Resources. Na seção Sources, são exibidos os arquivos MQ5 com código-fonte. Na seção Settings and files, pode-se adicionar outros arquivo, por exemplo, configurações de teste e modelos de gráficos.
Para adicionar arquivos existentes a um projeto ou para excluir os arquivos a partir dele, use os comandos do menu contextual. Tenha cuidado ao excluir, pois você pode estar removendo um arquivo de projeto (remover a ligação) ou completamente excluí-lo do disco rígido:
Criar um novo projeto é tão facilmente como a criação de um programa MQL5 convencional. Clique em "Novo projeto", selecione o tipo de programa e especifique suas propriedades (nome, manipuladores de eventos, etc.) no Assistente MQL5, no modo normal.
Para obter um arquivo executável EX5, você pode abrir um projeto e pressionar F7 (o comando de compilação) ou abrir o arquivo MQ5 principal do programa e compilá-lo.
Projetos em grupo no MQL5 Storage: detalhes de trabalho
Projetos em grupo são gerenciados a partir da seção Shared Projects. Se você não tiver conectado o repositório ainda, execute o comando Activate MQL5 Storage no menu de contexto desta pasta. MetaEditor verificará se o seu armazenamento contém dados armazenados e se existem quaisquer projetos disponíveis para você. Os dados existente serão recuperados do seu repositório e carregados na seu computador (Checkout). Os projetos em grupo serão exibidos na seção Shared Project, para extrai-los clique em "Extrair arquivos do repositório" no menu contextual.
Para criar um novo projeto grupal, selecione a pasta Shared Projects e clique em "Novo projeto":
Em seguida, complete as etapas do Assistente MQL5: defina o tipo, nome e propriedades do futuro programa. Para projetos em grupo, escolha nomes claros e compreensíveis, para que os outros participantes possam encontrá-los facilmente. Nos nomes dos projetos só podem ser usadas letras latinas sem espaços.
Imediatamente após a criação do projeto, ele é automaticamente adicionado ao repositório MQL5 Storage. Os arquivos usados pela biblioteca padrão no repositório não são adicionados, você pode adicioná-los manualmente, se necessário.
Para permitir outros participantes trabalharem com o projeto, abra suas propriedades. Você pode, especificando o login da MQL5.community, conceder permissões a usuários, bem como estabelecer os parâmetros gerais do trabalho em grupo:
- Projeto privado
- Livre para se juntar ao projeto
- Participação no projeto a pedido
A fim de facilitar o trabalho, ao compilar o projeto grupal, o executável final (EX5) é copiado automaticamente na pasta Experts, Indicators ou Scripts, dependendo do tipo de programa. Assim, você pode executar imediatamente o programa no terminal, sem ter que copiá-lo manualmente no diretório desejado.
Projetos públicos no MQL5 Storage: participação no desenvolvimento
Como mencionado acima, cada projeto em grupo, na MQL5 Storage, tem configurações de disponibilidade ao público: o projeto pode ser privado ou aberto à participação de outros usuários. Agora, todos os projetos com participação livre são exibidos na guia separada "Projetos públicos".
Todo mundo pode encontrar um projeto interessante e participar em seu desenvolvimento. Basta pressionar "Ingressar" e, em seguida, receber o projeto a partir do repositório.
Após ingressar, cada usuário recebe o direito apenas de visualizar o projeto. A fim de obter os direitos para enviar suas próprias alterações ao repositório, entre em contato com o autor do projeto. Para saber seu login, abra as propriedades do projeto no menu de contexto.
- Adicionada a capacidade de inserir facilmente
diferentes propriedades e recursos no código do programa. Por exemplo,
você pode adicionar rapidamente no código um arquivo. Selecione o
comando "Inserir - MQH como #incude", e, em seguida, escolha o arquivo a
ser incluído na janela que se abre. Após isso, ao código de programa é
adicionada a diretiva #include com o caminho apropriado para o arquivo
selecionado.
O mesmo menu do código do programa permite a adição de arquivos como uma matriz binária ou de texto. Por exemplo, você pode transferir modelos de gráficos junto com experts/indicadores: habilite seu modelo no código do programa na forma de uma matriz, em seguida, use a função FileSave para guardá-lo disco. Depois disso, o modelo pode ser aplicado a um gráfico utilizando a função ChartApplyTemplate.
//+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- arquivo de modelo como matriz binária unsigned char my_template[]= { 0xFF,0xFE,0x3C, ... ,0x00 // a matriz de dados é reduzida }; //--- armazenamento e implementação do modelo if(FileSave("my_template.tpl",my_template)) { Print("Custom template saved in \\MQL5\\Files"); if(ChartApplyTemplate(0,"\\Files\\my_template.tpl")) Print("Custom template applied to the current chart"); else Print("Failed to apply custom template"); } else Print("Failed to save custom template"); }
- Adicionada funcionalidade para conversão de linhas
entre formatos ASCII, HEX e Base64. Selecione a linha no código-fonte e
clique no comando adequado no menu "Editar - Converter":
- Corrigida a pesquisa por arquivos sem diferenciação de maiúsculas e minúsculas.
- Corrigido o bug no depurador durante o cálculo dos valores da expressão do tipo x.y[0][1].z.
- Corrigida a navegação pelo código usando os botões "Anterior" e "Avançar".
MQL5
- Adicionado o novo serviço online para proteção secundária de
programas MQL5, o MQL5 Cloud Protector. Esta proteção é semelhante com a
utilizada na mais grande loja de aplicativos de negociação, o Mercado MetaTrader, onde arquivos de produtos (EX5) enviados por vendedores são ainda compilados em código nativo.
Agora, este tipo de proteção está disponível para todos os usuários da plataforma. Basta executar o comando Serviço - MQL5 Cloud Protector no MetaEditor. Esta proteção difere da do Mercado em que o arquivo não está ligado ao computador do usuário. Arquivos protegidos pela MQL5 Cloud Protector podem ser executados em qualquer computador como arquivos EX5 convencionais.O serviço MQL5 Cloud Protector é seguro. Proteção adicional é aplicada apenas no arquivo já compilado. O código-fonte não é enviado para nenhum lugar. Primeiro, o programa é compilado num arquivo EX5, no computador do usuário, em seguida, o arquivo compilado é enviado através de uma conexão criptografada ao serviço, onde é protegido e devolvido ao utilizador.
- Adicionadas funções para trabalhar com instrumentos financeiros personalizados.
Função Ação CustomSymbolCreate Cria um símbolo personalizado com o nome especificado no grupo definido CustomSymbolDelete Remove o símbolo personalizado com o nome especificado CustomSymbolSetInteger Define o valor do tipo inteiro para o símbolo personalizado CustomSymbolSetDouble Define o valor do tipo real para o símbolo personalizado CustomSymbolSetString Define o valor do tipo cadeia de caracteres para o símbolo personalizado CustomSymbolSetMarginRate Define o coeficiente de cobrança da margem - dependendo do tipo e direção da ordem - para o símbolo personalizado CustomSymbolSetSessionQuote Define a hora de início e fim da sessão de cotação especificada para o símbolo especificado e dia da semana CustomSymbolSetSessionTrade Define a hora de início e fim da sessão de negociação especificada para o símbolo especificado e dia da semana CustomRatesDelete Exclui todas as barras no histórico de preço do instrumento personalizado, no intervalo de tempo selecionado CustomRatesReplace Substitui todo o histórico de preços do instrumento personalizado pelos dados na matriz do tipo MqlRates, no intervalo de tempo definido CustomRatesUpdate Adiciona ao histórico do instrumento personalizado as barras que faltam e substitui os dados existentes na matriz do tipo MqlRates CustomTicksAdd Adiciona dados de uma matriz do tipo MqlTick ao histórico de preços de um símbolo personalizado. O símbolo personalizado deve ser selecionado na janela Market Watch (Observação do mercado). CustomTicksDelete Exclui todos os ticks no histórico de preço do instrumento personalizado, no intervalo de tempo selecionado CustomTicksReplace Substitui todo o histórico de preço do instrumento personalizado pelos dados na matriz do tipo MqlTick, no intervalo de tempo definido
- Adicionadas Coleções de dados genéricas à biblioteca padrão, elas contêm classes e interfaces para definição de coleções com base em modelos.
As novas coleções fortemente tipadas proporcionam uma maior comodidade e
desempenho durante manipulação de dados do que as coleções tipadas
convencionais.
A biblioteca está localizada no diretório de trabalho do terminal na pasta Include\Generic.
- adicionado o suporte a modelos para dados do tipo union.
- Adicionada a propriedade do instrumento de negociação SYMBOL_VISIBLE. Chamada de SymbolInfoInteger(symbol, SYMBOL_VISIBLE) retorna false, se o símbolo especificado não é visível na Observação do mercado.
- Adicionado o evento CHARTEVENT_MOUSE_WHEEL. Este evento é chamado ao rolar o pressionar a roda do mouse no gráfico (se para ele é definida propriedade CHART_EVENT_MOUSE_WHEEL=true).
- Adicionadas novas propriedades do gráfico:
- CHART_EVENT_MOUSE_WHEEL - ativar/desativar a geração do evento de rolagem e pressionado de roda do mouse no gráfico CHARTEVENT_MOUSE_WHEEL. Valores possíveis: 0 e 1.
- CHART_CROSSHAIR_TOOL - habilitar/desabilitar o recurso de alternância de mouse no modo "fio de retículo" pressionando o botão do meio do mouse. Valores possíveis: 0 e 1.
- CHART_CONTEXT_MENU - habilitar/desabilitar a exibição do menu de contexto pressionando o botão direito do mouse no gráfico. Valores possíveis: 0 e 1.
- CHART_EVENT_MOUSE_WHEEL - ativar/desativar a geração do evento de rolagem e pressionado de roda do mouse no gráfico CHARTEVENT_MOUSE_WHEEL. Valores possíveis: 0 e 1.
- Agora ao calcular a escala da janela do indicador não são levados em conta os buffers de desenho com o estilo DRAW_NONE.
- Adicionada a geração do evento CHARTEVENT_CHART_CHANGE ao definir a propriedade CHART_SCALEFIX (escala fixa) para o gráfico.
- Adicionada a função ArraySwap, ela permite compartilhar rapidamente conteúdo de matrizes dinâmicas.
bool ArraySwap( void& array1[], // primeira matriz void& array2[] // segunda matriz );
A função implementa matrizes dinâmicas do mesmo tipo e as mesmas dimensões. Para matrizes multidimensionais, o número de elementos em todas as dimensões, excepto o primeiro, tem de ser o mesmo.
- Adicionada a nova propriedade TERMINAL_RETRANSMISSION - porcentagem de pacotes de rede re-enviados (re-transmits) no protocolo TCP/IP
para todos os aplicativos e serviços executados no computador. A perda
de pacotes ocorre mesmo em redes rápidas e configuradas corretamente.
Quando ela ocorre, não há confirmação do fornecimento de pacotes entre o
receptor e o remetente. Por conseguinte, pacotes perdidos são
reenviados.
O terminal não calcula esse valor; ele é solicitado uma vez por minuto a partir do sistema operacional. Além disso, não é uma indicação da qualidade da conexão entre um terminal particular e um servidor de negociação, uma vez que a porcentagem é calculada para toda a atividade da rede, incluindo de sistema e de atividade de fundo.
Propriedade TERMINAL_RETRANSMISSION adicionada à enumeração ENUM_TERMINAL_INFO_DOUBLE, para acessá-la, usa-se a função TerminalInfoDouble. - Aprimorado o trabalho com o histórico de negociação.
Signals
- Corrigida a colocação do tipo de execução de ordem com
base no resíduo (filling) durante o fechamento forçado de posições
abertas com o sinal. Nas configurações de cópia dos sinais existe a
opção "Stop, se a conta for inferior a US$ XXX": se o nível de fundos na
conta cair abaixo do indicado, a cópia dos sinais de negociação é
automaticamente interrompida, todas as posições são forçosamente
fechadas. Anteriormente, após o fechamento forçado de posições, em
alguns casos, para ordens de fechamento, o tipo de preenchimento era
indicado de maneira incorreta. Agora, o terminal verifica os tipos de
preenchimento permitidos nas configurações do símbolo e especifica a
opção válida nas ordens.
Tester
- O comportamento da função HistoryOrderSelect no testador de estratégias é alinhado com o terminal do cliente.
- O coportamento das funções CopyTicks e CopyTicksRange no testador de estratégias é alinhado com o terminal do cliente.
- Otimizada a exibição de objetos gráficos para os testes no modo visual.
- Corrigida a exibição de resultados de teste de instrumentos bolsistas (com modelo bolsista de gestão de risco).
Agora, o gráfico mostra apenas o capital (equity), o saldo e a carga
sobre o depósito não são mostrados. As condições de negociação dessas
contas são estimadas com base no nível dos fundos. O saldo mostra apenas
o dinheiro na conta e não leva em conta os ativos e passivos do trader.
Carga no depósito (margin/equity) não é mostrada, uma vez que a margem é
o custo atual do ativo/passivo levando em conta o desconto, e ela varia
com o capital.
21 julho 2017
MetaTrader 5 build 1640: criação e teste de instrumentos financeiros personalizados
Terminal
- Adicionada a possibilidade de criar instrumentos
financeiros personalizados. Agora você pode criar qualquer instrumento,
definir para ele tipos de configurações, importar para ele dados de
preços, e conferir seus gráficos.
Criando um símbolo personalizado
Abra a janela de gerenciamento de símbolos através do menu de contexto "Observação do mercado" e clique em "Criar símbolo":
Há muitas opções disponíveis para configuração. Sua lista e descrição pode ser encontrada na documentação. Você pode configurar rapidamente um instrumento personalizado, basta copiar os parâmetros de qualquer instrumento similar, e, em seguida, mudar o que você precisa. Para fazer isso, selecione um instrumento existente no campo "Copiar de".
O nome do símbolo personalizado não deve interferir com os nomes dos símbolos transmitidos pelas corretoras. Se você se conetar ao servidor e nele houver um símbolo que coincide com o personalizado, o símbolo personalizado será excluído.Aqui você também pode encontrar os comandos importação e exportação de configurações. Você pode facilmente compartilhar símbolos personalizados ou transferir símbolos entre seus terminais. As configurações são exportadas para arquivos de texto JSON.
Gerenciando símbolos personalizados
Todos os símbolos são exibidos num grupo separado - Custom. Para alterar ou apagar um símbolo, use o menu de contexto na lista:
Importando o histórico de preço
Você pode importar dados de preços para seu próprio símbolo a partir de qualquer arquivo de texto. Escolha um símbolo, e, em seguida, clique na guia "Barras".
Na caixa de diálogo de importação, especifique o caminho para o arquivo com os dados e defina as configurações:
- Separador — separador de elementos num arquivo de texto.
- Omissão de colunas e linhas — número de colunas (da esquerda para a direita) e linhas (de cima para baixo) que deve ser ignorado durante a importação.
- Deslocamento — mudança de horário em horas. Esta opção é usada ao importar os dados armazenados noutro fuso horário.
- Apenas selecionados — esta opção permite importar apenas as linhas selecionadas na janela de visualização de linhas. As linhas podem ser selecionadas usando o mouse mantendo pressionada a tecla "Ctrl" ou "Shift".
O arquivo com barras de minuto deve estar no formato: Data Hora Open High Low Close VolumeDeTicks Volume Spread. Por exemplo:
2016.06.27 00:01:00 1.10024 1.10136 1.10024 1.10070 18 54000000 44Para seu o símbolo personalizado, você pode usar os dados de qualquer instrumento existente. Exporte-os (essa funcionalidade foi adicionada na versão anterior da plataforma), modifique-os, se necessário, e, em seguida, importe de volta.
2016.06.27 00:02:00 1.10070 1.10165 1.10070 1.10165 32 55575000 46
2016.06.27 00:03:00 1.10166 1.10166 1.10136 1.10163 13 13000000 46
2016.06.27 00:04:00 1.10163 1.10204 1.10155 1.10160 23 51000000 41
No MetaTrader 5, o histórico é armazenado na forma de barras de minuto. Todos os outros timeframes são baseados nelas. Ao importar, você pode usar os dados dos timeframes maiores, mas deve ter em conta que os gráficos dos timeframes menores, por enquanto, terão lacunas. Por exemplo, quando você importa dados horários, no gráfico de minuto, você verá uma barra por cada hora.Os dados de preço dos símbolos personalizados são armazenados separadamente no diretório Custom (fora dos diretórios de dados de servidores de negociação específicos):
C:\Users\[windows account]\AppData\Roaming\MetaQuotes\Terminal\[instance id]\bases\Custom
Usando símbolos personalizados
O uso de símbolos personalizados não difere do dos fornecidos pela corretora. Eles também são exibidos na janela "Observação do mercado", e podem abrir gráficos em que podem ser colocados indicador e objetos analíticos. Além disso, porém, não se pode negociar em símbolos personalizados.
Testando estratégias em símbolos personalizados
Os símbolos personalizados criados podem ser utilizados para testar os robôs de negociação e indicadores no testador de estratégias. Isso permite a otimização de estratégias, mesmo para os instrumentos financeiros que não estão disponíveis atualmente na corretora. Basta corretamente importar o histórico e definir as propriedades do símbolo personalizado.
Ao calcular a margem e o lucro, o testador de estratégias utiliza automaticamente as cotações de Forex disponíveis. Suponha que estamos criando o símbolo personalizado AUDCAD.custom com Forex, como tipo de cálculo de margem, e USD como moeda de nossa conta. Neste caso, com nase no nome do instrumento Forex o testador procura os símbolos necessários na seguinte ordem:
- primeiro são procurados os símbolos AUDUSD.custom (para o cálculo da margem) e USDCAD.custom (para o cálculo do lucro em transações)
- em seguida, se um destes instrumentos não estiver presente, será procurado o primeiro símbolo que corresponde - pelo nome - aos pares de moedas necessários, isto é, AUDUSD e USDCAD respectivamente. Por exemplo, encontrados AUDUSD.b e NZDUSD.b, as cotações destes símbolos serão utilizados ao calcular a margem e o lucro.
Instrumentos com outros tipos de cálculo de margem (Futures, Stock Exchange) requerem um par de moeda a fim de converter a moeda do instrumento para a moeda do depósito. Imagine que criamos um símbolo personalizado com moedas de lucro e de margem expressas em libras esterlinas (GBP), enquanto a moeda de depósito é o franco suíço (CHF). Neste caso, a busca de instrumentos para teste é realizada na seguinte ordem:
- Verifica-se a presença do instrumento financeiro que corresponde ao par de moedas GBPCHF (GBP vs CHF).
- Se não ele não existir, será procurado o primeiro instrumento de negociação que corresponde - pelo nome - ao par de moedas GBPCHF, por exemplo, GBPCHF.b ou GBPCHF.def.
Ao testar usando instrumentos personalizados, certifique-se de que na conta de negociação estão disponíveis todos os pares de moedas necessários para os cálculos. Caso contrário, o cálculo de resultados financeiros e requisitos de garantia não será possível para o teste.
Mais funcionalidades nas futuras versões da plataforma
O desenvolvimento de instrumentos personalizados ainda não foi concluído, e mais funções serão adicionadas nas próximas compilações da plataforma. Você poderá importar o histórico para os símbolos personalizadas diretamente a partir dos EAs, bem como transmitir dados (adicionar cotações) de esses símbolos em tempo real.
- Adicionada a filtragem do canal de transações de acordo com o volume.
No canal, é possível ocultar transações com um volume inferior ao especificado. Assim, no canal ficam apenas as transações grandes que têm maior impacto no mercado.
Dê um duplo clique na primeira linha do canal de transações, especifique o volume mínimo em lotes e, em seguida, clique em qualquer outra área do livro de ofertas. Transações serão filtradas, enquanto o valor atual do filtro aparecerá no título da coluna de volume.
Também é possível definir o volume mínimo através do menu de contexto do canal de transações.
- Adicionada a possibilidade de ligar o livro de ofertas
ao gráfico em execução. Toda vez que você alterne para ver o gráfico de
um instrumento financeiro, no livro de ofertas, será ligado exatamente o
mesmo instrumento. Você não terá que abrir um livro de ofertas
separados para cada novo símbolo.
- Adicionada a atualização da barra de ferramentas após minimizar e maximizar a janela do terminal.
- Corrigida a geração do histórico de negociação no cruzamento dos bilhetes das transações e das posições.
MQL5
- Adicionada a possibilidade de criar perfis de programas
MQL5 sobre o histórico de preço. Isto permite verificar rapidamente o
desempenho dos programas sem esperar por novos ticks.
Durante a criação de perfis sobre dados reais, o programa é executado num gráfico habitual, no terminal. Muitos programas, especialmente indicadores, realizam cálculos apenas após a chegada de um novo tick (OnTick, OnCalculate). Assim, para avaliar o desempenho, é necessário aguardar o aparecimento de novos ticks em tempo real. Ao testar em dados históricos, você pode dar a carga correta para o programa. A criação de perfis é executada no testador de estratégias num modo visual, de modo que você possa receber eventos de novos ticks de vez.
- Adicionado o suporte União (union).
Trata-se de um tipo de dados especial que consiste de uma série de
variáveis que compartilham o mesmo espaço de memória.
Consequentemente, a união permite interpretar a mesma sequência de bits
de duas (ou mais) formas diferentes. A união começa com a palavras-chave
"union".
union LongDouble { long long_value; double double_value; };
Em contraste com a estrutura, os diferentes membros da união pertencem ao mesmo local de memória. Neste exemplo, é declarada a união LongDouble, em que o valor do tipo long e o valor do tipo double dividem a mesma área de memória. É importante entender que é impossível fazer com que esta união armazene simultaneamente um valor inteiro long e um real double (como seria na estrutura), porque as variáveis double_value e long_value se sobrepõem (na memória). Por outro lado, o programa MQL5 é capaz de processar os dados da união como um número inteiro (long) ou um real (double) a qualquer momento. Consequentemente, a união permite a obtenção de dois (ou mais) variantes de representação da mesma sequência de dados.
Ao declarar a união, o compilador automaticamente aloca uma área de memória suficiente para armazenar - na união - as variáveis de maior de tipo segundo o volume. A mesma sintaxe é usada para acessar o elemento de união como para as estruturas, ou seja, o operador "ponto".union LongDouble { long long_value; double double_value; }; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- LongDouble lb; //--- obtemos e exibimos o número inválido -nan(ind) lb.double_value=MathArcsin(2.0); printf("1. double=%f integer=%I64X",lb.double_value,lb.long_value); //--- maior número normalizado (DBL_MAX) lb.long_value=0x7FEFFFFFFFFFFFFF; printf("2. double=%.16e integer=%I64X",lb.double_value,lb.long_value); //--- menor positivo normalizado (DBL_MIN) lb.long_value=0x0010000000000000; printf("3. double=%.16e integer=%.16I64X",lb.double_value,lb.long_value); } /* Resultado de execução 1. double=-nan(ind) integer=FFF8000000000000 2. double=1.7976931348623157e+308 integer=7FEFFFFFFFFFFFFF 3. double=2.2250738585072014e-308 integer=0010000000000000 */
- Adicionada a geração automática de um operador de cópia
implícito para objetos de estruturas e classes. Agora, o compilador cria
automaticamente operadores de cópia que permitem escrever entradas
simples para objetos, como b=a:
class Foo { int value; public: string Description(void){return IntegerToString(value);}; //--- construtor por padrão Foo(void){value=-1;}; //--- construtor com parâmetros Foo(int v){value=v;}; }; //+------------------------------------------------------------------+ //| estrutura contendo o objeto do tipo Foo | //+------------------------------------------------------------------+ struct MyStruct { string s; Foo foo; }; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- MyStruct a,b; Foo an_foo(5); a.s="test"; a.foo=an_foo; Print("a.s=",a.s," a.foo.Description()=",a.foo.Description()); Print("b.s=",b.s," b.foo.Description()=",b.foo.Description()); //--- Print("b=a"); b=a; //--- Print("a.s=",a.s," a.foo.Description()=",a.foo.Description()); Print("b.s=",b.s," b.foo.Description()=",b.foo.Description()); /* Resultado de execução; a.s=test a.foo.Description()=5 b.s= b.foo.Description()=-1 b=a a.s=test a.foo.Description()=5 b.s=test b.foo.Description()=5 */ }
No operador implícito, é realizada a cópia de objetos recebidos.
- Se o membro é um objeto, é chamado o operador de cópia correspondente para este objeto.
- Se o membro é uma matriz de objetos, a matriz de recebimento
é aumentada ou reduzida ao tamanho de requisição usando ArrayResize
antes de chamar o operador de cópia apropriado para cada elemento.
- Se o membro é uma matriz de tipos de simples, para copiar, usada a função arraycopy.
- Se o membro é um ponteiro para um objeto, é copiado o ponteiro, mas não o objeto para o qual ele aponta.
Se necessário, você pode substituir o comportamento e, em vez do operador implícito de cópia, criar sua própria versão usando sobrecarga.
- Otimizado o uso de memória ao acessar o histórico de preço a partir dos EAs usando o Copy* funções. Ao trabalhar com grandes quantidades de dados, o consumo de memória será reduzido repetidamente.
- Agora a função TimeToStruct retorna um valor booleano, permitindo verificar o sucesso da conversão de datetime para MqlDateTime.
- Adicionada a restrição do uso de funções FileWriteStruct e FileReadStruct para estruturas que contêm cadeias de caracteres, matrizes dinâmicas, objetos e ponteiros.
- Adicionados códigos de resposta:
- TRADE_RETCODE_REJECT_CANCEL — solicitação - para ativação de ordem pendente - rejeitada, enquanto a ordem é rejeitada
- TRADE_RETCODE_LONG_ONLY — solicitação rejeitada, uma vez que
a regra "Somente posições longas são permitidas" é definida para o
símbolo
- TRADE_RETCODE_SHORT_ONLY — solicitação rejeitada, uma vez
que a regra "Somente posições curtas são permitidas" é definida para o
símbolo"
- TRADE_RETCODE_CLOSE_ONLY — solicitação rejeitada, uma vez
que a regra "Somente o fechamento de posições existentes é permitido" é
definida para o símbolo
- TRADE_RETCODE_REJECT_CANCEL — solicitação - para ativação de ordem pendente - rejeitada, enquanto a ordem é rejeitada
- Adicionado um novo valor retornado pela função SymbolInfoInteger com parâmetro SYMBOL_ORDER_MODE. SYMBOL_ORDER_CLOSEBY — sinalizador de possibilidade de colocar ordens de fechamento de posição usando a oposta (Close By).
- À enumeração ENUM_SYMBOL_INFO_INTEGER adicionada a propriedade booleana SYMBOL_CUSTOM. Ele permite que você saiba se o símbolo é personalizado. Para obter a propriedade, use a função SymbolInfoInteger.
- Adicionada a possibilidade de obter razões para criar ordens, transações e posições.
Novas propriedades
- Para posições, adicionada a propriedade POSITION_REASON, que pode ser obtida usando PositionGetInteger.
- Para transações, adicionada a propriedade DEAL_REASON, que pode ser obtida usando HistoryDealGetInteger.
- Para ordens, adicionada a propriedade ORDER_REASON, que pode ser obtida usando OrderGetInteger e HistoryOrderGetInteger.
Razões para criar ordens, transações e posições
Para obter razões a fim de criar operações de negociação, adicionadas três enumerações:
ENUM_POSITION_REASON ENUM_DEAL_REASON ENUM_ORDER_REASON Descrição de razões POSITION_REASON_CLIENT DEAL_REASON_CLIENT ORDER_REASON_CLIENT Transação realizada como resultado da ativação de uma ordem colocada a partir de um terminal desktop POSITION_REASON_MOBILE DEAL_REASON_MOBILE ORDER_REASON_MOBILE Transação realizada como resultado da ativação de uma ordem colocada a partir de um aplicativo móvel POSITION_REASON_WEB DEAL_REASON_WEB ORDER_REASON_WEB Transação realizada como resultado da ativação de uma ordem colocada a partir da plataforma web POSITION_REASON_EXPERT DEAL_REASON_EXPERT ORDER_REASON_EXPERT Transação realizada como resultado da ativação de uma ordem colocada a partir de um programa MQL5, Expert Advisor ou script - DEAL_REASON_SL ORDER_REASON_SL Transação realizada como resultado da ativação de uma ordem Stop Loss - DEAL_REASON_TP ORDER_REASON_TP Transação realizada como resultado da ativação de uma ordem Stop Loss - DEAL_REASON_SO ORDER_REASON_SO Transação realizada como resultado do evento Stop Out - DEAL_REASON_ROLLOVER - Transação realizada devido à transferência da posição - DEAL_REASON_VMARGIN - Transação realizada após creditada/debitada a margem de variação - DEAL_REASON_SPLIT - Transação realizada após o fracionamento (redução do preço) do ativo que tinha a posição aberta durante a declaração do fracionamento
- Otimizada a sincronização e acesso ao histórico de ticks.
- Corrigido o erro de retorno de ticks para a matriz estática na função CopyTicksRange. Anteriormente, neste caso, sempre eram retornos 0 ticks.
- Várias correcções foram feitas na biblioteca de lógica difusa Fuzzy.
Signals
- Corrigida a abertura de um sinal do site quando não há conexão da conta de negociação.
Tester
- Otimizado e acelerado o trabalho com o histórico de ordens e transações. A velocidade de operação será aumentada ao trabalhar com grandes quantidades de dados (dezenas de milhares de entradas no histórico).
- Corrigido o cálculo fixo do tempo de espera da posição no relatório de teste.
MetaEditor
- No depurador, corrigida a exibição de classes estáticas de matrizes de membros.
- Adicionada uma lista de pontos de interrupção no
programa que está sendo depurado. A lista pode ser aberta usando o menu
de contexto da guia "Depuração":
Para navegar até um ponto de interrupção, clique duas vezes nele.
26 abril 2017
MetaTrader 5 build 1596: acesso ao histórico de preço
Terminal
- Adicionado o acesso ao histórico de barra e de ticks.
Agora é possível baixar todo o histórico de ticks de minuto a partir do
servidor, más só através da MQL5, com ajuda da interface da plataforma. O
acesso a dados de preço se expande no que diz respeito à preparação
para o lançamento da função fonte de dados personalizada. Em breve a
plataforma poderá plotar gráficos com base em seus próprios dados de
preço, criar símbolos sintéticos e usar gráficos off-line.
Para baixar dados, abra o gestor de símbolos no menu de contexto da "Observação do mercado".
Agora, nele, estão disponíveis duas guias novas, isto é: "Barras" e "Ticks". Selecione o símbolo, período e clique em "Pedido". A plataforma pedirá todos os dados disponíveis a partir do servidor ou serão exibidos imediatamente se eles já estiverem carregados. Os dados de preço armazenados podem ser exportados para arquivos CSV.
- Adicionada a exibição de tempo com precisão de milissegundos para posições, transações e ordens.
- Na caixa de diálogo de negociação corrigida a
notificação sobre a recusa na execução do pedido para fechamento da
posição usando a posição oposta.
MQL5
- Corrigido o trabalho da função PositionSelect. Em alguns casos, não era selecionada a posição com o menor bilhete.
- Corrigido o trabalho das funções CopyTicks e CopyTicksRange ao solicitar o histórico de ticks a uma grande profundidade.
Signals
- Corrigido o erro de cópia de sinais ao aumentar o tamanho
de uma posição já existente. O erro ocorria, em alguns casos, em contas
de compensação.
Tester
- Corrigido o processamento de ordens limit para
instrumentos bolsistas. As ordens, colocadas melhor do que o mercado
(preço de compra abaixo do de mercado, ou preço de venda acima do de
mercado), são executadas sem derrapagem. As ordens, colocadas pior do
que o mercado, são executadas imediatamente após a colocação segundo o
preço de mercado nesse mesmo momento.
Documentação atualizada.
24 março 2017
MetaTrader 5 build 1570: melhoria do mostruário do Mercado e expansão de funções de modelo em MQL5
Terminal
- Atualizado o mostruário da loja de aplicativos MetaTrader Market.
A escolha de robôs de negociação e indicadores técnicos tornou-se mais
fácil. Nós não só atualizamos o design, mas também acrescentamos a
seleção de produtos:
- Na página principal agora são mostrados os mais populares Experts, indicadores, produtos recentes do Mercado, bem como os melhores aplicativos gratuitos.
- Nas seções de Experts, indicadores e utilitários apareceram
subcategorias: robôs de cobertura e de grade, indicadores de tendência e
multimoeda, e muito mais.
- Corrigida tanto a atualização do terminal de cliente
quanto a mecânica das compras embutidas no Mercado, Sinais e Hospedagem
Virtual, ao utilizar a conta de usuário de Windows com privilégios
restritos.
- Corrigido o erro que, em alguns casos, levava à classificação incorreta do histórico de posições.
- otimizada e corrigida a exibição da aba "Ativos".
MQL5
- Adicionado o suporte para a sobrecarga de funções de modelo de parâmetros. Por exemplo, se existir uma função de modelo que
registra no primeiro parâmetro o valor do segundo parâmetro usando uma
conversão explícita de tipos. Em linguagem MQL5 é proibida a conversão
do tipo string para o tipo bool, mas podemos fazer isto nós mesmos.
Criamos uma sobrecarga de função de modelo:
//+------------------------------------------------------------------+ //| Função de modelo | //+------------------------------------------------------------------+ template<typename T1,typename T2> string Assign(T1 &var1,T2 var2) { var1=(T1)var2; return(__FUNCSIG__); } //+------------------------------------------------------------------+ //| Sobrecarga especial para o caso bool+string | //+------------------------------------------------------------------+ string Assign(bool &var1,string var2) { var1=(StringCompare(var2,"true",false) || StringToInteger(var2)!=0); return(__FUNCSIG__); } //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { int i; bool b; Print(Assign(i,"test")); Print(Assign(b,"test")); }
Como resultado da execução deste código, podemos ver que para o par int+string foi utilizada a função de modelo Assign(), enquanto, na segunda chamada, para o par bool+string já foi utilizada a versão sobrecarregada.
string Assign<int,string>(int&,string) string Assign(bool&,string)
- adicionada a possibilidade de especialização explícita de
funções de modelo. Para fazer isto, antes da lista de parâmetros de
chamada, é preciso especificar os parâmetros de digitação:
template<typename T> T Func() { return (T)0; } void OnInit() { Func<double>(); // especialização explícita da função de modelo }
Assim, a especialização não se realiza através do parâmetro de chamada, mas sim especificando os tipos.
- Otimizada a exibição de indicadores de usuário com o tipo de desenho DRAW_ZIGZAG.
- Na enumeração de tipos de transações ENUM_DEAL_TYPE adicionados novos valores:
- DEAL_DIVIDEND — operação de dividendo.
- DEAL_DIVIDEND_FRANKED — operação de dividendo franqueado (não tributável, a empresa paga pelo cliente).
- DEAL_TAX — dedução de imposto.
- Corrigida a exibição de indicadores com o tipo de desenho DRAW_FILLING. Caso coincidam as coordenadas das linhas superior e inferior, agora é desenhada uma linha fina.
- Corrigido o cálculo de coordenadas do objeto "Etiqueta bitmap" (Bitmap Label) ao definir o parâmetro CHART_SHOW na condição false. Este parâmetro é definido pela função ChartSetInteger e permite ocultar todos os elementos do gráfico de preço a fim de criar uma interface própria de programa.
- Corrigido o erro de transcodificação de imagens de 24 bits ao serem colocadas nos recursos do aplicativo MQL5.
- Corrigido o erro de impressão de estruturas das funções ArrayPrint.
- Atualizadas as bibliotecas-padrão MQL5.
MetaEditor
- Adicionada a tradução da interface de usuário para malaio.
Signals
- Corrigida a abertura da pagina de sinal no terminal,
durante a transição a partir do site da MQL5.community, caso a conta de
negociação não esteja conectada.
Tester
- Corrigido o erro da função CopyTicks em execução, no testador de estratégias.
- Corrigida a classificação de transações do tipo "Retirada" (Withdrawal) ao gerar um relatório de teste.
- Corrigida a modificação de ordens pendentes.
Hosting
- Corrigida a exibição do assistente da hospedagem virtual em telas de altíssima resolução (4K).
Documentação atualizada.
17 fevereiro 2017
MetaTrader 5 build 1545: rápida alternância entre janelas e alteração dos preços usando o mouse
Terminal
- Foi adicionada a alternância rápida entre as janelas "Caixa de Ferramentas" e "Testador de Estratégias."
- foi adicionada a possibilidade de alterar os preços e volumes das ordens usando a roda do mouse:
- Agora, ao alternar para baixar os terminais móveis, é
armazenada a lista de seus servidores de negociação. Após instalar o
MetaTrader 5, para iPhone ou Android, no dispositivo móvel, aparecerá
imediatamente uma lista pronta com os servidores. Assim, você poderá
conectar rapidamente as contas de negociação existentes. O servidor da
conta conectada atualmente será exibido primeiro no terminal móvel.
- Foi reduzida significativamente a carga - sobre o
terminal - criada pelos gráficos e objetos recolhidos, ou seja, em
segundo plano.
- Foi corrigido o erro que, em alguns casos, levava à ativação incorreta dos Trailing-Stops.
- Foi corrigido o erro de filtragem de símbolo, no histórico de negociação da conta.
- Foi corrigido o erro de exibição do campo "Type", no histórico de posições.
- Foi corrigido o erro de formação e apresentação do histórico de negociação sob a forma de posições.
MQL5
- Foi corrigida a exibição de indicadores personalizados com o tipo de plotagem DRAW_COLOR_LINE, DRAW_COLOR_ZIGZAG e DRAW_COLOR_SECTION ao utilizar a cor CLR_NONE.
- Foi corrigido o erro nos modelos ao digitar o ponteiro constante.
- Foi corrigido o controle do acesso aos membros de classe private e protected.
Tester
- Foi corrigida a ativação de ordens limit - nos instrumentos financeiros - quando o valor da ordem a ser colocada é pior em relação ao mercado (quer o preço de compra é superior quer o preço de venda é inferior ao proposto pelo mercado).
- Foi removida a restrição no teste de indicadores personalizáveis com mais de 64 parâmetros de entrada.
- Foi adicionada a tradução da interface de usuário para hindi.
Documentação atualizada.
27 janeiro 2017
MetaTrader 5 build 1525: Apresentação do histórico na forma de posições e melhorias no testador
Terminal
- Foi adicionada a apresentação do histórico na forma de
posições. O terminal de recolhe dados sobre transações relacionadas com a
posição (abertura, aumento, fechamento parcial e total) e agrupa este
dados numa única conta, onde é possível ver imediatamente:
- Momento - de abertura e fechamento de posição - a ser determinado pela primeira e a última transação, respectivamente
- Volume da posição; se a posição é fechada parcialmente, são exibidos o volume fechado e o volume original
- Preço de abertura médio ponderado e preço de fechamento de posição
- Resultado financeiro total das transações relacionadas com a posição
Para contas de cobertura, esse tipo de apresentação de posições, na verdade, é semelhante ao histórico da conta na plataforma MetaTrader 4.
- Momento - de abertura e fechamento de posição - a ser determinado pela primeira e a última transação, respectivamente
- Foi adicionado um comando para processar o histórico de transações no gráfico de um determinado símbolo.
- Para exibir todas as transações somente no símbolo da posição/transação selecionada, clique em "Adicionar transação por [nome do símbolo]." Transações serão adicionadas a todos os gráficos abertos atualmente de acordo com este símbolo. Se não houver gráficos abertos, será aberto um novo.
- Para exibir as transações para todos os símbolos a partir do histórico da conta, clique em "Adicionar todas as transações." Em todos os gráficos abertos, serão adicionadas todas as operações de acordo com o símbolo correspondente.
- Foram adicionadas tanto a exibição do nome internacional
do instrumento de negociação nas especificações do contrato, como a
possibilidade de procurar segundo ele na caixa de diálogo de controle de
instrumentos.
- Foi adicionada a possibilidade de definir rapidamente a
resolução para a janela do terminal. A função será útil para aqueles que
fazem vídeos. No menu, estão disponíveis as mais populares resoluções
para a publicação em serviços de vídeo, como YouTube.
- Escalas e perfis de gráficos migrados a partir de
[diretório de dados do terminal\Profiles] para [diretório de dados do
terminal\MQL5\Profiles]. Agora é possível adicionar facilmente escalas
no repositório MQL5 Storage e utilizá-las com qualquer um dos seus computadores.
- Foi adicionado o suporte para variáveis de recurso. Sua
utilização pode facilitar muito a escrita de alguns programas. Por
exemplo, você pode escrever um código em OpenCL num arquivo CL separado
e, em seguida, incluir esse arquivo - como uma cadeia de caracteres -
nos recursos de seu programa MQL5. Anteriormente, em vez disso, era
necessário descrever esse código como uma variável de cadeia grande.
Declaração da variável de recurso
#resource caminho_para_o_arquivo_do_recurso as tipo_de_variável_de_recurso nome_de_variável_de_recurso
Características
- Para arquivos de sequência de caracteres, a codificação de BOM
(cabeçalho) é detectada automaticamente. Se não houver nenhum BOM, a
codificação será determinada pelo conteúdo. São suportadas codificações
ANSI, UTF-8 e UTF-16. Todas as cadeias de caracteres são convertidas
para Unicode.
- Os dados deste recurso podem ser tratados por intermédio de uma variável. O endereçamento automático via "::<resource name>" não funciona.
- O tipo especial de variável de recurso bitmap informa ao compilador que o recurso é uma representação gráfica. A variável de recurso, neste caso, obtém o tipo uint.
- Ao usar uma imagem de 24 bits, para todos seu pixels de componente de canal-alfa, define-se como 255.
- Ao usar uma imagem de 32 bits, sem canal-alfa, para todos seu pixels de componente de canal-alfa, também é definido como 255.
- Após carregar uma imagem de 32 bits com canal-alfa não acontece nenhuma manipulação de pixels.
- A matriz-variável de recurso de tipo bitmap pode ter duas dimensões. Neste caso, o tamanho da matriz será definido como [altura_de_imagem][largura_de_imagem].
- No caso de uma matriz unidimensional, o número de elementos será definido como altura_de_imagem*largura_de_imagem.
- Se o tamanho do arquivo de recurso não é um múltiplo do tamanho do elemento da matriz, em seguida, o resto dos dados é cortado. Por exemplo, quando o tamanho do arquivo é 14 bytes, para a matriz int o número de elementos será 3, e os restantes 2 bytes (14 - sizeof(int)*3) serão descartados.
Exemplos de utilização
#resource "data.bin" as int ExtData[] // declaração de matriz de tipo numérico, que contém dados a partir do arquivo data.bin #resource "data.bin" as MqlRates ExtData[] // declaração de matriz de estrutura simples, que contém dados a partir do arquivo data.bin #resource "data.txt" as string ExtCode // declaração de cadeias de caracteres, que contém dados a partir do arquivo data.txt #resource "data.txt" as string ExtCode[] // declaração de matriz de sequência de caracteres, que contém dados a partir do arquivo data.txt #resource "image.bmp" as bitmap ExtBitmap[] // declaração de matriz unidimensional, que contém em si a varredura a partir do arquivo BMP, tamanho da matriz = height * width #resource "image.bmp" as bitmap ExtBitmap2[][] // declaração de matriz bidimensional, que contém em si a varredura a partir do arquivo BMP, tamanho da matriz [height][width]
- Para arquivos de sequência de caracteres, a codificação de BOM
(cabeçalho) é detectada automaticamente. Se não houver nenhum BOM, a
codificação será determinada pelo conteúdo. São suportadas codificações
ANSI, UTF-8 e UTF-16. Todas as cadeias de caracteres são convertidas
para Unicode.
- Foi adicionada a propriedade CHART_SHOW para desativa a
exibição do gráfico. Para obter e instalar a propriedade, são utilizadas
as funções ChartGetInteger e ChartSetInteger.
Se for definido como false, será desativada a plotagem de todos os atributos do gráfico de colunas de preços e serão removidas todos os recuos nas bordas do gráfico de colunas: escala do tempo e preço, barra de navegação rápida, marcas de eventos de calendário, ícones de transação, dicas de indicadores e barras, painéis indicadores, histogramas de volume, etc.
A desativação da plotagem é uma solução ideal para criar sua própria interface de programa usando recursos gráficos.
Os objetos gráficos sempre são plotados independentemente do valor da propriedade CHART_SHOW.
- Foi adicionada a propriedade CHART_KEYBOARD_CONTROL para
ativar/desativar o controle de gráficos usando os teclas ("Home", "End",
"PageUp", "+", "-", "Seta para cima", etc.). Ao
definir CHART_KEYBOARD_CONTROL=false, é possível desativar a rolagem e
dimensionamento do gráfico, no entanto, ao fazer isto, mantem-se a
possibilidade de obter eventos - usando essa teclas - em OnChartEvent.
Para obter e definir propriedades, são utilizadas as funções ChartGetInteger e ChartSetInteger.
- Foram adicionadas novas funçóes e propriedade para trabalhar com OpenCL.
Novas propriedades para trabalhar com a memória
Usando CLGetInfoIntegrer agora é possível quatro novas propriedades:
- CL_DEVICE_MAX_WORK_GROUP_SIZE — número total de grupos locais de trabalho para o dispositivo OpenCL.
- CL_KERNEL_WORK_GROUP_SIZE — número total de grupos locais de trabalho para o programa OpenCL.
- CL_KERNEL_LOCAL_MEM_SIZE — tamanho da memória local em bytes,
que é usada pelo programa OpenCL para todas as tarefas simultâneas no
grupo. Utilize CL_DEVICE_LOCAL_MEM_SIZE para obter o máximo disponível.
- CL_KERNEL_PRIVATE_MEM_SIZE — tamanho mínimo de memória privada em bytes a ser usado por cada tarefa na kernel do programa OpenCL.
bool CLExecutionStatus(int kernel)
Retornar o estado de execução do programa OpenCL. Como parâmero é enviado o identificador para a kernel do programa OpenCL.
bool CLSetKernelArgMemLocal(int kernel_handle,int arg_index,ulong local_mem_size)
Ele define o buffer local como argumento da função kernel. Como parâmero são enviados: o identificador para a kernel do programa OpenCL, o número do argumento de função OpenCL e tamanho de buffer.
- CL_DEVICE_MAX_WORK_GROUP_SIZE — número total de grupos locais de trabalho para o dispositivo OpenCL.
- Foi adicionado o código de resposta
TRADE_RETCODE_LIMIT_POSITIONS. O número de posições abertas que você
pode ter em sua conta pode ser restrito pelas configurações do servidor.
Após atingir o limite, em resposta à colocação de uma ordem, o servidor
retorna o erro TRADE_RETCODE_LIMIT_POSITIONS. A restrição opera de
forma diferente dependendo do tipo de registro de posições na conta:
- Sistema de compensação — leva em conta o número de posições abertas. Ao atingir o limite, a plataforma não permite colocar ordens novas, cuja execução poderia levar a aumentar o número de posições abertas. Na verdade, a plataforma colocará ordens apenas nos símbolos, nos quais já existem posições abertas. No sistema de compensação, ao verificar o limite, não são tidas em conta as ordens pendentes atuais, uma vez que sua execução pode levar a uma alteração nas posições atuais, em vez de um aumento de seu número.
- No sistema de cobertura, além das posições abertas, são tidas em conta as ordens pendentes colocadas, uma vez que sua execução sempre leva a abertura de uma nova posição. Ao atingir o limite, a plataforma não permite colocar ordens de mercado nem ordens pendentes para abrir posições.
- Foi corrigido o erro que em alguns casos causava que ticks fossem ignorados no histórico de negociação.
- Foram corrigidos os erros de digitação indireta de escalas.
- Foi atualizada a biblioteca para trabalhar com estatísticas matemáticas.
Market
- Foi corrigida a abertura da página do produto ao baixar a versão demo.
Tester
- Após completar a otimização, os resultados são classificados automaticamente na coluna "Resultados."
- No menu de contexto da guia de resultados de otimização e diário, foi adicionada uma opção a fim de alternar automaticamente para resultados, após concluir a otimização.
- O testador de estratégias agora permanece no modo de otimização, após iniciar um único teste. Anteriormente, ao iniciar um teste único, a partir da guia de resultados de optimização, o testador de estratégias mudava automaticamente para o modo de teste único. Para realizar a re-otimização, foi necessário incluí-lo novamente nas configurações.
- Agora os conjuntos de parâmetros de entrada podem ser
armazenados não só sob a forma de arquivos set, mas também como
configurações do testador local de estratégias, com fácil acesso a eles
através do menu de contexto.
- Foi adicionada tradução da interface para o mongol, húngaro, romeno e urdu.
MetaEditor
- Foi adicionada a possibilidade de alterar a ordem das
expressões a serem observadas na janela de depuração. Basta arrastar a
expressão para a posição desejada com o mouse.
- Foi corrigido o erro na determinação da codificação nos arquivos de origem.
- Foi corrigida a busca por arquivos em UTF-8.
- Foi corrigido o erro na seleção de texto com o mouse ao haver nele caracteres de tabulação.
- Foi adicionada tradução da interface para húngaro e romeno.
Documentação atualizada.
9 dezembro 2016
MetaTrader 5 build 1495: Melhoras na MQL5 para trabalhar com gráficos personalizados
MQL5
- Foi adicionada a função CopyTicksRange.
- Na classe CCanvas foram adicionadas funções de suavização melhoradas:
- A documentação MQL5 foi adicionada a descrição da biblioteca gráfica, com a qual é possível construir rapidamente gráficos de barras, distribuições e gráficos lineares diretamente sobre os gráficos de preços.
- As constantes Status do terminal de cliente foram adicionados identificadores de estado de teclas de atalho. A chamada de TerminalInfoInteger(TERMINAL_KEYSTATE_XXX) retorna o mesmo código de status de teclas como a função GetKeyState() a partir de MSDN.
- Não suporta conversão do tipo string para o tipo bool. Para verificar as cadeias de caracteres será preciso especificar explicitamente a condição. Por exemplo, para o código a seguir, na nova versão, será emitido um erro de compilação:
string str; ... if(str) // aparecerá o erro de compilação "Cannot convert type 'string' to 'bool'" (nas compilações anteriores não acontecia o erro) Print("str is true");
É necessário escrever uma condição explícita:
string str; ... //--- verifica se a cadeia de caracteres é inicializada if(str!=NULL) Print("str is true"); ou //--- verifica se o valor da cadeia de caracteres é "true" if(StringCompare(str,"true",false)) Print("str is true"); ou //--- verifica se a cadeia de caracteres é um número e não é igual a zero if((int)str!=0) Print("str is true");
Correções de crash-logs.
2 dezembro 2016
Plataforma web MetaTrader 5: autenticação de dois fatores e alteração de senha
- Para reforçar a segurança das contas de negociação foi
adicionada uma autenticação de dois fatores usando senhas de uso único.
Para ativar a autenticação de dois fatores, use o aplicativo móvel
MetaTrader 5. Faça login e, na janela "Opções", abra o gerador One-time
password (OTP). Associe a ele todas suas contas de negociação, assim
cada uma irá gerar automaticamente uma senha única de seis dígitos
descartável. Insira-a ao iniciar sessão na plataforma web.
- Foi adicionada a possibilidade de alterar as senhas habitual e de investidores. Aproveite esta oportunidade para criar um identificador pessoal de fácil uso com o qual não esquecerá sua senha.
- À plataforma web também foi adicionada a geração automática de contas de demostração. Agora você pode fazer login na MetaTrader 5 Web a partir de qualquer navegador e começar imediatamente a negociar no mercado Forex, de ações ou futuros.
24 novembro 2016
MetaTrader 5 build 1485: modos de teste adicionais e gráficos na biblioteca padrão
Terminal
- Foi alterada a ordem de exibição das entradas no registro do terminal e MetaEditor. Anteriormente, no início, no registro eram exibidas as entradas mais recentes, agora, as mais antigas. Inverter a ordem de classificação fará a leitura do registro mais fácil e familiar.
Além disso, através do menu de contexto do registro agora é possível ocultar as colunas "Tempo" e "Fonte". - No histórico de negociação, as ordens e transações de fechamento de posição - no modo de cobertura - agora mostram o bilhete de posição fechada. Isso facilita a busca de operações pares de abertura e fechamento.
- Foi corrigido o erro que levava à cópia dos níveis SL/TP a partir das posições atuais para a posição nova do mesmo instrumento. O erro acontecia ao utilizar a função Negociação em um clique (por exemplo, painel no gráfico, janela Observação do mercado) no modo de cobertura.
- Foi corrigida a exibição de objetos de seta em telas de alta resolução (4K).
MQL5
- Foi adicionada a função ArrayPrint para saída no registro de matrizes de tipos e estruturas simples.
void ArrayPrint( const void& array[], // matriz de saída uint digits=_Digits, // número de casas decimais const string separator=NULL, // delimitador entre os valores dos campos de estrutura ulong start=0, // índice do primeiro elemento de saída ulong count=WHOLE_ARRAY, // número de elementos de saída ulong flags=ARRAYPRINT_HEADER|ARRAYPRINT_INDEX|ARRAYPRINT_LIMIT|ARRAYPRINT_ALIGN );
ArrayPrint não exibe, no registro, todos os campos da matriz de estruturas, uma vez que os campos tanto de matriz como de ponteiros de objetos são omitidos. Para exibição de todos os campos dessa estrutura, será necessário escrever a função de saída em massa com a formatação desejada.//--- exibe os valores das 10 últimas barras MqlRates rates[]; if(CopyRates(_Symbol,_Period,1,10,rates)) { ArrayPrint(rates); Print("Verificação\n[time]\t[open]\t[high]\t[low]\t[close]\t[tick_volume]\t[spread]\t[real_volume]"); for(int i=0;i<10;i++) { PrintFormat("[%d]\t%s\t%G\t%G\t%G\t%G\t%G\t%G\t%I64d\t",i, TimeToString(rates[i].time,TIME_DATE|TIME_MINUTES|TIME_SECONDS), rates[i].open,rates[i].high,rates[i].low,rates[i].close, rates[i].tick_volume,rates[i].spread,rates[i].real_volume); } } else PrintFormat("CopyRates failed, error code=%d",GetLastError()); //--- exemplo de saída /* [time] [open] [high] [low] [close] [tick_volume] [spread] [real_volume] [0] 2016.11.09 04:00:00 1.11242 1.12314 1.11187 1.12295 18110 10 17300175000 [1] 2016.11.09 05:00:00 1.12296 1.12825 1.11930 1.12747 17829 9 15632176000 [2] 2016.11.09 06:00:00 1.12747 1.12991 1.12586 1.12744 13458 10 9593492000 [3] 2016.11.09 07:00:00 1.12743 1.12763 1.11988 1.12194 15362 9 12352245000 [4] 2016.11.09 08:00:00 1.12194 1.12262 1.11058 1.11172 16833 9 12961333000 [5] 2016.11.09 09:00:00 1.11173 1.11348 1.10803 1.11052 15933 8 10720384000 [6] 2016.11.09 10:00:00 1.11052 1.11065 1.10289 1.10528 11888 9 8084811000 [7] 2016.11.09 11:00:00 1.10512 1.11041 1.10472 1.10915 7284 10 5087113000 [8] 2016.11.09 12:00:00 1.10915 1.11079 1.10892 1.10904 8710 9 6769629000 [9] 2016.11.09 13:00:00 1.10904 1.10913 1.10223 1.10263 8956 7 7192138000 Verificação [time] [open] [high] [low] [close] [tick_volume] [spread] [real_volume] [0] 2016.11.09 04:00:00 1.11242 1.12314 1.11187 1.12295 18110 10 17300175000 [1] 2016.11.09 05:00:00 1.12296 1.12825 1.1193 1.12747 17829 9 15632176000 [2] 2016.11.09 06:00:00 1.12747 1.12991 1.12586 1.12744 13458 10 9593492000 [3] 2016.11.09 07:00:00 1.12743 1.12763 1.11988 1.12194 15362 9 12352245000 [4] 2016.11.09 08:00:00 1.12194 1.12262 1.11058 1.11172 16833 9 12961333000 [5] 2016.11.09 09:00:00 1.11173 1.11348 1.10803 1.11052 15933 8 10720384000 [6] 2016.11.09 10:00:00 1.11052 1.11065 1.10289 1.10528 11888 9 8084811000 [7] 2016.11.09 11:00:00 1.10512 1.11041 1.10472 1.10915 7284 10 5087113000 [8] 2016.11.09 12:00:00 1.10915 1.11079 1.10892 1.10904 8710 9 6769629000 [9] 2016.11.09 13:00:00 1.10904 1.10913 1.10223 1.10263 8956 7 7192138000 */
- Foi corrigido o erro ao adicionar cadeias de caracteres do tipo S1=S2+S1
- Foi alterado o comportamento da função ArrayResize. Ao enviar - como parâmetros reserve_size - o valor -1, a função liberta a memória não utilizada (memória reservada), desde que o aumento no tamanho da matriz não aconteça. Alteração do tamanho da matriz para 0 com valor reserve_size=-1 equivalente à chamada ArrayFree. O novo comportamento permite otimizar o uso de memória em programas MQL5.
void OnStart() { int arr[]; //--- quanta memória é usada inicialmente Print("Array size:",ArraySize(arr)," Memory used:",MQLInfoInteger(MQL_MEMORY_USED)," MB"); //--- quanta memória é usado para uma matriz de tamanho 1, mas com uma reserva de ArrayResize(arr,1,1024*1024); Print("Array size:",ArraySize(arr)," Memory used:",MQLInfoInteger(MQL_MEMORY_USED)," MB"); //--- após aumentar a matriz, o tamanho da memória utilizada não é alterado pela reserva ArrayResize(arr,1024*512,1024*1024); Print("Array size:",ArraySize(arr)," Memory used:",MQLInfoInteger(MQL_MEMORY_USED)," MB"); //--- após reduzir a matriz, o tamanho da memória utilizada também não é alterado ArrayResize(arr,1); Print("Array size:",ArraySize(arr)," Memory used:",MQLInfoInteger(MQL_MEMORY_USED)," MB"); //--- a memória sem uso é liberada pela remoção da reserva ArrayResize(arr,1,-1); Print("Array size:",ArraySize(arr)," Memory used:",MQLInfoInteger(MQL_MEMORY_USED)," MB"); }
- A biblioteca padrão foram adicionadas funções para plotagem de gráficos. Para usar, habilite o arquivo MQL5\Include\Graphics\Graphic.mqh em seu projeto.
Plotagem de gráfico de 3 séries de dados usando GraphPlot:#include <Graphics/Graphic.mqh> double Func1(double x) { return MathPow(x,2); } double Func2(double x) { return MathPow(x,3); } double Func3(double x) { return MathPow(x,4); } void OnStart() { GraphPlot(Func1,Func2,Func3,-2,2,0.05,CURVE_LINES); }
Resultado:
Plotagem de gráfico com base na matriz de dados usando GraphPlot:<br2>
#include <Math/Stat/Binomial.mqh> #include <Graphics/Graphic.mqh> void OnStart(void) { double vars[101]; double results[101]; const int N=2000; //--- MathSequence(0,N,20,vars); MathProbabilityDensityBinomial(vars,N,M_PI/10,true,results); ArrayPrint(results,4); GraphPlot(results); //--- }
Resultado:
- Foram atualizadas as funções de trabalho com estatística matemática na biblioteca padrão. Foi realizada uma verificação grande quanto à qualidade e precisão de todas as funções na versão MQL5, bem como na linguagem de origem R. Para controlar a precisão e a velocidade do trabalho, juntamente com biblioteca estática são distribuídos testes de unidade. Eles estão localizados no diretório \MQL5\Scripts\UnitTests\Stat.
- TestStat.mq5 — script de teste base para verificar os resultados dos cálculos
- TestPrecision.mq5 — teste de precisão de cálculos
- TestBenchmark.mq5 — teste com medida do desempenho de cálculos
Tester
- Foram estendidas as configurações de espera na execução de pedidos de negociação durante o teste. Agora é possível verificar o robô de negociação em uma variedade de condições financeiras mais amplas: desde o caso ideal sem demora a qualquer atraso definido pelo usuário.
Anteriormente estava disponível apenas o modo de atraso aleatório.
- Foi corregido erro de formação de volume de tick de barras ao testar em modo OHLC em М1.
- Foi corrigida a colocação de tempo de abertura de ordens e posições em milissegundos ao negociar no modo de cobertura.
- Foi corregido o erro "old tick" (tick obsoleto) durante o teste multi-moeda ou multi-timeframe no modo de ticks reias.
- Foram aceleradas as funções CopyTicks quando os ticks solicitados eram lidos a partir do banco de dados no disco.
MetaEditor
- Foram adicionados os comados de trabalho com o repositório versionado de códigos-fonte MQL5 Storage ao menu de contexto do arquivo no Navegador e na barra de ferramentas.
- Foi corrigido o erro que levava à violação da integridade do banco de dados local MQL5 Storage quando se trabalhava com mais de 1024 arquivos no repositório.
- Foram corrigidos bugs de exibição da árvore em arquivos da MQL5 Storage.
- Foi corrigido a exibição de arquivo após a substituição de texto em massa.
Documentação atualizada.
14 outubro 2016
MetaTrader 5 build 1455: Biblioteca de funções matemáticas MQL5
Terminal
- Foram adicionados dicas pop-up para os botões Buy, Sell e Close nos diálogos da negociação. As dicas explicam exatamente quais ativos são comprados e vendidos durante a execução de uma operação, ajudando traders iniciantes a entender o processo de negociação.
- Foram adicionados novos ícones de ordens, transações e posições nas guias "Negociação" e "Histórico".
- Foram otimizados e acelerados consideravelmente (até 4-5 vezes) a exibição e atualização do livro de ofertas, gráfico de ticks do livro de ofertas e canal de negociações.
- Foi corrigido o erro de sincronização do histórico de ticks em tempo de não-negociação. Em alguns casos, o erro levava ao consumo excessivo de tráfego de rede.
MQL5
-
Na biblioteca padrão, foi incluía a versão MQL5 da biblioteca de análise numérica ALGLIB.
Possibilidades da biblioteca
- Álgebra linear
- Solução de sistemas de equações lineares e não lineares
- Interpolação
- Otimização
- Transformada rápida de Fourier
- Integração numérica
- Aproximação de mínimos quadrados lineares e no-lineares
- Solução de equações diferenciais ordinárias
- Cálculo de funções especiais
- Estatística descritiva e testes de hipóteses
- Análise de dados: classificação, regressão
- Implementação de algoritmos de álgebra linear, interpolação, etc. na aritmética de alta precisão (usando MPFR)
Como usar
Os arquivos da biblioteca ALGLIB estão localizados no diretório \MQL5\Include\Math\Alglib. Para usar as funções, adicione o arquivo principal da biblioteca ao seu programa:
#include <Math\Alglib\alglib.mqh>
-
A biblioteca padrão foram adicionadas funções de trabalho com estatística matemática. Agora, em MQL5, estão disponíveis as possibilidades da linguagem R, ela é um dos melhores instrumentos de processamento estatístico e análise de dados.<br1>
Possibilidades da biblioteca
A biblioteca estatística contém funções para cálculo de características estatísticas de dados, bem como funções para trabalhar com distribuições estatísticas:
- Funções para calcular as características estatísticas de elementos de matriz
- Funções para trabalhar com distribuições estatísticas: distribuição normal, distribuição log-normal, distribuição beta, etc.
Como usar
Os arquivos da biblioteca ALGLIB estão localizados no diretório \MQL5\Include\Math\Stat. Para usar as funções, adicione o arquivo com as funções desejadas ao seu programa, por exemplo:
#include <Math\Stat\Binomal.mqh> #include <Math\Stat\Cauchy.mqh>
Leia descrições detalhadas das funções da biblioteca no artigo Distribuições estatísticas em MQL5: pegamos as melhores a partir de R.
-
Na biblioteca padrão, foi incluía a versão MQL5 da biblioteca Fuzzy, ela implementa sistemas de inferência de lógica difusa Mastop e Sugeno.
Possibilidades da biblioteca
- 13 funções de associação
- Forma flexível de criação de regras para sistemas fuzzy
- Sistema de inferência de lógica difusa Mastop
- Sistema de inferência de lógica difusa Sugeno
- 5 métodos de exclusão da difusão para sistemas do tipo Mamdani
- Número ilimitado de variáveis de entrada e saída
Como usar
Os arquivos da biblioteca Fuzzy estão localizados no diretório \MQL5\Include\Math\Fuzzy. Para usar as funções, adicione o arquivo com as funções desejadas ao seu programa, por exemplo:
#include <Math\Fuzzy\mamdanifuzzysystem.mqh> #include <Math\Fuzzy\sugenofuzzysystem.mqh>
Uma descrição detalhada da biblioteca pode ser encontrada ni Code Base: Fuzzy, biblioteca para trabalhar com lógica difusa
- Foi adicionada a propriedade CHART_QUICK_NAVIGATION para habilitar/desabilitar a barra de navegação rápida no gráfico. Para alterar e obter o estado das propriedades, utilize as funções ChartSetInteger e ChartGetInteger.
A barra é chamada pressionado a tecla Enter ou Space. Ao usá-la, é possível passar rapidamente para a data especificada no gráfico, alternar o símbolo e período. Se seu programa MQL5 manipula as teclas Enter ou Space, desative a propriedade CHART_QUICK_NAVIGATION para o terminal não capturar esses eventos. Além disso, a barra de navegação rápida pode ser chamada mediante duplo clique.
- Foram adicionadas as funções FileLoad e FileSave para facilitar a leitura e armazenamento de matizes nos arquivos. Ao contrário de FileRead* e FileWrite*, essas funções não precisam o manipulador de arquivo. FileLoad e FileSave trabalham com matrizes de tipos numéricos, bem como com estruturas simples sem cadeias de caracteres, matrizes dinâmicas ou objetos de uma classe.
long FileLoad( const string filename, // [in] nome do arquivo void &buffer[], // [out] matriz na qual é tomado em consideração o arquivo uint common_flag=0 // [in] 0 - busca do arquivo na pasta Files do terminal, FILE_COMMON - na pasta comum dos terminais ); bool FileSave( const string filename, // [in] nome do arquivo const void &buffer[], // [in] matriz armazenada no arquivo uint common_flag=0 // [in] 0 - criação do arquivo na pasta Files do terminal, FILE_COMMON - na pasta comum dos terminais );
Exemplo de como armazenar, numa pasta, uma matriz de ticks e, em seguida, lê-la.
//--- parâmetros de entrada input int ticks_to_save=1000; // número de ticks //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { string filename=_Symbol+"_ticks.bin"; MqlTick ticks[]; //--- int copied=CopyTicks(_Symbol,ticks,COPY_TICKS_ALL,0,ticks_to_save); if(copied!=-1) { PrintFormat(" CopyTicks(%s) copied %d ticks",_Symbol,copied); //--- se o histórico de ticks estiver sincronizado, o código de erro será igual a zero if(!GetLastError()==0) PrintFormat("%s: Ticks are not synchronized. Error=",_Symbol,copied,_LastError); //--- armazenamos os ticks no arquivo if(!FileSave(filename,ticks,FILE_COMMON)) PrintFormat("FileSave() failed, error=%d",GetLastError()); } else PrintFormat("Failed CopyTicks(%s), Error=",_Symbol,GetLastError()); //--- agora lemos de volta estes ticks a partir do arquivo ArrayFree(ticks); long count=FileLoad(filename,ticks,FILE_COMMON); if(count!=-1) { Print("Time\tBid\tAsk\tLast\tVolume\tms\tflags"); for(int i=0;i<count;i++) { PrintFormat("%s.%03I64u:\t%G\t%G\t%G\t%I64u\t0x%04x", TimeToString(ticks[i].time,TIME_DATE|TIME_SECONDS),ticks[i].time_msc%1000, ticks[i].bid,ticks[i].ask,ticks[i].last,ticks[i].volume,ticks[i].flags); } } }
- Foi modificada a exibição do indicador personalizado com modo de desenho DRAW_CANDLES. Agora é possível definir de uma a três cores. A exibição de velas depende de quantas cores são definidas.
Se for indicada uma cor, todas as velas no gráfico serão completamente pintadas com essa cor.
//--- velas pintadas na mesma cor #property indicator_label1 "One color candles" #property indicator_type1 DRAW_CANDLES //--- foi indicado apenas uma cor, por isso todas as velas terão apenas uma cor #property indicator_color1 clrGreen
Se forem indicadas duas cores, os contornos das velas serão desenhadas usando a primeira cor, enquanto o corpo usando a segunda.
//--- a cor das velas difere da cor das sombras #property indicator_label1 "Two color candles" #property indicator_type1 DRAW_CANDLES //--- sombras e contorno de velas de cor verde, corpo de cor branca #property indicator_color1 clrGreen,clrWhite
Se forem indicadas duas cores, os contornos das velas serão desenhadas usando a primeira cor, enquanto o as velas de alta e baixa serão definidas usando uma segunda e terceira.
//--- o cor das velas é diferente da cor das sombras #property indicator_label1 "One color candles" #property indicator_type1 DRAW_CANDLES //--- as sombras e contornos de cor verde; o corpo da vela de alta de cor branca; corpo da vela de baixa de cor vermelha #property indicator_color1 clrGreen,clrWhite,clrRed
Assim, usando o estilo DRAW_CANDLES, é possível criar suas próprias opções personalizadas para colorir velas. Também é possível alterar dinamicamente todas as cores -no processo de trabalho do indicador- mediante a função PlotIndexSetInteger(índice_de_construção_DRAW_CANDLES, PLOT_LINE_COLOR, número_de_modificador, cor), aqui o número_de_modificador pode ter os seguintes valores:
- 0 – cor do contorno e as sombras
- 1 – cor do corpo da vela de alta
- 2 – cor do corpo da vela de baixa
//--- definimos a cor do contorno e das sombras PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,clrBlue); //--- definimos a cor do corpo para a vela de alta PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,clrGreen); //--- definimos a cor do corpo para a vela de baixa PlotIndexSetInteger(0,PLOT_LINE_COLOR,2,clrRed);
- Foram corrigidos vários bugs e foi acelerado o trabalhar com o histórico de ticks usando as funções CopyTicks.
- Permitido usar operadores nas interfaces.
Market
- Foi corrigido o erro que, em alguns casos, levava a um pedido repetido de autorização na MQL5.community ao comprar no Mercado.
Tester
- Foi adicionada a tradução da interface do usuário para grego, malaio e hebraico.
Documentação atualizada.
29 setembro 2016
Plataforma web MetaTrader 5: otimização do código e novas possibilidades da interface
- Foi adicionada a possibilidade de alterar a dimensão dos blocos do aplicativo web, incluindo a "Observação do mercado" e as janelas com gráficos de cotações.
- Agora está disponível a classificação por colunas nas guias "Negociação" e "Histórico", na janela "Caixa de ferramentas". Além disso, a largura das colunas pode ser alterada.
- Foram adicionados um instrumento de seleção rápida de símbolo é a guia "Detalhes."
- Foi melhorado o código para acelerar o funcionamento geral do terminal web: a inicialização da conta, a seleção de símbolos e a negociação em si agora funcionam com uma maior velocidade.
16 setembro 2016
MetaTrader 5 build 1430: guia Exposure atualizada
Terminal
- Foi desenvolvido um novo algoritmo que ajuda a geração
da guia "Ativos" para o mercado de ações. Agora o terminal adapta a
apresentação de ativos dependendo do sistema de gerenciamento de riscos
utilizado para a conta de negociação: Retail Forex, Futures ou
Modelo de bolsa.
A seção "Ativos" ajudará aqueles que negociam com moedas ou futuros a entender seu estado atual no mercado. As mesmas moedas podem se encontrar em uma variedade de instrumentos, sendo membros de um par de moedas, sendo a moeda básica, etc. Por exemplo, você pode ter posições opostas nos pares GBPUSD, USDJPY e GBPJY. Neste tipo de situação, será muito problemático compreender, por um lado, qual é a quantidade de moeda que você tem e, por outro, quanto você deve. No entanto, a situação é ainda mais complicada quando o número dessas posições é superior a 3. Nesta situação, é fácil proceder à verificação do estado final da conta na seção "Ativos".
Examinemos um exemplo, no caso de ter três posições:
Buy GBPJPY 1 lot at 134.027 — obtivemos 100 000 GBP, 134 027 000 JPY
Sell USDJPY 1 lot at 102.320 — entregamos 100 000 USD, obtivemos 102 320 000 JPY
Sell GBPUSD 1 lot at 1.30923 — entregamos 100 000 GBP, obtivemos 103 920 USD
Nós compramos e vendemos simultaneamente 100 000 GPB. Em GBP temos 0, e a guia "Ativos" não exibe esta moeda. Em USD, em um caso, entregamos moeda, em outro, obtemos. Como a nossa moeda de depósito é também USD, a guia Ativos calcula o total e totaliza-o com o saldo atual. A moeda JPY participou em duas negociações, a guia também exibe o valor total.
A seção ajudará aqueles que negociam segundo o modelo de bolsa a entender como usar o dinheiro. Ao contrário do modelo anterior, uma vez finalizada a negociação, o dinheiro é diretamente debitado/creditado do/ao saldo. Por exemplo, ao comprar EURRUB, você recebe imediatamente euros, e a partir do saldo debita-se o valor correspondente em rublos. Durante a negociação, mesmo o saldo da conta pode se tornar negativo, isto é: quando você está negociando com dinheiro emprestado, os ativos adquiridos agirão como fundos de manutenção. Nesta situação, a guia "Ativos" permitirá que você entenda facilmente o estado de negociação da conta.
Adicionalmente, neste caso, exibe-se o valor de liquidação, isto é, a soma entre a quantidade de fundos na conta e o valor (resultado) de fechamento das posições atuais, de acordo com o preço de mercado.
- Foi corrigido o erro de exibição do tipo de negociação no histórico de operações de negociação.
- Foi corrigida a exibição da janela de notificação sobre riscos durante a reconexão da conta de negociação.
- Foi melhorado e corrigido o trabalho com o diálogo de seleção de instrumentos de negociação ao ter um número grande de símbolos (alguns milhares e mais).
- Foi corrigida a exibição de níveis nos indicadores embutidos, calculados com base na média móvel (Bollinger Bands, Adaptive Moving Average, etc.). O problema surgia ao construir os indicadores em uma janela separada.
- Foi corrigido o erro que, em alguns casos, não permitia colocar a ordem em um contrato futuro. O problema surgia se o preço na ordem coincidia com o limite superior ou inferior do preço do contrato.
MQL5
- Foi otimizada e acelerada a compilação de programas MQL5.
- Foi adicionado o suporte dos modificadores final e override para classes, estruturas e funções.
Modificador final para classes e estruturas
A presença do modificador final, ao declarar a estrutura ou classe, restringe a futura herança a partir dele. Se a classe (estrutura) não precisar de alterações futuras ou se essas alterações não estiverem disponíveis por razões de segurança, será bom que a declare com o modificador final. Quando você fizer isso, todos os métodos da classe também serão implicitamente considerados como final.
class CFoo final { //--- corpo da classe }; class CBar : public CFoo { //--- тело класса };
Ao tentar herdar a partir da classe com o modificador final, como foi mostrado no exemplo acima, o compilador exibirá o erro:cannot inherit from 'CFoo' as it has been declared as 'final'
see declaration of 'CFoo'
Modificador override para a função
O modificador override indica que a função declarada deve substituir o método da classe pai. Durante a substituição, o uso deste modificador permite evitar erros como, por exemplo, a alteração aleatória de assinatura. Outro exemplo mais detalhado seria, na classe básica, está definido o método func, ele aceita como argumento a variável do tipo int:
class CFoo { void virtual func(int x) const { } };
Além disso, o método é substituído na classe herdada:
class CBar : public CFoo { void func(short x) { } };
No entanto, de acordo com o erro, o tipo de argumento é alterado de int para short. De fato, neste caso, não acontece uma substituição, senão uma sobrecarga do método. Após agir segundo o algoritmo para determinar a função sobrecarregada, em determinadas situações, o compilador pode selecionar o método definido na classe base, em vez do método substituído.
Para evitar esses erro, é preciso adicionar explicitamente o modificador override ao método override.
class CBar : public CFoo { void func(short x) override { } };
Se, durante a substituição, for alterada a assinatura do método, o compilador não poderá encontrar, na classe pai, o método com exatamente a mesma assinatura e exibirá o erro de compilação:'CBar::func' method is declared with 'override' specifier but does not override any base class method
Modificador final para a função
Ao contrário, o modificador final restringe a substituição de método nas classes-herdeiras. Se a realização do método for auto-suficiente é estiver totalmente concluída, declare-o com o modificador final, para que ele não seja modificado posteriormente.
class CFoo { void virtual func(int x) final { } }; class CBar : public CFoo { void func(int) { } };
Ao tentar substituir o método com o modificador final, como foi mostrado no exemplo acima, o compilador exibirá o erro:'CFoo::func' method declared as 'final' cannot be overridden by 'CBar::func'
see declaration of 'CFoo::func'
- Foi corrigido o erro de compilação de funções modelo com parâmetros padrão.
Market
- Foi corrigida a série de erros na classificação de produtos do Mercado-
Tester
- Foi corrigida a atualização das ordens de mercado atuais, nas posições abertas e posições no modo de teste visual.
- Foi removida a derrapagem (slippage) de execução de ordens Buy Limit e Sell Limit ao testar em instrumentos financeiros.
- Foi corrigido o erro que levava à geração de preços incorretos no modo de teste "Segundo os preços de abertura".
- Foi corrigida a formação de eventos OnTradeTransaction durante o teste.
- Ao testar com base em ticks reais, no diário do testador, são exibidas informações sobre a discrepância de preços dos ticks (bid ou last, dependendo do preço é baseada a barra) para os valores low ou high disponíveis na barra minuto.
MetaEditor
- Foram corrigidos os erros de exibição de dados nos arquivos do código fonte.
Documentação atualizada.
19 agosto 2016
MetaTrader 5 build 1395: aceleração de operações de negociação e melhorias no teste visual
Terminal
- Foi otimizado e consideravelmente acelerado o envio de comandos de negociação para o terminal de cliente.
- Foi corrigido um bug que não permitia executar programas MQL5 nos terminais, ao trabalhar em versões de 32 bits do Windows 10 build 1607.
- Foi adicionado ao navegador a exibição do modo de trabalho da conta de negociação, isto é, a cobertura e compensação (Hedging e Netting).
- Foi adicionado ao navegador um comando de menu de contexto para conetar a conta desejada ao terminal web.
- Foi redesenhada a seção do menu "Ajuda", foram anexados links para assistir a vídeos de treinamento.
- Foram corrigidos vários erros de interface, ao trabalhar em telas de alta resolução (4K).
- Foram corrigidos os erros na tradução da interface do usuário para persa.
MQL5
- Foram adicionados os ponteiros 'void *', o que permitirá
criar coleções abstratas de objetos. Neste tipo de variável, você pode
armazenar um ponteiro para um objeto de qualquer classe.
Para a conversão inversa, recomenda-se usar o operador dynamic_cast<nome da classe *>(ponteiro void *). Se a conversão não for possível, o resultado será NULL.
class CFoo { }; class CBar { }; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { void *vptr[2]; vptr[0]=new CFoo(); vptr[1]=new CBar(); //--- for(int i=0;i<ArraySize(vptr);i++) { if(dynamic_cast<CFoo *>(vptr[i])!=NULL) Print("CFoo * object at index ",i); if(dynamic_cast<CBar *>(vptr[i])!=NULL) Print("CBar * object at index ",i); } CFoo *fptr=vptr[1]; // emitirá o erro de apresentação de ponteiros, vptr[1] não é um objeto CFoo } //+------------------------------------------------------------------+
- Foi adicionado o suporte do operador [] para a cadeia de
caracteres, isso irá permitir obter um símbolo a partir da cadeia de
caracteres no índice. Se o índice especificado sair dos limites da
cadeia de carateres, o resultado será 0.
string text="Hello"; ushort symb=text[0]; // retorna o código do símbolo 'H'
- Foi adicionada a segunda opção do processador de eventos
TesterInit com rótulo int OnTesterInit(void), ele pode retornar o código
INIT_SUCCEEDED (0) ou INIT_FAILED (o qualquer valor diferente de zero).
Se OnTesterInit retornar um valor diferente de zero, não começará a
otimização.
- Foi corrigido o erro pelo cual diferentes sobrecargas da função ChartGetString dava um resultado diferente.
Tester
- Foram adicionados comandos e atalhos adicionais para o
teste visual. Agora, os gráficos, tanto no testador visual como no
terminal, podem ser configurados: alterar cores, controlar a exibição de
vários elementos, aplicar modelos, etc.
- Foi corrigido o trabalho da função Sleep em modo de teste "segundo os preços de abertura" ("Price Open").
- Foi corrigido o erro que causava a formação de um estado incorreto das barras, ao trabalhar em períodos W1 e MN1.
MetaEditor
- MetaEditor: Foi adicionada a tradução da interface do usuário para chines tradicional.
Documentação atualizada.