Sistema de negociação DiNapoli

Conteúdo

1. Introdução
2. Níveis DiNapoli: fundamento
3. Princípios fundamentais e termos
4. Extensões de Fibonacci/DiNapoli
5. Táticas de negociação baseadas nos níveis DiNapoli
6. Estratégias "Sapador A" e "Sapador B"
7. Indicador de níveis DiNapoli
8. Conclusão
9. Lista de referência

1. Introdução

Todos os dias na negociação, surgem novas estratégias e numerosas melhorias nos sistemas de negociação clássicos. O trader, economista e autor de livros populares Jou DiNapoli criou um dos métodos mais populares num momento oportuno. Ele construiu um sistema com base nos níveis de Fibonacci, que atualmente é usado por muitos traders em todo o mundo.

Proponho examinar seu sistema em pormenor. Tentei o mais lucidamente explicar conceitos e princípios de negociação básicos - para este procedimento - que não podem ser descritos sem um conhecimento estreito com os níveis de Fibonacci. Que tipo de níveis são esses? Como podem ser entendidos e aplicados na prática? E, o mais importante, como eles funcionam na negociação?

2. Níveis DiNapoli: fundamento

Exibição do fundamento dos níveis DiNapoli

Consideremos os princípios gerais de negociação com base nos níveis DiNapoli. Em essência, estudaremos como devem ser plotados corretamente nos gráficos, o que eles exibirão em relação ao movimento do preço e como - com sua ajuda - definir pontos de entrada no mercado.

Como mencionei acima, a estratégia DiNapoli baseia-se nos níveis de Fibonacci. Neste procedimento, usam-se exclusivamente marcações horizontais, por sua vez, os arcos e leques de Fibonacci não encontraram aplicação particular na estratégia.

Exemplo de disposição inadequada de níveis Fibonacci

Exemplo de colocação correta de níveis de Fibonacci

Níveis DiNapoli são níveis de suporte e resistência inerentemente, mas interpretados mais profundamente do que no caso clássico. Eles são baseados não só nos níveis de Fibonacci, mas também na chamada oscilação do mercado (veja abaixo), ou, mais simplesmente, na tendência. Para construir níveis DiNapoli, precisamos de apenas três níveis de Fibonacci, isto é: 61,8%, 50% e 38,2%. São eles que irão atuar no nosso gráfico como níveis de suporte e resistência. No gráfico, as linhas de Fibonacci são traçadas de baixo para quando a tendência é de alta e, de cima para baixo quando a tendência é de queda.

Idealmente linhas alinhadas de 0% a 100% no sentido da tendência atual. Todos os níveis de Fibonacci que têm um valor maior do que 100% são utilizados para fixar os valores de fechamento de posição.

Oscilação do mercado

Níveis DiNapoli podem ser usados de duas maneiras, ou seja, como extensão e como correção. 

A correção é usada para localizar os pontos de entrada alvo em posições de negociação, enquanto a grade de extensão é construída para procurar pontos de saída do mercado.

3. Princípios fundamentais e termos

• O nó de Fibonacci é um ponto - no gráfico de preço - onde termina o movimento de correção. Joe Dinapoli aconselha que se deve trabalhar apenas com os nós que estão na faixa de 38,2% a 61,8%. Qualquer coisa abaixo de 38,2% é muito pequeno e acima de 61,8% é muito alto (ou seja, a tendência não pode ser restaurada).
  
• A oscilação de mercado (distância entre os extremos) é a distância desde o início até o fim do movimento do preço, na qual são realizados níveis de Fibonacci. Se, após a correção, o preço muda seu ponto máximo ou mínimo, você também deve mover o ponto mais externo dos seus níveis. Neste caso, aumenta a oscilação.
  
• O acúmulo é um local no gráfico onde existe agrupamento de vários nós de Fibonacci, isto é, um conjunto de níveis de correção próximos uns dos outros. 
  
• O ponto focal (extremo) é o ponto extremo da oscilação do mercado, ou seja, o nível a partir do qual inicia a correção de preços. Ao alterar o estremo, no gráfico aparece um outro ponto focal, portanto, pode haver muitos no gráfico na área de uma oscilação.
• O nível alvo é o ponto - no gráfico de preço - onde você deseja colocar o Take-Profit.
  
•  O ponto alvo é qualquer ponto - no gráfico - em que você planeja certa ação (entrada no mercado, sair dele, etc.).
• A reação é a correção final no movimento de tendência. No raio de uma oscilação podem ser formadas várias reações.
  

Extensão, correção e ponto focal

O gráfico de preços está em constante movimento, sempre é necessário ajustar as oscilações do mercado em relação ao gráfico. Ao acontecer isto, as oscilações aumentam seu escopo, de modo que o número de pontos focais pode variar no gráfico. No centro das oscilações do mercado aparecem as correções do preço, elas são chamadas de "reações". Cada uma terá seu próprio número.

Reações no gráfico

Dicas de DiNapoli

• Os sinais que chegam a partir destes níveis produzem fruto só se os níveis de correção, de acúmulo/suporte estiverem na zona entre 38,2% e 61,8%. Não vale a pena prestar atenção aos outros sinais.
• Os níveis para fixação do lucro serão as habituais extensões de Fibonacci, elas se estendem até à última correção, a fim de colocar o Stop-Loss nos níveis 161,8% e 261,8%.
• O número oscilações no gráfico sempre é igual ao número de números focais. Os números focais estão sempre mais à direita das reações com as quais estão associados.
  
• Ou seja, a correção de preços formada na oscilação dos níveis deve ser localizada à esquerda do número focal.
  
• Quanto maior o timeframe, menor é o número de reacções. Quando você está trabalhando em diferentes intervalos de tempo, você pode perceber que, nos timeframes pequenos, o movimento do preço é muito rápido, e esses pequenos movimentos nem sequer aparecem nos timeframe maiores.
• Esta regra também é utilizada na ordem inversa, ou seja, quando há um lugar onde o preço encontra forte resistência/suporte, você vai poder encontrar as reações e oscilações desejadas que não são exibidas nos timeframe maiores indo para os intervalos de tempo menores.

4. Extensões de Fibonacci/DiNapoli

Precisaremos da grade de extensões de níveis DiNapoli para determinar os locais de fechamento das posições, além disso, essa grade servirá como base para construir esses locais. Desta vez, usaremos os níveis de 100%, 161,8% e 261,8%, eles serão - para nós - os pontos-alvo para colocar o Take-Profit.

Extensões de níveis de Fibonacci (DiNapoli)

A grade de extensões de Fibonacci será construída no gráfico como se segue:

• Para a tendência de baixa — desde o mínimo até o pico de correção do preço formado pela linha de recuperação do preço, a partir de 38,2% e acima. 
• Para a tendência de alta — desde o máximo de preço e até o mínimo de correção do preço que cruza o nível 38,2% e acima.

Exemplo ilustrativo de como colocar no gráfico "Grade de extensões de Fibonacci"

Em seu livro "Trading with DiNapoli Levels", o autor presta muita atenção a conceitos como "Números focales múltiplos" e "Oscilações de mercado" ("Multiple Focus Numbers" e "Market Swings"). Estes modelos são específicos para instrumentos com "flats" frequentes (quando não há uma tendência clara estabelecida). A plotagem de "flats" é mais complicada do que os simples desenhos das "oscilações". A principal dificuldade consiste em isolar níveis que são irrelevantes para nós.

Resumidamente listo as conclusões que fiz depois de ler o livro. Suas vantagens indubitáveis consistem no fato de não ter sido escrito por um simples teórico, mas sim por um trader experiente e diretor administrativo. Outro argumento de peso a seu favor é a utilização de níveis de Fibonacci que têm resistido à passagem do tempo e que são harmoniosos e balanceados matematicamente. Entre outras coisas, os exemplos dados no livro descrevem não só os mercados de ações e de mercadorias, mas também a negociação de futuros de moeda, cujos princípios podem ser aplicados ao mercado Forex.

Leia melhor este trabalho no original, porque a tradução pode distorcer e obscurecer o contexto de umas técnicas muito complexas. Muitos dos novos termos introduzidos por DiNapoli também requerem um estudo cuidadoso e um completo entendimento.

5. Táticas de negociação baseadas nos níveis DiNapoli

Passemos diretamente para o sistema de negociação segundo os níveis DiNapoli. Em suma, se tomarmos apenas o ideologia básica de seus livros, podemos construir algumas táticas de negociação com níveis "agressivo" e "calmo".

• O agressivo inclui 2 formas de entrar no mercado, isto é, táticas "Arbustos" e "Bonsai". Seu princípio de negociação é semelhante, a única diferença é onde se colocam os Stop-Loss.
• O calmo também descreve 2 maneiras: "Sapador A" e "Sapador B".

Ao utilizar o método de negociação agressivo, o cálculo é feito para saber se o preço vai se desviar do nível de 38,2% e da oscilação já formada. A diferença entre as estratégias de "Arbustos" e "Bonsai" consiste em após qual nível Fibo deve ser definido o Stop-Loss.

Comecemos com o método de negociação "Arbustos". De acordo com as regras deste método, as posições devem ser abertas quando o preço - na grade de correções - ultrapassa o nível de 38,2% na direção da tendência atual, enquanto o Stop-Loss deve ser colocado adiante do nível de 50%. De acordo com o método de "Bonsai", entramos no mercado como o de "Arbustos", no entanto colocamos o Stop-Loss enquanto não atinjamos o nível de Fibonacci de 50%.

Não é por acaso que este tipo de negociação é chamada de agressiva, pois há risco de que - no gráfico - não aconteça a recuperação do preço. Muitas vezes, a correção eventualmente passa para a nova tendência ora o preço se mantem brevemente na fase de correção. Portanto, se você decidir utilizar este esquema, você terá que esperar por uma verificação do sinal, por segurança.

Estratégia "Arbustos"

O livro também descreve algumas das características negativas inerentes à estratégia "Bonsai". Por exemplo, DiNapoli enfatiza que na bolsa de valores pode acontecer uma derrapagem muito forte durante a execução da ordem Stop, uma vez que não há nenhum suporte para um nível poderoso, o que significa que não haverá nem negociações nem notificações. É por isso que a escolha dependerá da corretora e da plataforma de negociação. Por outro lado, é pouco provável que aconteça algo similar se você trabalha em instrumentos de alta liquidez com baixo volume no mercado.

6 Estratégias "Sapador A" e "Sapador B"

O "Sapador A" e "Sapador B" é a estratégia mais pacífica e menos arriscada. Segundo ela, a entrada no mercado também é realizada após o fim da correção, porém o trabalho em si é feito usando seguro.

• Sapador A. Em primeiro lugar, aguardamos o fim da primeira correção (por enquanto não abrimos posições) e, depois, esperamos a formação de uma segunda correção. Somente após isto, abrimos posições. Colocamos o Stop-Loss da mesma forma como na estratégia anterior, ou seja, antes do próximo nível de Fibonacci. 
• Sapador B. Abrimos posições somente após a terceira correção, a quarta, etc. Em outras palavras, entramos no mercado somente após uma séria confirmação da tendência, o que nos dá um forte seguro contra falsos sinais.

O que obtemos como resultado desta estratégia? Recebemos entradas esporádicas no mercado. A tendência não é sempre tão duradoura para dar 3, ou mais, movimentos de correção consecutivos que correspondam às regras desse sistema de negociação (sistema esse cujo recuo deve estar nos níveis de 38,2% — 61,8%). Por outro lado, assim, conseguimos filtrar sinais falsos, nos quais a correção de preço não se torna a continuação da tendência.

Estratégia "Sapador A"

Quando, no mercado, você se deparar com uma tendência bastante longa e um monte de correções (reações) e se você aderir a todas as regras de análise, seu gráfico aparecerá severamente desordenado mostrando níveis e linhas insignificantes. Na verdade, a maioria deles pode ser simplesmente descartado como informação interferência que não está sujeita às regras de negociação dos níveis DiNapoli.

Imagine que você vê no gráfico um forte movimento ascendente que tem algumas reações. Em algum momento acontece uma correção em todos os movimentos do preço para cima, como resultado disso, o preço começa a reescrever os mínimos de algumas reações. Essas reações devem ser excluídas, e seus mínimos não devem ser incluídos no trabalho.

7. Indicador de níveis DiNapoli

Especialmente para aqueles traders que não querem gastar tempo construindo níveis DiNapoli manualmente - colocando de níveis de Fibonacci -, desenvolveu-se um indicador que constrói e plota estes níveis no gráfico. O indicador anexado aos arquivos no final do artigo. Ele está disponível na biblioteca de códigos abertos. Consideraremos o trabalho com ele um pouco mais. O nome do indicador foi alterado para facilitar a leitura.

Para instalar o indicador, basta colocar o arquivo na pasta Indicators no diretório do terminal MetaTrader5. Ele não tem muitas configurações, principalmente deve ser ajustada a cor para exibição. As cores podem ser mudadas como quiser, mas se você é um novato, não é recomendado alterar os parâmetros, a fim de evitar a erros na exibição e análise de mercado feita pelos indicadores.

O indicador para exibição automática de níveis DiNapoli também inclui um indicador "Zigzag" com notificação sonora sobre a reversão do ZigZag. No gráfico, o indicador marca em vermelho a linha para colocar o Stop-loss, em azul, a linha para começar, as linhas horizontais restantes são alvos para o preço. Além disso, o indicador mostra linhas verticais que marcam o tempo (elas podem ser desativadas nas configurações do indicador).

Parâmetros de entrada do indicador

Exibição do indicador "DiNapoli Levels" no gráfico de preços do terminal

Parâmetros:

• Minimum points in a ray (por padrão = 400) — alteração de largura de níveis verticais de tempo;
• Show the vertical lines (por padrão = true) — exibir/não exibir níveis verticais de tempo;
• Number of history bars (por padrão = 5000) — número de barras cobertas pelo indicador integrado "Zigzag" no histórico;
• Play sound (por padrão = true) — ativar notificação sonora sobre a alteração de direção do "Zigzag";
• Sound file (por padrão = "expert.wav") — seleção de arquivo para notificação sonora;
• Start Line color (por padrão = Blue) — cor da linha horizontal de partida;
• Stop Line color (por padrão = Red) — cor da linha horizontal para colocação de Stop-Loss;
• Target1 Line color (por padrão = Green) — cor de linha horizontal para o alvor №1;
• Target2 Line color (por padrão = DarkOrange) — cor de linha horizontal para o alvo №2;
• Target3 Line color (por padrão = DarkOrchid) — cor de linha horizontal para o alvo №3;
• Target4 Line color (por padrão = DarkSlateBlue) — cor de linha horizontal para o alvo №4;
• Time Target1 color (por padrão = DarkSlateGray) — cor de linha vertical de tempo №1;
• Time Target2 color (por padrão = SaddleBrown) — cor de linha vertical de tempo №2;
• Time Target3 color (por padrão = DarkSlateGray) — cor de linha vertical de tempo №3;
• Time Target4 color (por padrão = DarkSlateGray) — cor de linha vertical de tempo №4;

Para começar, apresentamos os parâmetros básicos de indicador em que todo o código é construído.

Os parâmetros de código iniciais são os seguintes:

//------------------------------------------------------------------------------------
//                                                                 DiNapoli Levels.mq5
//                                                   The modified indicator FastZZ.mq5
//                                       Added DiNapoli Target Levels and Time Targets
//                                                         victorg, www.mql5.com, 2013
//------------------------------------------------------------------------------------
#property copyright   "Copyright 2012, Yurich"
#property link        "https://login.mql5.com/pt/users/Yurich"
#property version     "3.00"
#property description "FastZZ plus DiNapoli Target Levels."
#property description "The modified indicator 'FastZZ.mq5'."
#property description "victorg, www.mql5.com, 2013."
//------------------------------------------------------------------------------------
#property indicator_chart_window                                    // Exibir o indicador na janela do gráfico
#property indicator_buffers 3                                       // Número de buffers para cálculo do indicador
#property indicator_plots   1                                       // Número de janelas do indicador
#property indicator_label1  "DiNapoli Levels"                       // Define o rótulo para a série gráfica
#property indicator_type1   DRAW_COLOR_ZIGZAG                       // Estilo de desenho do indicador. N - número da série gráfica
#property indicator_color1  clrTeal,clrOlive                        // Cor para exibição da linha N, onde N é o número de série gráfica
#property indicator_style1  STYLE_SOLID                             // Estilo de linha na série gráfica
#property indicator_width1  1                                       // Espessura na série gráfica
//------------------------------------------------------------------------------------
input int    iDepth=400;                  // Mínimo de pontos no feixe
input bool   VLine=true;                  // Exibir linhas verticais
input int    iNumBars=5000;               // Número de barras no histórico
input bool   Sound=true;                  // Ativar notificações sonoras
input string SoundFile="expert.wav";      // Arquivo de som
input color  cStar=clrBlue;               // Cor da linha de partida
input color  cStop=clrRed;                // Cor da linha de Stop
input color  cTar1=clrGreen;              // Cor da linha de alvo №1
input color  cTar2=clrDarkOrange;         // Cor da linha de alvo №2
input color  cTar3=clrDarkOrchid;         // Cor da linha de alvo №3
input color  cTar4=clrDarkSlateBlue;      // Cor da linha de alvo №4
input color  cTarT1=clrDarkSlateGray;     // Cor da linha de tempo №1
input color  cTarT2=clrDarkSlateGray;     // Cor da linha de tempo №2
input color  cTarT3=clrSaddleBrown;       // Cor da linha de tempo №3
input color  cTarT4=clrDarkSlateGray;     // Cor da linha de tempo №4
input color  cTarT5=clrDarkSlateGray;     // Cor da linha de tempo №5

Introduzimos as variáveis no indicador.

//Principais variáveis
double   DiNapoliH[],DiNapoliL[],ColorBuffer[],Depth,A,B,C,Price[6];
int      Last,Direction,Refresh,NumBars;
datetime AT,BT,CT,Time[5];
color    Color[11];
string   Name[11]={"Start Line","Stop Line","Target1 Line","Target2 Line",
                   "Target3 Line","Target4 Line","Time Target1","Time Target2",
                   "Time Target3","Time Target4","Time Target5"};

Após escrever os principais parâmetros e introduzir as variáveis, podemos começar a escrever a parte principal do indicador.

Parte principal:

// Começamos a inicialização do indicador
void OnInit()
  {
  int i;
  string sn,sn2;
  
// Colocamos as condições para os pontos no feixe
  if(iDepth<=0)Depth=500; 
  else Depth=iDepth;   
  
// Colocamos as condições para as barras no histórico     
  if(iNumBars<10)NumBars=10;
  else NumBars=iNumBars;
  
// Configuramos a exibição de buffers de indicador  
  SetIndexBuffer(0,DiNapoliH,INDICATOR_DATA); 
  SetIndexBuffer(1,DiNapoliL,INDICATOR_DATA);
  SetIndexBuffer(2,ColorBuffer,INDICATOR_COLOR_INDEX);
  
//Colocamos a precisão de exibição para os valores do indicador
  IndicatorSetInteger(INDICATOR_DIGITS,Digits()); 
  
// Configuramos a renderização de linhas  
  PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0); 
  PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0); 
  
// Configuramos um nome curto para o indicador  
  sn="DiNapoli"; sn2=""; 
  for(i=1;i<100;i++)
    {
// Configuramos a busca de gráfico   
    if(ChartWindowFind(0,sn)<0){break;}
    sn2="_"+(string)i; sn+=sn2;
    }
    
// Definimos a exibição de símbolo    
  IndicatorSetString(INDICATOR_SHORTNAME,sn);
  for(i=0;i<11;i++) Name[i]+=sn2;
  
// Inicializamos os buffers com valores vazios   
  ArrayInitialize(DiNapoliH,0); ArrayInitialize(DiNapoliL,0);

Passamos para a realização do indicador:

// Configuramos as linhas coloridas do indicador
  Color[0]=cStar; Color[1]=cStop; Color[2]=cTar1; Color[3]=cTar2;
  Color[4]=cTar3; Color[5]=cTar4; Color[6]=cTarT1; Color[7]=cTarT2;
  Color[8]=cTarT3; Color[9]=cTarT4; Color[10]=cTarT5;
  Depth=Depth*_Point;
  Direction=1; Last=0; Refresh=1;
  for(i=0;i<6;i++)
    {
    if(ObjectFind(0,sn)!=0)
      {
      
// Configuramos as linhas horizontais e verticais     
      ObjectCreate(0,Name[i],OBJ_HLINE,0,0,0);
      ObjectSetInteger(0,Name[i],OBJPROP_COLOR,Color[i]);
      ObjectSetInteger(0,Name[i],OBJPROP_WIDTH,1);
      ObjectSetInteger(0,Name[i],OBJPROP_STYLE,STYLE_DOT);
//    ObjectSetString(0,Name[i],OBJPROP_TEXT,Name[i]);// descrição de objeto
      }
    }
  if(VLine==true)
    {
    for(i=6;i<11;i++)
      {
      if(ObjectFind(0,sn)!=0)
        {
        ObjectCreate(0,Name[i],OBJ_VLINE,0,0,0);
        ObjectSetInteger(0,Name[i],OBJPROP_COLOR,Color[i]);
        ObjectSetInteger(0,Name[i],OBJPROP_WIDTH,1);
        ObjectSetInteger(0,Name[i],OBJPROP_STYLE,STYLE_DOT);
//      ObjectSetString(0,Name[i],OBJPROP_TEXT,Name[i]);// descrição de objeto
        }
      }
    }
  }
  
// Adicionamos a função, ao remover o indicador no gráfico, são removidos todos os objetos gráficos do indicador
void OnDeinit(const int reason)
  {
  int i;
   
  for(i=0;i<11;i++) ObjectDelete(0,Name[i]);
  ChartRedraw();
  return;
  }

Agora calculamos os buffers de indicador:

// Função de iteração de indicador
int OnCalculate(const int total,        // Tamanho de TimeSeries de entrada
                const int calculated,   // Barras processadas para chamada
                const datetime &time[], // Matriz com valores de tempo
                const double &open[],   // Matriz com valores de abertura
                const double &high[],   // Matriz para copiar preços máximos 
                const double &low[],    // Matriz de preços mínimos
                const double &close[],  // Matriz de preços de fechamento
                const long &tick[],     // Parâmetro contendo o histórico de volume de ticks
                const long &real[],     // Volume real
                const int &spread[])    // Matriz contendo o histórico de spreads                

  {
  int i,start;
  bool set;
  double a;

// Definimos a verificação de barras
  if(calculated<=0)
    {
    start=total-NumBars; if(start<0)start=0;
    
// Inicializamos os buffers com valores vazios  
    Last=start; ArrayInitialize(ColorBuffer,0);
    ArrayInitialize(DiNapoliH,0); ArrayInitialize(DiNapoliL,0);
    }
    
// Cálculo da nova barra    
  else start=calculated-1;
  for(i=start;i<total-1;i++)
    {
    set=false; DiNapoliL[i]=0; DiNapoliH[i]=0;
    if(Direction>0)
      {
      if(high[i]>DiNapoliH[Last])
        {
        DiNapoliH[Last]=0; DiNapoliH[i]=high[i];
        if(low[i]<high[Last]-Depth)
          {
          if(open[i]<close[i])
            {
            DiNapoliH[Last]=high[Last];
            A=C; B=high[Last]; C=low[i];
            AT=CT; BT=time[Last]; CT=time[i];
            Refresh=1;
            }
          else
            {
            Direction=-1;
            A=B; B=C; C=high[i];
            AT=BT; BT=CT; CT=time[i];
            Refresh=1;
            }
          DiNapoliL[i]=low[i];
          }
          
// Definimos as cores de linhas      
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        set=true;
        }
      if(low[i]<DiNapoliH[Last]-Depth&&(!set||open[i]>close[i]))
        {
        DiNapoliL[i]=low[i];
        if(high[i]>DiNapoliL[i]+Depth&&open[i]<close[i])
          {
          DiNapoliH[i]=high[i];
          A=C; B=high[Last]; C=low[i];
          AT=CT; BT=time[Last]; CT=time[i];
          Refresh=1;
          }
        else
          {
          if(Direction>0)
            {
            A=B; B=C; C=high[Last];
            AT=BT; BT=CT; CT=time[Last];
            Refresh=1;
            }
          Direction=-1;
          }
          
// Definimos as cores de linhas
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        }
      }
    else
      {
      if(low[i]<DiNapoliL[Last])
        {
        DiNapoliL[Last]=0; DiNapoliL[i]=low[i];
        if(high[i]>low[Last]+Depth)
          {
          if(open[i]>close[i])
            {
            DiNapoliL[Last]=low[Last];
            A=C; B=low[Last]; C=high[i];
            AT=CT; BT=time[Last]; CT=time[i];
            Refresh=1;
            }
          else
            {
            Direction=1;
            A=B; B=C; C=low[i];
            AT=BT; BT=CT; CT=time[i];
            Refresh=1;
            }
          DiNapoliH[i]=high[i];
          }
          
// Definimos as cores de linhas           
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        set=true;
        }
      if(high[i]>DiNapoliL[Last]+Depth&&(!set||open[i]<close[i]))
        {
        DiNapoliH[i]=high[i];
        if(low[i]<DiNapoliH[i]-Depth&&open[i]>close[i])
          {
          DiNapoliL[i]=low[i];
          A=C; B=low[Last]; C=high[i];
          AT=CT; BT=time[Last]; CT=time[i];
          Refresh=1;
          }
        else
          {
          if(Direction<0)
            {
            A=B; B=C; C=low[Last];
            AT=BT; BT=CT; CT=time[Last];
            Refresh=1;
            }
          Direction=1;
          }
// Definimos as cores de linhas            
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        }
      }
    DiNapoliH[total-1]=0; DiNapoliL[total-1]=0;
    }
//------------
  if(Refresh==1)
    {

Ciclo final do ciclo do indicador:    

// Verificar se o número de barras é suficiente para o cálculo
    Refresh=0; a=B-A;
    Price[0]=NormalizeDouble(a*0.318+C,_Digits);           // Início;
    Price[1]=C;                                            // Stop
    Price[2]=NormalizeDouble(a*0.618+C,_Digits);           // Alvo№1
    Price[3]=a+C;                                          // Alvo№2;
    Price[4]=NormalizeDouble(a*1.618+C,_Digits);           // Alvo№3;
    Price[5]=NormalizeDouble(a*2.618+C,_Digits);           // Alvo№4;
    for(i=0;i<6;i++) ObjectMove(0,Name[i],0,time[total-1],Price[i]);
    if(VLine==true)
      {
 
// Retornamos o valor arredondado para o mais próximo número inteiro do valor especificado      
      a=(double)(BT-AT);
      Time[0]=(datetime)MathRound(a*0.318)+CT;             // Alvo de tempo№1
      Time[1]=(datetime)MathRound(a*0.618)+CT;             // Alvo de tempo№2
      Time[2]=(datetime)MathRound(a)+CT;                   // Alvo de tempo№3
      Time[3]=(datetime)MathRound(a*1.618)+CT;             // Alvo de tempo№4
      Time[4]=(datetime)MathRound(a*2.618)+CT;             // Alvo de tempo№5
      for(i=6;i<11;i++) ObjectMove(0,Name[i],0,Time[i-6],open[total-1]);
      }
    ChartRedraw();
    
// Se a direção for alterada, ativamos o som
    if(Sound==true&&calculated>0)PlaySound(SoundFile);
    }
  return(total);
  }
//------------------------------------------------------------------------------------

O indicador está anexado no apêndice do artigo.

8. Conclusão

Espero que esta informação básica lhe dê uma ideia positiva do que é a negociação segundo o método DiNapoli. Seria mais correto chamar estes níveis de "Abordagem original para trabalhar com níveis e extensões padrão de Fibonacci". O princípio fundamental de trabalho com os níveis continua a ser o mesmo, simplesmente DiNapoli introduziu uma série de novas regras que devidamente executadas dão resultados consistentes no mercado.

Programas utilizados no artigo:

#	Nome	Tipo	Descrição
1	DiNapoli  Levels.mq5	Indicador	Indicador para o cálculo automático e construção de níveis DiNapoli

9. Lista de referência

1. Joe DiNapoli, Trading with DiNapoli Levels. — Coast Investment Software, 1998