Cualquier pregunta de los recién llegados sobre MQL4 y MQL5, ayuda y discusión sobre algoritmos y códigos - página 194

 
Quién sabe: si cierra una parte de un pedido, ¿desaparecerá su mago o su comentario?
 
Renat Akhtyamov:
¿Quién sabe si al cerrar una parte de la orden, su magia o su comentario desaparecen?

El magik permanecerá, el ticket de pedido cambiará y el comentario contendrá el ticket de pedido padre de#xxxxxxxxxxx. El pedido padre tendrá una entrada de pedido hijo: a#xxxxxxxxxxx

 
Artyom Trishkin:

Magik permanecerá, el ticket de pedido cambiará y el comentario contendrá el ticket de pedido padre de#xxxxxxxxxxx. El pedido padre tendrá una entrada de pedido hijo: to#xxxxxxxxxxx

Bien. Gracias.
 
geratdc:


Sí, esta K también está envariables externas en el sombrero de copa - tal vez es el valor de retorno de alguna función...


Alexey, ¿qué puedes decir sobre mi problema? Intento adjuntar trailing stop a las órdenes inversas. ¿Se ha encontrado con un problema de este tipo?

Y para poder responder algo sobre este problema, hay que entender el problema en sí. Y a partir de esto

geratdc:

Necesito ayuda - Tengo 3 órdenes de stop pero el ejemplo de trailing stop de los videos tutoriales :) sólo para órdenes no vinculadas, en mi caso están vinculadas por el algoritmo, es decir, el takeprofit se calcula por la suma de las tres órdenes o una si me metí en una tendencia. Bueno, he pensado en algo pero mi Asesor Experto no ha empezado a ganar más - ha empezado a ganar la misma cantidad de órdenes pero consigo 2-3 veces menos operaciones en comparación con mi anterior EA sin trailing. Así que mi arrastre no es un arrastre sino una tontería. ¿Cómo debo colocarlo en los pedidos vinculados? ¿Alguien puede darme una idea? Me temo que no se me ocurre nada más. Aquí está el resultado de mi "arrastre" - se muestra en azul:

Se adjunta el resultado de 1 prueba. ¿Hay un trailing stop o no? No lo entiendo. ¿Por qué no se incrementó el beneficio del mismo periodo? ¿Sólo el número de tratos se redujo en 2-3 veces?


No puedo entender nada. Lo más extraño es"he inventado algo", pero ¿ha entendido lo que ha inventado? Y esto es"Cómo lo hago en los pedidos vinculados". Pero luego está el"me temo que no se me ocurre nada más".

 
Alexey Viktorov:

Y para poder responder algo sobre este problema, hay que entender el problema en sí. Y de esto.

No puedo entender nada. Lo más raro es"lo tengo resuel to", pero ¿sabes lo que has resuelto? Y luego está"¿Cómo lo hago en las órdenes de captura vinculadas?" Pero luego está el"me temo que no se me ocurre nada más".


Según tengo entendido, los trailing stops no se pueden aplicar correctamente a las órdenes, por lo que deberíamos prestar mucha atención a esta función CalculateProfit, concretamente a la variable "op" según la cual las órdenes se cierran si la suma de los beneficios de las 3 órdenes es igual al TakeProfit y tratar de rastrear esta variable. Intentaré pensar en algo en este sentido. Entiendo que es difícil tratar con terceros abracadabra)))).
 
geratdc:

Según tengo entendido, los trailing stops no se pueden aplicar correctamente a las órdenes, por eso deberíamos fijarnos en esta función CalculateProfit, en concreto, en la variable "op" según la cual las órdenes se cierran si la suma de los beneficios de las 3 órdenes es igual al TakeProfit e intentar hacer el trailing a través de esta variable. Intentaré pensar en algo en este sentido. Entiendo que es difícil tratar con abracadabra de terceros)).
¿Por qué no puedes aplicarlo? Es necesario no adjuntar o inventar algo a las funciones de los demás, y escribir las tuyas propias para que realicen todo lo que tú quieras. ¿Cuál puede ser el problema? Cualquiera que sea el número de pedidos, calcule el precio medio y arrastre a partir de él. Cuando se cumple alguna condición, al recorrer todas las órdenes del bucle, reordena sus stops en un nuevo nivel, que se calcula a partir del precio medio de todas las órdenes existentes en una dirección.
 
