Do básico ao intermediário: Indicador (I)

No artigo anterior Do básico ao intermediário: Eventos (II), vimos como poderíamos manter algum tipo de informação de forma meio que permanente entre momentos diferentes de utilização da plataforma MetaTrader 5. Sei que alguns podem até imaginar que aquele tipo de conteúdo é um tanto quanto desnecessário. Porém, no momento em que você vier a necessitar manter alguma informação entre chamadas. Irá se lembrar daquilo e dizer: Cara obrigado por ter me dado aquela dica. Valeu mesmo.

De qualquer forma, estamos apenas começando a nossa exploração. Como já temos alguns conceitos básicos. Que já nos permite criar pequenos programas e também, já vimos como é a base de funcionamento de uma programação baseada em eventos. Chegou a hora de entender alguns conceitos básicos, que muitos tentam implementar, porém que já foram pensados e que por padrão, você não precisa implementar. Apenas utilizar quando assim for necessário.

E neste caso, estou falando daquelas abas, que estão presentes por padrão, em praticamente todos aplicativos do MetaTrader 5. Digo praticamente, pois pode ser, que tenhamos mais ou menos abas ali. No entanto, se você como programador entender como utilizar aquelas mesmas abas. Acabará se tornando um usuário bem mais observador e exigente, com relação ao que outros programadores poderão lhe estar apresentando como interface.

Então para começar a falar e explicar um pouco mais sobre este assunto. Vamos iniciar um novo tópico.

Abas padrão

Todo e qualquer código, criado inteiramente em MQL5, puro e simples. Poderá ou não ter o que podemos chamar de janela básica de configuração. Esta janela não estará presente em todas as aplicações. Isto por que, em aplicações como scripts e serviços, podemos ou não ter esta janela presente. Porém, em indicadores e Expert Advisores, ela sempre nos será apresentada, com alguns elementos, ou melhor dizendo, abas padrão. Estas não são criadas pelo programador em si. Mas estão definidas dentro do que podemos dizer, ser o ambiente do MetaTrader 5. Fazendo assim com que tenhamos um padrão de utilização e configuração de qualquer indicador ou Expert Advisor.

Porém devido a uma ou outra questão. Muitos programadores costumam adicionar elementos de configuração, que não seriam de fato necessários de serem adicionados. Isto porque, tais elementos já poderiam ser ajustados no que se refere a estas abas que serão mostradas por padrão ao usuário. Mas a pergunta é: Você meu caro leitor, sabe como acessar elementos definidos nas abas padrão? E quando pergunto isto, estou perguntando como programador, e não como usuário.

Quando me refiro a abas padrão, estou me referindo ao que podemos ver na sequência de imagens logo abaixo.

Imagem 01

Imagem 02

Imagem 03

Imagem 04

Estas são abas padrão de um indicador. Como no momento estamos focados em entender e aprender como eventos funcionam em um indicador. Justamente por ser mais simples. Devemos aprender o máximo de coisas sobre ele, antes de entramos em coisas mais complicadas. Mas este sistema de abas padrão, é bem interessante e até mesmo muito bem bolado. Servido para diversos casos perfeitamente bem. Isto a ponto de não precisamos implementar quase nenhum tipo de entrada extra, para a grande maioria dos casos. Mas então por que, muitos programadores criam entradas extras? Bem, o motivo, é que isto de fato se faz necessário, quando este esquema padrão, fornecido pelo MetaTrader 5, não é capaz de suprimir as nossas necessidades. Mas antes que você saia adicionando coisas a esmo, é bom entender primeiro como utilizar estas abas, a fim de manter sua aplicação dentro do que seria o padrão do MetaTrader 5.

Basicamente, a única aba que precisamos manipular, isto caso você sinta necessidade de fazê-lo. Seria a aba vista na imagem 01. Isto por que, nesta aba, podemos adicionar elementos a fim de tornar as coisas mais representativas em termos de dizer o objetivo pelo qual aquela aplicação existe. Fazer isto é algo muito simples, fácil e direto. Porém como aqui estamos e ficaremos focados apenas na parte didática. Não irei ficar adicionando elementos nesta aba. Porém, toda via e, entretanto, você meu caro leitor, deve pensar sobre como trabalhar nesta primeira aba. Ainda mais se vier a querer disponibilizar suas aplicações.

Pois bem, para adicionar ou modificar esta aba, vista na imagem 01. Precisamos dizer ao compilador, o que colocar nela. Para isto iremos utilizar uma diretiva de compilação. Tal diretiva atende como #property. Esta diretiva, nos permite definir uma série de coisa, que vão desde informar a versão da aplicação, até um link para um local específica na web. Depois procure ver a documentação para mais detalhes a este respeito. Você deve já ter notado esta diretiva sendo aplicada em todos os meus códigos vistos aqui nos artigos. Basicamente a única que defino por padrão é a propriedade de copyright. Mas vamos ver como podemos definir outra só para que você tenha uma noção do que podemos fazer. Para isto, vamos usar o código logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property version "1.0"
04. #property icon "Example.ico"
05. #property description "This is a demonstration application whose purpose is only didactic.\nIt is part of a sequence of articles published in the MQL5 community."
06. #property link "https://www.mql5.com/pt/articles/15794"
07. //+------------------------------------------------------------------+
08. int OnInit()
09. {
10.    return INIT_SUCCEEDED;
11. };
12. //+------------------------------------------------------------------+
13. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
14. {
15.    return rates_total;
16. };
17. //+------------------------------------------------------------------+

Código 01

Assim no momento em que este código 01 for executado, você irá ver que a imagem 01, agora irá ser apresentada de uma maneira diferente. Isto pode ser visto logo abaixo.

Imagem 05

Repare no fato de que agora temos um ícone diferente do ícone padrão e também temos uma descrição a respeito do objetivo da aplicação em si. Tudo isto está sendo definido entre as linhas dois e cinco. Repare no fato de que precisamos informar o diretório e o arquivo de imagem para ser utilizado como ícone. No anexo irei deixar as coisas, de forma que você poderá experimentar e entender, como fazer para colocar um ícone desejado. No caso, como você pode observar no código 01, o arquivo de ícone deverá estar na pasta onde o código do indicador se encontra. Porém você pode colocar ele em outros locais. Basta dizer a localização para o compilador conseguir encontrar o arquivo desejado.

Mas espere um pouco. Está faltando uma informação aí. Que é a que estamos declarando na linha seis do código 01. Onde ela foi parar? Bem, na verdade esta informação que antes ficava visível na aba, passou a ficar associada a uma outra informação. Assim passando o mouse no que seria a informação copyright, temos o que pode ser visto na imagem logo abaixo.

Imagem 06

Assim podemos notar que todas as informações estão de fato presentes. Sendo que esta última, que pode ser vista na imagem 06. Irá, caso venhamos a clicar no ponto que originou o link, abrir o navegador e seremos direcionados para o local indicado na linha seis do código 01. Como na maior parte das vezes, imagino que você meu caro leitor, esteja de fato criando algo para uso pessoal. Tais coisas podem vir a ser ignoradas. Não sendo de fato preciso implementar tais propriedade da aplicação. Porém, existem casos em que de fato precisamos dizer ao compilador como o código deverá ser gerado. Ou melhor dizendo, já que esta frase talvez tenha ficado confusa. Existem circunstâncias especiais, onde mesmo fazendo uso de um código para nosso uso pessoal, precisamos configurar estas propriedades de compilação.

Um destes casos, é justamente quando estamos criando um indicador, cujo objetivo é plotar algo no gráfico. No entanto, talvez você tenha sentido falta de explicarmos sobre as demais abas, vistas no início deste tópico. Porém, peço a você, meu caro e estimado leitor, que tenha um pouco de calma e paciência. Iremos voltar naquelas abas em breve. Mas neste momento, precisamos fazer uma outra coisa. Isto para que de fato, aquelas demais abas possam vir a fazer de fato sentido.

Um indicador básico

Até o início deste artigo, a única coisa que de fato fizemos, foi gerar um monte de informações e as imprimir no terminal. Isto a fim de podemos visualizar as mesmas de alguma forma. Porém, finalmente chegou a hora de podemos visualizar algo sendo desenhado no gráfico. Para tornar as coisas mais agradáveis e compreensíveis, irei utilizar um gráfico no estilo padrão do MetaTrader 5. Isto será feito apenas para fins de demonstração. Mas você pode utilizar o gráfico com a configuração que melhor lhe atender. Ou que mais vier a lhe agradar.

Ok. Nos dois artigos anteriores, foi explicado o funcionamento de dois eventos básicos que são gerados pelo MetaTrader 5. O evento Deinit e o evento Init. Ambos tinham como objetivo, dizer a nossa aplicação como ela deveria se comportar. Porém, todo e qualquer indicador, precisa de fato de dois eventos. Um que seria o evento Init, que já foi explicado. E o outro que seria o evento Calculate.

Agora preste muita atenção meu caro leitor, pois isto é muito importante. Um evento Calculate será capturado pela função OnCalculate, que deverá estar presente no código do indicador. Porém, temos duas versões desta mesma função. Ou seja, o MQL5, nos fornece a possibilidade de usar uma função que se encontra sobrecarregada por padrão. Sendo uma delas vista logo abaixo, e a outra logo na sequência.

int  OnCalculate(
   const int        rates_total,       // price[] array size
   const int        prev_calculated,   // number of handled bars at the previous call
   const int        begin,             // index number in the price[] array meaningful data starts from
   const double&    price[]            // array of values for calculation
   );

int  OnCalculate(
   const int        rates_total,       // size of input time series
   const int        prev_calculated,   // number of handled bars at the previous call
   const datetime&  time[],            // Time array
   const double&    open[],            // Open array
   const double&    high[],            // High array
   const double&    low[],             // Low array
   const double&    close[],           // Close array
   const long&      tick_volume[],     // Tick Volume array
   const long&      volume[],          // Real Volume array
   const int&       spread[]           // Spread array
   );

Mas por que os desenvolvedores do MQL5 fizeram isto? Bem, acredito que o motivo seja tornar a execução do indicador mais eficiente e consistente. Isto porque, existem diversas maneiras de se calcular algo. Ainda mais que na maior parte das vezes, um indicador estará de fato calculando uma média de valores. Assim sendo, os desenvolvedores, vendo que poderiam melhorar a performance da plataforma MetaTrader 5, decidiram permitir que alguns destes cálculos, NÃO PRECISASEM serem feitos pelo indicador. Já que a própria plataforma poderia nos dizer o resultado de antemão. Talvez para você isto não venha a fazer muito sentido neste momento. Mas acredite, conforme você for praticando e estudando cada vez mais, irá notar que isto de fato faz bastante sentido.

Mas então, qual versão de sobrecarga deverei utilizar? A resposta para esta pergunta é: Depende. Não existe esta de que, você precisa usar uma ou outra versão em detrimento da outra. Ambas versões fazem basicamente o mesmo tipo de coisa. Recebem o evento Calculate. E pronto. O que vai acontecer daí em diante depende do que você planeja e precisa fazer.

Porém existe um detalhe, que não deixa de ser um tanto quanto curioso aqui. E que devo confessar que foi uma bela de uma melhoria feita pelos desenvolvedores da plataforma. Dependendo de você estar usando uma ou outra versão de OnCalculate. O usuário terá acesso ou não a aba que é vista na imagem 02. Hã? Como assim? Bem, se você procura ver artigos com imagens, animações ou vídeos de versões antigas do MetaTrader 5 funcionando. Irá notar que em praticamente todas as vezes a aba vista na figura 02 irá aparecer, mesmo quando ela era completamente desnecessária.

No entanto, em algum momento, isto deixou de existir. Caso você venha a utilizar a versão com menos argumentos a aba vista na figura 02, irá estar disponível. Caso você venha a utilizar a versão com mais argumentos a mesma aba, não estará disponível. Por isto que eu disse que as coisas seriam explicadas no seu devido tempo. Se isto fosse mencionado naquele momento. Não faria nenhum sentido. Mas agora já fará total sentido. Ainda mais quando viermos a implementar algum tipo de indicador.

Para começar, vamos criar um bem, mas bem simples mesmo. Onde praticamente tudo será feito e criado pelo MetaTrader 5. Nós como programadores faremos o mínimo necessário para que as coisas venham a funcionar. E para que as coisas fiquem, a mais didática quanto for possível ser feito. Iremos fazer isto em etapas. Mesmo que o código em si seja muito simples de entender e de ser feito. Porém fazendo em pequenas etapas, todos, inclusive iniciantes em um nível básico, conseguirão acompanhar. Desde é claro estejam estudando estes artigos daqui.

Nosso código começa da seguinte maneira:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    return INIT_SUCCEEDED;
07. };
08. //+------------------------------------------------------------------+
09. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
10. {
11.    return rates_total;
12. };
13. //+------------------------------------------------------------------+

Código 02

