加载中…
个人资料
  • 博客等级:
  • 博客积分:
  • 博客访问:
  • 关注人气:
  • 获赠金笔:0支
  • 赠出金笔:0支
  • 荣誉徽章:
正文 字体大小:

曾经高价出售的稳健王EA,中英文解读。

(2015-05-27 10:03:39)
标签:

股票

mt4智能交易系统ea

分类: MT4智能交易系统EA
数字模型,仅供交流研讨语法,切勿用于实盘。
//--------------------------------------------------
extern string temp = "资金9000  下0.01手起步  EURGBP M15";
extern bool 弹窗报警开关(默认打开) = TRUE;
extern bool 当净值小于余额的百分50暂停EA = TRUE;
extern int K长度大于本点数时暂停运行EA = 20;
extern int 有几个多单或空单持仓时暂停EA = 75;
extern double 当点差大于几个点时暂停EA = 5;
extern int 有几个持仓时见微利就平仓 = 30;
extern double 多个持仓时到设定的获利额就平仓 = 500.0;
extern bool 达到设定的获利额就平仓吗 = TRUE;
extern double 达到设定的获利额就平仓 = 3000.0;
extern bool 达到设定的亏损额就平仓吗 = FALSE;
extern double 达到设定的亏损额就平仓 = 1000.0;
extern int 加码间隔点数一 = 25;//1-7单 加码间隔
extern int 加码间隔点数二 = 75;//8单以上  加码间隔
extern int 总体盈利点数 = 30;
extern string Commentt = "qq125808047";
double gd_216 = 1.0;
int gi_224 = 15;//盈利点数
int gi_228 = 13;
double gd_232 = 1.0;
int gi_240 = 13;
int gi_244 = 25;//1-7 加码间隔
int gi_248 = 75;//8单以上  加码间隔
int gi_252 = 1;
bool gi_256 = FALSE;
bool gi_260 = FALSE;
bool gi_264 = TRUE;
bool gi_268 = FALSE;
double gd_272 = 0.01;
double gd_280 = 1.3;
int gi_288 = 15000;
bool gi_292 = FALSE;
int gi_296 = 258;
int gi_300 = 0;
int gi_304 = 0;
int gi_308 = 0;
int gi_312;
int gi_316;
bool gi_320;
bool gi_324;
double gd_328;
double gd_336;
double gd_344;
double gd_352;
double gd_376;
double gd_384;
int gd_100 = 1;

int init() {
   if(!IsTesting())
   if (Digits == 3 || Digits == 5) gd_100 = 10;
   gi_308 = LotDecimal();
   gi_244 = 加码间隔点数一;
   gi_248 = 加码间隔点数二*10;
   gi_224 = 总体盈利点数;
   if (gi_264) gi_260 = FALSE;
   return (0);
}

int deinit() {
   return (0);
}