//+------------------------------------------------------------------+
//|                                     BLACKJACK&HOOKERS TrailX.mq4 |
//|                        Copyright 2017, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

extern double  Lots           = 0.01;
extern double  TakeProfit     = 1;
extern int     Step           = 1;

extern double  TrailXStep     = 1;
extern double  TrailXStop     = 1;

extern int     MaPeriod       = 100;
extern int     MaShift        = 1;

extern int     Magic          = 123;
extern int     Slippage       = 5;

int timeprev=0;

extern double price,op,cn,tp;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(Digits == 3 || Digits == 5)
      //TakeProfit     *= 10;
      Step           *= 10;
      //TrailXStep     *= 10;
      //TrailXStop     *= 10;
      Slippage       *= 10;

      
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   if (timeprev == Time[0]) return;
   timeprev = Time[0];
   double maprice=iMA(Symbol(),0,MaPeriod,MaShift,MODE_SMA,PRICE_CLOSE,1); 
   op=CalculateProfit();
   cn=CountTrades();
   tp=TakeProfit;
   if (tp>TakeProfit)
   {
      TakeProfit+=tp;
   }
   
 

 
   if (cn==0 && CountBuy() + CountSell() == 0 && Ask > maprice)
   {
      if (OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, "", Magic, 0, Blue)<0)
            Print("Не удалось открыть ордер на покупку");
            
   }
   
   if (cn==0 && CountBuy() + CountSell() == 0 && Bid < maprice)
   {
      if (OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, "", Magic, 0, Red)<0)
            Print("Не удалось открыть ордер на продажу");
            
   }
   

   
   if(cn==1 && CountBuy()==1) 
   {
      price=FindLastBuyPrice();
      if((price-Ask)>=Step*Point)
      {
         if(OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,0,0,"",Magic,0,Red)<1)
            Print("Не удалось открыть ордер на продажу");
      }
   }
   else if(cn==1 && CountSell()==1) 
   {
      price=FindLastSellPrice();
      if((Bid-price)>=Step*Point)
      {
         if(OrderSend(Symbol(),OP_BUY,Lots,Ask,Slippage,0,0,"",Magic,0,Blue)<1)
            Print("Не удалось открыть ордер на покупку");
      }
   }
   
   
   
   if(cn==2 && CountBuy()==1 && CountSell()==1) 
   {
      price=FindLastSellPrice();
      if((price-Bid)>=Step*Point)
      {
         if(OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,0,0,"",Magic,0,Red)<1)
               Print("Не удалось открыть ордер на продажу");
               
      }
      else 
      price=FindLastSellPrice();
      if((Bid-price)>=Step*Point)
      {
         if(OrderSend(Symbol(),OP_BUY,Lots,Ask,Slippage,0,0,"",Magic,0,Blue)<1)
            Print("Не удалось открыть ордер на покупку");
           
      }
   }
   else if(cn==2 && CountSell()==1 && CountBuy()==1) 
   {
      price=FindLastBuyPrice();
      if((Ask-price)>=Step*Point)
      {
         if(OrderSend(Symbol(),OP_BUY,Lots,Ask,Slippage,0,0,"",Magic,0,Blue)<1)
               Print("Не удалось открыть ордер на продажу");
               
      }
      else 
      price=FindLastBuyPrice();
      if((price-Ask)>=Step*Point)
      {
         if(OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,0,0,"",Magic,0,Red)<1)
            Print("Не удалось открыть ордер на покупку");
           
      }
   }
   
   Trailing();

   if (op>=tp)
   {
         CloseAll();    
   }


}    
//---------------------------------------------------------------------------------------
void Trailing()           
            {  

               if (op > (TakeProfit+TrailXStep))
               {
                  tp=(TakeProfit+TrailXStep);
               }
               if (op > (TakeProfit+TrailXStep-TrailXStop) && op < (TakeProfit+TrailXStep+TrailXStop))
               {
                  tp=(TakeProfit+TrailXStep-TrailXStop);
               }
               
            }
//---------------------------------------------------------------------------------------
double CalculateProfit()
  {
   double oprofit=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY || OrderType()==OP_SELL)
              {
               oprofit+=OrderProfit();
              }
           }
        }
     }
   return(oprofit);
  }
//--------------------------------------------------------------------------------------
void CloseAll()
  {
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(!OrderClose(OrderTicket(),OrderLots(),Bid,Slippage))
                  Print("Не удалось закрыть ордер на покупку");
              }
            if(OrderType()==OP_SELL)
              {
               if(!OrderClose(OrderTicket(),OrderLots(),Ask,Slippage))
                  Print("Не удалось закрыть ордер на продажу");
              }
           }
        }
     }
  }
//---------------------------------------------------------------------------------------------------
double FindLastBuyPrice()
  {
   int oldticket,ticket= 0;
   double oldopenprice = 0;
   for(int cnt=OrdersTotal()-1; cnt>=0; cnt--)
     {
      if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderType()==OP_BUY)
           {
            oldticket=OrderTicket();
            if(oldticket>ticket)
              {
               ticket=oldticket;
               oldopenprice=OrderOpenPrice();
              }
           }
        }
     }
   return(oldopenprice);
  }
//---------------------------------------------------------------------------------------------------
double FindLastSellPrice()
  {
   int oldticket,ticket= 0;
   double oldopenprice = 0;
   for(int cnt=OrdersTotal()-1; cnt>=0; cnt--)
     {
      if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderType()==OP_SELL)
           {
            oldticket=OrderTicket();
            if(oldticket>ticket)
              {
               ticket=oldticket;
               oldopenprice=OrderOpenPrice();
              }
           }
        }
     }
   return(oldopenprice);
  }
//----------------------------------------------------------------------------------------------
int CountBuy()
  {
   int count=0;
   for(int trade=OrdersTotal()-1; trade>=0; trade--)
     {
      if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderType()==OP_BUY)
            count++;
        }
     }
   return(count);
  }
//----------------------------------------------------------------------------------------------
int CountSell()
  {
   int count=0;
   for(int trade=OrdersTotal()-1; trade>=0; trade--)
     {
      if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderType()==OP_SELL)
            count++;
        }
     }
   return(count);
  }
//+---------------------------------------------------------------------------------+
int CountTrades()
{
    int count=0;
    for (int i=OrdersTotal()-1; i>=0; i--)
      {  
         if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         {
            if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
               if(OrderType() == OP_BUY || OrderType() == OP_SELL)
                  count++; 
         }
      }
      return(count);
}
//----------------------------------------------------------------------------------+
int FindLastOrderType()
{
      for(int i = OrdersTotal()-1; i>=0; i--)
      {
         if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         {
            if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
            return(OrderType());
         } 
      }
      return(-1);
}
//----------------------------------------------------------------------------------+

Esta es una variante de trailing por la función CalculateProfit(), ambas variantes de trailing tienen los mismos indicadores en el comercio - tanto en el número de operaciones como en los beneficios. Los beneficios no son muchos - ahora añadiré volatilidad e indicadores de entrada más precisos. Creo que un mismo indicador puede resolver estos problemas, ¿no? Digamos, que analiza los últimos 5 compases o algo así. ¿Cómo se llaman estos indicadores de barra? ¿Y cuál es el mejor plazo? Comparta su opinión por favor, cómo puedo conseguir dos pájaros con un solo indicador ... Tengo dos pájaros de un tiro :)

¿Cómo ves las barras de arrastre en este EA?

 
Alexey Viktorov:
¿Por qué no puedes aplicarlo? No tienes que añadir o inventar algo a la función de otro, sino escribir la tuya propia para que haga lo que tú quieres. ¿Cuál podría ser el problema? Cualquiera que sea el número de pedidos, calcule el precio medio y arrastre a partir de él. Cuando se cumple alguna condición, al pasar por todas las órdenes del bucle, reordena sus paradas en un nuevo nivel que se calcula a partir del precio medio de todas las órdenes de una dirección.