Note que não temos absolutamente nada sendo feito aqui ainda. O código contém apenas o básico para que o compilador saiba como criar a aplicação desejada. Ou seja, um indicador, que irá apresentar todas a abas como mostrado no início deste artigo. A próxima coisa que iremos fazer, será descrever nosso indicador. Para fazer isto, precisamos dizer ao compilador o que deverá ser criado. Existem duas formas de se fazer isto. Uma dinâmica, que é bem mais complicada e que não será explicada neste momento. E a outra estática, que é consideravelmente mais simples e direta. Sendo a ideal para pequenos códigos e voltada para que esteja iniciando ou apenas querendo criar um indicador simples, rápido e prático. Para isto, iremos modificar o código 02, para a versão vista logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+------------------------------------------------------------------+
07. int OnInit()
08. {
09.    return INIT_SUCCEEDED;
10. };
11. //+------------------------------------------------------------------+
12. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
13. {
14.    return rates_total;
15. };
16. //+------------------------------------------------------------------+

Código 03

Este é o segundo passo que precisamos dar. Apesar de que a declaração que está sendo feito na linha cinco, está sendo feita, por conta de um pequeno bug que ainda persiste no uso do sistema padrão do MetaTrader 5. Sem esta linha, você NÃO CONSEGUIRÁ TROCAR A COR de plotagem do indicador. Mesmo sendo um indicador super simples. Mas a declaração mais importante aqui é a que estamos fazendo na linha quatro. Nesta linha estamos dizendo que tipo de coisa queremos que seja plotada no gráfico. No caso será uma linha de preço. Mas que tipo de preço? Quais serão as definições e propriedades desta linha a ser plotada? Calma meu caro leitor, não já iremos chegar neste ponto. Tenha um pouco de calma.

Uma vez definido o tipo de indicador que será criado, precisamos definir algumas outras características do mesmo. Para isto precisamos recorrer a documentação do MQL5, para saber como declarar os próximos pontos. Então voltando lá na documentação e procurando o termo #property vamos procurar uma informação que está diretamente relacionada ao que está sendo declarado na linha quatro. Ou seja, o tipo de indicador. Então procurando esta informação, iremos ver algo que está sendo destacado na imagem logo abaixo.

Imagem 07

Este ponto que está sendo destacado na imagem 07, é muito importante para nós. Isto porque sem ele, não conseguiremos dizer ao MetaTrader 5, como o indicador será de fato mostrado. Assim vamos atras desta enumeração ENUM_DRAW_TYPE. E ao encontramos ela na documentação, iremos ver uma tabela como mostrado logo abaixo.

Imagem 08

A informação que precisamos é justamente esta que está sendo marcada em verde, nesta imagem 08. Ou seja, precisamos de um buffer para dados. Cada tipo de indicador precisa de mais ou menos coisas. Como este que estamos criando é bem simples, iremos precisar apenas de um buffer. Com esta informação em mãos podemos voltar ao código 03 e adicionar mais algumas coisas a ele. Mas antes de fazermos isto, precisamos de uma outra informação. Esta tem a ver com a quantidade de coisas que o indicador precisará desenhar na tela. Para encontrar esta informação, devemos procurar uma outra informação dentro da propriedade #property. Esta é mostrada logo abaixo.

Imagem 09

Então indo atrás desta segunda informação que precisamos, iremos nos com a mesma tabela. Porém agora o valor que iremos precisar utilizar é a soma destes dois outros valores, mostrados na imagem 10:

Imagem 10

Com todas estas informações em mãos, finalmente podemos voltar ao código 03 e adicionar mais algumas coisas a ele. Assim o código fica como mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+----------------+
07. #property indicator_buffers         1
08. #property indicator_plots           1
09. //+------------------------------------------------------------------+
10. int OnInit()
11. {
12.    return INIT_SUCCEEDED;
13. };
14. //+------------------------------------------------------------------+
15. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
16. {
17.    return rates_total;
18. };
19. //+------------------------------------------------------------------+

Código 04

Agora olhando este código 04, podemos ver na linha sete a declaração da qual buscamos e encontramos na imagem 08. Já na linha oito, temos a indicação de uma outra informação que é igual a soma dos valores visto na imagem 10. Com isto agora estamos finalmente preparados para tornar o indicador finalmente funcional. Sendo assim o último passo a ser dado é mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+----------------+
07. #property indicator_buffers         1
08. #property indicator_plots           1
09. //+----------------+
10. double   gl_buffer[];
11. //+------------------------------------------------------------------+
12. int OnInit()
13. {
14.    SetIndexBuffer(0, gl_buffer, INDICATOR_DATA);
15. 
16.    return INIT_SUCCEEDED;
17. };
18. //+------------------------------------------------------------------+
19. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
20. {
21.    for (int c = prev_calculated; c < rates_total; c++)
22.       gl_buffer[c] = price[c];
23. 
24.    return rates_total;
25. };
26. //+------------------------------------------------------------------+

Código 05

E aí está meu caro leitor. Um completo e totalmente funcional indicador. Onde podemos pedir para ele, marcar qualquer tipo de informação que o MetaTrader 5, vier a nos oferecer. E ele conseguirá fazer isto perfeitamente. Mas espera um pouco aí, como assim? Já vi códigos de outros indicadores e eles tem muito mais coisas. Isto não deve estar correto. Já tentei criar diversos indicadores e todos tem muito mais coisa que isto que você está apresentado. Não acredito que isto de fato funciona. Quero ver, ou melhor vou experimentar para ver se isto de fato funciona.

Bem, meu caro leitor, eu até entendo o seu espanto. Isto porque, qualquer código de indicador que você vier a observar, irá ter muito mais coisas do que isto que estamos fazendo aqui. Mas para provar que este código de fato funciona. Vamos ver algumas animações.

Animação 01

Nesta animação 01, estou mostrando como colocar o indicador e depois trocar a cor do mesmo. Note que é bem simples e intuitivo.

Animação 02

Nesta animação 02, é mostrado como podemos modificar o estilo de linha do indicador. Novamente algo bem intuitivo.

Animação 03

Já nesta animação 03, podemos ver como modificar a espessura da linha que estará sendo utilizada pelo indicador. Neste caso seria bom se o MetaTrader 5, pudesse utilizar estilos diferentes, em diferentes espessuras. Mas tudo bem, então até que os desenvolvedores venham a implementar isto, como sendo um padrão para as linhas de indicador. Teremos que nos adaptar a esta atual condição do MetaTrader 5.

Animação 04

E finalmente agora, já nesta animação 04, podemos visualizar a forma de mudar o tipo de cálculo que será feito no indicador. Note que é bem simples, claro e direto. Não tendo nenhum tipo de prejuízo com relação a forma de trabalhar no indicador. Ficou faltando a questão sobre mostrar como a aba vista na figura 04 funciona. Mas como este tipo de coisa é muito intuitiva e simples de entender. Bastando para isto que você tenha a curiosidade de experimentar o uso de tal aba.

Não vejo necessidade de explicar ela aqui. Mesmo por que, tal aba é somente utilizada para fins de construção de setup operacional. Raramente um operador iniciante de fato irá tentar mexer nesta aba. Mas como programador, você, meu caro leitor, precisa entender como esta aba trabalha e como você pode vir a implementar a mesma em termos de código. E sim, é possível configura a forma de funcionamento do indicador, sem precisar mexer nesta aba. Isto usando MQL5 puro. Mas isto será visto mais para a frente em um momento mais oportuno.

Agora que já vimos como o código funciona, isto na prática, vamos dar uma rápida espiada no que foi adicionado no último passo da implementação. O que será explicado aqui, depois iremos abordar de uma forma um pouco mais avançada. No entanto, é preciso que você, comece a entender logo de início, como e porque precisamos destas linhas que foram implementadas no último passo. Começando pelo fato de termos a linha 10.

Normalmente, não é aconselhável fazer uso de variáveis globais. E isto já foi explicado nos primeiros artigos desta série. Porém, esta variável declarada na linha 10 é um caso especial. Nesta situação, realmente precisamos de uma variável global. Visto que ela é necessária para diversas coisas que iremos ver no futuro. No entanto, neste momento, o que você precisa entender, meu caro leitor, é que esta variável é a que irá conter os dados que irão ser plotados no gráfico. Criando assim o indicador que você pode ver nas animações.

Para que isto seja possível, precisamos dizer ao MetaTrader 5, QUAL É A VARIÁVEL, que ele deverá utilizar, visto que pode haver diversas variáveis sendo declaradas em um código real. Este tipo de informação é efetuado, utilizando o que pode ser visto na linha 14. Basicamente é isto. Uma vez que fizemos isto, podemos finalmente, começar a capturar o evento Calculate. E assim passar a utilizar os dados que o MetaTrader 5, estará nos fornecendo. Isto a fim de atribuir valores para a variável declarada na linha 10. 

Fazer isto não é complicado, na verdade é bem simples na maior parte das vezes. Isto por que, tudo que precisamos fazer é calcular um valor e atribuir o mesmo a uma dada posição dentro de que seria o array declarado na linha 10. Agora preste atenção meu caro leitor. Quando foi explicado sobre arrays, foi dito que existem dois tipos de arrays. Os dinâmicos e os estáticos. Porém, TODO E QUALQUER ARRAY que será usado para armazenar dados para fins de plotagem em um indicador, deve ser obrigatoriamente do tipo dinâmico. No entanto, você NÃO DEVE alocar memória para ele. Quem fará isto será o próprio MetaTrader 5, conforme for sendo necessário fazer tal alocação. Por conta disto, podemos utilizar o código visto na linha 22. Isto por que, na linha 14 dizemos que aquela variável será usada para armazenar dados referente ao indicador a ser plotado. Sendo assim, o MetaTrader 5 passará a assumir o controle total sobre a memória que precisa ser ou não alocada.

Agora existe também outro ponto de atenção aqui. O ideal e desejável é que toda e qualquer aplicação a ser executada no MetaTrader 5, seja a mais eficiente possível. Isto para evitar consumir muito tempo e também permitir que a plataforma se mantenha estável. Por conta disto, veja como este laço da linha 21 está sendo criado. A primeira impressão que você talvez tenha, é que, toda vez que um evento Calculate for capturado. Iremos ler todos os dados presentes no array price, desde o início até o seu final. No entanto não é bem assim que as coisas acontecem. Pelo menos não deveria ser assim.

Basicamente e internamente o MetaTrader 5, mantem alguns valores internos para controle do que está sendo feito pelas aplicações. Então, na primeira vez que o evento Calculate for capturado pelo nosso indicador. O valor de rates_total nos dirá a quantidade de dados presentes no array price. Já o valor de prev_calculated, poderá ou não ser igual a zero. Mas com toda a certeza ele irá estar apontando para o primeiro dado na série. Isto pode ser mudado, como veremos futuramente. Por hora você apenas precisa entender isto que foi dito. E esta condição acontecerá, somente na primeira vez. Isto se o seu código estiver devidamente implementado. Seguindo as regras e sendo educado.

Na próxima chamada, o valor de prev_calculated poderá ou não ser igual ao valor de rates_total. Caso seja igual, significa que não houve nenhuma mudança significativa. Porém, se for menor o laço será executado para atualizar o valor a ser plotado no gráfico.

Então, se você implementar corretamente o código. Na primeira execução ele será lento. Porém em todas as demais capturas de um evento Calculate, iremos executar o mínimo de operações. Fazendo assim com que a plataforma execute rapidamente qualquer tipo de análise e mostre de maneira muito rápida o resultado para o operador.

Ok, mas não entendi uma coisa. Como poderia ocorrer um evento Calculate, se os valores de prev_calculated e rates_total seriam iguais? Isto não seria um tanto quanto perda de tempo? Já que o laço da linha 21 não iria executar nenhum tipo de atividade? Sim meu caro leitor. De fato isto é verdade. Porém, o MetaTrader 5, NÃO irá disparar um evento Calculate, sem mais nem menos. Ele apenas o irá disparar se ocorrer mudança na cotação do ativo. Por conta disto em momentos de muita volatilidade no mercado, acontecerá uma verdadeira onda gigante de eventos chegando. Se o seu código estiver mal otimizado, isto fará com que a plataforma acabe ficando um tanto quanto lenta. Mas isto não é culpa da mesma, e sim de uma aplicação mal otimizada que estará consumindo tempo e recurso.

Considerações finais

Muito bem, neste artigo criamos o nosso primeiro indicador totalmente prático e funcional. O objetivo aqui, não é e não será mostrar como se cria de fato uma aplicação. Mas ajudar a você, meu caro e estimado leitor, a entender como você pode por conta própria desenvolver suas próprias ideias. As colocando em prática, de forma segura, simples e prática.

Como este assunto, precisa de fato, ser muito bem assimilado e estudado. Não vou me estender além do necessário. Tornando assim o material muito mais denso e complexo do que acredito ser necessário e possível de ser estudado com calma. Então no anexo, você irá ter dois dos códigos vistos aqui. Mas poderá fazer uso dos mesmos para compreender o passo a passo mostrado no artigo.

No próximo artigo iremos continuar onde este daqui está sendo finalizado. Já que ainda falta falar da segunda forma de declaração da função OnCalculate.