Errores, fallos, preguntas - página 3143

 
Wizard #:
Buenas tardes! ¿El código necesita la línea PositionSelectByTicket... Si es así, ¿cómo escribo el ticket correctamente dentro de él, usandoPositionGetTicket(i) o dejando elPositionGetInteger(POSITION_TICKET)? Gracias de antemano.

No es por ser grosero... ¿La documentación no dice claramente

La función devuelve una entrada de posición por el índice en la lista de las posiciones abiertas y selecciona automáticamente esta posición para seguir trabajando con ella


Si la posición ya está seleccionada, ¿por qué volver a seleccionarla con la función PositionSelectByTicket?

 
Alexey Viktorov #:

No seas maleducado... ¿Acaso la documentación no dice claramente

Si la posición ya está seleccionada, ¿por qué volver a seleccionarla con la función PositionSelectByTicket?

Gracias por su respuesta. Me lo preguntaba, porque habiendo mirado en la biblioteca <Trade/Trade.mqh>, la función PositionClose(const ulong ticket,const ulong deviation) también utiliza PositionSelectByTicket. Y la propia función PositionClose( const ulong ticket,const ulong deviation ) es utilizada a menudo por los codificadores en combinación con el bucle for(int i = PositionsTotal()-1; i >= 0; i--) , haciendo un bucle por todas las posiciones. Y me pregunto si estoy usando uno de más en alguna parte.
 
Wizard #:
Hola, ¿es necesaria la línea PositionSelectByTicket en el código... Si es así, ¿cómo escribir correctamente un ticket dentro de él, a través dePositionGetTicket(i) o dejarPositionGetInteger(POSITION_TICKET)? Gracias de antemano.
int IsPositions()
{
   int pos = 0;     
   
   int total = PositionsTotal();
   for(int i = total-1; i >= 0; i--)
   {
      if(!PositionGetTicket(i))
         continue;        
          
      if(PositionGetString(POSITION_SYMBOL) == Symbol_T && PositionGetInteger(POSITION_MAGIC) == EXPERT_MAGIC)
         pos = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? 1 : (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) ? -1 : 0;
   }
   
   return(pos);
}
 
Roman #:
Gracias. Así que PositionGetTicket(i) será suficiente yPositionSelectByTicket no será necesario.
 
Wizard #:
Gracias por su respuesta. Empecé a preguntarme, porque habiendo mirado en la biblioteca <Trade/Trade.mqh>, la función PositionClose(const ulong ticket,const ulong deviation) también utiliza PositionSelectByTicket. Y la propia función PositionClose( const ulong ticket,const ulong deviation ) es utilizada a menudo por los codificadores en combinación con el bucle for(int i = PositionsTotal()-1; i >= 0; i--) , haciendo un bucle por todas las posiciones. Y me pregunto si estoy usando uno de más en alguna parte.

La función PositionClose(const ulong ticket,const ulong deviation) de la biblioteca recibe un ticket de la posición a cerrar, pero nadie sabe cómo se ha recibido el ticket y si la posición existe.

Por lo tanto, PositionSelectByTicket comprueba principalmente si hay algo que cerrar. ¿Y por qué han decidido que todas las posiciones se cierren a menudo en el bucle? No necesariamente...

 
Alexey Viktorov #:

La función PositionClose(const ulong ticket,const ulong deviation) de la biblioteca recibe un ticket de la posición a cerrar, pero nadie sabe cómo se ha recibido el ticket y si la posición existe.

Por lo tanto, PositionSelectByTicket comprueba principalmente si hay algo que cerrar. ¿Y por qué han decidido que todas las posiciones se cierren a menudo en el bucle? No necesariamente...

Sí, ahora lo entiendo todo. Recientemente he tenido un EA, lo he escrito siguiendo tu ejemplo (con medias) de un foro, combinándolo con el código de Timur Mashnin. Ahora he decidido cambiar las condiciones allí y reescribirlas un poco, sustituyendo todo por funciones del sistema, sin librerías. Si con un simple PositionSelect todo era muy simple, una posición - una elección, entonces con el bucle aquí por supuesto necesito más consideraciones y lógica.
 

Hola

¿Puede ayudarme, por favor?

con el código.

Hizo un indicador en el probador funciona correctamente

Cuando lo pongo en el gráfico no se muestra correctamente

No puedo entender por qué está mal.

//+------------------------------------------------------------------+
//|                                                        Oscil.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property  indicator_buffers 5
#property indicator_plots   5