int start() {
   double ld_4 = 0;
   if (MathAbs(iHigh(NULL, PERIOD_M5, 1) - iLow(NULL, PERIOD_M5, 1)) >= K长度大于本点数时暂停运行EA * gd_100 * Point) {
      if (弹窗报警开关(默认打开) != TRUE) return (0);
      Alert("上根K线的长度大于设定的长度,可能仍然在单边行情中,所以在本根K线暂停运行EA");
      return (0);
   }
   if (MathAbs(Bid - iOpen(NULL, PERIOD_M5, 0)) >= K长度大于本点数时暂停运行EA * gd_100 * Point) {
      if (弹窗报警开关(默认打开) != TRUE) return (0);
      Alert("本根的现价-开盘价大于设定的长度,可能是单边行情的起点或仍然在单边行情中,所以在本根K线立即暂停运行EA");
      return (0);
   }
   gd_384 = MathAbs(Bid - gd_376);
   gd_376 = Bid;
   int li_16 = 0;
   int li_20 = 0;
   for (int li_24 = 0; li_24 < OrdersTotal(); li_24++) {
      bool chenggong = OrderSelect(li_24, SELECT_BY_POS);
      if (OrderSymbol() == Symbol() && OrderType() == OP_BUY && OrderMagicNumber() == gi_296) li_16++;
      if (OrderSymbol() == Symbol() && OrderType() == OP_SELL && OrderMagicNumber() == gi_296) li_20++;
   }
   if (li_16 == 有几个多单或空单持仓时暂停EA || li_20 == 有几个多单或空单持仓时暂停EA) return (0);
   if (((li_16 + li_20) >= 有几个持仓时见微利就平仓) && AccountProfit() >= 多个持仓时到设定的获利额就平仓) {
      for (int li_28 = OrdersTotal() - 1; li_28 >= 0; li_28--) {
         chenggong = OrderSelect(li_28, SELECT_BY_POS, MODE_TRADES);
         if ((OrderType() == OP_BUY ||OrderType() == OP_SELL) && OrderSymbol() == Symbol())
          {
          chenggong =OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0, CLR_NONE);
            Alert("有多个多单持仓时,当获利达到设定的获利额多空单就一次性全部平仓");
         }
      }
   }
   if (Ask - Bid >= 当点差大于几个点时暂停EA * gd_100 * Point) return (0);
   if (当净值小于余额的百分50暂停EA == TRUE && AccountEquity() < 0.2 * AccountBalance()) {
      if (弹窗报警开关(默认打开) != TRUE) return (0);
      Alert(Symbol(), "【", Period(), "】当前的净值小于余额的50%,已经自动暂停EA的运行! 净值= ", AccountEquity(), ",余额= ", AccountBalance(), ",余额的百分20= ", AccountBalance() / 2.0);
      return (0);
   }
   if (达到设定的亏损额就平仓吗 == TRUE && AccountProfit() <= (-达到设定的亏损额就平仓)) {
      for (int li_32 = OrdersTotal() - 1; li_32 >= 0; li_32--) {
       chenggong =OrderSelect(li_32, SELECT_BY_POS, MODE_TRADES);
         if (OrderType() < OP_BUYLIMIT && OrderSymbol() == Symbol()) {
            chenggong = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0, CLR_NONE);
            Alert("持仓浮亏达到设定的亏损额全部平仓");
         }
      }
   }
   if (达到设定的获利额就平仓吗 == TRUE && AccountProfit() >= 达到设定的获利额就平仓) {
      for (int li_36 = OrdersTotal() - 1; li_36 >= 0; li_36--) {
    chenggong = OrderSelect(li_36, SELECT_BY_POS, MODE_TRADES);
         if (OrderType() < OP_BUYLIMIT && OrderSymbol() == Symbol()) {
        chenggong =OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0, CLR_NONE);
            Alert("持仓浮盈达到设定的获利额全部平仓");
         }
      }
   }
   if (gi_308 == 0) gi_308 = LotDecimal();
   Information();
   if (gi_264 != gi_268) {
      gi_320 = TRUE;
      gi_324 = TRUE;
   }
   if (gi_300 != iTime(NULL, PERIOD_M1, 0)) {
      gi_312 = 0;
      gi_316 = CountTrades("buy");
      if (gi_316 == 0 && gi_320 == TRUE) {
         gd_344 = NewLot("buy");
         while (gi_312 < 1) {
            gi_312 = OrderSend(Symbol(), OP_BUY, gd_344, Ask, 3, 0, 0, Commentt, gi_296, 0, Blue);
            if (gi_312 < 1) {
               Sleep(1000 * (60 * gi_252));
            } else yerrect("buy");
            RefreshRates();
         }
      }
      gi_316 = CountTrades("sell");
      if (gi_316 == 0 && gi_324 == TRUE) {
         gd_352 = NewLot("sell");
         while (gi_312 < 1) {
            gi_312 = OrderSend(Symbol(), OP_SELL, gd_352, Bid, 3, 0, 0, Commentt, gi_296, 0, Red);
            if (gi_312 < 1) {
               Sleep(1000 * (60 * gi_252));
            } else yerrect("sell");
            RefreshRates();
         }
      }
      gi_300 = iTime(NULL, PERIOD_M1, 0);
   }
   if (gi_304 != iTime(NULL, PERIOD_M1, 0)) {
      gi_312 = 0;
      gi_316 = CountTrades("buy");
      if (gi_316 > 0 && NextOrder("buy")) {
         gd_328 = NextLot("buy");
         while (gi_312 < 1) {
            gi_312 = OrderSend(Symbol(), OP_BUY, gd_328, Ask, 3, 0, 0, Commentt, gi_296, 0, Blue);
            if (gi_312 < 1) {
               Sleep(1000 * (60 * gi_252));
            } else yerrect("buy");
            RefreshRates();
         }
      }
      gi_316 = CountTrades("sell");
      if (gi_316 > 0 && NextOrder("sell")) {
         gd_336 = NextLot("sell");
         while (gi_312 < 1) {
            gi_312 = OrderSend(Symbol(), OP_SELL, gd_336, Bid, 3, 0, 0, Commentt, gi_296, 0, Red);
            if (gi_312 < 1) {
               Sleep(1000 * (60 * gi_252));
            } else yerrect("sell");
            RefreshRates();
         }
      }
      gi_304 = iTime(NULL, PERIOD_M1, 0);
   }
   return (0);
}

void yerrect(string as_0) {
   double ld_8;
   double ld_16 = AveragePrice(as_0);
   for (int li_24 = OrdersTotal() - 1; li_24 >= 0; li_24--) {
       bool chenggong = OrderSelect(li_24, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != gi_296) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == gi_296) {
         if (as_0 == "buy") {
            if (OrderType() == OP_BUY) {
               ld_8 = ld_16 + gi_224 * gd_100 * Point;
               if (OrderTakeProfit() != ld_8) {
              chenggong =OrderModify(OrderTicket(), ld_16, OrderStopLoss(), ld_8, 0, Yellow);
               }
            }
         }
         if (as_0 == "sell") {
            if (OrderType() == OP_SELL) {
               ld_8 = ld_16 - gi_224 * gd_100 * Point;
               if (OrderTakeProfit() != ld_8) {
                chenggong = OrderModify(OrderTicket(), ld_16, OrderStopLoss(), ld_8, 0, Yellow);
               }
            }
         }
      }
   }
}

double NewLot(string as_0) {
   double ld_8;
   double ld_16 = MarketInfo(Symbol(), MODE_MINLOT);
   if (as_0 == "buy") {
      if (gi_260) ld_8 = gd_272;
      else ld_8 = NormalizeDouble(gd_272 * NormalizeDouble(AccountBalance() / gi_288, 0), gi_308);
   }
   if (as_0 == "sell") {
      if (gi_260) ld_8 = gd_272;
      else ld_8 = NormalizeDouble(gd_272 * NormalizeDouble(AccountBalance() / gi_288, 0), gi_308);
   }
   if (ld_8 < ld_16) ld_8 = ld_16;
   return (ld_8);
}

double NextLot(string as_0) {
   double ld_8;
   if (gi_268) gd_280 = LotExponent();
   if (as_0 == "buy") ld_8 = NormalizeDouble(FindLastOrder(as_0, "Lots") * gd_280, gi_308);
   if (as_0 == "sell") ld_8 = NormalizeDouble(FindLastOrder(as_0, "Lots") * gd_280, gi_308);
   return (ld_8);
}

double LotExponent() {
   double ld_0 = 0;
   for (double ld_8 = 1; ld_0 < AccountBalance(); ld_0 += 10.0 * (gd_272 * MathPow(ld_8, 12) * (gi_248 - gi_248 * gd_100 / 4))) {
      ld_8 = (100.0 * ld_8 + 1.0) / 100.0;
      ld_0 = 0;
      for (int li_16 = 0; li_16 <= 5; li_16++) ld_0 += 10.0 * (gd_272 * MathPow(ld_8, li_16) * (gi_248 - gi_244 * gd_100 * li_16));
      for (li_16 = 6; li_16 <= 9; li_16++) ld_0 += 10.0 * (gd_272 * MathPow(ld_8, li_16) * (gi_248 - gi_248 / 10));
      for (li_16 = 10; li_16 <= 11; li_16++) ld_0 += 10.0 * (gd_272 * MathPow(ld_8, li_16) * (gi_248 - gi_248 / 6));
   }
   Print("下单量: = " + DoubleToStr(ld_8, 2));
   return (ld_8);
}

int NextOrder(string as_0) {
   int li_8;
   bool li_12 = FALSE;
   double ld_16 = iClose(Symbol(), PERIOD_M15, 1);
   double ld_24 = iOpen(Symbol(), PERIOD_M15, 1);
   if (as_0 == "buy") {
      li_8 = NormalizeDouble(gi_244 * MathPow(gd_216, CountTrades(as_0)), 0);
      if (CountTrades(as_0) == 7) li_8 = gi_248 / 10;
      if (CountTrades(as_0) == 8) li_8 = gi_248 / 10;
      if (CountTrades(as_0) == 9) li_8 = gi_248 / 10;
      if (CountTrades(as_0) == 10) li_8 = gi_248 / 10;
      if (CountTrades(as_0) == 11) li_8 = gi_248 / 6;
      if (CountTrades(as_0) == 12) li_8 = gi_248 / 6;
      if (CountTrades(as_0) == 13) li_8 = gi_248 / 4;
      if (FindLastOrder(as_0, "Price") - Ask >= li_8 * gd_100 * Point && CountTrades(as_0) < gi_228) {
         if (gi_256) {
            if (ld_24 <= ld_16) li_12 = TRUE;
            else li_12 = FALSE;
         } else li_12 = TRUE;
      }
   }
   if (as_0 == "sell") {
      li_8 = NormalizeDouble(gi_244 * MathPow(gd_232, CountTrades(as_0)), 0);
      if (CountTrades(as_0) == 7) li_8 = gi_248 / 10;
      if (CountTrades(as_0) == 8) li_8 = gi_248 / 10;
      if (CountTrades(as_0) == 9) li_8 = gi_248 / 10;
      if (CountTrades(as_0) == 10) li_8 = gi_248 / 10;
      if (CountTrades(as_0) == 11) li_8 = gi_248 / 6;
      if (CountTrades(as_0) == 12) li_8 = gi_248 / 6;
      if (CountTrades(as_0) == 13) li_8 = gi_248 / 4;
      if (Bid - FindLastOrder(as_0, "Price") >= li_8 * gd_100 * Point && CountTrades(as_0) < gi_240) {
         if (gi_256) {
            if (ld_24 >= ld_16) li_12 = TRUE;
            else li_12 = FALSE;
         } else li_12 = TRUE;
      }
   }
   return (li_12);
}

double FindLastOrder(string as_0, string as_8) {
   double ld_16;
   double ld_24;
   int li_32 = 0;
   for (int li_36 = OrdersTotal() - 1; li_36 >= 0; li_36--) {
       bool chenggong = OrderSelect(li_36, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != gi_296) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == gi_296) {
         if (as_0 == "buy") {
            if (OrderType() == OP_BUY) {
               if (OrderTicket() > li_32) {
                  ld_16 = OrderOpenPrice();
                  ld_24 = OrderLots();
                  li_32 = OrderTicket();
               }
            }
         }
         if (as_0 == "sell") {
            if (OrderType() == OP_SELL) {
               if (OrderTicket() > li_32) {
                  ld_16 = OrderOpenPrice();
                  ld_24 = OrderLots();
                  li_32 = OrderTicket();
               }
            }
         }
      }
   }
   if (as_8 == "Price") return (ld_16);
   if (as_8 == "Lots") return (ld_24);
   return (0.0);
}

int CountTrades(string as_0) {
   int li_8 = 0;
   for (int li_12 = OrdersTotal() - 1; li_12 >= 0; li_12--) {
       bool chenggong = OrderSelect(li_12, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != gi_296) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == gi_296) {
         if (as_0 == "buy")
            if (OrderType() == OP_BUY) li_8++;
         if (as_0 == "sell")
            if (OrderType() == OP_SELL) li_8++;
      }
   }
   return (li_8);
}

double AveragePrice(string as_0) {
   double ld_8 = 0;
   double ld_16 = 0;
   for (int li_24 = OrdersTotal() - 1; li_24 >= 0; li_24--) {
       bool chenggong = OrderSelect(li_24, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != gi_296) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == gi_296) {
         if (as_0 == "buy") {
            if (OrderType() == OP_BUY) {
               ld_8 += OrderOpenPrice() * OrderLots();
               ld_16 += OrderLots();
            }
         }
         if (as_0 == "sell") {
            if (OrderType() == OP_SELL) {
               ld_8 += OrderOpenPrice() * OrderLots();
               ld_16 += OrderLots();
            }
         }
      }
   }
   ld_8 = NormalizeDouble(ld_8 / ld_16, Digits);
   return (ld_8);
}

void Information() {
   if (gi_292) {
      Comment("" + "                             "
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              平台商: " + AccountCompany() + " 杠杆 1:" + DoubleToStr(AccountLeverage(), 0)
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              多单个数:" + CountTrades("buy")
         + "\n"
         + "                              多单获利:" + DoubleToStr(Balance("buy", "Balance"), 2)
         + "\n"
         + "                              多单手数: " + DoubleToStr(Balance("buy", "Lot"), 2)
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              空单个数:" + CountTrades("sell")
         + "\n"
         + "                              空单获利:" + DoubleToStr(Balance("sell", "Balance"), 2)
         + "\n"
         + "                              空单手数: " + DoubleToStr(Balance("sell", "Lot"), 2)
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              浮动盈亏: " + DoubleToStr(Balance("buy", "Balance") + Balance("sell", "Balance"), 2)
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              "
         + "\n"
      + "                               ");
   }
}

double Balance(string as_0, string as_8) {
   double ld_16 = 0;
   for (int li_24 = OrdersTotal() - 1; li_24 >= 0; li_24--) {
       bool chenggong = OrderSelect(li_24, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != gi_296) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == gi_296) {
         if (as_0 == "buy") {
            if (OrderType() == OP_BUY) {
               if (as_8 == "Balance") ld_16 = ld_16 + OrderProfit() - OrderSwap() - OrderCommission();
               if (as_8 == "Lot") ld_16 += OrderLots();
            }
         }
         if (as_0 == "sell") {
            if (OrderType() == OP_SELL) {
               if (as_8 == "Balance") ld_16 = ld_16 + OrderProfit() - OrderSwap() - OrderCommission();
               if (as_8 == "Lot") ld_16 += OrderLots();
            }
         }
      }
   }
   return (ld_16);
}

double LotDecimal() {
   double ld_0 = MarketInfo(Symbol(), MODE_LOTSTEP);
   int li_8 = MathCeil(MathAbs(MathLog(ld_0) / MathLog(10)));
   return (li_8);
}
//---------------------------------------------------------------------------------
汉化如下:
//-------------------------------
extern string temp = "资金9000  下0.01手起步  EURGBP M15";
extern bool 弹窗报警开关(默认打开) = TRUE;
extern bool 当净值小于余额的百分50暂停EA = TRUE;
extern int K长度大于本点数时暂停运行EA = 20;
extern int 有几个多单或空单持仓时暂停EA = 75;
extern double 当点差大于几个点时暂停EA = 5;
extern int 有几个持仓时见微利就平仓 = 30;
extern double 多个持仓时到设定的获利额就平仓 = 500.0;
extern bool 达到设定的获利额就平仓吗 = TRUE;
extern double 达到设定的获利额就平仓 = 3000.0;
extern bool 达到设定的亏损额就平仓吗 = FALSE;
extern double 达到设定的亏损额就平仓 = 1000.0;
extern int 加码间隔点数一 = 25;//1-7单 加码间隔
extern int 加码间隔点数二 = 75;//8单以上  加码间隔
extern int 总体盈利点数 = 30;
extern string Commentt = "qq125808047";
double 买单间隔点数计算系数 = 1.0;
int 盈利点数 = 15;//盈利点数
int 买单允许下单总个数 = 13;
double 卖单间隔点数计算系数 = 1.0;
int 卖单允许下单总个数 = 13;
int 前7单加码间隔点数 = 25;//1-7 加码间隔
int 第8单以后间隔点数 = 75;//8单以上  加码间隔
int 下单失败后EA停顿时间 = 1;
bool 使用15分图判断趋势吗 = FALSE;
bool 固定手数吗 = FALSE;
bool 可变手数吗 = TRUE;
bool gi_268 = FALSE;
double 默认手数 = 0.01;
double gd_280 = 1.3;
int 下单手数计算用变量 = 15000;
bool 显示信息吗 = FALSE;
int EA识别号码 = 258;
int 限制一根柱子下注一次 = 0;
int 限制一根柱子下注一次2 = 0;
int 小数点位数 = 0;
int 下单函数返回值;
int 卖单或买单总个数;
bool 可以做买单吗;
bool 可以做卖单吗;
double 下一笔买单手数;
double 下一笔卖单手数;
double gd_344;
double gd_352;
double gd_376;
double gd_384;
int 点数是Point的倍数 = 1;

int init() {
   if(!IsTesting())
   if (Digits == 3 || Digits == 5) 点数是Point的倍数 = 10;
   小数点位数 = LotDecimal();
   前7单加码间隔点数 = 加码间隔点数一;
   第8单以后间隔点数 = 加码间隔点数二*10;
   盈利点数 = 总体盈利点数;
   if (可变手数吗) 固定手数吗 = FALSE;
   return (0);
}

int deinit() {
   return (0);
}

int start() {
   double ld_4 = 0;
   if (MathAbs(iHigh(NULL, PERIOD_M5, 1) - iLow(NULL, PERIOD_M5, 1)) >= K长度大于本点数时暂停运行EA * 点数是Point的倍数 * Point) {
      if (弹窗报警开关(默认打开) != TRUE) return (0);
      Alert("上根K线的长度大于设定的长度,可能仍然在单边行情中,所以在本根K线暂停运行EA");
      return (0);
   }
   if (MathAbs(Bid - iOpen(NULL, PERIOD_M5, 0)) >= K长度大于本点数时暂停运行EA * 点数是Point的倍数 * Point) {
      if (弹窗报警开关(默认打开) != TRUE) return (0);
      Alert("本根的现价-开盘价大于设定的长度,可能是单边行情的起点或仍然在单边行情中,所以在本根K线立即暂停运行EA");
      return (0);
   }
   gd_384 = MathAbs(Bid - gd_376);
   gd_376 = Bid;
   int li_16 = 0;
   int li_20 = 0;
   for (int i = 0; i < OrdersTotal(); i++) {
      bool result = OrderSelect(i, SELECT_BY_POS);
      if (OrderSymbol() == Symbol() && OrderType() == OP_BUY && OrderMagicNumber() == EA识别号码) li_16++;
      if (OrderSymbol() == Symbol() && OrderType() == OP_SELL && OrderMagicNumber() == EA识别号码) li_20++;
   }
   if (li_16 == 有几个多单或空单持仓时暂停EA || li_20 == 有几个多单或空单持仓时暂停EA) return (0);
   if (((li_16 + li_20) >= 有几个持仓时见微利就平仓) && AccountProfit() >= 多个持仓时到设定的获利额就平仓) {
      for (int li_28 = OrdersTotal() - 1; li_28 >= 0; li_28--) {
         result = OrderSelect(li_28, SELECT_BY_POS, MODE_TRADES);
         if ((OrderType() == OP_BUY ||OrderType() == OP_SELL) && OrderSymbol() == Symbol())
          {
          result =OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0, CLR_NONE);
            Alert("有多个多单持仓时,当获利达到设定的获利额多空单就一次性全部平仓");
         }
      }
   }
   if (Ask - Bid >= 当点差大于几个点时暂停EA * 点数是Point的倍数 * Point) return (0);
   if (当净值小于余额的百分50暂停EA == TRUE && AccountEquity() < 0.2 * AccountBalance()) {
      if (弹窗报警开关(默认打开) != TRUE) return (0);
      Alert(Symbol(), "【", Period(), "】当前的净值小于余额的50%,已经自动暂停EA的运行! 净值= ", AccountEquity(), ",余额= ", AccountBalance(), ",余额的百分20= ", AccountBalance() / 2.0);
      return (0);
   }
   if (达到设定的亏损额就平仓吗 == TRUE && AccountProfit() <= (-达到设定的亏损额就平仓)) {
      for (int li_32 = OrdersTotal() - 1; li_32 >= 0; li_32--) {
       result =OrderSelect(li_32, SELECT_BY_POS, MODE_TRADES);
         if (OrderType() < OP_BUYLIMIT && OrderSymbol() == Symbol()) {
            result = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0, CLR_NONE);
            Alert("持仓浮亏达到设定的亏损额全部平仓");
         }
      }
   }
   if (达到设定的获利额就平仓吗 == TRUE && AccountProfit() >= 达到设定的获利额就平仓) {
      for (i = OrdersTotal() - 1; i >= 0; i--) {
         result = OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
         if (OrderType() < OP_BUYLIMIT && OrderSymbol() == Symbol()) {
            result =OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0, CLR_NONE);
            Alert("持仓浮盈达到设定的获利额全部平仓");
         }
      }
   }
   if (小数点位数 == 0) 小数点位数 = LotDecimal();
   显示信息();
   if (可变手数吗 != gi_268) {
      可以做买单吗 = TRUE;
      可以做卖单吗 = TRUE;
   }
   if (限制一根柱子下注一次 != iTime(NULL, PERIOD_M1, 0)) {
      下单函数返回值 = 0;
      卖单或买单总个数 = CountTrades("buy");
      if (卖单或买单总个数 == 0 && 可以做买单吗 == TRUE) {
         gd_344 = NewLot("buy");
         while (下单函数返回值 < 1) {
            下单函数返回值 = OrderSend(Symbol(), OP_BUY, gd_344, Ask, 3, 0, 0, Commentt, EA识别号码, 0, Blue);
            if (下单函数返回值 < 1) {
               Sleep(1000 * (60 * 下单失败后EA停顿时间));
            } else 修改订单获利价格("buy");
            RefreshRates();
         }
      }
      卖单或买单总个数 = CountTrades("sell");
      if (卖单或买单总个数 == 0 && 可以做卖单吗 == TRUE) {
         gd_352 = NewLot("sell");
         while (下单函数返回值 < 1) {
            下单函数返回值 = OrderSend(Symbol(), OP_SELL, gd_352, Bid, 3, 0, 0, Commentt, EA识别号码, 0, Red);
            if (下单函数返回值 < 1) {
               Sleep(1000 * (60 * 下单失败后EA停顿时间));
            } else 修改订单获利价格("sell");
            RefreshRates();
         }
      }
      限制一根柱子下注一次 = iTime(NULL, PERIOD_M1, 0);
   }
   if (限制一根柱子下注一次2 != iTime(NULL, PERIOD_M1, 0)) {
      下单函数返回值 = 0;
      卖单或买单总个数 = CountTrades("buy");
      if (卖单或买单总个数 > 0 && NextOrder("buy")) {
         下一笔买单手数 = NextLot("buy");
         while (下单函数返回值 < 1) {
            下单函数返回值 = OrderSend(Symbol(), OP_BUY, 下一笔买单手数, Ask, 3, 0, 0, Commentt, EA识别号码, 0, Blue);
            if (下单函数返回值 < 1) {
               Sleep(1000 * (60 * 下单失败后EA停顿时间));
            } else 修改订单获利价格("buy");
            RefreshRates();
         }
      }
      卖单或买单总个数 = CountTrades("sell");
      if (卖单或买单总个数 > 0 && NextOrder("sell")) {
         下一笔卖单手数 = NextLot("sell");
         while (下单函数返回值 < 1) {
            下单函数返回值 = OrderSend(Symbol(), OP_SELL, 下一笔卖单手数, Bid, 3, 0, 0, Commentt, EA识别号码, 0, Red);
            if (下单函数返回值 < 1) {
               Sleep(1000 * (60 * 下单失败后EA停顿时间));
            } else 修改订单获利价格("sell");
            RefreshRates();
         }
      }
      限制一根柱子下注一次2 = iTime(NULL, PERIOD_M1, 0);
   }
   return (0);
}

//+---------------------------------------------------------------------------------------+
//|下单后根据价格的平均值修改获利价格                          
//+---------------------------------------------------------------------------------------+
void 修改订单获利价格(string 订单种类) {
   double 获利价格;
   double 订单价格 = 计算订单价格平均值(订单种类);
   for (int i = OrdersTotal() - 1; i >= 0; i--) {
      bool result = OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != EA识别号码) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == EA识别号码) {
         if (订单种类 == "buy") {
            if (OrderType() == OP_BUY) {
               获利价格 = 订单价格 + 盈利点数 * 点数是Point的倍数 * Point;
               if (OrderTakeProfit() != 获利价格) {
                   result =OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 获利价格, 0, Yellow);
               }
            }
         }
         if (订单种类 == "sell") {
            if (OrderType() == OP_SELL) {
               获利价格 = 订单价格 - 盈利点数 * 点数是Point的倍数 * Point;
               if (OrderTakeProfit() != 获利价格) {
                   result = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 获利价格, 0, Yellow);
               }
            }
         }
      }
   }
}

//+---------------------------------------------------------------------------------------+
//返回最初下单手数,如果是固定则返回0.01手,如果不是固定0.01手则根据账户资金,每15000下单0.01手
//参数:订单种类:"buy"(买),"sell"(卖)
//返回值:                              
//+---------------------------------------------------------------------------------------+
double NewLot(string 订单种类) {
   double 返回值;
   double 最小下单手数 = MarketInfo(Symbol(), MODE_MINLOT);
   if (订单种类 == "buy") {
      if (固定手数吗) 返回值 = 默认手数;
      else 返回值 = NormalizeDouble(默认手数 * NormalizeDouble(AccountBalance() / 下单手数计算用变量, 0), 小数点位数);
   }
   if (订单种类 == "sell") {
      if (固定手数吗) 返回值 = 默认手数;
      else 返回值 = NormalizeDouble(默认手数 * NormalizeDouble(AccountBalance() / 下单手数计算用变量, 0), 小数点位数);
   }
   if (返回值 < 最小下单手数) 返回值 = 最小下单手数;
   return (返回值);
}

double NextLot(string 订单种类) {
   double 返回值;
   if (gi_268) gd_280 = LotExponent();
   if (订单种类 == "buy") 返回值 = NormalizeDouble(FindLastOrder(订单种类, "Lots") * gd_280, 小数点位数);
   if (订单种类 == "sell") 返回值 = NormalizeDouble(FindLastOrder(订单种类, "Lots") * gd_280, 小数点位数);
   return (返回值);
}

double LotExponent() {
   double ld_0 = 0;
   for (double 返回值 = 1; ld_0 < AccountBalance(); ld_0 += 10.0 * (默认手数 * MathPow(返回值, 12) * (第8单以后间隔点数 - 第8单以后间隔点数 * 点数是Point的倍数 / 4))) {
      返回值 = (100.0 * 返回值 + 1.0) / 100.0;
      ld_0 = 0;
      for (int i = 0; i <= 5; i++) ld_0 += 10.0 * (默认手数 * MathPow(返回值, i) * (第8单以后间隔点数 - 前7单加码间隔点数 * 点数是Point的倍数 * i));
      for (i = 6; i <= 9; i++) ld_0 += 10.0 * (默认手数 * MathPow(返回值, i) * (第8单以后间隔点数 - 第8单以后间隔点数 / 10));
      for (i = 10; i <= 11; i++) ld_0 += 10.0 * (默认手数 * MathPow(返回值, i) * (第8单以后间隔点数 - 第8单以后间隔点数 / 6));
   }
   Print("下单量: = " + DoubleToStr(返回值, 2));
   return (返回值);
}

//+---------------------------------------------------------------------------------------+
//判断是否可以做下一个订单
//参数:订单种类:"buy"(买),"sell"(卖)
//返回值:True:可以,FALSE:不可以                              
//+---------------------------------------------------------------------------------------+
bool NextOrder(string 订单种类) {
   int 加码间隔点数;
   bool 返回值 = FALSE;
   double 前一个蜡烛的终值_15分图 = iClose(Symbol(), PERIOD_M15, 1);
   double 前一个蜡烛的始值_15分图 = iOpen(Symbol(), PERIOD_M15, 1);
   if (订单种类 == "buy") {
      加码间隔点数 = NormalizeDouble(前7单加码间隔点数 * MathPow(买单间隔点数计算系数, CountTrades(订单种类)), 0);
      if (CountTrades(订单种类) == 7) 加码间隔点数 = 第8单以后间隔点数 / 10;
      if (CountTrades(订单种类) == 8) 加码间隔点数 = 第8单以后间隔点数 / 10;
      if (CountTrades(订单种类) == 9) 加码间隔点数 = 第8单以后间隔点数 / 10;
      if (CountTrades(订单种类) == 10) 加码间隔点数 = 第8单以后间隔点数 / 10;
      if (CountTrades(订单种类) == 11) 加码间隔点数 = 第8单以后间隔点数 / 6;
      if (CountTrades(订单种类) == 12) 加码间隔点数 = 第8单以后间隔点数 / 6;
      if (CountTrades(订单种类) == 13) 加码间隔点数 = 第8单以后间隔点数 / 4;
      if (FindLastOrder(订单种类, "Price") - Ask >= 加码间隔点数 * 点数是Point的倍数 * Point && CountTrades(订单种类) < 买单允许下单总个数) {
         if (使用15分图判断趋势吗) {
            if (前一个蜡烛的始值_15分图 <= 前一个蜡烛的终值_15分图) 返回值 = TRUE;
            else 返回值 = FALSE;
         } else 返回值 = TRUE;
      }
   }
   if (订单种类 == "sell") {
      加码间隔点数 = NormalizeDouble(前7单加码间隔点数 * MathPow(卖单间隔点数计算系数, CountTrades(订单种类)), 0);
      if (CountTrades(订单种类) == 7) 加码间隔点数 = 第8单以后间隔点数 / 10;
      if (CountTrades(订单种类) == 8) 加码间隔点数 = 第8单以后间隔点数 / 10;
      if (CountTrades(订单种类) == 9) 加码间隔点数 = 第8单以后间隔点数 / 10;
      if (CountTrades(订单种类) == 10) 加码间隔点数 = 第8单以后间隔点数 / 10;
      if (CountTrades(订单种类) == 11) 加码间隔点数 = 第8单以后间隔点数 / 6;
      if (CountTrades(订单种类) == 12) 加码间隔点数 = 第8单以后间隔点数 / 6;
      if (CountTrades(订单种类) == 13) 加码间隔点数 = 第8单以后间隔点数 / 4;
      if (Bid - FindLastOrder(订单种类, "Price") >= 加码间隔点数 * 点数是Point的倍数 * Point && CountTrades(订单种类) < 卖单允许下单总个数) {
         if (使用15分图判断趋势吗) {
            if (前一个蜡烛的始值_15分图 >= 前一个蜡烛的终值_15分图) 返回值 = TRUE;
            else 返回值 = FALSE;
         } else 返回值 = TRUE;
      }
   }
   return (返回值);
}

//+---------------------------------------------------------------------------------------+
//|查询最后一个已经约定的买订单或者卖订单的开仓价格和开仓手数
//参数:订单种类:"buy"(买),"sell"(卖)
//      查询种类:"Price"(查询价格),"Lots"(查询开仓手数)  
//返回值:订单价格或者订单手数                              
//+---------------------------------------------------------------------------------------+
double FindLastOrder(string 订单种类, string 查询种类) {
   double 订单开仓价格;
   double 订单开仓手数;
   int 订单号码 = 0;
   for (int i = OrdersTotal() - 1; i >= 0; i--) {
      bool result = OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != EA识别号码) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == EA识别号码) {
         if (订单种类 == "buy") {
            if (OrderType() == OP_BUY) {
               if (OrderTicket() > 订单号码) {
                  订单开仓价格 = OrderOpenPrice();
                  订单开仓手数 = OrderLots();
                  订单号码 = OrderTicket();
               }
            }
         }
         if (订单种类 == "sell") {
            if (OrderType() == OP_SELL) {
               if (OrderTicket() > 订单号码) {
                  订单开仓价格 = OrderOpenPrice();
                  订单开仓手数 = OrderLots();
                  订单号码 = OrderTicket();
               }
            }
         }
      }
   }
   if (查询种类 == "Price") return (订单开仓价格);
   if (查询种类 == "Lots") return (订单开仓手数);
   return (0.0);
}

//+---------------------------------------------------------------------------------------+
//|查询已经约定的买订单或者卖订单的个数
//参数:订单种类:"buy"(买),"sell"(卖)
//返回值:订单个数                              
//+---------------------------------------------------------------------------------------+
int CountTrades(string 订单种类) {
   int 返回值 = 0;
   for (int i = OrdersTotal() - 1; i >= 0; i--) {
      bool result = OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != EA识别号码) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == EA识别号码) {
         if (订单种类 == "buy")
            if (OrderType() == OP_BUY) 返回值++;
         if (订单种类 == "sell")
            if (OrderType() == OP_SELL) 返回值++;
      }
   }
   return (返回值);
}

//+---------------------------------------------------------------------------------------+
//|计算已经约定的买单或者卖单的价格的平均值
//参数:订单种类:"buy"(买),"sell"(卖)
//返回值:对应订单种类的价格平均值                              
//+---------------------------------------------------------------------------------------+
double 计算订单价格平均值(string 订单种类) {
   double 返回值 = 0;
   double 总手数 = 0;
   for (int i = OrdersTotal() - 1; i >= 0; i--) {
       bool result = OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != EA识别号码) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == EA识别号码) {
         if (订单种类 == "buy") {
            if (OrderType() == OP_BUY) {
               返回值 += OrderOpenPrice() * OrderLots();
               总手数 += OrderLots();
            }
         }
         if (订单种类 == "sell") {
            if (OrderType() == OP_SELL) {
               返回值 += OrderOpenPrice() * OrderLots();
               总手数 += OrderLots();
            }
         }
      }
   }
   返回值 = NormalizeDouble(返回值 / 总手数, Digits);
   return (返回值);
}

//+---------------------------------------------------------------------------------------+
//|显示EA目前的交易信息                       
//+---------------------------------------------------------------------------------------+
void 显示信息() {
   if (显示信息吗) {
      Comment("" + "                              "
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              平台商: " + AccountCompany() + " 杠杆 1:" + DoubleToStr(AccountLeverage(), 0)
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              多单个数:" + CountTrades("buy")
         + "\n"
         + "                              多单获利:" + DoubleToStr(Balance("buy", "Balance"), 2)
         + "\n"
         + "                              多单手数: " + DoubleToStr(Balance("buy", "Lot"), 2)
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              空单个数:" + CountTrades("sell")
         + "\n"
         + "                              空单获利:" + DoubleToStr(Balance("sell", "Balance"), 2)
         + "\n"
         + "                              空单手数: " + DoubleToStr(Balance("sell", "Lot"), 2)
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                              浮动盈亏: " + DoubleToStr(Balance("buy", "Balance") + Balance("sell", "Balance"), 2)
         + "\n"
         + "                              ------------------------------------------------"
         + "\n"
         + "                             "
         + "\n"
      + "                               ");
   }
}

//+---------------------------------------------------------------------------------------+
//|查询已经约定的买订单或者卖订单的赢利状况或者总手数
//参数:订单种类:"buy"(买),"sell"(卖)
//      查询种类:"Balance"(账户赢利状况),"Lot"(总手数)
//返回值:买订单或者卖订单的赢利状况或者总手数                              
//+---------------------------------------------------------------------------------------+
double Balance(string 订单种类, string 查询种类) {
   double 返回值 = 0;
   for (int i = OrdersTotal() - 1; i >= 0; i--) {
       bool result = OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() != Symbol() || OrderMagicNumber() != EA识别号码) continue;
      if (OrderSymbol() == Symbol() && OrderMagicNumber() == EA识别号码) {
         if (订单种类 == "buy") {
            if (OrderType() == OP_BUY) {
               if (查询种类 == "Balance") 返回值 = 返回值 + OrderProfit() - OrderSwap() - OrderCommission();
               if (查询种类 == "Lot") 返回值 += OrderLots();
            }
         }
         if (订单种类 == "sell") {
            if (OrderType() == OP_SELL) {
               if (查询种类 == "Balance") 返回值 = 返回值 + OrderProfit() - OrderSwap() - OrderCommission();
               if (查询种类 == "Lot") 返回值 += OrderLots();
            }
         }
      }
   }
   return (返回值);
}

//+---------------------------------------------------------------------------------------+
//|查询改变标准手最小单位的小数点位数(xm微型账号时:返回值2.0)
//+---------------------------------------------------------------------------------------+
double LotDecimal() {
   double 改变标准手最小单位 = MarketInfo(Symbol(), MODE_LOTSTEP);
   int 返回值 = MathCeil(MathAbs(MathLog(改变标准手最小单位) / MathLog(10)));
   return (返回值);
}

0

阅读 收藏 喜欢 打印举报/Report
  

新浪BLOG意见反馈留言板 欢迎批评指正

新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 产品答疑

新浪公司 版权所有