MetaTrader 4 / Sistemas comerciales
English Русский 中文 Deutsch 日本語 Português 한국어 Français Italiano Türkçe
La Regla de Oro de los Traders

La Regla de Oro de los Traders

MetaTrader 4 — Sistemas comerciales | 18 agosto 2015, 09:27
1 687 0
Genkov
Genkov

Introducción

La principal tarea de un trader no es sólo encontrar el momento adecuado para entrar en el mercado. También es necesario encontrar el momento adecuado para salirse. La regla de oro del trading dice: "Siempre corta sus pérdidas cortas y deje correr sus ganancias".

Para hacer un beneficio basado en la alta expectativa matemática, debemos entender tres principios básicos del buen trading.

  1. Conocer el riesgo al entrar en el mercado (que es un valor inicial de Stop Loss);
  2. Cortar sus ganancias cortas y permitir ejecutar sus ganancias (no cerrar su posición antes de que sea requerido por su sistema);
  3. Conocer la esperanza matemática de su sistema – probar y ajustar regularmente.


Método de Trailing (arrastre) de Posiciones paso a paso, permitiendo ejecutar beneficios

¿Pero realmente necesitamos conocer esto para operar con éxito? Un trading exitoso se basa sobre todo en un sistema correctamente diseñado teniendo en cuenta momentos adecuados para entrar en el mercado. Tales consideraciones se realizan utilizando el poder de la expectativa y las reglas de trailing de posiciones paso a paso que permiten ejecutar ganancias al más alto nivel posible.

El momento de entrada de mercado puede encontrarse de muchas maneras, por ejemplo, usando modelos de velas, modelos de onda, etc. Al mismo tiempo, debe considerarse el factor de ganancia (ratio de pérdidas/ganancias).

Este método se basa en el siguiente requisito: un trader selecciona el menor valor posible de Stop Loss al abrir una posición. Ese valor se puede determinar usando varios métodos, por ejemplo, puede ser igual a 1.5% del depósito. Cuando el mercado alcanza un beneficio igual al valor de Stop Loss, la mitad del lote se cierra pero el Stop Loss ¡no se cambia!

Por lo tanto, creamos a una especie de una red de seguridad, en caso de que el mercado vaya de manera opuesta. Es decir, reducimos nuestro riesgo fijando las pérdidas mínimas. Si el mercado se mueve en dirección favorable al volver alguna vez hacia adelante, se activa el Stop Loss (Fig. 1-3).


Fig. 1. Apertura de posiciones


Fig. 2. Ajuste del Stop Loss

Si el mercado ha vuelto hacia atrás:


Fig. 3. Si el mercado ha retrocedido, estás en el nivel de break-even (punto de equiibrio)

Código de Programa del trailing de Posición

Ofrecemos un código de programa que arrastra posiciones abiertas y se actualiza en el segundo principio de oro, ya que permite ganancias al más alto nivel posible.

Si el mercado aún se mueve en dirección favorable y alcanza un valor predeterminado, por ejemplo, de 100 pips, el Stop Loss se restablece al nivel de break-even. Se hacen más reajustes al llegar a la ganancia en intervalos predeterminados, por ejemplo, 50 pips. Podemos mover el Stop Loss de cada próxima barra pero a los brokers no les gustan los reajustes frecuentes, especialmente cuando el trade se realiza en timeframes inferiores. El archivo de error (stdlib.mq4) dde la carpeta de librerias tiene el error # 8 error="demasiadas peticiones frecuentes" exactamente para ese caso.

El método para determinar cada nivel de Stop Loss es seleccionado una posición de precio en el momento de obtener un beneficio según los niveles de Fibonacci. Se construyen aquí los niveles de Fibonacci aplicados según el método del túnel de Vegas.

El cálculo de niveles de Fibonacci se realizan en función de la generación de niveles de LevelFibo():

