Preguntas de los principiantes MQL5 MT5 MetaTrader 5 - página 1322

Nuevo comentario
 
Buenas tardes, hay muchos buffers de indicadores del mismo tipo, que se pueden calcular en el bucle, pero ¿cómo hacer un array de buffers de indicadores? Lo he probado a través de la estructura, y todo estaba bien, SetIndexBuffer() funcionaba sin errores, pero cuando llega OnCalculate(), los tamaños del array no cambian y siguen siendo 0. Por favor, aconsejen cómo organizar el cálculo de los buffers de los indicadores en el bucle, tal vez por nombres, como: "buff_0", "buff_1", etc., pero cómo hacer esto no lo sé(( De lo contrario, es una hoja muy larga sale(
 
SanAlex:

Supongo que eso es lo que tenías en mente: parece que ha funcionado.

Gracias.

Todo es correcto, perono es exactamente lo que tenía en mente!!! La orden se coloca a lo largo de la tendencia (según el indicador) y se cierra en la toma y tan pronto como se cierra - una nueva orden se abre en la misma dirección (a lo largo de la tendencia), pero esto es sólo una parte de mi idea.

La segunda parte es que una orden que no fue cerrada por Takei cuando la tendencia se invierte (cuando el indicador da una señal de un cambio en la dirección del precio) no debe ser cerrada (lo que usted ha hecho).

En resumen, las dos partes deben funcionar como un par.

 
Alexey Viktorov:

Ayer me descargué este milagro para verlo... De repente me quedé sin internet. Después de una tormenta eléctrica tuve trabajos técnicos durante el resto del día. Así que decidí reescribirlo en MQL5 por ociosidad y lo publiqué aquí.

Así que todas las nubes tienen un forro de plata.........

¡Muchas gracias!

Puede ser útil, si mi idea se hace realidad.

 
VANDER:
Lo he probado a través de la página y parece que funciona bien

¿No es así como funciona?

int size=100;

struct All
   {
   double buff[];
   } all[];

int OnInit()
   {
   IndicatorBuffers(size);
   ArrayResize(all,size);
   for(int i=0; i<size; i++)
      {
      SetIndexBuffer(i,all[i].buff);
      SetIndexStyle(i,DRAW_LINE);
      }
   return(INIT_SUCCEEDED);
   }

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
   {
   for(int i=0; i<size; i++)
      {
      all[i].buff[shift]=i;
      }
   return(rates_total);
   }
 

Sprut 185:

Ahora tenemos que aplicarle la Martingala, es decir, abrir órdenes sin tendencia con un determinado paso, multiplicador y tomar la media.

En resumen, las dos partes deben trabajar en pareja.

¿Quiere decir que la siguiente posición debe abrirse con el doble lote 2-4-8-16 en la COMPRA y el opuesto 2-4-8-16 en la VENTA?

Tengo una función de este tipo - la construí yo mismo de alguna manera.

//+------------------------------------------------------------------+
//| ENUM_LOT_RISK                                                    |
//+------------------------------------------------------------------+
enum LotMax
  {
   Lot=0,   // Lots
   Lotx2=1, // Lots*2
   Risk=2,  // Risk
  };
//+------------------------------------------------------------------+
input LotMax InpLotRisk              = Risk;         // : Lots,- Lots*2,- Risk
input double MaximumRisk             = 0.02;         // : Maximum Risk in percentage
input double DecreaseFactor          = 3;            // : Descrease factor
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double TradeSizeOptimized(void)
  {
   double price=0.0;
   double margin=0.0;
//--- select lot size
   if(!SymbolInfoDouble(_Symbol,SYMBOL_ASK,price))
      return(0.0);
   if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,margin))
      return(0.0);
   if(margin<=0.0)
      return(0.0);
   double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_MARGIN_FREE)*MaximumRisk/margin,2);
//--- calculate number of losses orders without a break
   if(DecreaseFactor>0)
     {
      //--- select history for access
      HistorySelect(0,TimeCurrent());
      //---
      int    orders=HistoryDealsTotal();  // total history deals
      int    losses=0;                    // number of losses orders without a break
      for(int i=orders-1; i>=0; i--)
        {
         ulong ticket=HistoryDealGetTicket(i);
         if(ticket==0)
           {
            Print("HistoryDealGetTicket failed, no trade history");
            break;
           }
         //--- check symbol
         if(HistoryDealGetString(ticket,DEAL_SYMBOL)!=_Symbol)
            continue;
         //--- check Expert Magic number
         if(HistoryDealGetInteger(ticket,DEAL_MAGIC)!=UNO_MAGIC)
            continue;
         //--- check profit
         double profit=HistoryDealGetDouble(ticket,DEAL_PROFIT);
         if(profit>0.0)
            break;
         if(profit<0.0)
            losses++;
        }
      //---
      if(losses>1)
         lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
     }
//--- normalize and check limits
   double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   lot=stepvol*NormalizeDouble(lot/stepvol,0);
   double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   if(lot<minvol)
      lot=minvol;
   double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   if(lot>maxvol)
      lot=maxvol;
//--- return trading volume
   return(lot);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedBuy(void)
  {
   double PROFIT_BUY=0.00;
   for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of open positions
     {
      string   position_GetSymbol=PositionGetSymbol(i); // GetSymbol позиции
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_BUY)
           {
            PROFIT_BUY=PROFIT_BUY+m_position.Select(Symbol());
           }
        }
     }
   double Lots=MaximumRisk;
   double ab=PROFIT_BUY;
   switch(InpLotRisk)
     {
      case Lot:
         Lots=MaximumRisk;
         break;
      case Lotx2:
         if(ab>0 && ab<=1)
            Lots=MaximumRisk*2;
         if(ab>1 && ab<=2)
            Lots=MaximumRisk*4;
         if(ab>2 && ab<=3)
            Lots=MaximumRisk*8;
         if(ab>3)
            Lots=TradeSizeOptimized();
         break;
      case Risk:
         Lots=TradeSizeOptimized();
         break;
     }
   return(Lots);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedSell(void)
  {
   double PROFIT_SELL=0.00;
   for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of open positions
     {
      string   position_GetSymbol=PositionGetSymbol(i); // GetSymbol позиции
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_SELL)
           {
            PROFIT_SELL=PROFIT_SELL+m_position.Select(Symbol());
           }
        }
     }
   double Lots=MaximumRisk;
   double ab=PROFIT_SELL;
   switch(InpLotRisk)
     {
      case Lot:
         Lots=MaximumRisk;
         break;
      case Lotx2:
         if(ab>0 && ab<=1)
            Lots=MaximumRisk*2;
         if(ab>1 && ab<=2)
            Lots=MaximumRisk*4;
         if(ab>2 && ab<=3)
            Lots=MaximumRisk*8;
         if(ab>3)
            Lots=TradeSizeOptimized();
         break;
      case Risk:
         Lots=TradeSizeOptimized();
         break;
     }
   return(Lots);
  }
//+------------------------------------------------------------------+

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Es necesario sustituir en la apertura de la posición - aquí en lugar de InpLots con OptimizedBuy() y OptimizedSell()

      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,OptimizedBuy(),price,0.0,0.0))

      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,OptimizedSell(),price,0.0,0.0))
 
SanAlex:

¿Quiere decir que la siguiente posición se abrirá con el doble lote 2-4-8-16 en COMPRA y el opuesto 2-4-8-16 en VENTA?

Tengo una función de este tipo - la construí yo mismo de alguna manera.

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Es necesario reemplazarlo en la apertura de la posición - aquí en lugar de InpLots con OptimizedBuy() y OptimizedSell()

pero para esta función, sería mejor tener esta función - se cerraría en el beneficio (en la moneda)

input double InpTProfit              = 40000;        // : Take Profit --> (In currency the amount)
input double InpSLoss                = 1000000;      // : Stop Loss --> (In currency the amount)
//+------------------------------------------------------------------+
//| ProfitOnTick closing                                             |
//+------------------------------------------------------------------+
void ProfitOnTick(void)
  {
//---
   double PROFIT_BUY=0.00;
   double PROFIT_SELL=0.00;
   int total=PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      string   position_GetSymbol=PositionGetSymbol(i);
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_BUY)
           {
            PROFIT_BUY=PROFIT_BUY+PositionGetDouble(POSITION_PROFIT);
           }
         else
           {
            PROFIT_SELL=PROFIT_SELL+PositionGetDouble(POSITION_PROFIT);
           }
        }
      if(PROFIT_BUY<-InpSLoss || PROFIT_BUY>=InpTProfit)
        {
         CheckForCloseBuy();
        }
      if(PROFIT_SELL<-InpSLoss || PROFIT_SELL>=InpTProfit)
        {
         CheckForCloseSell();
        }
     }
  }
//+------------------------------------------------------------------+
 
SanAlex:

Pero para esta función sería deseable tener esta función, que cerraría en beneficio (en moneda)

Voy a tratar de explicar el significado de mi idea y el funcionamiento del EA que estoy creando con más claridad.

Necesitas un simple Martin - por ejemplo AutoProfit 3, en el que sólo hay que añadir que la apertura de órdenes se basó en las señales de los indicadores (de acuerdo a la tendencia), pero no como en AutoProfit - ya que las cartas caen en ......... y eso es todo.

Con aproximadamente los mismos parámetros de salida que en el archivo adjunto.
Archivos adjuntos:
pbx0dcw.jpg  201 kb
 
Sprut 185:

Permítanme que intente explicar más claramente el significado de mi idea y el trabajo de la EA que se está creando.

Usted necesita un simple Martin - por ejemplo AutoProfit 3, en el que sólo tiene que añadir que la apertura de las órdenes fue en la señal del indicador (la tendencia), en lugar de como en AutoProfit - como la tarjeta se encuentra ......... y eso es todo.

Por lo tanto, se abre en una señal del indicador - pero si aparece una señal opuesta, se abrirá en la otra dirección. Y si esa posición no se cierra en beneficio, se colgará hasta que se cierre en beneficio. Si la señal se voltea hacia el otro lado y cierra esa posición abierta, no le sirve.

 
SanAlex:

Si la señal se vuelve en sentido contrario, se abrirá en la otra dirección, y si esa posición no ha cerrado con beneficios, se quedará ahí hasta que cierre con beneficios. Si una señal hacia el otro lado se volcó y cerró esa posición abierta, no le conviene.

A la derecha .......... y si esa posición no ha cerrado en beneficio, se quedará ahí hasta que cierre en beneficio.

Pero la posición que no se cerró en beneficio(por ejemplo, en compra) debe permanecer y bajar hasta un determinado escalón en el que se abre otra orden (en compra) con el volumen multiplicado y el tiempo medio de pérdida, etc., hasta que la tendencia se invierta, pero la apertura de posiciones en la pista no se detendrá.

Por eso he escrito que deben funcionar simultáneamente 2 bloques: Martin y por indicador.

Si no he explicado bien algo, estoy dispuesto a hacer una demostración por Skype y enseñarte cómo debería ser.

 
Sprut 185:

Todo es correcto .......... y si esa posición no ha cerrado en beneficio, se quedará ahí hasta que cierre en beneficio.

Pero la posición que no se cerró en beneficio(por ejemplo, en compra) debería permanecer y bajar hasta un determinado escalón, donde se abriría otra orden (en compra) con el volumen multiplicado y el timing medio bajaría, etc., hasta que la tendencia se invierta, pero la apertura de posiciones en la operación no se detendría.

Por eso escribí que 2 bloques deben trabajar simultáneamente - Martin y por indicador.

Si algo no está bien explicado, estoy dispuesta a hacer una demostración por Skype y mostrarle cómo debería ser.

Martin debe activarse sólo cuando la señal del indicador sea opuesta o no dependa de ella?

Ejemplo: He abierto una posición de compra según el indicador. El precio se ha movido hacia abajo por la distancia establecida, y el indicador ya muestra una Venta. ¿Debe abrirse la posición de compra?

1...131513161317131813191320132113221323132413251326132713281329...1503
Nuevo comentario
Razón de la queja: