有您的持续关注
我们会做得更好

智能交易系统swb grid汉化版



智能交易系统swb grid汉化版来自网络,可能对编程爱好的新手在逻辑思考上有很大的帮助,对汉化的作者应该深表谢意。

本网收集整理智能交易EA仅为MQL4编程爱好者提供语法及相关编程技巧的学习研究之用,智能交易存在极高的风险测试请用模拟盘,请勿用于实盘。 swb grid 汉化版源码如下:

//+------------------------------------------------------------------+
//|                                                          SWB.mq4 |
//|                                     Copyright 2014, QQ:125808047 |
//+------------------------------------------------------------------+
#property copyright "Copyright @2013, 125808047"
#property link      ""

#define buy -2
#define sell 2
//---- input parameters
extern string    文本甲             = "SWB 125808047";
extern string    订单备注           = "TOG 01";                           //Trigger on Grid
extern int       魔术号码           = 125808047;                           //每chart,每货币兑使用单独的号码
extern string    文本乙             = "------常改动的参数------";
extern double    起始手数           = 0.01;
extern bool      使用自动赢利模式   = true;
extern double    止盈因子           = 0.2;                                //即浮赢超过20美元,全部平仓
double           止盈钱数           = 3.5;                                //美元,初值,后面会调整
extern int       跟踪止损标准       = 13; 
extern string    文本丙             = "部分平台划点可能超过3";
extern int       划点               = 3;  
extern string    文本丁             = "------不常改动的参数------";
extern double    网格间距           = 15;
extern bool      使用隐形模式       = true;
extern bool      使用每日目标       = false;
extern double    每日目标点数       = 100;
extern bool      使用tick数据       = true;
extern bool      是否周五交易       = true;
extern bool      使用止盈止损       = false;
extern double    止损点数           = 60;
extern double    止盈点数           = 30;
extern bool      使用加码策略       = true;
extern int       加码层数           = 9;                                  //一般而言,应设置在5以内
extern double    加码倍数           = 2;
extern double    不加码增加值       = 0.01;                           
extern bool      自动计算手数       = false;
extern double    风险比例           = 0.5;                               
extern string    文本戊             = "------对冲参数------";
extern bool      使用对冲           = false;
extern int       使用对冲起始层次   = 5;
extern double    对冲手数因子       = 2.4;
extern double    对冲止盈因子       = 0.5;
extern double    对冲加码倍数       = 1.5;
extern int       对冲加码层次       = 5;
extern string    MACD_Settings      = "------MACD触发器------";
extern bool      使用MACD指标       = false;
extern int       Fast               = 12;
extern int       slow               = 26;
extern int       Signal             = 9;
extern string    OsMa_Settings      = "------OsMA触发器------";
extern bool      使用OsMA指标       = true;
extern int       fast_ema           = 12;
extern int       slow_ema           = 26;
extern int       信号周期           = 9;
extern string    CCI_Settings       = "------CCI触发器------";
extern bool      使用CCI指标        = false;
extern int       CCI周期            = 60;
extern int       CCI穿越阈值        = 100;
extern string    随机振荡指标       = "------KDJ触发器------";  
extern bool      使用KDJ指标        = false;
extern int       K周期              = 110;
extern int       D周期              = 3;
extern int       滚动值             = 3;
//----
double           pt;
double           最小手数;
double           止损水平;
int              prec               = 0;
int              a                  = 0;
int              ticket             = 0;
//----
double s_lot,s_lot2,hf,对冲止盈点数,甲加码倍数,乙加码倍数,从哪层开始对冲加码,净值初值;
bool             Close_All;                                              // Part of Close_All Inhibit ...
string           opt                = "NULL";
int              现;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
//----
   if (使用tick数据) 现 = 0; 
   else 现 = 1;                                                         //用在触发器指标上的
   if(Digits==3 || Digits==5) pt=10*Point;                              //五位平台,所谓的点数要向前进位
   else                       pt=Point;
   最小手数 = MarketInfo(Symbol(),MODE_MINLOT);
   止损水平 = MarketInfo(Symbol(),MODE_STOPLEVEL);
   if(起始手数<最小手数) Print("手数太小!");
   if(止损点数<止损水平) Print("止损点数太小了!");
   if(止盈点数<止损水平) Print("止盈点数太小了!");
   if(最小手数==0.01)    prec=2;                                          //用来后面控制位数的
   if(最小手数==0.1)     prec=1;               
//----
   s_lot               = 起始手数;                                        //起始手数=0.01
   if(使用对冲==false)使用对冲起始层次=0; 
   hf                  = 对冲手数因子;                                     //2.4
   对冲止盈点数        = 对冲止盈因子*网格间距*pt;                           //暂定15点,五位平台是150点
   甲加码倍数          = 加码倍数;                                         //2
   乙加码倍数          = 对冲加码倍数;                                      //1.5,五级以上风险很大,故减少倍数
   从哪层开始对冲加码  = 对冲加码层次;                                      //5
//----
   return(0);
}                                                                       //initial结束
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
   if (自动计算手数)                                                      //缺省false
   {
     起始手数=AccountFreeMargin()/100000*风险比例;                        //假设可用1万刀,风险比例0.5,则起始手数=0.05
     if (起始手数<0.01) 起始手数=0.01;
   } 
   else s_lot=起始手数;                                                  //如果不使用自动计算手数功能,将0.01的初值赋值给s_lot
//+------------------------------------------------------------------+                                             
   if (使用自动赢利模式) 止盈钱数=AccountEquity()/100*止盈因子;             //缺省true,止盈因子=0.2,止盈钱数=20$(假设一万刀净值)
//+------------------------------------------------------------------+
   if (使用每日目标 && 计算日目标()>=每日目标点数)                          //缺省false,不执行
   {
     Comment("\n每日目标已达到.");
     return(0);
   }
//+------------------------------------------------------------------+
   if (!是否周五交易 && DayOfWeek()==5 && total()==0)                     //缺省是true,故不执行
   {
     Comment("\n周五不工作.");
     return(0);
   }
//+------------------------------------------------------------------+
   int 总订单数=0,买单总数=0,卖单总数=0,对冲单总数,正常单总数=0,OOT,FOOT;            // Close_All Inhibit ...
   bool s对冲=false,b对冲=false; 
   string 标识="0";
   for(int cnt=0; cnt<=OrdersTotal(); cnt++)                            //统计订单的
   {
      bool cg = OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==魔术号码 && OrderType()<2)
      {
         总订单数+=1; 
         OOT=OrderOpenTime();
         if(OrderType()==0) 买单总数+=1;                                 
         if(OrderType()==1) 卖单总数+=1;                                  
         if(总订单数==1 || OOT<FOOT)                                     //有点晕,有可能是确保某一个方向的遍历
         { 
          FOOT=OOT; 
          标识="B"; 
          if(OrderType()==1) 标识="S";                                   //顺便识别当前订单的开单方向
         }//if                                                          
      }//if 魔术号码
   }//for
//----
   if(标识=="B")
   {
      正常单总数=买单总数; 
      对冲单总数=卖单总数; 
      opt="BUY";  
      if(使用对冲 && 买单总数>=使用对冲起始层次-1) s对冲=true;               //多个买单中,若允许对冲,且超过一定次数,则允许卖方向的对冲
   }
   if(标识=="S")
   {
      正常单总数=卖单总数; 
      对冲单总数=买单总数; 
      opt="SELL"; 
      if(使用对冲 && 卖单总数>=使用对冲起始层次-1) b对冲=true; 
   }
//----
   加码倍数=甲加码倍数;                                                   //2
   if(乙加码倍数>0.0 && 正常单总数>=从哪层开始对冲加码-1) 加码倍数=乙加码倍数; 
//----
   if(总订单数==0) Close_All=false;                                      //如果总订单数为零,则全平状态置假
//+------------------------------------------------------------------+
   if(正常单总数==0 && a==0 && 对冲单总数==0)                              //无订单,且全平仓干净了,则准备开仓   
   {                                                                    //以下是开买单
     if(买卖信号()==buy && Close_All==false)                             //出现买信号,且不存在全平情况
     {    
        if(使用隐形模式)                                                  //true,防止被平台后台操纵,以市价单模式开仓
        {
          if(使用止盈止损)                                                //false
          {s_lot=起始手数;
           ticket=OrderSend(Symbol(),0,s_lot,Ask,划点,0,Ask+止盈点数*pt,订单备注,魔术号码,0,Blue); 
          }
          else                                                          //不止盈止损的话 
          {s_lot=起始手数;
           ticket=OrderSend(Symbol(),0,s_lot,Ask,划点,0,0,订单备注,魔术号码,0,Blue); 
          }
        }
        else                                                            //不隐形的话,一次性以限价单的模式开出全部订单
        {
          if(使用止盈止损) 
          {
             s_lot=起始手数;                                             //0.01
             if(OrderSend(Symbol(),0,起始手数,Ask,划点,0,Ask+止盈点数*pt,订单备注,魔术号码,0,Blue)>0)              //0=OP_BUY
             {
                for(int i=1; i<加码层数; i++)
                {
                    if(使用加码策略)                                      //true
                    { s_lot=NormalizeDouble(起始手数*MathPow(加码倍数,i),prec); 
                                                                        //0.01*2^i,
                                                                        //i=1,s_lot=0.02
                                                                        //i=2,s_lot=0.04
                                                                        //i=3,s_lot=0.08
                                                                        //...
                      ticket=OrderSend(Symbol(),2,s_lot,Ask-(网格间距*i)*pt,划点,0,(Ask-(网格间距*i)*pt)+止盈点数*pt,订单备注,魔术号码,0,Blue); 
                                                                        //间距网格间距(15点)开网格,五位是150点
                                                                        //Matrix TOG相比于SWB4.1原版,把止损(Ask-(range*i)*pt)-sl*pt去掉了
                                                                        //2=OP_BUY Limit挂单
                    }
                    else                                                   //不加码           
                    { s_lot=NormalizeDouble(起始手数+不加码增加值*i,prec);
                      ticket=OrderSend(Symbol(),2,s_lot,Ask-(网格间距*i)*pt,划点,0,(Ask-(网格间距*i)*pt)+止盈点数*pt,订单备注,魔术号码,0,Blue); 
                                                                        //2=OP_BUY Limit挂单
                    }
                }//for 开全部网格限价单结束
             }//if 发送买单成功
          }//if(使用止盈止损) 
          else                                                             //如果不使用止盈止损
          {
             s_lot=起始手数;
             if(OrderSend(Symbol(),0,起始手数,Ask,划点,0,0,订单备注,魔术号码,0,Blue)>0)
             {
                for(i=1; i<加码层数; i++)
                {
                    if(使用加码策略)
                    { s_lot=NormalizeDouble(起始手数*MathPow(加码倍数,i),prec); 
                      ticket=OrderSend(Symbol(),2,s_lot,Ask-(网格间距*i)*pt,划点,0,0,订单备注,魔术号码,0,Blue);        //没设止盈
                    }
                    else                                                 //不加码             
                    { s_lot=NormalizeDouble(起始手数+不加码增加值*i,prec);
                      ticket=OrderSend(Symbol(),2,s_lot,Ask-(网格间距*i)*pt,划点,0,0,订单备注,魔术号码,0,Blue); 
                    }
                }//for 开全部网格限价单结束
             }//if 发送买单成功
          }//else //如果不使用止盈止损 
        }//else//不隐形的话    
        if(s对冲==true) ticket=OrderSend(Symbol(),1,s_lot*hf,Bid,划点,0,Bid-对冲止盈点数,"使用对冲",魔术号码,0,Red);    //1=卖单,反向对冲
     }//if开买单结束
     //---
     if(买卖信号()==sell && Close_All==false)                             // 以下是开卖单
     {
        if(使用隐形模式)
        {
          if(使用止盈止损)
          { s_lot=起始手数; 
            ticket=OrderSend(Symbol(),1,s_lot,Bid,划点,0,Bid-止盈点数*pt,订单备注,魔术号码,0,Red); //Matrix TOG把止损Bid+sl*pt改成0了
          }
          else                                                             //不止损止盈        
          { s_lot=起始手数; 
            ticket=OrderSend(Symbol(),1,s_lot,Bid,划点,0,0,订单备注,魔术号码,0,Red); 
          }
        }//if(使用隐形模式)
        else                                                             //不隐形
        {
          if(使用止盈止损) 
          {
             s_lot=起始手数;
             if(OrderSend(Symbol(),1,起始手数,Bid,划点,0,Bid-止盈点数*pt,订单备注,魔术号码,0,Red)>0)
             {
                for(i=1; i<加码层数; i++)
                {
                    if(使用加码策略)
                    { s_lot=NormalizeDouble(起始手数*MathPow(加码倍数,i),prec); 
                      ticket=OrderSend(Symbol(),3,s_lot,Bid+(网格间距*i)*pt,划点,0,(Bid+(网格间距*i)*pt)-止盈点数*pt,订单备注,魔术号码,0,Red);                                                    //3=Sell Limit挂单
                    }
                    else              
                    { s_lot=NormalizeDouble(起始手数+不加码增加值*i,prec);
                      ticket=OrderSend(Symbol(),3,s_lot,Bid+(网格间距*i)*pt,划点,0,(Bid+(网格间距*i)*pt)-止盈点数*pt,订单备注,魔术号码,0,Red); 
                    }
                }//for 开卖单网格结束
             }//if 开卖单成功
          }//if(使用止盈止损) 
          else                                                             //不止盈止损
          {
             s_lot=起始手数;
             if(OrderSend(Symbol(),1,起始手数,Bid,划点,0,0,订单备注,魔术号码,0,Red)>0)
             {
                for(i=1; i<加码层数; i++)
                {
                    if(使用加码策略)
                    { s_lot=NormalizeDouble(起始手数*MathPow(加码倍数,i),prec); 
                      ticket=OrderSend(Symbol(),3,s_lot,Bid+(网格间距*i)*pt,划点,0,0,订单备注,魔术号码,0,Red); 
                    }
                    else                                                //不加码
                    { s_lot=NormalizeDouble(起始手数+不加码增加值*i,prec);         
                      ticket=OrderSend(Symbol(),3,s_lot,Bid+(网格间距*i)*pt,划点,0,0,订单备注,魔术号码,0,Red); 
                    }
                }//for 开卖单网格结束
             }//if 卖单下单成功
          }//else //不止盈止损     
        }//else //不隐形
        if(b对冲==true) ticket=OrderSend(Symbol(),0,s_lot*hf,Ask,划点,0,Ask+对冲止盈点数,"使用对冲",魔术号码,0,Blue);     //0=买单
     } // if 开卖单结束 
   }//if(正常单总数==0 && a==0 && 对冲单总数==0)                             //开单结束
//+------------------------------------------------------------------+
   if(使用隐形模式 && 正常单总数>0 && 正常单总数<加码层数 && 对冲单总数==0)     //还没对冲的时候,且只在隐形模式下             
   {                                                                    
     int type; 
     double op, 上单手数; 
     for(i=0; i<OrdersTotal(); i++)
     {
         cg = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
         if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=魔术号码) continue;       //隐形模式下,没有挂单
         type=OrderType();
         op=OrderOpenPrice();
         上单手数=OrderLots();
     }//for
     //---
     if(type==0 && 买卖信号()==buy && Ask<=op-网格间距*pt && Close_All==false) // 又出现买入信号,且在上单以下网格间距开外,则继续开买单(逆势加码)
     {
        if(使用止盈止损)
        {
           if(使用加码策略)
           { s_lot=NormalizeDouble(上单手数*加码倍数,prec);               //加码倍数=2
             ticket=OrderSend(Symbol(),0,s_lot,Ask,划点,0,Ask+止盈点数*pt,订单备注,魔术号码,0,Blue); 
           }
           else                                                         //不加码         
           { s_lot=NormalizeDouble(上单手数+不加码增加值,prec); 
             ticket=OrderSend(Symbol(),0,s_lot,Ask,划点,0,Ask+止盈点数*pt,订单备注,魔术号码,0,Blue); 
           }
        }//if(使用止盈止损)
        else                                                             //如果不使用止盈止损的话
        {
           if(使用加码策略)
           { s_lot=NormalizeDouble(上单手数*加码倍数,prec); 
             ticket=OrderSend(Symbol(),0,s_lot,Ask,划点,0,0,订单备注,魔术号码,0,Blue); 
           }
           else                                                          //不加码            
           { s_lot=NormalizeDouble(上单手数+不加码增加值,prec); 
             ticket=OrderSend(Symbol(),0,s_lot,Ask,划点,0,0,订单备注,魔术号码,0,Blue); 
           }
        }//else //如果不使用止盈止损的话
        
        if(s对冲==true) ticket=OrderSend(Symbol(),1,s_lot*hf,Bid,划点,0,Bid-对冲止盈点数,"使用对冲",魔术号码,0,Red); //反冲使用卖单
     }                                                                  //买单加码结束
     //---
     if(type==1 && 买卖信号()==sell && Bid>=op+网格间距*pt && Close_All==false) //又出现卖的信号,且在上单+网格间距开外,则继续开卖单(逆势加码)
     {
        if( 使用止盈止损 )
        {
           if(使用加码策略)
           { s_lot=NormalizeDouble(上单手数*加码倍数,prec); 
             ticket=OrderSend(Symbol(),1,s_lot,Bid,划点,0,Bid-止盈点数*pt,订单备注,魔术号码,0,Red); 
            }
           else              
           { s_lot=NormalizeDouble(上单手数+不加码增加值,prec); 
             ticket=OrderSend(Symbol(),1,s_lot,Bid,划点,0,Bid-止盈点数*pt,订单备注,魔术号码,0,Red); 
           }
        }//if(使用止盈止损)
        else                                                            //如果不使用止盈止损的话
        {
           if(使用加码策略)
           { s_lot=NormalizeDouble(上单手数*加码倍数,prec);               //prec的作用是根据平台不同,调整位数
             ticket=OrderSend(Symbol(),1,s_lot,Bid,划点,0,0,订单备注,魔术号码,0,Red); 
           }
           else              
           { s_lot=NormalizeDouble(上单手数+不加码增加值,prec); 
             ticket=OrderSend(Symbol(),1,s_lot,Bid,划点,0,0,订单备注,魔术号码,0,Red); 
           }
        }//else //如果不使用止盈止损的话
        
        if(b对冲==true) ticket=OrderSend(Symbol(),0,s_lot*hf,Ask,划点,0,Ask+对冲止盈点数,"使用对冲",魔术号码,0,Blue); 
     }//卖单加码结束
   }//逆势加码结束
//+------------------------------------------------------------------+
   double 甲类订单手数总和=0,对冲订单手数总和,订单手数总和,待对冲手数; cnt=0;                         
   for(cnt=0; cnt<=OrdersTotal(); cnt++)
   {
      cg = OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==魔术号码 && OrderType()<2)
      {
         if((标识=="B" && OrderType()==1) || (标识=="S" && OrderType()==0)) 对冲订单手数总和+=OrderLots(); 
         订单手数总和+=OrderLots(); 
         甲类订单手数总和=订单手数总和-对冲订单手数总和;
         待对冲手数=甲类订单手数总和-对冲订单手数总和;
      }
   }//for
//+------------------------------------------------------------------+
   if(使用止盈止损 && total()>1)                                          //缺省不使用该功能
   {
     double s_l, t_p;
     for(i=0; i<OrdersTotal(); i++)
     {
         cg = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
         if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=魔术号码 || OrderType()>1) continue; //不考虑挂单
         type=OrderType();
         s_l =OrderStopLoss();
         t_p =OrderTakeProfit();
     }
     for(i=OrdersTotal()-1; i>=0; i--)
     {
       cg = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
       if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=魔术号码 || OrderType()>1) continue;  //非当前货币,或魔术号码不对,或挂单,
       if(OrderType()==type)
       {
          if(OrderStopLoss()!=s_l || OrderTakeProfit()!=t_p)
             cg = OrderModify(OrderTicket(),OrderOpenPrice(),s_l,t_p,0,CLR_NONE);
       }
     }//for 循环结束
   }//if 功能块结束
//+------------------------------------------------------------------+
  double 已挣=0;
  for( i=0; i<OrdersTotal(); i++)
  { 
      cg = OrderSelect(i,SELECT_BY_POS,MODE_HISTORY);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=魔术号码 )  continue;
      已挣 +=OrderProfit();
   }
   double 浮赢=0;
   for(i=0; i<OrdersTotal(); i++)
   {
      cg = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=魔术号码 || OrderType()>1) continue;
      浮赢 +=OrderProfit();
   }
   if(浮赢>=止盈钱数 || a>0) 
   {
      closeall();
      closeall();
      closeall();                                                         //为了彻底删除订单,删除后,置状态a的次数,确认total()为零
      a++;
      if(total()==0) a=0;
   }
//----
   Comment("操作方向 = ",opt,"  |  LEVEL = ",正常单总数,"  |  对冲LEVEL = ",使用对冲起始层次,"  |  正常手数 = ",DoubleToStr(甲类订单手数总和,2),
   "  |  对冲手数 = ",DoubleToStr(对冲订单手数总和,2),"  /  净头寸 = ",DoubleToStr(待对冲手数,2),"\n",
   "已挣钱 = ",DoubleToStr(已挣,2),"  |  浮赢 = ",DoubleToStr(浮赢,2));
//---- 
   if(!使用隐形模式 && 使用止盈止损 && total()<加码层数) closeall();        //使用隐形模式=true
//----
   if (跟踪止损标准 >0) 修改止损(跟踪止损标准);                               //跟踪止损标准=13
//----
   return(0);
}                                                                       //主函数结束
//+------------------------------------------------------------------+
double 计算日目标() //缺省是不计算
{
  int day=Day(); double res=0;
  for(int i=0; i<OrdersHistoryTotal(); i++)
  {
      bool cg = OrderSelect(i,SELECT_BY_POS,MODE_HISTORY);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=魔术号码) continue;
      if(TimeDay(OrderOpenTime())==day) res+=OrderProfit();
  }
  return(res);
}                                                                         
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
int total()
{
  int total=0;
  for(int i=0; i<OrdersTotal(); i++)
  {
      bool cg = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=魔术号码) continue;  //订单太多,不符合的跳开,这种代码可能执行起来快些
      total++;                                                              //不是当前货币兑,或者,魔术号码不对,进行下一次遍历
  }
  return(total);
}
//+------------------------------------------------------------------+
int 买卖信号()
{
  
/*bool MABUY=false;bool MASELL=false;
  bool MACDB=false;bool MACDS=false;
  bool OSMAB=false;bool OSMAS=false;
  bool CCIB=false;bool CCIS=false;*/ 
  
 double sto1 = iStochastic(Symbol(),0,K周期,D周期,滚动值,1,0,MODE_MAIN,0);
 double sto2 = iStochastic(Symbol(),0,K周期,D周期,滚动值,1,0,MODE_MAIN,1);
 double sig1 = iStochastic(Symbol(),0,K周期,D周期,滚动值,1,0,MODE_SIGNAL,0);
 double sig2 = iStochastic(Symbol(),0,K周期,D周期,滚动值,1,0,MODE_SIGNAL,1); 
 
 double Buy1_1 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_OPEN, MODE_MAIN, 现 + 0);
 double Buy1_2 = 0;
 double Buy2_1 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_CLOSE, MODE_MAIN, 现 + 2);
 double Buy2_2 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_CLOSE, MODE_SIGNAL, 现 + 2);
 double Buy3_1 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_CLOSE, MODE_MAIN, 现 + 1);
 double Buy3_2 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_CLOSE, MODE_SIGNAL, 现 + 1);

 double Sell1_1 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_OPEN, MODE_MAIN, 现 + 0);
 double Sell1_2 = 0;
 double Sell2_1 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_CLOSE, MODE_MAIN, 现 + 2);
 double Sell2_2 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_CLOSE, MODE_SIGNAL, 现 + 2);
 double Sell3_1 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_CLOSE, MODE_MAIN, 现 + 1);
 double Sell3_2 = iMACD(NULL, 0, Fast, slow, Signal, PRICE_CLOSE, MODE_SIGNAL, 现 + 1);
 
 double osma0 = iOsMA(NULL, 0, fast_ema,slow_ema,信号周期,PRICE_CLOSE, 现 + 0);
 double osma1 = iOsMA(NULL, 0, fast_ema,slow_ema,信号周期,PRICE_CLOSE, 现 + 1);
 
 double cci1 = iCCI(Symbol(),0,CCI周期,PRICE_TYPICAL,现+0);
 double cci2 = iCCI(Symbol(),0,CCI周期,PRICE_TYPICAL,现+1);



/* if (Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2) MACDB=true;
   if (Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2) MACDS=true;
   
   if (osma1 < 0 && osma0 > 0 ) OSMAB=true;
   if (osma1 > 0 && osma0 < 0 ) OSMAB=true;
   
   if (cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值) CCIB=true;
   if (cci1<CCI穿越阈值 && cci2>CCI穿越阈值) CCIS=true; 
   
    */
 
   if (使用KDJ指标) {//stochs
   if (sto1>sig1 && sto2<sig2) return (buy);
   if (sto1<sig1 && sto2>sig2) return (sell);
} 
   if(使用MACD指标){//macd
   if (Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2) return (buy);
   if (Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2) return (sell);
}
   if (使用OsMA指标){//osma
   if (osma1 < 0 && osma0 > 0) return (buy);
   if (osma1 > 0 && osma0 < 0) return (sell);
}
   if (使用CCI指标){//cci
   if (cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值) return (buy);
   if (cci1<CCI穿越阈值 && cci2>CCI穿越阈值) return (sell);
}
   if (使用MACD指标 && 使用CCI指标 /*&& 使用OsMA指标 && 使用KDJ指标*/){//macd cci
   if (Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && /*osma1 < 0 && osma0 > 0 &&*/ cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值/* && sto1>sig1 && sto2<sig2*/) return (buy);
   if (Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 && /*osma1 > 0 && osma0 < 0 &&*/ cci1<CCI穿越阈值 && cci2>CCI穿越阈值/* && sto1<sig1 && sto2>sig2*/) return (sell);
}  
   if (使用MACD指标 && 使用CCI指标 && 使用OsMA指标 /*&& 使用KDJ指标*/){//macd cci osma
   if (Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && osma1 < 0 && osma0 > 0 && cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值/* && sto1>sig1 && sto2<sig2*/) return (buy);
   if (Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 && osma1 > 0 && osma0 < 0 && cci1<CCI穿越阈值 && cci2>CCI穿越阈值/* && sto1<sig1 && sto2>sig2*/) return (sell);
}  
   if (使用MACD指标 && 使用CCI指标 && 使用OsMA指标 && 使用KDJ指标){//macd cci osma stochs
   if (Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && osma1 < 0 && osma0 > 0 && cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值 && sto1>sig1 && sto2<sig2) return (buy);
   if (Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 && osma1 > 0 && osma0 < 0 && cci1<CCI穿越阈值 && cci2>CCI穿越阈值 && osma1 > 0 && osma0 < 0 && sto1<sig1 && sto2>sig2) return (sell);
}  
   if (!使用MACD指标 && 使用CCI指标 && 使用OsMA指标 && 使用KDJ指标){//cci osma stochs   
   if (/*Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && */osma1 < 0 && osma0 > 0 && cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值 && sto1>sig1 && sto2<sig2) return (buy);
   if (/*Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 &&*/ osma1 > 0 && osma0 < 0 && cci1<CCI穿越阈值 && cci2>CCI穿越阈值 && sto1<sig1 && sto2>sig2) return (sell);
}  
   if (使用OsMA指标 && 使用KDJ指标){//osma stochs
   if (/*Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && */osma1 < 0 && osma0 > 0 && /*cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值 &&*/ sto1>sig1 && sto2<sig2) return (buy);
   if (/*Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 && */osma1 > 0 && osma0 < 0 && /*cci1<CCI穿越阈值 && cci2>CCI穿越阈值 &&*/ sto1<sig1 && sto2>sig2) return (sell);
}  
   if (使用MACD指标 && 使用KDJ指标){//macd stochs
   if (Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && /*osma1 < 0 && osma0 > 0 && cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值 &&*/ sto1>sig1 && sto2<sig2) return (buy);
   if (Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 && /*osma1 > 0 && osma0 < 0 && cci1<CCI穿越阈值 && cci2>CCI穿越阈值 &&*/ sto1<sig1 && sto2>sig2) return (sell);
}  
   if (使用MACD指标 && !使用CCI指标 && 使用OsMA指标 /*&& 使用KDJ指标*/){//macd osma// 
   if (Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && osma1 < 0 && osma0 > 0 /*&& cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值 && sto1>sig1 && sto2<sig2*/) return (buy);
   if (Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 && osma1 > 0 && osma0 < 0 /*&& cci1<CCI穿越阈值 && cci2>CCI穿越阈值 && sto1<sig1 && sto2>sig2*/) return (sell);
}  
   if (使用MACD指标 /*&& !使用CCI指标*/ && 使用OsMA指标 /*&& 使用KDJ指标*/){//macd osma stochs
   if (Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && osma1 < 0 && osma0 > 0 && /*cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值 &&*/ sto1>sig1 && sto2<sig2) return (buy);
   if (Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 && osma1 > 0 && osma0 < 0 &&/* cci1<CCI穿越阈值 && cci2>CCI穿越阈值 &&*/ sto1<sig1 && sto2>sig2) return (sell);
}  
   if (/*使用MACD指标 &&*/ 使用CCI指标 && 使用OsMA指标 /*&& 使用KDJ指标*/){//osma cci
   if (/*Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 &&*/ osma1 < 0 && osma0 > 0 && cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值/* && sto1>sig1 && sto2<sig2*/) return (buy);
   if (/*Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 &&*/ osma1 > 0 && osma0 < 0 && cci1<CCI穿越阈值 && cci2>CCI穿越阈值/* && sto1<sig1 && sto2>sig2*/) return (sell);
}  
   if (/*使用MACD指标 && */使用CCI指标 /*&& 使用OsMA指标*/ && 使用KDJ指标){//cci stochs
   if (/*Buy1_1 < Buy1_2 && Buy2_1 < Buy2_2 && Buy3_1 > Buy3_2 && osma1 < 0 && osma0 > 0 &&*/ cci1>-1*CCI穿越阈值 && cci2<-1*CCI穿越阈值 && sto1>sig1 && sto2<sig2) return (buy);
   if (/*Sell1_1 > Sell1_2 && Sell2_1 > Sell2_2 && Sell3_1 < Sell3_2 && osma1 > 0 && osma0 < 0 &&*/ cci1<CCI穿越阈值 && cci2>CCI穿越阈值 && sto1<sig1 && sto2>sig2) return (sell);
}  
  return(0);
  }
 