//+------------------------------------------------------------------+
   void LevelFibo()
   {
   double Fb1,Fb2,Fb3,Fb4,Fb5,Fb6,Fb7,Fb8,Fb9,Fb10,Fb11,Fb12,Fb13;
   // Canal de "Vegas"
   double Ma144_1 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   double Ma169_1 = iMA(NULL,0,169,0,MODE_EMA,PRICE_CLOSE,1);
   // Media de canal de "Vegas"
   double MedVegas=NormalizeDouble((Ma144_1+Ma169_1)/2,Digits); 
   // calculo de los valores de los niveles de Fibo usando el método de "Vegas"
   Fb1=MedVegas-377*Point;     Fb12=MedVegas+377*Point;
   Fb2=MedVegas-233*Point;     Fb11=MedVegas+233*Point;
   Fb3=MedVegas-144*Point;     Fb10=MedVegas+144*Point;
   Fb4=MedVegas-89*Point;      Fb9=MedVegas+89*Point;
   Fb5=MedVegas-55*Point;      Fb8=MedVegas+55*Point;
   Fb6=MedVegas-34*Point;      Fb7=MedVegas+34*Point;
   }
//+------------------------------------------------------------------+

Cuando se calcula el Stop Loss para las posiciones de compra, la ganancia es la diferencia entre el precio máximo de la primera barra del OrderOpenPrice() de nivel alto [1] y la posición de apertura. El nivel de Stop Loss se define como el nivel de Fibonacci "más cercano" en relación con el valor Min de la primera barra baja [1] (Fig. 4).


Fig. 4. Cálculo del Stop Loss laa posiciones de compra

Al calcular el Stop Loss para posiciones de venta, la ganancia es la diferencia entre el nivel de posicines abiertas OrderOpenPrice() y el precio máximo de la primera barra alta [1] (Fig. 5).


Fig. 5. Cálculo del Stop Loss para posiciones de venta

Para las posiciones de compra, los valores de Stop Loss están basados en el niveles de Fibo. Según el valor más bajo de la primera vela, se presenta como una función separada.

A continuación se muestra el código de la función:

//+---------------------------------------------------------------------+
//| Función (tabla) para especificar valores de Stop Loss               |
//| de la posición de compra por los niveles de Fibo según              |
//| el valor más bajo de la primera vela                                |
//+---------------------------------------------------------------------+
 void StopLevelFiboBuy()
   {
   if(Low[1]>Fb12)                                newSL_B=Fb12-100*Point;
   if(Low[1]<=Fb12 && Low[1]>(Fb12+Fb11)/2)       newSL_B=(Fb12+Fb11)/2;
   if(Low[1]<=(Fb12+Fb11)/2 && Low[1]>Fb11)       newSL_B=Fb11;
   if(Low[1]<=Fb11 && Low[1]>(Fb11+Fb10)/2)       newSL_B=(Fb11+Fb10)/2;
   if(Low[1]<=(Fb10+Fb11)/2 && Low[1]>Fb10)       newSL_B=Fb10;
   if(Low[1]<=Fb10 && Low[1]>(Fb10+Fb9)/2)        newSL_B=Fb9;
   if(Low[1]<=(Fb10+Fb9)/2 && Low[1]>Fb9)         newSL_B=Fb8;
   if(Low[1]<=Fb9  && Low[1]>Fb8)                 newSL_B=Fb7;
   if(Low[1]<=Fb8  && Low[1]>Fb7)                 newSL_B=(Fb7+MedVegas)/2;
   if(Low[1]<=Fb7  && Low[1]>MedVegas)            newSL_B=Fb6;
   if(Low[1]<=MedVegas && Low[1]>(MedVegas+Fb6)/2)newSL_B=Fb6;
   if(Low[1]<=(MedVegas+Fb6)/2 && Low[1]>Fb6)     newSL_B=Fb5;
   if(Low[1]<=Fb6  && Low[1]>Fb5)                 newSL_B=Fb4;
   if(Low[1]<=Fb5  && Low[1]>Fb4)                 newSL_B=(Fb3+Fb4)/2;
   if(Low[1]<=Fb4  && Low[1]>Fb3)                 newSL_B=Fb3;
   if(Low[1]<=Fb3  && Low[1]>(Fb3+Fb2)/2)         newSL_B=(Fb3+Fb2)/2;
   if(Low[1]<=(Fb3+Fb2)/2  && Low[1]>Fb2)         newSL_B=Fb2;
   if(Low[1]<=Fb2  && Low[1]>(Fb2+Fb1)/2)         newSL_B=(Fb1+Fb2)/2;
   if(Low[1]<=(Fb2+Fb1)/2 && Low[1]>Fb1)          newSL_B=Fb1;
   if(Low[1]<=Fb1)                                newSL_B=Fb1-100*Point;
   }
//+------------------------------------------------------------------+

La tabla de valores de Stop Loss por niveles de Fibo dependiendo del valor máximo de la primera vela de la función StopLevelFiboSell() para las posiciones de venta, está representada por el siguiente código:

//+----------------------------------------------------------------------+
//| Función (tabla) para especificar valores de Stop Loss                |
//| de la posición de venta por los niveles de Fibo según                |
//| el valor más alto de la primera vela                                 |
//+----------------------------------------------------------------------+
 void StopLevelFiboSell()
   {
   if(High[1]<=Fb12 && High[1]>(Fb12+Fb11)/2)        newSL_S=Fb12+100*Point;
   if(High[1]<=Fb12 && High[1]>Fb11)                 newSL_S=Fb12;
   if(High[1]<=Fb11 && High[1]>Fb11+Fb10)            newSL_S=Fb11;
   if(High[1]<=Fb10 && High[1]>(Fb10+Fb9)/2)         newSL_S=(Fb11+Fb10)/2;
   if(High[1]<=Fb9  && High[1]>Fb8)                  newSL_S=(Fb10+Fb9)/2;
   if(High[1]<=Fb8  && High[1]>Fb7)                  newSL_S=Fb9;
   if(High[1]<=Fb7  && High[1]>MedVegas)             newSL_S=Fb8;
   if(High[1]<=MedVegas && High[1]>MedVegas)         newSL_S=Fb7;
   if(High[1]<=(MedVegas+Fb6)/2 && High[1]>Fb6)      newSL_S=MedVegas;
   if(High[1]<=Fb6  && High[1]>Fb5)                  newSL_S=MedVegas;
   if(High[1]<=Fb5  && High[1]>Fb4)                  newSL_S=Fb6;
   if(High[1]<=Fb4  && High[1]>Fb3)                  newSL_S=Fb5;
   if(High[1]<=Fb3  && High[1]>Fb2)                  newSL_S=Fb4;
   if(High[1]<=Fb2  && High[1]>(Fb2+Fb1)/2)          newSL_S=(Fb2+Fb3)/2;
   if(High[1]<(Fb2+Fb1)/2   && High[1]>Fb1)          newSL_S=Fb2;
   if(High[1]<Fb1)                                   newSL_S=(Fb2+Fb1)/2;
   }
//+------------------------------------------------------------------+

Sería apropiado añadir la función de cálculo de los niveles de LevelFibo Fibonacci a cada una de las dos funciones de dependencia mencionada. Se ha hecho en los archivos demo adjuntos.

Ahora, observando la combinación de dos funciones, o más bien, habilitando la función de cálculo de los niveles de LevelFibo() en la función de identificación de los niveles de Stop Loss enfocados en estos niveles. Esta combinación tiene sentido, ya que las funciones trabajan juntas. Por lo tanto, se reducirá el número de llamadas a las funciones durante el trailing - sólo una de las dos seguirá.

Después de combinar, que se verá como sigue:

//+----------------------------------------------------------------------+
//| unción (tabla) para especificar los valores de Stop Loss             |
//| para la posición de compra por los niveles de Fibo según             |
//| el valor más bajo de la primera vela                                 |
//+----------------------------------------------------------------------+
   void StoplevelFiboBuy()
   {
   double Fb1,Fb2,Fb3,Fb4,Fb5,Fb6,Fb7,Fb8,Fb9,Fb10,Fb11,Fb12,Fb13;
   double Ma144_1 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   double Ma169_1 = iMA(NULL,0,169,0,MODE_EMA,PRICE_CLOSE,1);
   double MedVegas=NormalizeDouble((Ma144_1+Ma169_1)/2,Digits); 
   Fb1=MedVegas-377*Point;     Fb12=MedVegas+377*Point;
   Fb2=MedVegas-233*Point;     Fb11=MedVegas+233*Point;
   Fb3=MedVegas-144*Point;     Fb10=MedVegas+144*Point;
   Fb4=MedVegas-89*Point;      Fb9=MedVegas+89*Point;
   Fb5=MedVegas-55*Point;      Fb8=MedVegas+55*Point;
   Fb6=MedVegas-34*Point;      Fb7=MedVegas+34*Point;
   if(Low[1]>Fb12)                                newSL_B=Fb12-100*Point;
   if(Low[1]<=Fb12 && Low[1]>(Fb12+Fb11)/2)       newSL_B=(Fb12+Fb11)/2;
   if(Low[1]<=(Fb12+Fb11)/2 && Low[1]>Fb11)       newSL_B=Fb11;
   if(Low[1]<=Fb11 && Low[1]>(Fb11+Fb10)/2)       newSL_B=(Fb11+Fb10)/2;
   if(Low[1]<=(Fb10+Fb11)/2 && Low[1]>Fb10)       newSL_B=Fb10;
   if(Low[1]<=Fb10 && Low[1]>(Fb10+Fb9)/2)        newSL_B=Fb9;
   if(Low[1]<=(Fb10+Fb9)/2 && Low[1]>Fb9)         newSL_B=Fb8;
   if(Low[1]<=Fb9  && Low[1]>Fb8)                 newSL_B=Fb7;
   if(Low[1]<=Fb8  && Low[1]>Fb7)                 newSL_B=(Fb7+MedVegas)/2;
   if(Low[1]<=Fb7  && Low[1]>MedVegas)            newSL_B=Fb6;
   if(Low[1]<=MedVegas && Low[1]>(MedVegas+Fb6)/2)newSL_B=Fb6;
   if(Low[1]<=(MedVegas+Fb6)/2 && Low[1]>Fb6)     newSL_B=Fb5;
   if(Low[1]<=Fb6  && Low[1]>Fb5)                 newSL_B=Fb4;
   if(Low[1]<=Fb5  && Low[1]>Fb4)                 newSL_B=(Fb3+Fb4)/2;
   if(Low[1]<=Fb4  && Low[1]>Fb3)                 newSL_B=Fb3;
   if(Low[1]<=Fb3  && Low[1]>(Fb3+Fb2)/2)         newSL_B=(Fb3+Fb2)/2;
   if(Low[1]<=(Fb3+Fb2)/2  && Low[1]>Fb2)         newSL_B=Fb2;
   if(Low[1]<=Fb2  && Low[1]>(Fb2+Fb1)/2)         newSL_B=(Fb1+Fb2)/2;
   if(Low[1]<=(Fb2+Fb1)/2 && Low[1]>Fb1)          newSL_B=Fb1;
   if(Low[1]<=Fb1)                                newSL_B=Fb1-100*Point;
   }
// ----------------------------------------------------------------------+

El código de comando principal de las posiciones de trailin se representa como un fragmento del EA con la secuencia de acciones para la ejecución de las funciones antes mencionadas según los valores de precio de las barras actuales. Iniciar el trailing paso a paso después de que una orden provechosa de apertura haya sido seleccionada.

A continuación se muestra un pequeño fragmento del código de trailing:

//+------------------------------------------------------------------+
//| POSICIONES DE APERTURA DE TRAILING                               |
//+------------------------------------------------------------------+
for(int i=OrdersTotal()-1; i>=0; i--)
  {
   if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
     {Print("Order selection error = ",GetLastError());}
   if(OrderSymbol()==Symbol())
     {
      if(OrderType()==OP_BUY)
        {
         if(OrderMagicNumber()==Magic)
           {
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=SL_B*Point && OrderLots()==0.2)Close_B_lot();
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())/Point>=100 && OrderLots()==0.1 && OrderStopLoss()<OrderOpenPrice())
              {
               Print(" 1 - StopLoss shift");
               if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+2*Point,OrderTakeProfit(),0,Aqua))
                 {
                  Print(" at Modif.ord.# ",OrderTicket()," Error # ",GetLastError());
                 }
               return;
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=120*Point && OrderOpenPrice()>Ma144_1-144*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+21*Point;
               if((Bid-newSL_B)/Point<StopLevel)newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print("2nd shift of StopLoss ");
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=200*Point && (High[1]-OrderOpenPrice())<=250*Point)
              {
               StoplevelFiboBuy();
               if((Bid-newSL_B)/Point<StopLevel)newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 3rd shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=250*Point && OrderOpenPrice()>Ma144_1-144*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+10*Point;
               if((Bid-newSL_B)/Point<StopLevel) newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 4th shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=300*Point && (High[1]-OrderOpenPrice())<=350*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+20*Point;
               if((Bid-newSL_B)/Point<StopLevel) newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 5th shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            ...
           }
        }
     }
  }

La secuencia de trailing paso a paso consta de 8 pasos en la versión adjunta de la demo del EA.

A continuación la captura de pantalla muestra los pasos de operación de la demo del EA para el trailing de posición de compra. La posición se abrió debido a que se ha formado el modelo de "absorción de tres velas". Además, el "martillo invertido" está entre las velas absorbidas. Este hecho refuerza la fuerza de la señal para abrir una posición de compra.


Fig. 6. Ejemplo de trailing de posición de compra

El indicador "Vegas" puede usarse para ver líneas de Fibon con la clara pantalla clara. Puede verse en el sitio web MQL4: https://www.mql5.com/es/code/7148

La misma pequeña pantalla estirada desde la pantalla de "oscura":

Fig. 7. Captura de pantalla de la pantalla del monitor (versión demo para comprar)

Fig. 8. Ejemplo de trailing de posición de venta

Los parámetros de pruebas temporales deben instalarse para mostrar el trabajo del EA demo, como se muestra en la Fig. 9-10 a continuación:


Fig. 9. Parámetros de prueba del EA Demo_trail_Buy.mql


Fig. 10. Parámetros de prueba del EA Demo_trail_Sell.mql

Nota: Los archivos del EA demo se adjuntan al artículo, como mini robots para trailing de posiciones de compra y de venta. Las posiciones se abren aquí con un lote doble. Pero cuando el Stop Loss se mueve a un nivel de break-even, se confia en el movimiento del precio futuro hacia la dirección correcta y es posible agregar otra posición.


Conclusión

Los ejemplos presentados de órdenes de trailing muestran que órdenes de Stop Loss enfocados en un método móvil en los niveles dinámicos de Fibo pueden producir resultados positivos. El método descrito puede recomendarse para uso práctico en el trading.

Identificación de funciones de los niveles de Fibo dinámicos :

  • LevelFiboKgd.mq4
  • StopLevelFiboBuy.mq4
  • StopLevelFiboSell.mq4
  • Archivos demo:
  • Demo_trail_Buy_v1.mq4 – Archivo demo para Comprar
  • Demo_trail_Sell_v1.mq4 - Archivo demo para Vender


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

Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores
Sobre los Métodos de Análisis Técnico y Pronósticos de Mercado Sobre los Métodos de Análisis Técnico y Pronósticos de Mercado
El artículo muestra las capacidades y el potencial de un método matemático bien conocido juntado con el pensamiento visual y una perspectiva del mercado "fuera de caja". Por un lado, sirve para atraer la atención de un público más amplio ya que puede hacer que las mentes creativas reconsideren el paradigma del traqading como tal. Y por otro lado, puede dar lugar a desarrollos alternativos i implementaciones de código de programa con respecto a una amplia gama de herramientas para el análisis y predicción.
Técnica (Optimización) de Prueba y algunos criterios para la selección de los parámetros del Asesor Experto Técnica (Optimización) de Prueba y algunos criterios para la selección de los parámetros del Asesor Experto
No hay ningún problema en encontrar el Santo Grial de la prueba, sin embargo es mucho más difícil deshacerse de él. Este artículo aborda la selección de parámetros de funcionamiento del EA un con grupo automatizado de procesos de optimización y prueba de resultados con máxima utilización de las capacidades de rendimiento del Terminal y mínima carga del usuario final.
Análisis fractal de los movimientos de la moneda común Análisis fractal de los movimientos de la moneda común
¿Cómo de independientes son las cotizaciones de la moneda? ¿Son sus movimientos coordinados o ningún movimiento de una de las monedas sugiere el movimiento de la otra? El artículo describe un intento de abordar esta cuestión mediante la dinámica no lineal y los métodos de geometría fractal.
Pronóstico One-Step-Ahead de la econometría EURUSD Pronóstico One-Step-Ahead de la econometría EURUSD
El artículo se centra en la previsión de step-ahead para EURUSD utilizando software EViews y una evaluación adicional de la predicción de resultados en los programas de EViews. La previsión consiste en modelos de regresión y se evalúa por medio de un Asesor Experto para MetaTrader 4.