Lo he guardado, gracias. No lo creo todavía. Debo tener una biblioteca en mi cabeza de códigos y funciones, mientras que en los videotutoriales hemos repasado todo lo que he implementado hasta ahora. Quizá mejore y ponga en práctica tus consejos. Lo que he inventado hoy, ¿parece una red de arrastre? Bueno, el Asesor Experto hace un arrastre según los informes pero no sé cuál es el correcto - el arrastre incorrecto sólo aumentará la probabilidad de pérdida. Yo diría que tiene una probabilidad de 0,9 de fallar, más o menos así)))) Yo diría que tiene mucho miedo a los planos y el indicador es débil ahora - estúpidamente nos unimos a la tendencia y cuando tenemos 3 órdenes y el mercado de repente cambia de dirección y nos da un drawdown - perdemos.
 
geratdc:

Lo he guardado, gracias. Todavía no puedo pensar así. Debo tener una biblioteca en mi cabeza de códigos y funciones, y he pasado por los videotutoriales, eso es lo que estoy usando ahora. Tal vez mejore y ponga en práctica tus consejos. Lo que he inventado hoy, ¿parece una red de arrastre? Bueno, el Asesor Experto hace un arrastre de acuerdo con los informes, pero no sé cuál es el correcto - el arrastre incorrecto sólo aumentará la probabilidad de pérdida. Yo diría que tiene una probabilidad de 0,9 de fallar, más o menos así)))) Yo diría que tiene mucho miedo a los planos y el indicador es débil ahora - estúpidamente nos unimos a la tendencia y cuando tenemos 3 órdenes y el mercado de repente cambia de dirección y nos da un drawdown - perdemos.

Bueno, intentaré aportar mi granito de arena para educaros.

Me dirigiré a ti como "tú" cuando lo envíe. Tengo una instantánea del puntero...

Por favor, dime, ¿no te parece mal llamar a la misma función 5 veces en el mismo tick? Pero eso es la mitad del problema. Esta función recorre todos los pedidos. Y todo esto 5 veces en un tic... Y cuento con 4 funciones de este tipo. Podemos encajar fácilmente 3 funciones más con el bucle para buscar todos los pedidos sin devanarnos los sesos.

Aquí hay dos de ellos.

if (cn==0 && CountBuy() + CountSell() == 0 && Ask > maprice)
if (cn==0 && CountBuy() + CountSell() == 0 && Bid < maprice)
if(cn==1 && CountBuy()==1)


else if(cn==1 && CountSell()==1) 
if(cn==2 && CountBuy()==1 && CountSell()==1) 


else if(cn==2 && CountSell()==1 && CountBuy()==1)

Estos son.

Trailing();


}    
//---------------------------------------------------------------------------------------
void Trailing()           
            {  

               if (op > (TakeProfit+TrailXStep))
               {
                  tp=(TakeProfit+TrailXStep);
               }
               if (op > (TakeProfit+TrailXStep-TrailXStop) && op < (TakeProfit+TrailXStep+TrailXStop))
               {
                  tp=(TakeProfit+TrailXStep-TrailXStop);
               }
               
            }


Ni siquiera se acerca a la cola.

Para entender esto, tenemos que comprender claramente la definición de arrastre. No recuerdo textualmente, pero se puede describir de la siguiente manera: "Mover el nivel de StopLoss siguiendo el precio con el fin de disminuir las posibles pérdidas o aumentar el beneficio "garantizado".


Y esto

extern double price,op,cn,tp;

¿Qué aspecto tiene cuando se ejecuta el Asesor Experto? Probablemente cuatro líneas... ¿son necesarios?


Una última cosa por hoy: no es necesario tener una biblioteca en la cabeza. Basta con tener la documentación y saber utilizarla. Todavía no recuerdo todos los parámetros de iMA(_Symbol, _Period, ,,,,,) y además escribo sólo después de mirar la documentación. Y así casi todas las funciones. Por suerte, no hace mucho tiempo hicieron tooltips que no ayudan mucho. No estoy tratando de memorizar cómo escribir estos o aquellos enums. Así que tengo que mirar la documentación cada vez.

 

¿Puede decirme qué función comprueba el estado de esta casilla?


Razón de la queja: