A ociosidade é o estímulo do progresso. Marcação semiautomática de um modelo

Introdução

Qualquer marcação está determinando o extremo em um gráfico e compondo algumas figuras ou linhas definidas pelo usuário com bases nesses pontos. Os seguidores das ondas de Elliott precisam marcar certas ondas e as conclusões (qual é a onda), determinando o número etc. Os discípulos das ondas de Wolf precisam desenhar linhas de tendência e denotar alvos. As "borboletas" precisam de pontos e níveis para determinar as possíveis borboletas, caranguejos e outras figuras formalizadas por Gartley.

Os níveis de Murrey são necessários para aqueles que preferem esse método. O cálculo automático não nos permite envolver centenas, ou talvez milhares de formações, ao menos que não seja um software especial. Por outro lado, qualquer um pode ver a desvantagem da marcação automática em consequência dos métodos de condição de formalização. E não é todo o software que nos permite interferir no processo de marcação. Então, a aplicação de marcadores manuais e a atribuição do processamento de dados adicionais ao computador ampliam as capacidades do usuário.

Marcação semiautomática de um modelo de negociação

Vamos considerar a marcação das ondas de Wolf, por exemplo. (A descrição foi tirada do famoso livro de Linda Raschke «Street Smarts»).

A teoria de Bill sobre a estrutura de onda é baseada na primeira lei da física de Newton: para cada ação há uma reação oposta. Esse movimento cria uma onda definitiva com capacidades de projeção valiosas. Essa onda se define claramente quando há boa volatilidade.

Começando com um topo ou fundo no gráfico de barra, garantimos que começaremos nossa contagem em uma nova onda. Essa contagem é para uma configuração de compra. Começamos a contar em um topo. (A contagem de onda seria invertida se estivéssemos começando pela visão de fundo para uma configuração de venda).

1. A onda número 2 é um topo.
2. A onda número 3 é o fundo de um primeiro declínio.
3. A onda número 1 é o fundo antes da onda 2 (topo). O ponto 3 deve ser mais baixo que o ponto 1.
4. A onda número 4 é o topo da onda 3. O ponto da onda 4 deve ser mais alto que o fundo da onda 1.
5. Uma linha de tendência é desenhada do ponto 1 até o ponto 3. A extensão dessa linha se projeta para o ponto inverso antecipado que chamaremos de onda 5. Esse é o ponto de entrada do caminho para a linha EPA (de 1 a 4).
6. O Preço estimado de chegada (EPA) é a linha de tendência desenhada dos pontos 1 a 4. Ela projeta o preço antecipado do objeto. Nossa parada inicial é colocada abaixo da nova inversão formada no ponto 5. Depois, ela poderá ser movida rapidamente para o breakeven.

PONTO IMPORTANTE: Não é possível iniciar procurando a Wolfe Wave até que os pontos 1, 2, 3 e 4 tenham sido formados.

Tenha em mente que o ponto 3 deve ser mais baixo que o ponto 1 para uma configuração de compra. Ele deve ser mais alto que o ponto 1 para uma configuração de compra. Além disso, nas melhores ondas o ponto 4 será mais alto que o ponto 1 em uma configuração de compra e mais baixo que 1 em uma configuração de venda. Isso garante que as condições fuga de mercado absolutas não existam. Agora, estude os exemplos e veja se pode treinar seus olhos para começar a ver a configuração Wolfe Wave.

A exibição ilustra como uma Wolfe Wave se parece quando está começando a se formar. Os pontos 1, 2 e 3 já devem ter se formado. O ponto 2 deve ser um balanço significativo baixo ou alto. Uma linha de tendência é então desenhada entre os pontos 1 e 3. Isso projeta onde devemos antecipar o ponto 5.

O ponto 5 está formado. Compraremos o inverso dessa área e colocaremos uma parada curta embaixo dela. Se desenharmos uma linha de tendência do ponto 1 para o ponto 4, ela deve nos dar uma projeção de preço.

O ponto 2 é o ponto inicial par ao padrão. Sempre acho mais fácil começar a contar desse ponto. Depois, recue e encontre os pontos 1 e 3. Não esqueça que o ponto 4 deve ser mais alto que o ponto 1. Nossa linha de tendência é desenhada para projetar o ponto 5. O mercado encontra apoio nesse nível, então entramos em uma longa posição no mercado e colocamos uma parada logo abaixo do ponto 5. O mercado negocia para esse objetivo.

De acordo com a descrição em anexo, precisamos montar a marcação com os símbolos especiais (dígitos de 1 a 5 e depois desenhar as linhas de tendência do ponto 1 em que passam os pontos 4 e 5).

No método do manual, os objetos do texto são criados e designados para os pontos específicos no gráfico, depois as linhas de tendência são criadas e colocadas no gráfico. Os recursos da linguagem de programação permitem simplificar o processo e excluir a criação de objetos e o desenho de linhas de tendência do processo. Nessa abordagem, o usuário permanece para atribuir as marcações a certos pontos no gráfico e ter o desenho das linhas de tendência pronto.

Lembramos que existem duas formas de colocar as informações no gráfico.

A primeira é quando um objeto de texto criado é atribuído a um certo ponto no gráfico e o segundo é quando a vinculação é atribuída a um certo ponto da janela do gráfico.

Vamos usando esses recursos para criar objetos diferentes. Criamos o botão "OnOff" para remover os objetos já aplicados e as linhas já desenhadas, e o ligamos a um certo ponto da janela. E criamos os objetos que serão ligados aos pontos específicos no gráfico. Considerando que o gráfico pode ser reescalado e os objetos serão alterados junto com o gráfico, determinamos que a posição inicial dos pontos ligados à direta da barra zero do gráfico. Usaremos essa posição para ativar e desativar a função do desenho das linhas de tendência.

// Check the presence of the "OnOff" button, create it in case of absence
int    obj_total=ObjectsTotal();
  string index;
  for( i=0;i<obj_total;i++)
    {
     index=ObjectName(i);
      string Lbl = StringSubstr (index, 0, 12);
            if (Lbl == "Lable_On_Off") string LblOnOff=index;
     }
if (LblOnOff!="Lable_On_Off") OnOff(Red, 10);

em que

OnOff(Red, 10);

é a função de criação e posicionamento do botão "OnOff".

void OnOff (color clr_, int h)
         {                                      
         ObjectCreate("Lable_On_Off",OBJ_LABEL,0,0,0);// Creation of the "OnOff" button
         ObjectSetText("Lable_On_Off",CharToStr(204) , 12, "Wingdings", clr_);
         ObjectSet(   "Lable_On_Off", OBJPROP_CORNER, 3);     // The angle of displaying on the chart
         ObjectSet(   "Lable_On_Off", OBJPROP_XDISTANCE, 10);
         ObjectSet(   "Lable_On_Off", OBJPROP_YDISTANCE, h);
         } 
return;

Função embutida

CharToStr()

permite exibir os objetos no gráfico

"Wingdings"

apenas inserindo os códigos dos símbolos.

Executamos a ativação do indicador selecionando e movendo o botão "OnOff" para cima. Após mover e voltar do primeiro tick do gráfico, o botão é designado para a outra posição e muda para a cor verde, e mostramos os objetos à direita da primeira barra: os dígitos para a enumeração no gráfico pela função.

Colocamos os objetos no gráfico dependendo da posição do botão.

// Check if the "OnOff" button is at its place
   
if (ObjectGet("Lable_On_Off",OBJPROP_XDISTANCE)>70||
    ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)<20)// if it is not there then
       { 
          OnOff(Red, 10);// we move the "OnOff" button to its place and delete all marks, channel, trend line
         for ( i=0; i<point_kol; i++)
            ObjectDelete("Lable_"+i);
            ObjectDelete("TRDLine");
            ObjectDelete("FIBOCanal");
         return;
         }  
                                               
if (ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)>10 && 
    ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)!=40) //If the button is moved upwards then
       {  
         OnOff(Green, 40); // we fix it up there
         CreatePoint();   // Create points
       }

em que

CreatePoint();

é a função da posição inicial dos pontos calculados no gráfico.

void CreatePoint ()
      {
      double shcala=(WindowPriceMax()-WindowPriceMin());
      for( i = 0; i < point_kol; i++) // Create points
               {                                      
      ObjectCreate("Lable_"+i, OBJ_ARROW, 0,Time[Bars-1],Bid);
      ObjectSet("Lable_"+i,OBJPROP_ARROWCODE,140+i);
      ObjectSet("Lable_"+i,OBJPROP_WIDTH,2);
      ObjectSet("Lable_"+i,OBJPROP_COLOR,Green);
      ObjectMove("Lable_"+i, 0,(Time[0]+Period()*720), (WindowPriceMin()+shcala/2)-shcala/12*i);
               } 
      }

Aqui, quero chamar a atenção para o fato de que somente três pontos são ativos se essa marcação for usada, então adicionei uma variável extra para possibilitar a escolha de quantos pontos aplicar no gráfico, 3 ou 5. O valor padrão é 5, mas eu uso 3 percebendo visualmente os pontos intermediários eu mesmo.

extern int point_kol=5;

Usamos o canal Fibo em vez da linha de tendência direcionada para o movimento de preço presumido. Ele fornece a orientação expandida no gráfico. O canal fornece a orientação sobre o suporte e as linhas de resistência nos níveis Fibo. Nessa representação, podemos observar os alvos das intersecções da linha de tendência e os níveis Fibo, ela permite alocar acertas táticas de negociação.

Veja aqui como ela se parece:

Ligamos o indicador e movemos o botão para cima.

O gráfico diário. Colocamos os pontos e o indicador criado na linha de tendência e nos canais Fibo.

Conclusão

Esse tipo de representação se informação no gráfico permite implementar, por exemplo, a análise das ondas de Elliot. Como determinamos dois pontos extremos manualmente, podemos calcular novamente as ondas internas usando um período de tempo de um período mais baixo, e obter um resultado de uma análise adicional comparando-a com as condições específicas. Nesse ponto, um usuário pode especificar um valor explícito de um novo cálculo (impulso ou corretivo).

Aqui, também queria que os desenvolvedores da linguagem MLQ4 adicionassem a função de novo cálculo da posição da janela dos objetos em pixels para a ligação direta ao gráfico. O ponto é que o método proposto no momento para a biblioteca user32.dll e a chamada de parâmetros da janela atual dela mostra a mensagem de que o user32.dll está ausente. Isso significa que não há tal recurso em uma entrega típica de Windows XP e MetaTrader 4. Nessa implementação, tive que recusar a possibilidade da implementação de analisar por todo o gráfico, se não apenas movendo os pontos manualmente.

O próprio indicador (código fonte):

//|                                                 0_CTL.mq4 |
//|                                   Copyright © 2008, [e-mail] |
//|                                             http://www.fibook.ru |
//+------------------------------------------------------------------+
#property copyright "[e-mail]"
#property link      "http://www.fibook.ru"
#property indicator_chart_window
extern int point_kol=5;
string mon[]={"january", 
              "february", 
              "march", 
              "april", 
              "may", 
              "june", 
              "july", 
              "august", 
              "september", 
              "october", 
              "november", 
              "december"};
int i;
double coordinatsT[5], coordinatsP[5];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
  string info="Marking  "+ Symbol()+" by "+Day()+" "+mon[Month()-1]+" "+Year()+" г."; 
   CreateUp (info);
 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
//----
 
// Check the presence of the "OnOff" button, create it in case of absence
int    obj_total=ObjectsTotal();
  string index;
  for( i=0;i<obj_total;i++)
    {
     index=ObjectName(i);
      string Lbl = StringSubstr (index, 0, 12);
            if (Lbl == "Lable_On_Off") string LblOnOff=index;
     }
if (LblOnOff!="Lable_On_Off") OnOff(Red, 10);  
// Check if the "OnOff" button is at its place
   
if (ObjectGet("Lable_On_Off",OBJPROP_XDISTANCE)>70||
    ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)<20)// if it is not there then
       { 
          OnOff(Red, 10);// we move the "OnOff" button to its place and delete all marks, channel, trend line
         for ( i=0; i<point_kol; i++)
            ObjectDelete("Lable_"+i);
            ObjectDelete("TRDLine");
            ObjectDelete("FIBOCanal");
         return;
         }  
                                               
if (ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)>10 && 
    ObjectGet("Lable_On_Off",OBJPROP_YDISTANCE)!=40) //If the button is moved upwards then
       {  
         OnOff(Green, 40); // Fix it up there
         CreatePoint();   // Create points
       }  
         
           for (i=0; i<point_kol; i++)
               {   
                 coordinatsT[i]=ObjectGet("Lable_"+i,OBJPROP_TIME1); // Read the coordinates
                 coordinatsP[i]=ObjectGet("Lable_"+i,OBJPROP_PRICE1);
               }   
     
         // if all points are carried to the chart then we draw the additional objects
         if  ((coordinatsT[0]<Time[0])&&
              (coordinatsT[1]<Time[0])&&
              (coordinatsT[2]<Time[0])&&
              (coordinatsT[3]<Time[0])&&
              (coordinatsT[4]<Time[0]))  
            {
            ObjectCreate("TRDLine", OBJ_TREND, 0,0,0);
            ObjectCreate("FIBOCanal", OBJ_FIBOCHANNEL, 0,0,0);
            ObjectMove ("TRDLine", 0,coordinatsT[0],coordinatsP[0]);
            ObjectMove ("TRDLine", 1,coordinatsT[point_kol-2],coordinatsP[point_kol-2]);
            ObjectMove ("FIBOCanal", 0,coordinatsT[0],coordinatsP[0]);
            ObjectMove ("FIBOCanal", 2,coordinatsT[point_kol-2],coordinatsP[point_kol-2]);
            ObjectMove ("FIBOCanal", 1,coordinatsT[point_kol-1],coordinatsP[point_kol-1]);
            }
   return(0);
  }
//+------------------------------------------------------------------+
 
void OnOff (color clr_, int h)
         {                                      
         ObjectCreate("Lable_On_Off",OBJ_LABEL,0,0,0);// Creation of the "OnOff" button
         ObjectSetText("Lable_On_Off",CharToStr(204) , 12, "Wingdings", clr_);
         ObjectSet(   "Lable_On_Off", OBJPROP_CORNER, 3);     // The angle of displaying on the chart
         ObjectSet(   "Lable_On_Off", OBJPROP_XDISTANCE, 10);
         ObjectSet(   "Lable_On_Off", OBJPROP_YDISTANCE, h);
         } 
return;          
 
void CreatePoint ()
      {
      double shcala=(WindowPriceMax()-WindowPriceMin());
      for( i = 0; i < point_kol; i++) // Create points
               {                                      
      ObjectCreate("Lable_"+i, OBJ_ARROW, 0,Time[Bars-1],Bid);
      ObjectSet("Lable_"+i,OBJPROP_ARROWCODE,140+i);
      ObjectSet("Lable_"+i,OBJPROP_WIDTH,2);
      ObjectSet("Lable_"+i,OBJPROP_COLOR,Green);
      ObjectMove("Lable_"+i, 0,(Time[0]+Period()*720), (WindowPriceMin()+shcala/2)-shcala/12*i);
               } 
      } 
 void CreateUp(string info) 
               {
                  ObjectCreate("TextAlerts", OBJ_LABEL, 0, 0, 0);  
                  ObjectSetText("TextAlerts",info , 16, "Times New Roman", Green);
                  ObjectSet("TextAlerts", OBJPROP_CORNER, 0);
                  ObjectSet("TextAlerts", OBJPROP_XDISTANCE, 20);
                  ObjectSet("TextAlerts", OBJPROP_YDISTANCE, 10);       
               }