ФорумРазделы

Проблема определения позиции с максимальный убытком.

Новый комментарий
Доброго времени суток. Мне необходимо определить среди позиций buy позицию с самой большой ценой открытия и среди позиций sell позициб с самой минимальной ценой открытия и закрыть эти позиции. Пытался сделать  через определение цены откртытия PriceOpen, через индекс, но ничего не получается( подскажите как мождно сделать. пример функций определения buy с максимальной ценой открытий и sell с минимальной ценой открытия приведены в функциях max_vol_b и min_vol_s, а далее приведен пример определения нужной позиции. Проблема в том, что позиции вообще не закрываются, либо закрытие срабатывает только в одном направлении. еще бывает что все работает как нужно, а потом позиции просто висят и не закрываются 
CTrade trade;
CPositionInfo  m_position;


int max_vol_b()
  {
   int rez = 0;
   double rez1=0;
   for(int j=PositionsTotal()-1; j>=0; j--)
     {
      if(m_position.SelectByIndex(j))
        {
         if(m_position.PositionType() == POSITION_TYPE_BUY)
            if (rez==0 || m_position.PriceOpen()>rez)
            {
            rez1=m_position.PriceOpen();
            rez=j;
            }
        }
     }
   return(rez);
  }
//+------------------------------------------------------------------+
//|                                                                                |
//+------------------------------------------------------------------+
int min_vol_s()
  {
   int rez = 0;
   double rez1=0;
   for(int j=PositionsTotal()-1; j>=0; j--)
     {
      if(m_position.SelectByIndex(j))
        {
         if(m_position.PositionType() == POSITION_TYPE_SELL)
            if (rez==0 || m_position.PriceOpen()<rez)
            {
            rez1=m_position.PriceOpen();
            rez=j;
            }
        }
     }
   return(rez);
  }
 //+-----------------------------------------------------------------+
//|                                                                                |
//+------------------------------------------------------------------+
for(int j=PositionsTotal()-1; j>=0; j--)
      if(m_position.SelectByIndex(j))
      if(m_position.PositionType() == POSITION_TYPE_SELL)
        {
         ulong tick = m_position.Ticket();
         if ( j==min_vol_s()) 
             trade.PositionClose(tick);
        }
for(int j=PositionsTotal()-1; j>=0; j--)
      if(m_position.SelectByIndex(j))
      if(m_position.PositionType() == POSITION_TYPE_BUY)
        {
         ulong tick = m_position.Ticket();
         if ( j==max_vol_b()) 
             trade.PositionClose(tick);
        }
Когда определили цену максимальную\минимальную не надо запоминать эту цену. Надо записать в переменную тикет этой позиции и после завершения цикла выбрать позицию по тикету и закрыть её.
а что изменится? не совсем понимаю? по мне просто потеряем время
допустим открылась новая позиция и нам нужно будет прогнать еще раз фунцию и обновть переменную, когда можем просто из функции забрать это значение
конечная функция выглядит так: если профит позиций покрывает наибольший убыток позиции в противоположном направлении, то закрываем позицию 
if ((m_position.Profit()-(m_position.Volume()*2))+Profit_B_pos()>0 && (m_position.Profit()-m_position.Volume()*2)<0 
         && Profit_B_pos()>0 && tick==min_vol_s())
trade.PositionClose(tick);

торговля идет на ECN счётё, поэтому я сразу учитываю комиссию

Anton Novokhatskii #:
а что изменится? не совсем понимаю? по мне просто потеряем время

Никакой потери времени. Сейчас у вас по два цикла в каждое направление, на север и на йух. А я вам предлагаю один цикл убрать.

Anton Novokhatskii #:
допустим открылась новая позиция и нам нужно будет прогнать еще раз фунцию и обновть переменную, когда можем просто из функции забрать это значение

Даже если открылась ещё одна позиция, то она будет с меньшим убытком чем самая дальняя позиция…

int max_vol_b()
  {
   int rez = 0;
   double rez1=0;
   for(int j=PositionsTotal()-1; j>=0; j--)
     {
      if(m_position.SelectByIndex(j))
        {
         if(m_position.PositionType() == POSITION_TYPE_BUY)
            if (rez==0 || m_position.PriceOpen()>rez)
            {
            rez1=m_position.PriceOpen();
            rez=j;
            }
        }
     }
   return(rez);
  }
//+------------------------------------------------------------------+
//|                                                                                |
//+------------------------------------------------------------------+
int min_vol_s()
  {
   int rez = 0;
   double rez1=0;
   for(int j=PositionsTotal()-1; j>=0; j--)
     {
      if(m_position.SelectByIndex(j))
        {
         if(m_position.PositionType() == POSITION_TYPE_SELL)
            if (rez==0 || m_position.PriceOpen()<rez)
            {
            rez1=m_position.PriceOpen();
            rez=j;
            }
        }
     }
   return(rez);
  }
 //+-----------------------------------------------------------------+
//|                                                                                |
//+------------------------------------------------------------------+
double Profit_S_pos()
  {
   double rez3 = 0;
   for(int j=PositionsTotal()-1; j>=0; j--)
      if(m_position.SelectByIndex(j))
      if (m_position.PositionType()==POSITION_TYPE_SELL)
      if (m_position.Profit()-(m_position.Volume()*2)>0)
        {         
            rez3=rez3+m_position.Profit()-(m_position.Volume()*2);
        }
    
   return(NormalizeDouble(rez3,2));
  }
  
double Profit_B_pos()
  {
   double rez2 = 0;
   for(int j=PositionsTotal()-1; j>=0; j--)
      if(m_position.SelectByIndex(j))
      if (m_position.PositionType()==POSITION_TYPE_BUY)
      if (m_position.Profit()-(m_position.Volume()*2)>0)
        {       
            rez2=rez2+m_position.Profit()-(m_position.Volume()*2);
        }
   return(NormalizeDouble(rez2,2));
  }
 //+-----------------------------------------------------------------+
//|                                                                                |
//+------------------------------------------------------------------+
for(int j=PositionsTotal()-1; j>=0; j--)
      if(m_position.SelectByIndex(j))
      if(m_position.PositionType() == POSITION_TYPE_SELL)
        {
         ulong tick = m_position.Ticket();
         if ((m_position.Profit()-(m_position.Volume()*2))+Profit_B_pos()>0 && (m_position.Profit()-m_position.Volume()*2)<0 
         && Profit_B()>0 && tick==min_vol_s()) 
             trade.PositionClose(tick);
        }
for(int j=PositionsTotal()-1; j>=0; j--)
      if(m_position.SelectByIndex(j))
      if(m_position.PositionType() == POSITION_TYPE_BUY)
        {
         ulong tick = m_position.Ticket();
         if ((m_position.Profit()-(m_position.Volume()*2))+Profit_S_pos()>0 && (m_position.Profit()-m_position.Volume()*2)<0 
         && Profit_S()>0 && tick==max_vol_b()) 
         {
             trade.PositionClose(tick);
        }

у меня закрывается позиция с наибольшим убытком по buy, если sell позиции покрывают этот уыток и c наибольшим убытком по sell, если позиции buy покрывают этот убыток, поэтому мне нужно производить закрытие позиций в определенный момент

А по хорошему можно обойтись вообще одним циклом. Просто надо объявить две переменные для хранения тикетов Buy и Sell 

если я обьвлю эти переменные, я буду использовать их во время открытия позиции. Допустим эту позицию я закрыл, а торговля продолжается , мне нужно обновлять переменную, тк например я закрыл позицию Buy с  максимальной ценой открытия, но тткрылась ее одна позиция, цена открытия у которой меньше
12
Новый комментарий