新人对MQL4和MQL5的任何问题，对算法和代码的帮助和讨论

Valeriy Yastremskiy 2022.04.08 10:47 #19431

makssub #:

让它都在同一货币对内，例如EurUsd。两者都在购买中开放。

一般来说，这些是不同的任务，在不同的对上和在同一个对上。在同一批次的一个货币对上，2个订单/位置有不同的选择：非交叉和交叉。上面的那个下面的是亏损或盈利，这取决于与订单的距离。对于一个方向之间，一个在盈利，另一个在亏损，上面下面都在盈利或亏损。

它应该根据你的喜好来设置。如果交易量相同，你应该关闭相同的交易量。如果不相同，你应该计算盈利的资金量，亏损的资金量，计算盈利与亏损的比率，用这个比率乘以亏损头寸的手数，关闭这部分。

sashasonik 2022.04.08 14:15 #19432

Ivan Butko 新的蜡烛开始时工作，在通过代码运行后，按兵不动，等待下一个蜡烛的开始？

功能

  bool NewBar()
   {
      static datetime LastTime = 0;
      if(iTime(Symbol(), PERIOD_CURRENT, 0) != LastTime)
      {
         LastTime = iTime(Symbol(), PERIOD_CURRENT, 0);
         return (true);
      }
      else
         return (false);
   }

Maksim Burov 2022.04.08 14:24 #19433

Valeriy Yastremskiy #:

这些都是不同的任务，在不同的对子上和在同一对子上。其中，同一批次的2个订单/仓位有分歧，没有交叉，也有交叉。非交叉的价格对两者都是损失，交叉的只有订单之间有利润。上面的那个下面的是亏损或盈利，这取决于与订单的距离。对于一个方向之间，一个在盈利，另一个在亏损，上面下面都在盈利或亏损。

它应该根据你的喜好来设置。如果交易量相同，你应该关闭相同的交易量。如果不相同，你应该计算盈利的资金量，亏损的资金量，计算盈利与亏损的比率，用这个比率乘以亏损头寸的手数，关闭这部分。

这是正确的）这正是我想要的。要计算和关闭亏损的部分。
有什么例子吗？
我试了一下，而后迷惑了，失败了。

Ivan Butko 2022.04.08 14:38 #19434

Valeriy Yastremskiy #:

sashasonik#:

功能

非常感谢您!

sashasonik 2022.04.08 16:23 #19435

makssub #:

这是正确的）这正是我想要的。计算并关闭亏损部分。
有什么例子吗？
尝试了一段时间，感到很困惑，没有成功。

如果我没弄错的话，这些功能重叠了一个方向，即要么买，要么卖。简而言之，我们需要修改它。




//=========================================================================================================================================//
//  Функция расчета текущего состояния по открытым ордерам                                                                                 //
//=========================================================================================================================================//

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CurrentCondition(string OrdType, string inf)
{
   int    Pos   = 0;
   double result = 0, Count = 0, AveragePrice = 0, profit = 0;
   double LastPriceBuy, LastPriceSell, ProfitBuy, ProfitSell, SumProfit;
   for(int cnt = 0; cnt < OrdersTotal(); cnt++)
   {
      if(OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol() && (OrderMagicNumber() == MagicNumber || MagicCheck()))
         {
            if(OrderType() == OP_SELL || OrderType() == OP_BUY)
            {
               if(inf == "Lpos")
               {
                  profit = OrderProfit()              ;
                  Pos    = OrderTicket()              ;

                  if(profit > 0 && profit > Lprofit)
                  {
                     Lprofit1 = Lprofit                  ;
                     Lpos1    = Lpos                     ;
                     Lprofit  = profit                   ; //макс значение
                     Lpos     = Pos                      ;
                  }

                  if(profit < 0 && profit < Cprofit)
                  {
                     Cprofit = profit                    ; //мин  значение
                     Cpos    = Pos                       ;
                  }
               }

               SumProfit += OrderProfit() + OrderSwap() + OrderCommission() ;
               if(inf == "CurrentDrawdown")
                  result = MathMax((AccountBalance() + AccountCredit() - AccountEquity()) / (AccountBalance() + AccountCredit()) * 100, 0);
               if(inf == "CurrentUrov" && AccountMargin() > 0)
                  result = AccountEquity() / AccountMargin() * 100        ;
               if(inf == "TotalOrd")
                  result++                ;

               if(OrdType == "Buy")
               {
                  if(OrderType() == OP_BUY)
                  {
                     if(inf == "TotalBuy")
                        result++                         ;
                     if(inf == "LastLotBuy")
                        result  = OrderLots()            ;
                     if(inf == "SumLotBuy")
                        result += OrderLots()            ;
                     AveragePrice += OrderOpenPrice() * OrderLots()            ;
                     Count        += OrderLots()                              ;
                     LastPriceBuy  = OrderOpenPrice()                         ;
                     ProfitBuy += OrderProfit() + OrderSwap() + OrderCommission() ;
                     if(AveragePrice > 0 && Count > 0)
                     {
                        if(inf == "CalculateAveragePriceBuy")
                           return(NormalizeDouble(AveragePrice / Count, Digits));
                     }
                     else
                        return(0);
                  }
               }

               if(OrdType == "Sell")
               {
                  if(OrderType() == OP_SELL)
                  {
                     if(inf == "TotalSell")
                        result++                        ;
                     if(inf == "LastLotSell")
                        result  = OrderLots()           ;
                     if(inf == "SumLotSell")
                        result += OrderLots()           ;
                     AveragePrice  += OrderOpenPrice() * OrderLots()           ;
                     Count         += OrderLots()                             ;
                     LastPriceSell  = OrderOpenPrice()                        ;
                     ProfitSell += OrderProfit() + OrderSwap() + OrderCommission();
                     if(AveragePrice > 0 && Count > 0)
                     {
                        if(inf == "CalculateAveragePriceSell")
                           return(NormalizeDouble(AveragePrice / Count, Digits));
                     }
                     else
                        return(0);
                  }
               }
            }
         }
      }
   }

   if(inf == "Lpos")
      return(Lpos)                                    ;  //Ордер с наибольшим профитом
   if(inf == "Cpos")
      return(Cpos)                                    ;  //Ордер с наименьшим профитом
   if(inf == "LastPriceBuy")
      return(NormalizeDouble(LastPriceBuy, Digits))  ;
   if(inf == "LastPriceSell")
      return(NormalizeDouble(LastPriceSell, Digits))  ;
   if(inf == "ProfitBuy")
      return(NormalizeDouble(ProfitBuy,      2))  ;
   if(inf == "ProfitSell")
      return(NormalizeDouble(ProfitSell,      2))  ;
   if(inf == "SumProfit")
      return(NormalizeDouble(SumProfit,      2))  ;
   return(result)                                                             ;
}

//=========================================================================================================================================//
//   Перекрытие ордеров                                                                                                                    //
//=========================================================================================================================================//

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CheckOverlapping()
{
   Lpos = 0;
   Cpos = 0;
   Lprofit = 0;
   Cprofit = 0;

   Lpos = CurrentCondition("", "Lpos");
   Cpos = CurrentCondition("", "Cpos");

   if(totalord >= LeadingOrder)
   {
      if(Lprofit > 0 && Lprofit1 <= 0 && Cprofit < 0)
      {
         if(Lprofit + Cprofit > 0 && (Lprofit + Cprofit) * 100 / Lprofit > ProfitPersent)
         {
            Lpos1 = 0;
            CloseSelectOrder();
         }
      }
      else

         if(Lprofit > 0 && Lprofit1 > 0 && totalord > LeadingOrder && Cprofit < 0)
         {
            if(Lprofit + Lprofit1 + Cprofit > 0 && (Lprofit + Lprofit1 + Cprofit) * 100 / (Lprofit + Lprofit1) > SecondProfitPersent)
               CloseSelectOrder();
         }
   }
}

//=========================================================================================================================================//
//  Перекрытие ордеров                                                                                                                     //
//=========================================================================================================================================//

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CloseSelectOrder()
{
   if(Info)
      Print("Функция перекрытия ордеров.");
   int error =  0;
   int error1 = 0;
   int error2 = 0;
   int Result = 0;
   int Slippage = 2 * MarketInfo(Symbol(), MODE_SPREAD);

//                       ---------------------- последний  -----------------------

   while(error1 == 0)
   {
      RefreshRates();
      int i = OrderSelect(Lpos, SELECT_BY_TICKET, MODE_TRADES);
      if(i != 1)
      {
         Print("Ошибка! Невозможно выбрать ордер с наибольшим профитом. Выполнение перекрытия отменено.");
         return (0);
      }
      if(OrderSymbol() == Symbol() && (OrderMagicNumber() == MagicNumber || MagicCheck()))
      {
         if(OrderType() == OP_BUY)
         {
            error1 = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Slippage, Blue));
            if(error1 == 1)
            {
               if(Info)
                  Print("Лидирующий ордер закрыт успешно.");
               Sleep(500);
            }
            else
            {
               Print("Ошибка закрытия лидирующего ордера, повторяем операцию. ");
            }
         }

         //                        -----------------------------------------------------

         if(OrderType() == OP_SELL)
         {
            error1 = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Slippage, Red));
            if(error1 == 1)
            {
               if(Info)
                  Print("Лидирующий ордер закрыт успешно");
               Sleep(500);
            }
            else
            {
               Print("Ошибка закрытия лидирующего ордера, повторяем операцию. ");
            }
         }
      }
   }

//                       ---------------------- пред последний  -----------------------

   if(Lpos1 != 0)
   {
      while(error2 == 0)
      {
         RefreshRates();
         i = OrderSelect(Lpos1, SELECT_BY_TICKET, MODE_TRADES);
         if(i != 1)
         {
            Print("Ошибка! Невозможно выбрать пред ордер с наибольшим профитом. Выполнение перекрытия отменено.");
            return (0);
         }
         if(OrderSymbol() == Symbol() && (OrderMagicNumber() == MagicNumber || MagicCheck()))
         {
            if(OrderType() == OP_BUY)
            {
               error2 = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Slippage, Blue));
               if(error2 == 1)
               {
                  if(Info)
                     Print("Пред Лидирующий ордер закрыт успешно.");
                  Sleep(500);
               }
               else
               {
                  Print("Ошибка закрытия пред лидирующего ордера, повторяем операцию. ");
               }
            }
            //                        -----------------------------------------------------
            if(OrderType() == OP_SELL)
            {
               error2 = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Slippage, Red));
               if(error2 == 1)
               {
                  if(Info)
                     Print("Пред Лидирующий ордер закрыт успешно");
                  Sleep(500);
               }
               else
               {
                  Print("Ошибка закрытия Пред лидирующего ордера, повторяем операцию. ");
               }
            }
         }
      }
   }

//                      ----------- выбранный (обычно с наименьшим профитом ) -----------

   while(error == 0)
   {
      RefreshRates();
      i = OrderSelect(Cpos, SELECT_BY_TICKET, MODE_TRADES);
      if(i != 1)
      {
         Print("Ошибка! Невозможно выбрать ордер с наименьшим профитом. Выполнение перекрытия отменено.");
         return (0);
      }
      if(OrderSymbol() == Symbol() && (OrderMagicNumber() == MagicNumber || MagicCheck()))
      {
         if(OrderType() == OP_BUY)
         {
            error = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Slippage, Blue));
            if(error == 1)
            {
               if(Info)
                  Print("Перекрываемый ордер закрыт успешно.");
               Sleep(500);
            }
            else
            {
               Print("Ошибка закрытия перекрываемого ордера, повторяем операцию. ");
            }
         }

         //                             --------------------------------------------------

         if(OrderType() == OP_SELL)
         {
            error = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Slippage, Red));
            if(error == 1)
            {
               if(Info)
                  Print("Перекрываемый ордер закрыт успешно.");
               Sleep(500);
            }
            else
            {
               Print("Ошибка закрытия перекрываемого ордера, повторяем операцию. ");
            }
         }
      }
   }

   Result = 1;
   return (Result);
}

Valeriy Yastremskiy 2022.04.08 17:28 #19436

makssub #:

这是正确的）这正是我想要的。计算并关闭亏损部分。
有例子吗？
试了一下，很困惑，没有成功。

帆是怎么回事，有什么问题吗？你需要代码。我只是没有这样的问题。坦率地说，我不认为这样的资金管理方法是明智的。

Aleksandr Kononov 2022.04.10 07:36 #19437

你能告诉我如何在MT5的一个窗口中加载两个具有相同意图的指标吗？我试着在每次启动时改变INDICATOR_SHORTNAME，但没有帮助。也许有另一种方法？

Alexey Viktorov 2022.04.10 08:16 #19438

Aleksandr Kononov #:
请告知如何在MT5的一个窗口中加载2个具有相同意图的相同指标。我试过INDICATOR_SHORTNAME，我应该在每次启动的时候改变它。也许有另一种方法？

再找一个不值钱的输入法，改一改吧。

Maksim Burov 2022.04.10 08:43 #19439

Valeriy Yastremskiy #:

为什么要用防空洞，有什么问题吗？你需要一个密码。我只是没有这种问题。坦率地说，我不认为这种方法对一个资金经理来说是明智的。

下午好。我读过关于维尔的文章。我不会加减法。
我不能说任何关于资金管理的事情。我没有试过。
我已经附上了最新的版本。但我已经把自己的一切都搞乱了)
Order1(2) 所选订单的利润
Order1(3) 所选订单的手数

double FirstProfit(int a = 1)
{
   double  profit = 0, proflot = 0,
           OneProfLot = 0, result = 1, profit_1 = 0;
           
      OneProfLot = NormalizeDouble(Lots*Order1(2)/Order1(3),2);
      profit = NormalizeDouble(Lots*Order1(2)/Order1(3),2);
      proflot = Order1(3);
      while (profit >= Order1(2) && profit <= OneProfLot)
         {
            profit -= OneProfLot;
            if (profit !=0 && NormalizeDouble(profit + CalculateProfitHistory(),2) > NormalizeDouble(ProfitLot, Digits)*Lots*100) 
            profit_1 = profit;
            proflot = NormalizeDouble(proflot*profit/Order1(2),2);
 
         }
      }
   }
   if(a==1) {result = (double)profit_1;} else
   if(a==2) {result = (double)proflot;}  
   return(result);
}

Aleksandr Kononov 2022.04.10 09:12 #19440

Alexey Viktorov #:

再找一个不值钱的输入法，改一改吧。

没有人工干预的情况下呢？在mt4中，我有一些指标被设置在另一个上面，我不知道为什么。我希望它在mt5中是一样的，一般来说，我想了解它取决于什么。

新人对MQL4和MQL5的任何问题，对算法和代码的帮助和讨论 - 页 1944