//+------------------------------------------------------------------+
void closeall()
{
  for(int i=OrdersTotal()-1; i>=0; i--)
  {
      bool cg = OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
      if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=魔术号码) continue; 
      Close_All=true;                                                   // Close_All Inhibit ...
      if(OrderType()>1) cg = OrderDelete(OrderTicket());                     //删除所有挂单
      else
       {
        if(OrderType()==0) cg = OrderClose(OrderTicket(),OrderLots(),Bid,划点,CLR_NONE);
        else               cg = OrderClose(OrderTicket(),OrderLots(),Ask,划点,CLR_NONE);
      }
  }
} 
 //+------------------------------------------------------------------+
//| Trailing stop procedure                                          |
//+------------------------------------------------------------------+
void 修改止损( int byPips )                                              // 缺省byPips=13点
{
  if (byPips >=5)
  {
   for (int i = 0; i < OrdersTotal(); i++) 
   {
     bool cg = OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
     if (OrderSymbol()==Symbol() && OrderMagicNumber() == 魔术号码 && OrderType()<2)  
        {
         if (   OrderType() == OP_BUY
             && Bid - OrderOpenPrice() > byPips * pt //现价高于开单价+13点
             && (OrderStopLoss() < Bid - byPips * pt  || OrderStopLoss() == 0) //止损价位低于现价下方13点以外,比如未设为0
             ) cg = OrderModify(OrderTicket(), OrderOpenPrice(), Bid - byPips * pt, OrderTakeProfit(), Red);
         if (   OrderType() == OP_SELL
             && OrderOpenPrice() - Ask > byPips * pt 
             && (OrderStopLoss() > Ask + byPips * pt || OrderStopLoss() == 0) 
             ) cg = OrderModify(OrderTicket(), OrderOpenPrice(), Ask + byPips * pt, OrderTakeProfit(), Red);
        }//if 
      }//for
  }//if
} //修改止损结束

如您喜欢此文章请点下面分享按钮↴峰汇在线 » 智能交易系统swb grid汉化版
上一篇:
下一篇:
分享到:更多 ()