我将免费撰写一份顾问报告

Maksim Sovenko 2018.10.19 13:23 #841

Evgenij Litvintsev:

下午好！也许有人会有兴趣将我的策略自动化。它现在正在工作，但处于半自动模式，我想把它自动化。

我可以看到交易结果吗？

Николай 2018.10.20 17:34 #842

晚上好，请教您如何从一个函数中获得票据订单、手数和利润。

double OldTicketSell()//找到最远的卖出指令。

{

double MaxDist=0,oldprofit,lot;

int ticket=0。

double BID=MarketInfo(Symbol(),MODE_BID)。

double ASK=MarketInfo(Symbol(),MODE_ASK);

for(int i=OrdersTotal()-1; i>=0; i--)

{

如果(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))

{

如果(OrderType()==OP_SELL &&MaxDist<MathAbs(OrderOpenPrice()-ASK))

{

MaxDist=MathAbs（OrderOpenPrice()-ASK）。

ticket=OrderTicket()。

oldprofit = OrderProfit()。

lot = OrderLots();

}

return(ticket)。

}

功能很清楚，不清楚如何把找到的数据拿出来，或者有必要把它复制到地段和利润下。

I will write an 火鸟v63G 关闭所有'/'打开'工具

Konstantin Nikitin 2018.10.20 17:53 #843

Николай:

晚上好，请您告诉我如何从一个函数中获得票据订单、手数和利润。

这个函数是可以理解的，不清楚如何从中提取发现的数据，或者我应该把它复制到手数和利润下。

我们可以这样做

struct InfoOrder
{
     int ticket;
     double lot,
            profit,
            swap,
            commission,
            sl, tp;
     datetime timeOpen;
     string comment;
} infoOrder;

void OldSell(void)// Находим самый дальний ордер на продажу
{
   double MaxDist=0;
   double BID=MarketInfo(Symbol(),MODE_BID);
   double ASK=MarketInfo(Symbol(),MODE_ASK);
   for(int i=OrdersTotal()-1; i>=0; i--)
   {
   if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
        if(OrderType()==OP_SELL && MaxDist<MathAbs(OrderOpenPrice()-ASK))
         {
             MaxDist=MathAbs(OrderOpenPrice()-ASK);
             infoOrder.ticket=OrderTicket();
             infoOrder.profit = OrderProfit();
             infoOrder.lot = OrderLots();
         }
      }
   }
   return; 
}

Николай 2018.10.20 18:58 #844

Konstantin Nikitin:

你可以这样去做

这一切都很好，但我是个笨蛋，我正试图在我的知识范围内编写一个EA（我刚学了一点），我明白变量是一个结构，但如何从这个结构中获取数据却不清楚。例如，如果我们已经找到了最远的订单，那么利润应该除以手数，我们得到从当前价格到该手数的点数。然后我们得到一个相反订单的利润（我知道如何得到它），用它除以之前计算的相反订单的点数，我们得到手数，用这个手数来完全或部分关闭发现的远端订单。

Николай 2018.10.20 19:02 #845

Konstantin Nikitin:

我们可以这样做

我还想问一下，是否可以通过比较周期内订单的开盘价来找到离价格最远的订单，我想这样会更简单？

Konstantin Nikitin 2018.10.20 19:16 #846

Николай:

我还想问一下，是否可以通过比较周期内订单的开盘价来找到离价格最远的订单，我想这样会更简单？

当然是这样。而是否更容易取决于你需要什么。
这是对你上述问题的一个例子。

struct InfoOrder
{
     int ticket;
     double lot,
            profit,
            swap,
            commission,
            sl, tp;
     datetime timeOpen;
     string comment;
} infoOrder;

void OnTick()
{
     OldSell();
     Print("Ticket: ", infoOrder.ticket);
     Print("Profit: ", infoOrder.profit);
     Print("Lot: ", infoOrder.lot);
     Print("-----=====-----");
     
     return;
}

void OldSell(void)// Находим самый дальний ордер на продажу
{
   double MaxDist=0;
   double BID=MarketInfo(Symbol(),MODE_BID);
   double ASK=MarketInfo(Symbol(),MODE_ASK);
   for(int i=OrdersTotal()-1; i>=0; i--)
   {
   if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
        if(OrderType()==OP_SELL && MaxDist<MathAbs(OrderOpenPrice()-ASK))
         {
             MaxDist=MathAbs(OrderOpenPrice()-ASK);
             infoOrder.ticket=OrderTicket();
             infoOrder.profit = OrderProfit();
             infoOrder.lot = OrderLots();
         }
      }
   }
   return; 
}

Николай 2018.10.20 20:04 #847

Konstantin Nikitin:

当然，你可以。是否更容易取决于你需要什么。
再举个例子来说明你上面的问题。

看着这一切，我意识到我是一个怎样的小费者。所以，void OldSell(void)函数的结果被写入InfoOrder 结构中，然后你可以使用 infoOrder.ticket,infoOrder.profit,infoOrder.lot 等变量。

//-Структура для нахождения самого дальнего ордера на продажу
struct InfoOrder
{
     int ticket;
     double lot,
            profit,
            swap,
            commission,
            sl, tp;
     datetime timeOpen;
     string comment;
} infoOrder;

void OnTick()
{
     OldSell();
     Print("Ticketbuy: ", infoOrder.ticket);
     Print("Profitbuy: ", infoOrder.profit);
     Print("Lotbuy: ", infoOrder.lot);
     Print("Ticketsell: ", infoOrder.ticket);
     Print("Profitsell: ", infoOrder.profit);
     Print("Lotsell: ", infoOrder.lot);
     Print("-----=====-----");
     
     return;
}

void OldSell(void)// Находим самый дальний ордер на продажу
{
   double MaxDist=0;
   double BID=MarketInfo(Symbol(),MODE_BID);
   double ASK=MarketInfo(Symbol(),MODE_ASK);
   for(int i=OrdersTotal()-1; i>=0; i--)
   {
   if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
         if(OrderType()==OP_BUY && MaxDist<MathAbs(OrderOpenPrice()-BID))
          {
             MaxDist=MathAbs(OrderOpenPrice()-BID);
             infoOrder.ticketbuy=OrderTicket();
             infoOrder.profitbuy = OrderProfit();
             infoOrder.lotbuy = OrderLots();
           }  
             
        if(OrderType()==OP_SELL && MaxDist<MathAbs(OrderOpenPrice()-ASK))
          {
             MaxDist=MathAbs(OrderOpenPrice()-ASK);
             infoOrder.ticketsell=OrderTicket();
             infoOrder.profitsell = OrderProfit();
             infoOrder.lotsell = OrderLots();
          }
      }
   }
   return; 
}

Николай 2018.10.20 20:06 #848

Konstantin Nikitin:

当然，你可以。是否更容易取决于你需要什么。
再举个例子来说明你上面的问题。

忘记修改打印变量了

Konstantin Nikitin 2018.10.20 20:29 #849

Николай:
看着这一切，我意识到我是一个多么愚蠢的人。所以，void OldSell(void)函数的结果被写入InfoOrder 结构，然后我们可以使用 infoOrder.ticket,infoOrder.profit,infoOrder.lot.我把这个函数概括了一下，它是否正确？

//-Структура для нахождения самого дальнего ордера на продажу
struct InfoOrder
{
     int ticket;
     double lot,
            profit,
            swap,
            commission,
            sl, tp,
            MaxDist;
     datetime timeOpen;
     string comment;
} infoOrder;

void OnTick()
{
     if( OldOrder(OP_BUY) )
     {
        Print("Ticketbuy: ", infoOrder.ticket);
        Print("Profitbuy: ", infoOrder.profit);
        Print("Lotbuy: ", infoOrder.lot);
        Print("MaxDistbuy: ", infoOrder.MaxDist);
        Print("-----=====-----");
     }
     if( OldOrder(OP_SELL) )
     {
        Print("Ticketsell: ", infoOrder.ticket);
        Print("Profitsell: ", infoOrder.profit);
        Print("Lotsell: ", infoOrder.lot);
        Print("MaxDistsell: ", infoOrder.MaxDist);
        Print("-----=====-----");
     }
     
     return;
}

bool OldOrder(const int type)// Находим самый дальний ордер на продажу
{
   bool res = false;
   double MaxDist=0;
   double BID=MarketInfo(Symbol(),MODE_BID);
   double ASK=MarketInfo(Symbol(),MODE_ASK);
   for(int i=OrdersTotal()-1; i>=0; i--)
   {
   if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
         switch(type)
           {
            case OP_BUY:
               if(OrderType()!=OP_BUY) break;
               if(MaxDist<=MathAbs(OrderOpenPrice()-BID)) break;
               infoOrder.MaxDist=MathAbs(OrderOpenPrice()-BID);
               infoOrder.ticket=OrderTicket();
               infoOrder.profit = OrderProfit();
               infoOrder.lot = OrderLots();
               res = true;
               break;
             
           case OP_SELL:
               if(OrderType()!=OP_SELL) break;
               if(MaxDist>=MathAbs(OrderOpenPrice()-ASK)) break;
               infoOrder.MaxDist=MathAbs(OrderOpenPrice()-ASK);
               infoOrder.ticket=OrderTicket();
               infoOrder.profit = OrderProfit();
               infoOrder.lot = OrderLots();
               res = true;
               break;
        }
      }
   }
   return res; 
}

类似这样的事情。

Николай 2018.10.20 20:49 #850

在EA中发现了这个结构，你能告诉我它定义了什么吗？

struct TMartinData
{
   int    BUY_Positions;
   double BUY_LastPrice;
   double BUY_StopPrice;
   double BUY_Lots;
   datetime BUY_LastTime;
   bool   BUY_AllWD;
   int    SELL_Positions;
   double SELL_LastPrice;
   double SELL_StopPrice;
   double SELL_Lots;
   datetime SELL_LastTime;
   bool   SELL_AllWD;
} MartinData;

void OnTick()

void FillMartinData()
{
   datetime bfirst = TimeCurrent()+1;
   datetime blast = 0;
   datetime sfirst = TimeCurrent()+1;
   datetime slast = 0;
   MartinData.BUY_Positions = 0;
   MartinData.SELL_Positions = 0;
   MartinData.BUY_Lots = 0;
   MartinData.SELL_Lots = 0;
   MartinData.BUY_LastPrice = -1;
   MartinData.SELL_LastPrice = -1;
   MartinData.BUY_StopPrice = -1;
   MartinData.SELL_StopPrice = -1;
   MartinData.BUY_LastTime = 0;
   MartinData.SELL_LastTime = 0;
   MartinData.BUY_AllWD = true;
   MartinData.SELL_AllWD = true;
   for(int i=0;i<OrdersTotal();i++)
   {
     if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
     if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNum)
     {
        if (OrderType()==OP_BUY)
        {
           MartinData.BUY_Positions++;
           if (OrderOpenTime()<bfirst)
           {
              MartinData.BUY_Lots = OrderLots();
              MartinData.BUY_StopPrice = OrderStopLoss();
              bfirst = OrderOpenTime();
           }
           if (OrderOpenTime()>blast)
           {
              MartinData.BUY_LastPrice = OrderOpenPrice();
              blast = OrderOpenTime();
           }
           if (OrderStopLoss()<OrderOpenPrice())
              MartinData.BUY_AllWD = false;
        }
        else if (OrderType()==OP_SELL)
        {
           MartinData.SELL_Positions++;
           if (OrderOpenTime()<sfirst)
           {
              MartinData.SELL_Lots = OrderLots();
              MartinData.SELL_StopPrice = OrderStopLoss();
              sfirst = OrderOpenTime();
           }
           if (OrderOpenTime()>slast)
           {
              MartinData.SELL_LastPrice = OrderOpenPrice();
              slast = OrderOpenTime();
           }
           if ((OrderStopLoss()==0) || (OrderStopLoss()>OrderOpenPrice()))
              MartinData.SELL_AllWD = false;
        }
     }
   }
   MartinData.BUY_LastTime = blast;
   MartinData.SELL_LastTime = slast;
   if (MartinData.BUY_Positions==0) MartinData.BUY_AllWD = false;
   if (MartinData.SELL_Positions==0) MartinData.SELL_AllWD = false;
}

我将免费撰写一份顾问报告 - 页 85