Download MetaTrader 5

Padrões disponíveis para negociação de cestas de moedas. Parte II

5 abril 2017, 09:14
Andrei Novichkov
0
653

Introdução

No artigo anterior sobre padrões que surgem durante a negociação de moedas, toda a atenção centrou-se na combinação de indicadores com base em osciladores. O indicador combinado Williams’Percent Range servi-nos-rá de exemplo. Como resultado, nós obtivemos alguns padrões, analisamos seus prós e contras, tiramos conclusões sobre a aplicabilidade de cada um deles na negociação real.

No entanto, o trabalho feito não é suficiente, uma vez que os indicadores combinados com base nos osciladores não podem cobrir as necessidades de todo trader quanto à análise técnica do estado da cesta de moedas. É necessário completar o conjunto de negociação usando indicadores de tendência combinados que tenham seus próprios padrões. Só após estudá-los, nós poderemos dizer que nos aproximamos realmente de todos os tipos básicos de padrões e não nos esquecemos de nada. Isto deve tornar o conjunto de ferramentas técnicas bastante completo.

Para resolver este problema, criaremos um indicador de teste. Nós já realizamos esta tarefa, é por isso que podemos usar o código do artigo anterior no qual foram feitas algumas pequenas alterações. Antes de tudo, convém relembrar alguns detalhes sobre os indicadores de tendência combinados. Doravante usaremos a já conhecida terminologia dos artigos anteriores.


Características dos indicadores de tendência combinados

Os indicadores de tendência combinados não podem ser construídos sobre a base de qualquer indicador-mãe de tendência. Isto tem suas restrições.

Restrição № 1. Os indicadores combinados devem ser colocados numa janela separada. Na verdade, não vale a pena exibir tal indicador numa só janela com o gráfico de preço. Isto é provado pelo princípio da média sobre a qual são construídos os indicadores combinados, isto é, não é claro se, neste caso, eles serão exibidos. Surge a questão das unidades de medida, porque não sabemos se elas serão diferentes das que já estão na tabela. Daqui resulta que nem as médias móveis, nem as bandas de Bollinger e nem outros indicadores "on chart" podem servir como indicadores-mãe.

Restrição № 2.  O indicador combinado mostra o estado de apenas uma moeda, por conseguinte, para exibir o estado de um par de moedas, são necessários dois indicadores combinados. Como cada um deles está localizado numa janela separada, precisaremos dois janelas adicionais. A razão para esta separação é a diferença de escala. Os indicadores combinados com base em osciladores sempre mudam nos limites já conhecidos, no entanto, isto não acontece com os indicadores de tendência. Os valores máximo e mínimo não são conhecidos antecipadamente. E, portanto, não serve de nada usar a abordagem descrita anteriormente, isto é, aplicar a média móvel à diferença entre as leituras de dois indicadores combinados. Esse tipo de cálculos conjuntos são inadequados no caso da combinação de indicadores de tendência.

Restrições à lista de indicadores-mãe reduzem as probabilidades de utilizar indicadores de tendência combinados. Por exemplo, de toda a lista de indicadores de tendência no menu da MetaTrader 5, apenas o ADX e o StdDev servir-nos-ão previamente.

Mas isso não é motivo para abandonar a tarefa. Trabalharemos com os instrumentos à nossa disposição; começaremos com um indicador de tendência combinado conhecido, ou seja, com um índice de moeda.


Índice de moeda com média móvel

Escreveremos o indicador de teste testIndexMA.mq5, semelhante ao descrito neste artigo. Imediatamente adicionamos a ele uma média móvel:

//+------------------------------------------------------------------+
//|                                                 testDistance.mq5 |
//|                                   2016 MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   2
input color   clr= clrGreen;
input color   clrMA = clrMagenta;
input int maperiod  = 10; //Period MA
double ind[],ma[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
//int h,h1;
int OnInit()
  {
//--- indicator buffers mapping
   ArraySetAsSeries(ind,true);
   SetIndexBuffer(0,ind);        
  
   IndicatorSetString(INDICATOR_SHORTNAME,"testdistance");
   IndicatorSetInteger(INDICATOR_DIGITS,2);
   PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_LINE);
   PlotIndexSetInteger(0,PLOT_LINE_STYLE,STYLE_SOLID);
   PlotIndexSetInteger(0,PLOT_LINE_WIDTH,2);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,clr);
   PlotIndexSetString(0,PLOT_LABEL,"_tstdistance_");    
   ArraySetAsSeries(ma,true);  
   SetIndexBuffer(1,ma);
   PlotIndexSetInteger(1, PLOT_DRAW_TYPE, DRAW_LINE           );
   PlotIndexSetInteger(1, PLOT_LINE_STYLE, STYLE_SOLID            );
   PlotIndexSetInteger(1, PLOT_LINE_WIDTH, 1            );
   PlotIndexSetInteger(1, PLOT_LINE_COLOR, clrMA            );
   PlotIndexSetString (1, PLOT_LABEL, "_tstdistance_MA" );        
//---
   return(INIT_SUCCEEDED);
  }
  
string pair[]={"EURUSD","GBPUSD","AUDUSD","NZDUSD","USDCAD","USDCHF","USDJPY"};
bool bDirect[]={false,false,false,false,true,true,true};
int iCount=7;
  
double GetValue(int shift)
  {
   double res=1.0,t;
   double dBuf[1];
   for(int i=0; i<iCount; i++)
     {
      t=CopyClose(pair[i],PERIOD_CURRENT,shift,1,dBuf);
      if(!bDirect[i]) dBuf[0]=1/dBuf[0];
      res*=dBuf[0];
     }//end for (int i = 0; i < iCount; i++)
   return (NormalizeDouble(MathPow (res, 1/(double)iCount), _Digits) );  
  }  
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
      int rt=rates_total;
      for(int i=1; i<rt; i++)
        {
         ind[i]= GetValue(i);
        }
         rt -= maperiod;  
         for (int i = 1; i< rt; i++)
           {
            ma[i] = GetMA(ind, i, maperiod, _Digits);
           }        
     }
   else
     {
         ind[0]= GetValue(0);
          ma[0] = GetMA(ind, 0, maperiod, _Digits);
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
void OnDeinit(const int reason)
  {
   string text;
   switch(reason)
     {
      case REASON_PROGRAM:
         text="Indicator terminated its operation by calling the ExpertRemove() function";break;
      case REASON_INITFAILED:
         text="This value means that OnInit() handler "+__FILE__+" has returned a nonzero value";break;
      case REASON_CLOSE:
         text="Terminal has been closed"; break;
      case REASON_ACCOUNT:
         text="Account was changed";break;
      case REASON_CHARTCHANGE:
         text="Symbol or timeframe was changed";break;
      case REASON_CHARTCLOSE:
         text="Chart was closed";break;
      case REASON_PARAMETERS:
         text="Input-parameter was changed";break;
      case REASON_RECOMPILE:
         text="Program "+__FILE__+" was recompiled";break;
      case REASON_REMOVE:
         text="Program "+__FILE__+" was removed from chart";break;
      case REASON_TEMPLATE:
         text="New template was applied to chart";break;
      default:text="Another reason";
     }
   PrintFormat("%s",text);
  }
//+------------------------------------------------------------------+
double GetMA(const double& arr[], int index , int period, int digit) {
   double m = 0;
   for (int j = 0; j < period; j++)  m += arr[index + j];
   m /= period;
   return (NormalizeDouble(m,digit));
    }
De acordo com este conjunto de dados de origem, o indicador plotará o índice do dólar com uma média móvel rápida. Alteramos as cadeias de caracteres 49 e 50 para as seguintes:

string pair[]={"EURUSD", "EURJPY", "EURCHF", "EURGBP", "EURNZD", "EURCAD", "EURAUD"};
  bool bDirect[]={true,true,true,true,true,true,true};
Repetimos a compilação com o nome testIndexMA2.mq5. Como resultado, temos o mesmo indicador, mas ele também mostra o índice do euro. Colocamo-o para EURUSD H1:





Por ora, não estamos interessados em valores absolutos. Consideraremos os pontos de interseção no gráfico do indicador com MA pontos de potencial entrada no mercado. De acordo com os artigos anteriores, é necessário fixar estes pontos no fechamento da vela, coisa que já fizemos. Selecionamos as entradas encontradas usando linas verticais, isto é: azuis — compra, vermelho — venda. Você pode ver que há um resultado claramente positivo. No entanto, o lucro é pequeno e, obviamente, instável, por isso vale a pena pensar em aumentar a rentabilidade. Para começar, lembremos sobre a segunda moeda do par e adicionamos ao gráfico o índice do dólar numa janela separada:


Marcamos a intersecção do MA e o gráfico de índice dólar usando linhas verticais. Vamos analisar a imagem resultante.

  • A interseção entre o índice de uma das moedas e o MA indica uma possível mudança na tendência, mudança essa que será mais provável se tal interseção (mas na direção oposta) ocorrer na segunda moeda do par. Por exemplo, no par EURUSD, se o gráfico do índice USD atravessar o MA de baixo para cima, o gráfico de índice EUR deverá atravessar o MA de cima para baixo. A situação sinaliza o fortalecimento de uma moeda, enquanto a outra enfraquece.
  • Se houver pontos de interseção no gráfico do índice de ambas as moedas e eles terem a mesma direção, valerá a pena rejeitar a ideia de entrar no mercado. Esta situação indica uma alta probabilidade de surgir um movimento lateral.
  • Os pontos de intersecção deveriam ser óbvios, visíveis. Nós já consideramos esta questão no artigo anterior.

A partir do exposto, é possível fazer a primeira conclusão prática: para entrar no mercado, é preciso ter em conta o índice de ambas as moedas. O melhor é fazer isto durante o fortalecimento de uma moeda e o enfraquecimento simultâneo da outra. O primeiro "marcador" que sinaliza tal situação é a interseção do gráfico do índice de uma das moedas do par e o MA. Porém, não se deve entrar neste mercado, já que, primeiro, é preciso esperar o curso da segunda moeda na direção oposta.

Fica apenas a questão do atraso, isto é: qual é a distância máxima possível entre os pontos de interseção do gráfico do índice e do МА para as duas moedas do par? É óbvio que a distância mínima (e ideal) será zero. Quanto ao atraso máximo é difícil dar uma resposta inequívoca. Embora seja claro que esta distância deve estar presente. É perigoso entrar no mercado quando o enfraquecimento de uma moeda e o fortalecimento de outra estão muito separados no tempo. Neste caso, estamos diante de uma divergência e, como consequência, de um enfraquecimento da tendência.

Assim, nós consideramos a questão da entrada no mercado com base nos dados do indicador de tendência combinado. A fim de avaliar com mais precisão a qualidade do ponto de entrada proposto, passamos para o valor absoluto do indicador. Logo acima artigo, nós deixamo-los para mais tarde, mas chegou a hora para eles. 


Análise rápida usando o indicador ZigZag

Para os futuros trabalhos, usaremos um dos indicadores baseados no ZigZag deste artigo feito pelo respeitado colega Dmitry Fedoseev. Colocamos o indicador iUniZigZagPriceSW.mq5 diretamente no gráfico do índice USD:




Aqui o gráfico do ZigZag é exibido usando uma linha azul grossa. Nosso objetivo é analisar e sistematizar o comprimento dos segmentos do ZigZag. É possível que, dessa forma, obtenhamos a "amplitude dos swings" do índice dólar.

Modificamos ligeiramente o código do indicador:

//+------------------------------------------------------------------+
//|                                                 iUniZigZagSW.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 6
#property indicator_plots   3
//--- plot High
#property indicator_label1  "High"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrGreen
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- plot Low
#property indicator_label2  "Low"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrGreen
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
//--- plot ZigZag
#property indicator_label3  "ZigZag"
#property indicator_type3   DRAW_SECTION
#property indicator_color3  clrRed
#property indicator_style3  STYLE_SOLID
#property indicator_width3  1
//--- plot Direction
#property indicator_label4  "Direction"
#property indicator_type4   DRAW_LINE
#property indicator_style4  STYLE_SOLID
#property indicator_width4  1
//--- plot LastHighBar
#property indicator_label5  "LastHighBar"
#property indicator_type5   DRAW_LINE
#property indicator_style5  STYLE_SOLID
#property indicator_width5  1
//--- plot LastLowBar
#property indicator_label6  "LastLowBar"
#property indicator_type6   DRAW_LINE
#property indicator_style6  STYLE_SOLID
#property indicator_width6  1
#include <ZigZag\CSorceData.mqh>
#include <ZigZag\CZZDirection.mqh>
#include <ZigZag\CZZDraw.mqh>
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum EDirection
  {
   Dir_NBars=0,
   Dir_CCI=1
  };
//--- input parameters
input EDirection  DirSelect=Dir_NBars;
input int                  CCIPeriod   =  14;
input ENUM_APPLIED_PRICE   CCIPrice    =  PRICE_TYPICAL;
input int                  ZZPeriod=14;
input string               name="index-usd-zz.txt";
CZZDirection*dir;
CZZDraw*zz;
//--- indicator buffers
double         HighBuffer[];
double         LowBuffer[];
double         ZigZagBuffer[];
double         DirectionBuffer[];
double         LastHighBarBuffer[];
double         LastLowBarBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int h;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {
   switch(DirSelect)
     {
      case Dir_NBars:
         dir=new CNBars(ZZPeriod);
         break;
      case Dir_CCI:
         dir=new CCCIDir(CCIPeriod,CCIPrice);
         break;
     }
   if(!dir.CheckHandle())
     {
      Alert("Erro ao carregar o indicador 2");
      return(INIT_FAILED);
     }
   zz=new CSimpleDraw();
//--- indicator buffers mapping
   SetIndexBuffer(0,HighBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,LowBuffer,INDICATOR_DATA);
   SetIndexBuffer(2,ZigZagBuffer,INDICATOR_DATA);
   SetIndexBuffer(3,DirectionBuffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(4,LastHighBarBuffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(5,LastLowBarBuffer,INDICATOR_CALCULATIONS);
   h=FileOpen(name,FILE_CSV|FILE_WRITE|FILE_ANSI,',');
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   if(CheckPointer(dir)==POINTER_DYNAMIC)
     {
      delete(dir);
     }
   if(CheckPointer(zz)==POINTER_DYNAMIC)
     {
      delete(zz);
     }
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int ind=0;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[]
                )
  {
   int start;
   if(prev_calculated==0)
     {
      start=0;
     }
   else
     {
      start=prev_calculated-1;
     }
   for(int i=start;i<rates_total;i++)
     {
      HighBuffer[i]=price[i];
      LowBuffer[i]=price[i];
     }
   int rv;
   rv=dir.Calculate(rates_total,
                    prev_calculated,
                    HighBuffer,
                    LowBuffer,
                    DirectionBuffer);
   if(rv==0)return(0);
   zz.Calculate(rates_total,
                prev_calculated,
                HighBuffer,
                LowBuffer,
                DirectionBuffer,
                LastHighBarBuffer,
                LastLowBarBuffer,
                ZigZagBuffer);
   if(ind<= 10) ind++;
   if(ind == 10)
     {
      double mx=0,mn=1000000;
      double lg;
      for(int i=0;i<rates_total;i++)
        {
         if(ZigZagBuffer[i]==0 || ZigZagBuffer[i]==EMPTY_VALUE) continue;
         if(ZigZagBuffer[i] > mx) mx = ZigZagBuffer[i];
         if(ZigZagBuffer[i] < mn) mn = ZigZagBuffer[i];
        }
      lg=mx-mn;
      PrintFormat("Min index: %.05f Max index: %.05f Length: %.05f",mn,mx,lg);
      lg/=100;
      double levels[100];
      int    count[100];
      ArrayInitialize(count,0);
      for(int i=1; i<101; i++) levels[i-1]=NormalizeDouble(lg*i,_Digits);
      mn=0;
      for(int i=0;i<rates_total;i++)
        {
         if(ZigZagBuffer[i]==0 || ZigZagBuffer[i]==EMPTY_VALUE) continue;
         if(mn==0) mn=ZigZagBuffer[i];
         else
           {
            lg=MathAbs(mn-ZigZagBuffer[i]);
            for(int j=0; j<100; j++)
              {
               if(lg<levels[j])
                 {
                  count[j]++;
                  break;
                 }
              }
            mn=ZigZagBuffer[i];
           }
        }
      for(int i=0; i<100; i++)
        {
         PrintFormat("%d level: %.05f count: %d",i,levels[i],count[i]);
         FileWrite(h,i,levels[i],count[i]);
        }
      FileClose(h);
     }
   return(rates_total);
  }
//+------------------------------------------------------------------+
O indicador começa a trabalhar e no décimo tick determina o tamanho máximo possível do segmento do ZigZag. Tomando esta dimensão como 100%, calcularemos a magnitude de 1%, em seguida, ordenaremos todas as outras dimensões dos segmentos do ZigZag. Como resultado, temos uma matriz com o número de segmentos do ZigZag, com um tamanho de entre 1% e 100% do máximo. Os resultados são exibidos no arquivo e gráfico para Libre Office Calc (você pode aprender mais sobre eles carregando-os a partir do arquivo ZZdata.zip). Reproduzimos aqui o início do arquivo e a seção correspondente do gráfico:


Número em ordem Comprimento dos segmentos
Número de segmentos
0
0.01193 2975
1
0.02387
850
2
0.0358
197
3
0.04773
54
4
0.05967
17
Já não estamos tão interessados noutras áreas do gráfico, porque, basicamente, elas são preenchidas com zeros. É possível continuar e aperfeiçoar este estudo se reduzirmos o passo, mas concentrar-nos-emos nos resultados obtidos. Já podemos fazer a seguinte conclusão prática :
  • Deve-se ser cautelosos ao entrar no mercado sobre a tendência, quando o valor do segmento do ZigZag - segmento esse aplicado ao indicador combinado do índice da cesta de moedas - excede um determinado valor. Para o valor do segmento, aqui é tomado o comprimento da projeção do segmento do indicador ZigZag para o eixo do preço (ou seja, no eixo Y).

Naturalmente, surge a pergunta sobre o valor deste segmento "crítico". Ele pode ser determinado aplicando os métodos estatísticos aos dados acima. Se desejado, o trader pode realizar tal análise por conta própria, guiado pelo que julga sobre o risco aceitável. Para mim, eu assumi que o valor do segmento "crítico" não deve ser 0,03.

Neste exemplo, analisamos todo o período existente no histórico. No entanto, para capturar os últimos movimentos do mercado, o melhor é trabalhar os períodos mais pequenos (ano, trimestre, mês).

Análise como esta pode ser executada para todas as moedas da cesta para muitos timeframes. Seria interessante ver como, ao fazer isto, serão alterados os gráficos para os diferentes conjuntos de "moeda — timeframe". O desenvolvedor notará imediatamente que, se necessário, o algoritmo pode ser facilmente reproduzido no código. Mas, ao levar a cabo isto, não devemos esquecer a verdade, isto é: não vale a pena confiar apenas num sinal, você precisa olhar para confirmação. A técnica demonstrada pode ser aplicada a muitos indicadores de tendência habituais. Mas, no caso de osciladores, nem faz sentido nem dá nenhum resultado. 

Assim, avançamos mais um passo para melhorar a qualidade das aberturas de posição, ao usar indicadores combinados. Como já foi mencionado que é necessário buscar a confirmação dos sinais de um indicador, então, agora trataremos disso.


Uso compartilhado de diferentes indicadores combinados

Lembremo-nos do fato de nós já termos construído um indicador combinado com base no WPR. No último artigo, nós estudamos em detalhe seus código e padrões disponíveis. Desta vez, tentaremos aplicá-lo num par com índice de indicador combinado. A estrutura resultante deve ser eficiente, pois muitos sistemas de negociação são construídos apenas desta maneira, isto é: indicador de tendência + oscilador.

Portanto, pegamos os indicadores testDistance.mq5, testWPR.mq5 e testWPRjpy.mq5 do último artigo e colocamo-los no gráfico com o indicador combinado testDistance.mq5 do índice EUR. No último artigo, estudamos o gráfico EURJPY, por isto o indicador testWPRjpy deve ser reescrito a fim de trabalhar em USD. Preservamos o nome do indicador, para não alterar o indicador testDistance.mq5. Todos os indicadores desta seção podem ser encontrados na arquivo wpr.zip.

O indicador combinado WPR plotará a diferença entre as moedas combinadas do WPR que são incluídas em nosso par de moedas (isto é descrito em detalhe no artigo original). Nosso objetivo é detectar os padrões anteriormente descritos num indicador ao usar outro como filtro:





Na imagem são marcados pontos potenciais de entrada no mercado (não todos). Vale a pena considerar mais confiáveis as entradas que nas janelas superior (WPR combinado ) e inferior (índice combinado do euro) mostram-nos padrões unidirecionais. Aqui, estas entradas são marcadas com os números 1 e 6. Estes são os pontos de interseção dos gráficos do indicador com média móvel.

A entrada № 2 é interessante porque, neste ponto, o WPR combinado dá-nos apenas um padrão acadêmico com a interseção da linha de sobrevenda. Outras entradas não nos mostram provas suficientes do nível de confirmação. Embora a abertura real de posição nas áreas remanescentes não leve a perdas, eu não riscaria tanto durante a negociação real.

Será que é correto usar o indicador combinado que plota a diferença entre o WPR combinado e o WPR incluído na cesta de moedas? Não seria mais correto usar no par com índice combinado do euro o WPR combinado para o euro? Tentemos fazer isso substituindo testDistance.mq5 por testWPR.mq5:


Assim, nesta imagem, na janela inferior, vemos o indicador do WPR combinado para o euro. Será que se justifica sua colocação? Neste caso, obviamente, é justificada. Este indicador é corrigido em nossos pontos de entrada № 2 e 6 para uma vela (direção indicada pelas setas). A entrada no ponto № 1 não foi confirmada com muita confiança. A entrada nos pontos № 5 e № 3 não é recomendado. O indicador corrigiu o ponto № 4 mudando-o para o novo ponto №7.

Aparentemente estes resultados levam à conclusão de que é melhor usar o indicador combinado WPR de moeda da cesta, em vez do mesmo indicador da diferença entre o WPR combinado para as duas moedas do par de moedas. Mas isso só é verdade para esse caso particular. Já no caso de usar diariamente, eu descartaria o uso de ambas as formas de oscilador combinado se acumularem quaisquer estatísticas significativas.


Você pode argumentar: "o que há de tão especial nisto? O uso combinado de vários indicadores não é uma novidade, porque falar especificamente sobre isto no artigo? Além disso, os padrões aqui são irrelevantes."

No entanto, o objetivo desta parte do artigo foi o de responder a três perguntas:

  • Qual é a forma correta de usar os osciladores neste caso?
  • Há ou não proibição explícita sobre o uso de um dos modelos?
  • Quão corretamente identificados e confirmados são os padrões ao aplicar vários modelos de osciladores?

De acordo com nossas possibilidades, a resposta foi dada. Além disso, torna-se clara a maneira de testar as conclusões feitas.


Conclusão

Aqui termina a descrição de padrões simples que surgem ao negociar cestas de moedas. Mas, deve-se pôr fim a todo o assunto? De maneira nenhuma. Há ainda uma série de oportunidades interessantes.

Em conclusão, repito mais uma vez o óbvio: os indicadores anexados ao artigo não são destinados à negociação real! Eles apenas mostram certas situações e fazem claro certo fato. Eles estão muito longe de uma operação estável.

Programas utilizados no artigo:

 # Nome
Tipo
 Descrição
1 testIndexMA.mq5 Indicador Indicador de teste comum do dólar com média móvel
2 testIndexMA2.mq5 Indicador Indicador de teste comum do euro com média móvel
3 testIndexZig-Zag1.mq5 Indicador Indicador de teste Zig-Zag com possibilidade de medir e registrar o comprimento de segmentos individuais
4 testWPR.mq5 Indicador Indicador de teste combinado WPR para euro
5 testWPRjpy.mq5 Indicador Indicador de teste combinado WPR para dólar
6 testDistance.mq5 Indicador Indicador de teste combinado que plota a diferença entre os outros dois, neste caso, entre testWPR.mq5 e testWPRjpy.mq5 (euro-dólar)

Traduzido do russo por MetaQuotes Software Corp.
Artigo original: https://www.mql5.com/ru/articles/2960

Arquivos anexados |
testIndexMA.mq5 (4.82 KB)
testIndexMA2.mq5 (4.96 KB)
ZZdata.zip (37.28 KB)
wpr.zip (45.32 KB)
Interfaces Gráficas X: Novos recursos para a tabela Renderizada (build 9) Interfaces Gráficas X: Novos recursos para a tabela Renderizada (build 9)

Até agora, o tipo mais avançado de tabelas já desenvolvido em nossa biblioteca foi a CTable. Esta tabela é montada a partir de caixas de edição do tipo OBJ_EDIT, e seu posterior desenvolvimento tornou-se problemático. Portanto, em termos de capacidades máximas, é melhor desenvolver tabelas renderizadas do tipo CCanvasTable mesmo no atual estágio de desenvolvimento da biblioteca. Sua versão atual está completamente inerte, mas a partir deste artigo, nós vamos tentar corrigir esta situação.

Interfaces Gráficas X: O controle Caixa de Texto Multilinha (build 8) Interfaces Gráficas X: O controle Caixa de Texto Multilinha (build 8)

Neste artigo, nós vamos discutir o controle Caixa de Texto Multilinha. Ao contrário dos objetos gráficos do tipo OBJ_EDIT, a versão apresentada não terá restrições quanto ao número de caracteres de entrada. Ele também adiciona o modo para transformar a caixa de texto em um editor de texto simples, onde o cursor pode ser movido usando o mouse ou as teclas.

Interfaces Gráficas X: Atualizações para a tabela Renderizada e otimização do código (build 10) Interfaces Gráficas X: Atualizações para a tabela Renderizada e otimização do código (build 10)

Nós continuamos a complementar a tabela renderizada (CCanvasTable) com novas funcionalidades. A tabela terá agora: o realce das linhas quando o mouse estiver em cima; possibilidade de adicionar um array de ícones para cada célula e um método para trocá-los; possibilidade de definir ou modificar o texto da célula durante a execução do programa, e muito mais.

Tendência universal com GUI Tendência universal com GUI

No artigo, criaremos um indicador de tendência universal com base numa série de indicadores padrão. Será desenvolvida uma interface gráfica do usuário para selecionar o tipo de indicador e seus parâmetros. Exibiremos o indicador numa janela separada com fileiras de ícones coloridos.