#property  indicator_color1  clrNONE
#property  indicator_color2  clrRoyalBlue
#property  indicator_color3  clrPink
#property  indicator_color4  clrAqua
#property  indicator_color5  clrYellow

#property  indicator_width1 1
#property  indicator_width2 5
#property  indicator_width3 5
#property  indicator_width4 5
#property  indicator_width5 5

double MainLine[];
double UpLine[];
double DnLine[];
double muls[];
double x,y,z;
double price;
double mulSum=0;
double Pi   = 3.1415926535;
bool LastUp = false;
bool GoUp   = false;
input bool otl    = false;
/***********Range***************/
int    Length             = 3;
int    MajorRangeStrength = 4;


double MajorRangeBuy[];
double MajorRangeSell[];


double RangePrice  = 0.0,
       SweepB      = 0.0;
int    Switch2     = 0,
         SwitchB     = 0;
double Price2BuyA  = 0.0;
int    Price2BuyB  = 1.0;
double Price2SellA = 0.0;
int    Price2SellB = 0.0;
bool   BuySwitchB  = false,
       SellSwitchB = false;
       
int hendlMA_1;
double MA_1[];

int hendlMA_2;
double MA_2[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,MainLine,INDICATOR_DATA);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0);
   PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_HISTOGRAM); 
   ArraySetAsSeries(MainLine, true);
   
   SetIndexBuffer(1,UpLine,INDICATOR_DATA);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, 0);
   PlotIndexSetInteger(1,PLOT_DRAW_TYPE,DRAW_HISTOGRAM); 
   ArraySetAsSeries(UpLine, true);
   
   SetIndexBuffer(2,DnLine,INDICATOR_DATA);
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, 0);
   PlotIndexSetInteger(2,PLOT_DRAW_TYPE,DRAW_HISTOGRAM); 
   ArraySetAsSeries(DnLine, true);
   
   SetIndexBuffer(3,MajorRangeBuy,INDICATOR_DATA);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, 0);
   PlotIndexSetInteger(3,PLOT_DRAW_TYPE,DRAW_HISTOGRAM); 
   ArraySetAsSeries(MajorRangeBuy, true);
   
   SetIndexBuffer(4,MajorRangeSell,INDICATOR_DATA);
   PlotIndexSetDouble(4, PLOT_EMPTY_VALUE, 0);
   PlotIndexSetInteger(4,PLOT_DRAW_TYPE,DRAW_HISTOGRAM); 
   ArraySetAsSeries(MajorRangeSell, true);
   
   hendlMA_1=iMA(Symbol(),0,1,0,MODE_LWMA,PRICE_CLOSE);
   ArraySetAsSeries(MA_1,true);
   
   hendlMA_2=iMA(Symbol(),0,1,0,MODE_SMMA,PRICE_CLOSE);
   ArraySetAsSeries(MA_2,true);
   
   ArrayResize(muls, 99);
   
   mulSum = 0;
   
   for (int i0 = 0; i0 < 98; i0++) {//повторяем в цикле 98 раз
      if (i0 <= 18) y = 1.0 * i0 / 18; //если это первые 18 повторений
      else y = (i0 - 18) * 7.0 / 79.0 + 1.0; //иначе
      
      x = MathCos(Pi * y);
      z = 1.0 / (3.0 * Pi * y + 1.0);
      if (y <= 0.5) z = 1;
      
      muls[i0] = z * x;
      mulSum += muls[i0];
   }
   if(otl)Print(" Распределение создано muls[20]=",muls[20]);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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[])
  {
//---
  if (PeriodSeconds() <60*60 || PeriodSeconds() >10080*60) return(0);
   int depth=0;

   int l_ind_counted_8 = prev_calculated; //Возвращает количество баров, не измененных после последнего вызова индикатора.
   
   int bars=Bars(Symbol(),PERIOD_CURRENT);
   if (l_ind_counted_8 < 0) return (0);
   if (l_ind_counted_8 == 0)
      {
         depth = bars - 98;
         for(int a=0;a<bars;a++)
            {
               MainLine[a] = 0;
               UpLine[a] = 0;
               DnLine[a] = 0;
               MajorRangeBuy[a]=0;
               MajorRangeSell[a]=0;
            }
      }
   if (l_ind_counted_8 > 0)  depth = bars - l_ind_counted_8;
   if(otl)Print(" количество баров, не измененных после последнего вызова индикатора= ",l_ind_counted_8,"  Количество баров на текущем графике Bars=",bars,"  depth= ",depth);
   if (l_ind_counted_8 < 1) {
      for (int i2 = 1; i2 < 100; i2++) {
         MainLine[bars - i2] = 0;
         UpLine[bars - i2] = 0;
         DnLine[bars - i2] = 0;
      }
   }
   
   for (int i1 = depth; i1 >= 0; i1--) 
   {
      price = 0;
          
          CopyBuffer(hendlMA_1,0,0,bars,MA_1);
          
      for (int i2 = 0; i2 <= 98; i2++) 
         {
            if(i2 + i1>=bars)break;
            price += muls[i2] * MA_1[i2 + i1];
         }
          
      if (mulSum > 0.0) MainLine[i1] = price / mulSum;

     GoUp=MainLine[i1 + 1] > MainLine[i1] ;
     
      if (GoUp) 
      {
         if (!LastUp) DnLine[i1+1] = MainLine[i1+1];
         DnLine[i1] = MainLine[i1];
         UpLine[i1] = 0;
      }
         else
      {
         if (LastUp) UpLine[i1+1] = MainLine[i1+1];
         UpLine[i1] = MainLine[i1];
         DnLine[i1] = 0;
      }
      LastUp=GoUp; 

   }//  for (int i1

 //  return (0);

/***************** Range **********************/

  int counted_bars=prev_calculated;
  if(otl)Print(" Range counted_bars = ", counted_bars);
   if(counted_bars<0) return(-1);
   int position=bars-counted_bars;
   if (position<0) position=0;
   if (position==0) position=1;
   int rnglength = 250;
   double range = 0.0, srange = 0.0;
   if(otl) Print(" position=",position);
   
   for (int pos = position; pos >=0; pos--)
   {/***************** MAIN Range **********************/
      srange = 0.0;
      int j = 0;
      for (int i=0;i<rnglength;i++)
      {
         j++;
         int posr = pos + i;
         if (posr >= bars) break; 
         srange = srange + (High(posr) - Low(posr));
      }
      range = srange / j * Length;
      int BarNumber = bars-pos; //??????????
      if (BarNumber < 0)  BarNumber = 0;
          
          CopyBuffer(hendlMA_2,0,0,bars,MA_2);
          //Print(bars," - ",pos);
      if(pos<bars)RangePrice = MA_2[pos];  //Moving Average MODE_SMMA
      else RangePrice = MA_2[pos-1];

      if (BarNumber == 1)
      {
         SweepB  = range *  MajorRangeStrength;
         Price2BuyA = RangePrice;
         Price2SellA = RangePrice;
      }     

      if (BarNumber > 1)
      {

         if (Switch2  >  - 1)//проверка цикла на покупку
         {
            if (RangePrice < Price2BuyA) //если средняя цена ниже
            {
if (BuySwitchB ) MajorRangeBuy [pos +BarNumber - Price2BuyB] = 0;                                                                //OUT
                           Price2BuyA = RangePrice;
               Price2BuyB = BarNumber;
               BuySwitchB = true;
            } 
            else if (RangePrice > Price2BuyA)
            {
                            SwitchB = BarNumber - Price2BuyB;
MajorRangeBuy [pos +SwitchB] = MainLine[pos + SwitchB]*1.0005;                                                                                                                          //OUT
                BuySwitchB = true;

                              if (RangePrice - MA_2[pos + SwitchB] >= SweepB && SwitchB >= 1)
                              {
                     Switch2 =  - 1;
                     Price2SellA = RangePrice;
                     Price2SellB = BarNumber;
                     SellSwitchB = false;
                     BuySwitchB = false;
               }
            }
         }
         if (Switch2  < 1)//проверка цикла на продажу
         {
            if (RangePrice  > Price2SellA )
            {
if (pos +BarNumber - Price2SellB<bars&&SellSwitchB ) MajorRangeSell [pos +BarNumber - Price2SellB] = 0;                                                         //OUT
                           Price2SellA = RangePrice;
               Price2SellB = BarNumber;
               SellSwitchB = true;
                    }
                       else if (RangePrice < Price2SellA)
                    {
               SwitchB = BarNumber - Price2SellB ;

         if(pos+ SwitchB<bars)MajorRangeSell[pos + SwitchB] =MainLine[pos + SwitchB]*1.0005;                                                                                                                             //OUT
                SellSwitchB = true;             
        
                              if (pos + SwitchB<bars&&MA_2[pos + SwitchB] - RangePrice >= SweepB && SwitchB >= 1)
                              {
                                     Switch2 = 1;
                     Price2BuyA = RangePrice;
                     Price2BuyB = BarNumber;
                     SellSwitchB = false;
                     BuySwitchB = false;
                                  }
            }
         }
      }

   //   MajorRangeSell[pos] = 0;
    //  MajorRangeBuy[pos]  = 0;  
    }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//========================================================================================
double High(int index)
{   
   if(index < 0) return(-1);
   double Arr[];
   ENUM_TIMEFRAMES timeframe=PERIOD_CURRENT;
   if(CopyHigh(Symbol(),timeframe, index, 1, Arr)>0) 
        return(Arr[0]);
   else return(-1);
}
//========================================================================================
double Low(int index)
{   
   if(index < 0) return(-1);
   double Arr[];
   ENUM_TIMEFRAMES timeframe=PERIOD_CURRENT;
   if(CopyLow(Symbol(),timeframe, index, 1, Arr)>0) 
        return(Arr[0]);
   else return(-1);
}
 

¿Qué se devuelve a la estructura MqlTradeCheckResult?

En la documentación está escrito que"El importe del margen requerido para la operación comercial requerida".

Campo

Descripción

Retomar el código

Código de retorno

balanza

Valor del saldo que habrá tras la ejecución de la operación

equidad

Valor de laequidad, que será después de la ejecución de la operación

beneficio

Valor de la ganancia flotante que habrá tras la ejecución de la operación

margen

El importe del margen necesario para la operación requerida

margen_libre

La cantidad de capital que quedará después de la ejecución de la operación requerida

nivel_de_margen

El nivel de margen que se fijará tras la ejecución de la operación requerida

comentario

Comentario al código de respuesta, descripción del error


Pero lo que realmente se obtiene es el tamaño del margen total, actual y más el que se tomará después de ejecutar la operación.

Este es el guión

#include <Trade\Trade.mqh>
CTrade trade;
  MqlTradeRequest           my_request;
  MqlTradeCheckResult       my_check_result;
  MqlTick                   mqlTick;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
 {
  SymbolInfoTick(_Symbol, mqlTick);
  CheckOrder(0.01, ORDER_TYPE_SELL);
  Print(my_check_result.margin);
//---
  trade.PositionOpen(_Symbol, ORDER_TYPE_SELL, 0.01, mqlTick.bid, 0.0, 0.0);
//---
  CheckOrder(0.01, ORDER_TYPE_SELL);
  Print(my_check_result.margin);
 }/******************************************************************/

/********************************************************************\
||
\********************************************************************/
bool CheckOrder(double volume, ENUM_ORDER_TYPE order_type)
 {
  if(order_type != ORDER_TYPE_BUY && order_type != ORDER_TYPE_SELL)
    return false;
  ZeroMemory(my_request);
  ZeroMemory(my_check_result);
  bool checkOrder = false;
//--- setting my_request
  my_request.action = TRADE_ACTION_DEAL;
  my_request.symbol = _Symbol;
  my_request.volume = volume;
  my_request.type   = order_type;
  my_request.price  = order_type == ORDER_TYPE_BUY ? mqlTick.ask : mqlTick.bid;
  checkOrder = ::OrderCheck(my_request, my_check_result);
  if(my_check_result.retcode != 0)
    return(false);
//---
  return(true);
 }/******************************************************************/

y el resultado de la ejecución

2022.02.01 10:11:28.002 Test bag (EURUSD,H1)    2.25
2022.02.01 10:11:28.108 Test bag (EURUSD,H1)    4.5

Mientras no hay posiciones abiertas en la cuenta mi_comprobación_resultado.margen es igual al margen de la posición abierta con lote 0.01, y cuando ya hay 0.01 en la cuenta el margen del lote 0.02

Archivos adjuntos:
Test_bag.mq5  5 kb
 
Alexey Viktorov #:

Pero lo que realmente se obtiene es el tamaño del margen total, actual y más el que se tomará después de realizar esta operación.

Sí.

MarginOpen = CheckResult.margin - ::AccountInfoDouble(ACCOUNT_MARGIN); // Маржа для открытия.
 
fxsaber #:

Sí.

Que sea así, pero entonces debería ser igual en la documentación.

Si balans es el valor del saldo que habrá después de realizar la operación

entonces el margen - debería ser. Valor del margen, que será después de la ejecución de la operación comercial