Descargar MetaTrader 5

Sistema comercial de DiNapoli

30 mayo 2017, 13:00
Roman Vashchilin
0
517

Contenido

  1. Introducción
  2. Los niveles de DiNapoli: bases
  3. Fundamentos principales y terminología
  4. Expansiones de Fibonacci/DiNapoli
  5. Técnica comercial con los niveles de DiNapoli
  6. Las estrategias "Zapador A" y "Zapador B"
  7. Indicador de niveles de DiNapoli
  8. Conclusión
  9. Literatura

1 Introducción

Cada día aparecen nuevas estrategias de trading y tienen lugar numerosas modificaciones de los sistemas comerciales clásicos. Uno de los métodos más conocidos fue creado en su día por un tráder, economista y autor de libros: Joe DiNapoli.  Construyó su sistema sobre los niveles de Fibonacci, y hasta el momento presente muchos tráders de todo el mundo usan sus modificaciones.

Vamos a analizar su sistema con más detalle. He tratado de exponer de la forma más comprensible posible los hechos esenciales y los fundamentos de esta metodología, que no pueden ser descritos sin un conocimiento profundo de los niveles de Fibonacci. ¿De qué niveles hablamos? ¿Cómo podemos comprenderlos y utilizarlos en la práctica? Y lo más importante, ¿cómo funcionan en el trading?

2. Los niveles de DiNapoli: bases



Representando las bases de los niveles de DiNapoli


Vamos a analizar los fundamentos generales del comercio según los niveles de DiNapoli. Vamos a analizar brevemente cómo colocarlos correctamente en el gráfico, qué representarán con respecto al movimiento del precio y cómo definir con su ayuda los puntos de entrada en el mercado.

Como ya hemos mencionado más arriba, la estrategia de Joe DiNapoli se basa en los niveles de Fibonacci. En este método se usa exclusivamente la marca horizontal: los arcos y los abanicos de Fibonacci no han encontrado una aplicación especial en la estrategia.



Ejemplo de colocación incorrecta de los niveles de Fibonacci



Ejemplo de colocación correcta de los niveles de Fibonacci


Los niveles DiNapoli, por su naturaleza, son de apoyo y resistencia, pero pueden interpretarse de una forma más profunda que en el caso clásico. Se construyen sobre la base de los niveles de Fibonacci. Se basan en la llamada amplitud de mercado (mirar más abajo), o, dicho de otra forma, en la tendencia. Para construir los niveles de DiNapoli necesitaremos tres niveles de Fibonacci: 61,8%, 50% y 38,2%. Estos precisamente van a actuar en nuestro gráfico como niveles de apoyo y resistencia. En el gráfico, las líneas de Fibonacci se trazan de abajo a arriba en caso de tendencia ascendente, y de arriba a abajo en caso de tendencia descendente.

De forma ideal, las líneas se construyen de 0% a 100% en la dirección de la tendencia actual. Todos los niveles de Fibonacci que tengan un valor superior al 100%, se usan para colocar los puntos de cierre de posición.



Amplitud de mercado


Los niveles de DiNapoli se pueden usar de dos formas: como expansión o como corrección. 

La corrección se aplica para buscar los puntos de objetivo de entrada en las posiciones comerciales, las expansiones se construyen para buscar los puntos de salida del mercado.


3. Fundamentos principales y terminología

  • Nodo de Fibonacci: punto en el gráfico de precio en el que finaliza el movimiento de la corrección. Joe DiNapoli aconsaejaba trabajar con los nodos que se encuentran en el rango de 38,2% a 61,8%. Todo lo que encuentre por debajo de 38,2% será demasiado insignificante, y  lo que se halle por encima de 61,8%, será demasiado intenso (es decir, es posible que la tendencia no se recupere).
  • Amplitud de mercado (distancia entre extremos): es la distancia entre el inicio y el final del movimiento de precio en el que se trazan los niveles de Fibonacci. Si el precio después de finalizar la corrección cambia su punto de máximo o mínimo, deberemos también desplazar el punto extremo de nuestros niveles. En este caso, la amplitud aumentará.
  • Acumulación: lugar en el gráfico en el que se observa la acumulación de varios nodos de Fibonacci, es decir, múltiples niveles de correción cercanos los unos a los otros.
  • Punto focal (extremo): punto extremo de la amplitud de mercado, nivel desde el que se comienza la corrección del precio. Al cambiar el extremo en el gráfico, aparece otro punto focal, por eso puede haber muchos en el gráfico en la zona de una amplitud.  
  • Nivel de objetivo: punto en el gráfico de precio en el cual usted planea colocar el take-profit.
  • Punto de objetivo: cualquier punto en el gráfico, en el que usted planea alguna acción (entrada en el mercado, salida del mismo, etcétera).
  • Reacción: corrección finalizada dentro del movimiento de la tendencia. En el radio de una amplitud pueden formarse varias reacciones.


Expansiones, corrección y punto focal


Los gráficos de precios están en constante movimiento, y nos vemos obligados cada vez a corregir las amplitudes de mercado con respecto al gráfico. Además, cada vez tendrá lugar la expansión de las amplitudes, de esta forma, el número de puntos focales en el gráfico puede cambiar. En el centro de las amplitudes de mercado aparecen correcciones precio, que se llaman "reacciones". Cada una de ellas tendrá su número.



Reacciones en el gráfico


Consejos de DiNapoli

  • Las señales que lleguen desde estos niveles traen beneficios solo en el caso de que los niveles de corrección, así como también los de acumulación/apoyo, se encuentren en la zona de los niveles 38,2%-61,8%. No merece la pena prestar atención al resto de señales.
  • Los niveles de fijación serán las expansiones comunes de Fibonacci, que se estiran hasta la última corrección, para que en los niveles 161,8% y 261,8% coloquemos un stop-loss.
  • El número de amplitudes en el gráfico siempre es igual al número de cifras focales.
  • Las cifras focales siempre se encuentran a la derecha de las reacciones con las que están relacionadas. Es decir, las correcciones que se han formado en la amplitud de los niveles deberán encontrarse a la izquierda del número focal.
  • Cuanto mayor sea el marco temporal, menor será el número de reacciones. Cuando usted trabaje en diferentes intervalos temporales, podrá notar que en los marcos temporales menores el movimiento de precio es muy rápido, y en los marcos temporales mayores estos pequeños movimientos a veces ni se representan.Esta misma regla se utiliza en a la inversa: cuando aparece un lugar en el que el precio encuentra un fuerte apoyo/resistencia, usted podrá encontrar descendiendo a intervalos temporales menores las reacciones y amplitudes que necesita y que no aparecen en los marcos temporales mayores.


4. Expansiones de Fibonacci/DiNapoli

La cuadrícula de expasiones de los niveles de DiNapoli la necesitaremos para definir los lugares de cierre de nuestras posiciones. La cuadrícula de expansiones de Fibonacci actuará como la base de su construcción. Esta vez utilizaremos los niveles en 100%, 161,8% y 261,8%, que serán para nosotros el punto de objetivo para ubicar el take-profit.



Expansión de los niveles de Fibonacci (DiNapoli)


La cuadrícula de expansiones de Fibonacci se construye en el gráfico de esta forma:

  • Para la tendencia descendente, comenzando por el mínimo de precio y hasta el pico de la corrección de precio que ha formado la línea de retroceso del precio, comenzando desde 38,2% y por encima.
  • Para la tendencia ascendente, comenzando por el máximo de precio y hasta el mínimo de la corrección de precio que cruza el nivel 38,2% y por encima.



Ejemplo visual de la colocación de la "Cuadrícula de expansiones de Fibonacci" en el gráfico


En su libro "Trading con los niveles de DiNapoli", el autor presta especial atención a conceptos tales como "Números focales múltiples" y "Amplitudes de mercado". Estos modelos son característicos en el trabajo para instrumentos con "flats" puros, cuando no existe una tendencia claramente establecida. En lo que respecta al trabajo en el gráfico y a su construcción, estas figuras son más complejas que las "amplitudes" sencillas. La principal complicación es el cribado de niveles innecesarios por su falta de actualidad.

Voy a enumerar brevemente las conclusiones que he sacado tras leer el libro. Entre sus indudables aspectos positivos, destaca que lo escribió un tráder y jefe experimentado, y no un simple teórico. Otro argumento de peso a su favor es la aplicación de los niveles de Fibonacci, que han superado la prolongada puesta a prueba del tiempo, y además son matemáticamente elegantes y está verificados. Aparte, los ejemplos mostrados en el libro describen no solo los mercados de valores y mercancías, sino también el comercio de futuros y divisas, cuyos fundamentos se pueden aplicar también al mercado Fórex.

Es mejor leer este trabajo en el idioma original, ya que las traducciones pueden deformar el contexto y complicar la comprensión de los matices más sutiles de la metodología. La multitud de términos introducidos por DiNapoli también exige de un estudio exhaustivo y una comprenisón multidisciplinar.


5. Técnica comercial con los niveles de DiNapoli

Vamos a pasar directamente al sistema comercial con los niveles de DiNapoli. En pocas palabras, si tomamos solo la ideología principal de su libro, podemos construir varias tácticas comerciales con niveles: "agresiva" y "tranquila".

  • La agresiva incluye 2 modos de entrada en el mercado: se trata de las estrategias "Arbustos" y "Bonsái". El fundamento comercial de ambos es semejante, la única diferencia radica en el lugar de ubicación de los stop-loss.
  • La tranquila describe asimismo 2 modos: "Zapador A" y "Zapador B".

Al usar el método comercial agresivo, el cálculo se basa en que el precio retrocederá desde el nivel 38,2% y la amplitud ya formada. La diferencia entre las estrategias "Arbustos" y "Bonsái" reside solo en que después de un nivel de Fibonacci se establece un stop-loss.

Comenzaremos por el método comercial "Arbustos".  Según las normas de este método, las posiciones se deben abrir en el momento cuando el precio en la cuadrícula de correcciones construida cruce el nivel 38,2% en dirección a la tendencia actual, y el stop-loss se ubique más allá del nivel 50%. Según la metodología de "Bonsái", entramos en el mercado según la misma metodología que "Arbustos", pero colocaremos el stop-loss antes de llegar al nivel de Fibonacci 50%.

No en vano se conoce al comercio con estas metodologías como agresivo, puesto que existe el riesgo de que el retroceso del precio en el gráfico no se dé en absoluto. Y es que muchas veces la corrección al final pasa a ser una nueva tendencia, o el precio frena por un breve espacio de tiempo en el mercado plano. Por eso, si usted decide trabajar con este esquema, deberá esperar a que la señal quede completamente confirmada, para asegurarse.



Estrategia "Arbustos"


En el libro también se describen ciertas peculiaridades negativas de la estrategia "Bonsái". DiNapoli subraya que en este caso en la bolsa puede haber un deslizamiento fuerte durante la ejecución de la orden stop, puesto que no hay apoyo en un nivel potente, y esto significa que no habrá "segmentos planos", ni concordancia de solicitudes. En relación con esto, la elección dependerá de la compañía de corretaje y la plataforma comercial. Por otra parte, si trabajamos con instrumentos de alta liquidez y con un volumen pequeño de mercado, en este caso, algo semejante es muy poco probable.


6. Las estrategias "Zapador A" y "Zapador B"

Las estrategias más tranquilas y menos arriesgadas son "Zapador A" y "Zapador B".  La entrada en el mercado según estas estrategias se realiza tras la finalización de la corrección, pero el propio trabajo se llevará a cabo con seguro.

  • Zapador A. Primero tenemos que esperar a que finalice la primera corrección (por el momento no abrimos las posiciones), luego esperamos la formación de la segunda corrección. Solo después de ello, abrimos las posiciones. El stop-loss lo colocamos de la misma forma que en la estrategia anterior, es decir, tras el último nivel de Fibonacci.
  • Zapador B. Abrimos las posicones, pero no después de la segunda corrección formada, sino solo tras la tercera, la cuarta, etcétera. En otras palabras, entramos en el mercado solo después de que la tendencia haya sido confirmada con argumentos de peso, lo que nos protegerá con mayor seguridad contra señales falsas.
¿Qué obtenemos como resultado de esta estrategia? Obtenemos entradas poco ferecuentes en el mercado. La tendencia no siempre es tan prolongada como para dar 3 correcciones o más seguidas, y que encima se correspondan con las reglas de este sistema comercial (es decir, el final del retroceso debe estar en los niveles 38,2% — 61,8%). Por otra parte, de esta forma podemos filtrar las señales falsas, en las que la corrección del precio no se convierte en continuación de la tendencia.


Estrategia "Zapador A".


Si usted se encuentra en el mercado con una tendencia bastante prolongada y con multitud de correcciones en ella (reacciones), y usted además se ciñe a todas las normas de análisis, su gráfico acabará cargado con muchísimos niveles y líneas insignificantes. En realidad, la mayor parte de estos se pueden descartar, pues son un estorbo que no se encuentra en el marco de las normas comerciales de los niveles de DiNapoli.

Imagínese que usted ve en el gráfico de precio un potente movimiento ascendente, en el que hay varias reacciones. En algún momento tendrá lugar la corrección en todos los movimientos de precio hacia arriba, y como resultado de ello, el precio comenzará a reescribir los mínimos de algunas reacciones. Estas correcciones deben ser canceladas, y sus mínimos no deberán incluirse en el funcionamiento.

7. Indicador de niveles de DiNapoli

Especialmente para aquellos tráders que no quieran gastar tiempo en la construcción de los niveles de DiNapoli manualmente colocando los niveles de Fibonacci, ya se ha desarrollado un indicador que construye estos niveles y los dibuja en el gráfico. El indicador  viene en los archivos al final del artículo. Está disponible en la biblioteca de códigos abiertos. Vamos a analizar el trabajo con él con algo más de detalle. Se ha cambiado el nombre del indicador para que se lea con mayor facilidad.

La instalación del indicador tiene lugar de forma tradicional, colocando el archivo en la carpeta  Indicators del catálogo raíz de MetaTrader 5. No tiene muchos ajustes, básicamente solo se configura el color de los niveles para la representación. El color se puede camibar con libertad, pero si usted es un principiante, no recomendamos cambiar los parámetros, para evitar errores en la representación y el análisis del mercado por parte del indicador.

El indicador para la representación automática de los niveles de DiNapoli incluye el indicador "Zigzag" con notificación acústica sobre el viraje del zigzag. El indicador marca con una línea roja en el gráfico la línea de colocación del stop-loss; con color azul, el indicador marca la línea para el comienzo del trabajo: el resto de líneas horizontales son las líneas de objetivo a alcanzar por el precio. Además, el indicador muestra las líneas verticales de la marca de tiempo (se las puede desactivar en los ajustes del indicador).


Parámetros de entrada del indicador



Representación del indicador "DiNapoli Levels" en el gráfico de precios del terminal


Parámetros:

  • Minimum points in a ray (por defecto = 400): cambio de la anchura de los niveles temporales verticales;
  • Show the vertical lines (por defecto = true) — representar/no representar los niveles temporales verticales;
  • Number of history bars (por defecto = 5000) — número de barras abarcadas en la historia por el indicador incorporado "Zigzag";
  • Play sound (por defecto = true) — activar la notificación acústica sobre el cambio de dirección por parte del indicador "Zigzag";
  • Sound file (por defecto = "expert.wav") — elegir el archivo para la notificación acústica;
  • Start Line color (por defecto = Blue) — color de la línea horizontal inicial;
  • Stop Line color (por defecto = Red) — color de la línea horizontal para colocar el stop-loss;
  • Target1 Line color (por defecto = Green) — color de la línea horizontal para el objetivo №1;
  • Target2 Line color (por defecto = DarkOrange) — color de la línea horizontal para el objetivo №2;
  • Target3 Line color (por defecto = DarkOrchid) — color de la línea horizontal para el objetivo №3;
  • Target4 Line color (por defecto = DarkSlateBlue) — color de la línea horizontal para el objetivo №4;
  • Time Target1 color (por defecto = DarkSlateGray) — color de la línea temporal vertical №1;
  • Time Target2 color (por defecto = SaddleBrown) — color de la línea temporal vertical №2;
  • Time Target3 color (por defecto = DarkSlateGray) — color de la línea temporal vertical №3;
  • Time Target4 color (por defecto = DarkSlateGray) — color de la línea temporal vertical №4;

Para empezar, introduciremos los parámetros del indicador, sobre los que se construye todo su código.

Los parámetros iniciales del código tienen el aspecto siguiente:

//------------------------------------------------------------------------------------
//                                                                 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/ru/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 // Mostrar el indicador en la ventana del gráfico
#property indicator_buffers 3    // Número de búferes para calcular el indicador
#property indicator_plots   1    // Número de eventanas del indicador
#property indicator_label1  "DiNapoli Levels" // establece la marca para la serie gráfica
#property indicator_type1   DRAW_COLOR_ZIGZAG // Estilo de dibujado del indicador. N - número de la serie gráfica
#property indicator_color1  clrTeal,clrOlive  // Color para la muestra de la línea N, donde N es el número de la serie gráfica
#property indicator_style1  STYLE_SOLID       // Estilo de la línea en la serie gráfica
#property indicator_width1  1    // Grosor de la línea en la serie gráfica
//------------------------------------------------------------------------------------
input int    iDepth=400;              // Mínimo de puntos en el rayo
input bool   VLine=true;              // Mostrar líneas verticales
input int    iNumBars=5000;           // Número de barras en la historia
input bool   Sound=true;              // Activar notificaciones acústicas
input string SoundFile="expert.wav";  // Archivo de audio
input color  cStar=clrBlue;           // Color de la línea inicial
input color  cStop=clrRed;            // Color de la línea de stop
input color  cTar1=clrGreen;          // Color de la línea de objetivo №1
input color  cTar2=clrDarkOrange;     // Color de la línea de objetivo №2
input color  cTar3=clrDarkOrchid;     // Color de la línea de objetivo №3
input color  cTar4=clrDarkSlateBlue;  // Color de la línea de objetivo №4
input color  cTarT1=clrDarkSlateGray; // Color de la línea temporal №1
input color  cTarT2=clrDarkSlateGray; // Color de la línea temporal №2
input color  cTarT3=clrSaddleBrown;   // Color de la línea temporal №3
input color  cTarT4=clrDarkSlateGray; // Color de la línea temporal №4
input color  cTarT5=clrDarkSlateGray; // Color de la línea temporal №5

Introducimos las variables en el indicador.

//Variables principales
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"};

Después de describir los parámetros principales y de introducir las variables, podemos pasar a escribir la parte principal del indicador.

Parte principal:

// Comenzamos la inicialización del indicador
void OnInit()
  {
  int i;
  string sn,sn2;
  
// Establecemos las condiciones para los puntos en el rayo
  if(iDepth<=0)Depth=500; 
  else Depth=iDepth;   
  
// Establecemos las condiciones para las barras en la historia     
  if(iNumBars<10)NumBars=10;
  else NumBars=iNumBars;
  
// Ajustamos la representación de los búferes de indicador  
  SetIndexBuffer(0,DiNapoliH,INDICATOR_DATA); 
  SetIndexBuffer(1,DiNapoliL,INDICATOR_DATA);
  SetIndexBuffer(2,ColorBuffer,INDICATOR_COLOR_INDEX);
  
//Ajustamos la precisión de representación de los valores del indicador
  IndicatorSetInteger(INDICATOR_DIGITS,Digits()); 
  
// Ajustamos el dibujado de líneas  
  PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0); 
  PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0); 
  
// Ajustamos el nombre corto del indicador  
  sn="DiNapoli"; sn2=""; 
  for(i=1;i<100;i++)
    {
// Ajustamos la búsqueda de diagramas   
    if(ChartWindowFind(0,sn)<0){break;}
    sn2="_"+(string)i; sn+=sn2;
    }
    
// Establecemos la representación del símbolo    
  IndicatorSetString(INDICATOR_SHORTNAME,sn);
  for(i=0;i<11;i++) Name[i]+=sn2;
  
// Inicializamos los búferes con valores vacíos   
  ArrayInitialize(DiNapoliH,0); ArrayInitialize(DiNapoliL,0);

Pasamos a la composición del indicador:

// Ajustamos las líneas coloreadas del 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)
      {
      
// Ajustamos las líneas verticales y horizontales     
      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]);// descripción del 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]);// descripción del objeto
        }
      }
    }
  }
  
// Añadimos la función para que al quitar el indicador del gráfico se eliminen los objetos gráficos del indicador
void OnDeinit(const int reason)
  {
  int i;
   
  for(i=0;i<11;i++) ObjectDelete(0,Name[i]);
  ChartRedraw();
  return;
  }

Ahora calculamos los búferes del indicador:

// Función de iteración del indicador
int OnCalculate(const int total,        // Tamaño de las series temporales de entrada
                const int calculated,   // Barras procesadas en la llamada
                const datetime &time[], // Matriz con los valores temporales
                const double &open[],   // Matriz con los precios de apertura
                const double &high[],   // Matriz para el copiado de los precios máximos 
                const double &low[],    // Matriz para el copiado de los precios mínimos
                const double &close[],  // Matriz de los precios de cierre
                const long &tick[],     // Parámetro que contiene la historia del volumen de ticks
                const long &real[],     // Volumen real
                const int &spread[])    // Matriz que contiene la historia de spreads                

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

// Definimos la comprobación de barras
  if(calculated<=0)
    {
    start=total-NumBars; if(start<0)start=0;
    
// Inicializamos los búferes con valores vacíos  
    Last=start; ArrayInitialize(ColorBuffer,0);
    ArrayInitialize(DiNapoliH,0); ArrayInitialize(DiNapoliL,0);
    }
    
// Cálculo de una nueva 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];
          }
          
// Establecemos los colores de las líneas      
        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;
          }
          
// Establecemos los colores de las líneas
        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];
          }
          
// Establecemos los colores de las líneas           
        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;
          }
// Establecemos los colores de las líneas            
        ColorBuffer[Last]=0; Last=i; ColorBuffer[Last]=1;
        }
      }
    DiNapoliH[total-1]=0; DiNapoliL[total-1]=0;
    }
//------------
  if(Refresh==1)
    {

Ciclo final de cálculo del indicador:    

// Comprobando si el número de barras es suficiente para el cálculo
    Refresh=0; a=B-A;
    Price[0]=NormalizeDouble(a*0.318+C,_Digits);           // Comienzo;
    Price[1]=C;                                            // Стоп
    Price[2]=NormalizeDouble(a*0.618+C,_Digits);           // Objetivo№1
    Price[3]=a+C;                                          // Objetivo№2;
    Price[4]=NormalizeDouble(a*1.618+C,_Digits);           // Objetivo№3;
    Price[5]=NormalizeDouble(a*2.618+C,_Digits);           // Objetivo№4;
    for(i=0;i<6;i++) ObjectMove(0,Name[i],0,time[total-1],Price[i]);
    if(VLine==true)
      {
 
// Retornamos el valor redondeado hasta el número entero más próximo del valor indicado      
      a=(double)(BT-AT);
      Time[0]=(datetime)MathRound(a*0.318)+CT;             // Objetivo temporal№1
      Time[1]=(datetime)MathRound(a*0.618)+CT;             // Objetivo temporal№2
      Time[2]=(datetime)MathRound(a)+CT;                   // Objetivo temporal№3
      Time[3]=(datetime)MathRound(a*1.618)+CT;             // Objetivo temporal№4
      Time[4]=(datetime)MathRound(a*2.618)+CT;             // Objetivo temporal№5
      for(i=6;i<11;i++) ObjectMove(0,Name[i],0,Time[i-6],open[total-1]);
      }
    ChartRedraw();
    
// Si la dirección ha cambiado, activamos la reproducción de sonido
    if(Sound==true&&calculated>0)PlaySound(SoundFile);
    }
  return(total);
  }
//------------------------------------------------------------------------------------

El propio indicador se adjunta al final del artículo.


8. Conclusión

Espero que esta información le proporcione al lector una imagen positiva de lo que supone el comercio según el método de DiNapoli. Sería más correcto llamar a estos niveles "Un enfoque original sobre el trabajo con niveles estándar y expansiones de Fibonacci". El fundamento original del trabajo con los niveles permanece intacto, DiNapoli simplemente introdujo cierto número de normas nuevas que, de ejecutarse correctamente, dan un resultado estable en el mercado.

Programas usados en el artículo:

 # Nombre
Tipo
 Descripción
1 DiNapoli  Levels.mq5                 Indicador  Indicador para el cálculo automático y la construcción de los niveles de DiNapoli

9. Literatura

  1. Joe DiNapoli D44 Trading con los niveles de DiNapoli. - M.: IK Analytik, 2001

Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/3061

Archivos adjuntos |
DiNapoli_Levels.mq5 (22.35 KB)
Análisis de los gráficos del Balance/Equidad usando los símbolos y ORDER_MAGIC de los Asesores Expertos Análisis de los gráficos del Balance/Equidad usando los símbolos y ORDER_MAGIC de los Asesores Expertos

Cuando la cobertura (hedging) fue introducida en MetaTrader 5, apareció una perfecta oportunidad de negociar simultáneamente con varios Asesores Expertos en la misma cuenta. Además, puede surgir la situación cuando una estrategia es rentable, mientras que la otra trae pérdidas, y al final el gráfico del beneficio baila alrededor de cero. En este caso, es útil construir los gráficos del Balance y la Equidad para cada estrategia comercial por separado.

Cómo crear documentación usando los códigos fuente MQL5 Cómo crear documentación usando los códigos fuente MQL5

En el artículo se analiza la creación de documentación para el código en MQL5, comenzando por la automatización de la colocación de los tags necesarios. A continuación, se describe el trabajo con el programa Doxygen, su correcta configuración y la obtención de resultados en diferentes formatos: en html, en HtmlHelp y en PDF.

Pronóstico de los movimientos de mercado con la ayuda de la clasificación bayesiana e indicadores basados en el análisis espectral singular Pronóstico de los movimientos de mercado con la ayuda de la clasificación bayesiana e indicadores basados en el análisis espectral singular

En el artículo se analiza la ideología y la metodología de construcción de un sistema recomendatorio para el comercio operativo usando como base la combinación de las posibilidades de pronosticación con la ayuda del análisis espectral singular (AES) y un método importante de aprendizaje de máquinas basado en el teorema de Bayes.

¿Cuánto dura una tendencia? ¿Cuánto dura una tendencia?

En el artículo vamos a elegir varios métodos para identificar la tendencia y definir su duración con respecto al mercado plano. En la teoría, se considera que la proporición en tanto por ciento de la tendencia con respecto al flat es de un 30% frente a un 70%. Esto precisamente vamos a comprobar.