使用足够多的历史数据进行测试，才能反映出一个模型的真实情况，少量的历史数据往往带有欺骗性，容易使交易者对策略进行错误的评估。

模型：金肯特纳策略

测试合约周期：铁矿15分钟

模型代码：

Params
   Numeric AvgLength(40); //三价均线参数
   Numeric AtrLength(40); //真实波幅参数
   Numeric Lots(DefaultVol); //交易手数
Vars
   NumericSeries MovAvgVal(0); //三价均线
   NumericSeries UpBand(0); //通道上轨
NumericSeries DnBand(0); //通道下轨
   NumericSeries LiquidPoint(0); //出场条件
Begin
   // 三价均线
   MovAvgVal =Ma((High + Low + Close) / 3, AvgLength);
   // 通道上轨
   UpBand = MovAvgVal + AvgTrueRange(AtrLength);
   //通道下轨
   DnBand = MovAvgVal - AvgTrueRange(AtrLength);
   // 出场条件
   LiquidPoint = MovAvgVal;
   // 画线
   PlotNumeric("movAvgVal", MovAvgVal);
   PlotNumeric("upBand", UpBand);
   PlotNumeric("DnBand", DnBand);
   // 三价均线向上，并且价格上破通道上轨，开多单
   If ( MarketPosition != 1 And MovAvgVal[1] > MovAvgVal[2] And High >= UpBand[1] ) BK(Lots, Max ( Open, UpBand[1] ) );
   // 三价均线向下，并且价格下破通道下轨，开空单
   If ( MarketPosition != -1 And MovAvgVal[1] < MovAvgVal[2] And Low <= DnBand[1] ) SK ( Lots, Min ( Open, DnBand[1] ) );
   // 持有多单时，价格下破三价均线，平多单
   If ( MarketPosition == 1 And BarsSinceEntry >= 1 And Low <= LiquidPoint[1] ) SP ( DefaultVol, Min ( Open, LiquidPoint[1] ) );
   // 持有空单时，价格上破三价均线，平空单
   If ( MarketPosition == -1 And BarsSinceEntry >= 1 And High >= LiquidPoint[1] ) BP ( DefaultVol, Max ( Open, LiquidPoint[1] ) );
End

测试1：

从16年1月1日开始测试至今，初始资金1万元，固定手数为1手

从回测报告来看，这是一个年化收益率达180%以上，最大回撤控制在40%以内，看起来还不错的策略

测试2：

将测试时间修改为从上市日起至今，则发现同样的策略竟然在15年就已经严重亏损，早就爆仓出局了。

对比分析：

回顾一下铁矿的历史数据不难发现，在14年底，铁矿有长达三个月的震荡行情，使得价格在三价均线上下反复徘徊，产生大量的连续亏损信号。事实上，在这种相对极端的行情下，很多趋势类策略都很难产生较好的收益，而我们的金肯特纳策略也恰恰无法适配从而导致爆仓。

由此可见，一个看似还不错的策略，如果没有长时间历史数据测试的支撑，在极端行情下可能会面临着很大的风险。为了避免这种情况的发生，拉长历史数据、进行样本外回测，不失为一种规避风险的方法，而这一切的基础，便是要拥有足够长时间的历史数据。

独立的算法交易模型可以利用盘口的挂单数据进行计算和判断，支持复杂且高频率的交易策略，但如果编写的高频策略未经测试直接用于实盘，也同样会使得交易风险成倍增长。

wh9可针对算法策略进行逐笔Tick精确回测，直观展示每一笔的挂单状态和行情变化，为投资者提供精准的策略检验工具。

我们可以尝试如下策略：

当前TICK的买一量大于前面三笔TICK买一量的最大值，并且价格上涨，则买入开仓。

当前TICK的卖一量大于前面三笔TICK卖一量的最大值，并且价格下跌，则卖出开仓。

开仓后60秒平仓，或5个最小变动价位止损。

源码如下：

Data
   data0:"rb1910";
Vars
//--------------------------定义普通变--------------------------
   Numeric Lots; //委托数量
   Numeric OverPrice_M;//超价参数
   Numeric MinPr;//最小变动价位
//--------------------------定义可用持仓-------------------------
   Numeric Buy_J;//多头可用今仓
   Numeric Buy_L;//多头可用老仓
   Numeric Sell_J;//空头可用今仓
   Numeric Sell_L;//空头可用老仓
//--------------------------定义全局变量-------------------------
   Global_Numeric Bid_Max;//最大买一价
   Global_Numeric BidVol_Max; //最大买一量
   Global_Numeric Ask_Max;//最大卖一价
   Global_Numeric AskVol_Max;//最大卖一量
//--------------------------定义全局变量-------------------------
   Global_Numeric PriceBid;//记录多头开仓价位
   Global_Numeric PriceBidTime;//记录多头开仓时间
   Global_Numeric PriceAsk;//记录空头开仓价位
   Global_Numeric PriceAskTime;//记录空头开仓时间
//--------------------------定义全局变量-------------------------
   Global_Numeric Coin;
   Global_Numeric KF;//开平仓控制
//--------------------------定义数据区--------------------------
   Var_TickData data1;
   Var_TickData data2;//定义数据区
Begin
   Lots = 1;//委托数量
   OverPrice_M = 1;//超价参数
   MinPr = 1;//最小变动价位
   data1 = Def_TickData("rb1910",1,4); //数据容量
   data2=Def_TickData("rb1910",1,1);
   If(data1.State == 1)
   {
      BID_Max = Max1( data1[0].Bid1, data1[1].Bid1, data1[2].Bid1);//之前3笔TICK最大买一价(不含当前TICK)
      BidVol_Max = Max1(data1[0].BidVol1,data1[1].BidVol1,data1[2].BidVol1);//之前3笔TICK最大买一量(不含当前TICK)
      Ask_Max = Max1( data1[0].Ask1, data1[1].Ask1, data1[2].Ask1);//之前3笔TICK最大卖一价(不含当前TICK)
      AskVol_Max = Max1(data1[0].AskVol1,data1[1].AskVol1,data1[2].AskVol1);//之前3笔TICK最大卖一价量(不含当前TICK)
      Coin = 1;
   }
   If (Coin == 1)
   {
      Buy_J = A_TodayBuyRemainPosition(); //获得多头可用持仓量，今仓
      Buy_L = F_BuyRemainPosition - A_TodayBuyRemainPosition(); //获得多头可用持仓量，老仓
      Sell_J = A_TodaySellRemainPosition(); //获得空头可用持仓量，今仓
      Sell_L = F_SellRemainPosition - A_TodaySellRemainPosition(); //获得空头可用持仓量，老仓
      If (((Buy_J > 0) || (Buy_L > 0)) && KF == 1)//平多头持仓条件
      {
         If ((PriceBid - data2[0].Bid1 > 5 * MinPr) || (TimeDiff(PriceBidTime,CurrentTime()) > 60))//5个价位止损或开仓超过60秒
         {
            If (Buy_J > 0)
            {
               A_SendOrder(Enum_Sell,Enum_ExitToday,Lots,data2[0].Bid1);
               //卖平今仓
            }
            Else If (Buy_L > 0)
            {
               A_SendOrder(Enum_Sell,Enum_Exit,Lots,data2[0].Bid1);
               //卖平老仓
            }
            KF=0;
         }
      }
      Else If (((Sell_J > 0) || (Sell_L > 0)) && KF == 1)//平空头持仓条件
      {
         If ((PriceAsk - data2[0].Ask1> 5 * MinPr) || (TimeDiff(PriceAskTime,CurrentTime()) > 60))//5个价位止损或开仓超过60秒
         {
            If (Sell_J > 0)
            {
               A_SendOrder(Enum_Buy,Enum_ExitToday,Lots,data2[0].Ask1);//买平今仓
            }
            Else If(Sell_L > 0)
            {
               A_SendOrder(Enum_Buy,Enum_Exit,Lots,data2[0].Ask1);//买平老仓
            }
            KF=0;
         }
      }
      Else
      {
         If (KF == 0)
         {
            If ((data2[0].BidVol1 > BidVol_Max) && (data2[0].Bid1 > Bid_Max))//当前Tick的买1量大于前三笔最大买1量，且价格上涨，买开
            {
               A_SendOrder(Enum_Buy,Enum_Entry,Lots,data2[0].Ask1 + MinPr * OverPrice_M);
               //发出委托，以对手价超M个最小变动价位买开仓
               PriceBid = data2[0].Ask1 + Minpr * OverPrice_M;
               PriceBidTime = CurrentTime();
               KF = 1;
            }
            If ((data2[0].AskVol1 > AskVol_Max) && (data2[0].Ask1 < Ask_Max))//当前Tick的卖1量大于前三笔最大卖1量，且价格下跌，卖开
            {
               A_SendOrder(Enum_Sell,Enum_Entry,Lots,data2[0].Bid1 - MinPr * OverPrice_M);
               //发出委托，以对手价超M个最小变动价位卖开仓
               PriceAsk = data2[0].Bid1 - Minpr * OverPrice_M;
               PriceAskTime = CurrentTime();
               KF = 1;
            }
         }
      }
   }
End

我们选择螺纹1910合约进行算法交易模型回测，回测日志如下：

对于大资金客户，是否有下单单量大，唯恐惊扰行情趋势的困扰？是否有欲拉动行情却缕缕付出了大量成本的困扰？这里我们以此为例通过手动下单调用算法交易的方式介绍两个案例来解决你的困扰。

策略1：通过算法根据买卖量，自动拆分大单

交易思路解析：

1、取得手动下单的合约、手数、买卖方向、开平方向；自设委托价格。

2、如果为开仓：

（1）如果为买入开仓：

分批买入，取盘口卖一量*1/2与剩余下单手数比较，取数量较小值根据盘口卖一价买入，第一批成交后，再委托第二批，直至完全成交后退出算法。

（2）如果为卖出开仓：

分批卖出，取盘口买一量*1/2与剩余下单手数比较，取数量较小值根据盘口买一价卖出，第一批成交后，再委托第二批，直至完全成交后退出算法。

3、如果为平仓：

（1）如果为买入平仓：

同买入开仓。

如果合约为上海持仓，平仓时判断今仓，优先平今。

（2）如果为卖出平仓：

同卖出开仓。

如果合约为上海持仓，平仓时判断今仓，优先平今。

源码实现：

通过右上方菜单【运行】->【算法交易运行池】->【算法交易下单】，调出算法交易下单界面，按下图所示方法实现手动下单调用算法交易：

注：①如果再次下单，会再次加载该模型，不会直接在前一个算法交易模型中继续执行。

②如果模型中含有函数Exit()，则模型执行完毕后会自动退出。

策略2：拉动行情，每次自动把买盘吃光，将行情往上拉，反之亦然。

交易思路解析：

1、取值手动下单的合约、手数、买卖方向、开平方向；自设委托价格。

2、如果为开仓：

（1）如果为买入开仓：

分批买入，取盘口卖一量与剩余下单手数比较，取数量较小值根据盘口卖一价买入。

如果盘口卖一价变化，撤单并重新委托，取盘口卖一量与该批剩余下单手数比较，取数量较小值根据盘口卖一价买入，直至完全成交完全成交后退出算法。

（2）如果为卖出开仓：

分批卖出，取盘口买一量与剩余下单手数比较，取数量较小值根据盘口买一价卖出。

如果盘口买一价变化，撤单并重新委托，取盘口买一量与该批剩余下单手数比较，取数量较小值根据盘口买一价卖出，直至完全成交完全成交后退出算法。

3、如果为平仓：

（1）如果为买入平仓：

同买入开仓。

如果合约为上海持仓，平仓时判断今仓，优先平今。

（2）如果为卖出开仓：

同卖出开仓。

如果合约为上海持仓，平仓时判断今仓，优先平今。

源码实现：

通过右上方菜单【运行】->【算法交易运行池】->【算法交易下单】，调出算法交易下单界面，按下图所示方法实现手动下单调用算法交易：

注：①如果再次下单，会再次加载该模型，不会直接在前一个算法交易模型中继续执行。

②如果模型中含有函数Exit()，则模型执行完毕后会自动退出。

算法交易也支持多账号智能分批，既可以对多个账号进行分组，设定不同的委托手数倍率，也可以根据对手盘情况实时计算每一批的总手数，实现多账号智能分批、统一管理。

例如：

我们有三个交易账号需要同时开仓，三个交易账号的委托手数倍率分别为1、1.5、2.5。我们可在多账号下单界面中勾选要参与交易的账号，并设定好下单倍率。

我们可以一键对这三个账号一起进行智能分批下单。

首先，要求每批的总手数不超过盘口对手盘量的20%。首批三个账户按照1 : 1.5 ：2.5的比例进行下单。

其次，任何一个账号第一批成交以后（三个账号不一定同时都成交），第二批委托数量为对手盘量的20%乘以该账号的比例，直到全部成交。

最后，任何一个账号如3秒未全部成交，则执行追价策略确保成交。

这样既保证了总手数不对趋势造成影响，也同时完成了三个账号的分批建仓。

代码如下：
Vars
   Global_StringArray AID; //账号
   Global_String COD; //合约编码
   Numeric X; //循环变量
   Numeric T; //时间间隔
   Numeric P; //数值比例
   Numeric BSF; //买卖方向
   Numeric EEF; //开平方向
   Numeric VLM; //交易手数
   Numeric NOW; //当前时间
   Numeric ASKP; //卖一价
   Numeric ASKV; //卖一量
   Numeric ODFLG; //挂单判断标志
   Numeric OPFLG; //模型处理标志
   Global_Numeric ADN; //账号数量
   Global_Numeric TP; //下单总倍数
   Global_Numeric KPFLG; //委托处理标志
   Global_Numeric BKDFLG; //买开处理标志
   Global_NumericArray NP; //下单倍数
   Global_NumericArray BKID; //买开委托
   Global_NumericArray BKFLG; //买开标志
   Global_NumericArray BKDEL; //买开撤单标志
   Global_NumericArray BKSM; //买开总手数
   Global_NumericArray BKM; //买开委托手数
   Global_NumericArray BKP; //买开委托价格
   Global_NumericArray BKT; //买开委托时间
Begin
//------------------------委托获取------------------------//
If(1) //委托获取
{
   If(KPFLG == 0) //如果未开启委托处理
   {
      ADN = M_GetTradeAccountNum; //账号数量
      COD = M_GetTradeContract(); //合约编码
      BSF = M_GetTradeBuySell(); //买卖方向
      EEF = M_GetTradeEntryExit(); //开平方向
      VLM = M_GetTradeVol(); //交易手数
      For X = 0 To ADN - 1 //遍历账号
      {
         AID[X] = M_GetTradeAccount(X); //账号
         NP[X] = M_GetTradeOrderRatio(X); //下单倍数
         BKSM[X] = NP[X] * VLM; //买开总手数
         TP = TP + NP[X]; //下单总倍数
      }
      If(VLM > 0 && COD.A_IsExchangeOpen() == 1) //如果交易手数大于0，且当前状态是开盘
      {
         If(BSF == Enum_Buy && EEF == Enum_Entry) //如果是买开方向
         {
            Commentary("【" + COD + "做多：手动买开" + Text(VLM) + "手！】");
            BKDFLG = 1; //开启买开处理
         }
         KPFLG = 1; //开启委托处理
      }
   }
   If(KPFLG == 1 && COD.A_IsExchangeOpen() == 1) //如果已开启委托处理，且当前状态是开盘
   {
      OPFLG = 1; //开启模型处理
   }
}
//------------------------变量赋值------------------------//
If(OPFLG == 1) //变量赋值
{
   T = 3; //时间间隔
   P = 0.2; //数值比例
   NOW = CurrentTime(); //当前时间
   ASKP = COD.Price("Ask1"); //卖一价
   ASKV = COD.Price("AskVol1"); //卖一量
}
//------------------------成交判断------------------------//
If(OPFLG == 1) //成交判断
{
   For X = 0 To ADN - 1 //遍历账号
   {
      If(BKFLG[X] == 1) //如果有买开委托
      {
         If(F_OrderStatus(BKID[X]) == Enum_Filled) //如果买开委托成交
         {
            Commentary("【" + COD + "做多：买开委托成交！" + AID[X] + "】");
            BKFLG[X] = 0; //买开标志归0
            BKDEL[X] = 0; //买开撤单标志归0
         }
         Else If(F_OrderStatus(BKID[X]) == Enum_Canceled) //如果买开委托已撤
         {
            Commentary("【" + COD + "做多：买开委托已撤！" + AID[X] + "】");
            If(F_OrderFilledLot(BKID[X]) > 0) //如果买开委托部分成交
            {
               BKM[X] = BKM[X] - F_OrderFilledLot(BKID[X]); //买开委托手数
            }
            If(BKM[X] > 0) //如果买开委托手数大于0
            {
               BKP[X] = ASKP; //买开委托价格
               Commentary("【" + COD + "做多：买开委托追价！" + AID[X] + "】");
               BKID[X] = COD.A_SendOrder(Enum_Buy,Enum_Entry,BKM[X],BKP[X],AID[X]); //发出买开委托
               BKT[X] = NOW; //买开委托时间
            }
            BKDEL[X] = 0; //买开撤单标志归0
         }
         Else If(F_OrderStatus(BKID[X]) == Enum_Declared || F_OrderStatus(BKID[X]) == Enum_FillPart) //如果买开委托挂单
         {
            If(BKDEL[X] == 0) //如果未撤单
            {
               If(TimeDiff(BKT[X],NOW) >= T) //如果时间间隔T秒
               {
                  Commentary("【" + COD + "做多：买开委托撤单！" + AID[X] + "】");
                  COD.F_DeleteOrder(F_OrderContractNo(BKID[X]),AID[X]); //撤掉买开委托挂单
                  BKDEL[X] = 1; //已发出撤掉买开委托挂单
               }
            }
         }
      }
   }
   ODFLG = 1; //挂单判断标志初始化
   For X = 0 To ADN - 1 //遍历账号
   {
      If(BKFLG[X] == 1 || BKSM[X] > 0) //如果有买开委托，或有剩余买开手数
      {
         ODFLG = 2; //存在买开委托挂单
      }
   }
   If(ODFLG == 1) //如果没有买开委托
   {
      Commentary("【" + COD + "做多：买开委托完成！】");
      BKDFLG = 0; //买开处理标志归0
      Exit(); //退出公式
   }
}
//------------------------委托处理------------------------//
If(OPFLG == 1) //委托处理
{
   If(BKDFLG == 1) //如果已开启买开处理
   {
      For X = 0 To ADN - 1 //遍历账号
      {
         If(BKFLG[X] == 0) //如果没有买开委托
         {
            If(TP > 0) //如果已取得下单总倍数
            {
               BKM[X] = Min(Floor((NP[X] / TP) * P * ASKV),BKSM[X]); //买开委托手数
            }
            If(BKM[X] > 0) //如果买开委托手数大于0
            {
               BKP[X] = ASKP; //买开委托价格
               Commentary("【" + COD + "做多：公式买开" + Text(BKM[X]) + "手！" + AID[X] + "】");
               Commentary("【" + COD + "做多：买开委托发出！" + AID[X] + "】");
               BKID[X] = COD.A_SendOrder(Enum_Buy,Enum_Entry,BKM[X],BKP[X],AID[X]); //发出买开委托
               BKSM[X] = BKSM[X] - BKM[X]; //买开总手数自减买开处理手数
               BKT[X] = NOW; //买开委托时间
               BKFLG[X] = 1; //已发出买开委托
            }
         }
      }
   }
}
End

指令价模型虽然可以定位到更好的入场点，但也会出现信号消失的问题。太晚入场，会失去好的入场时机，造成策略整体收益下降；过早入场，可能会频繁出现信号消失，导致恢复持仓成本的增加。我们需要找到两者之间的平衡点，使模型获得相对较高的收益。

我们尝试使用出现信号立刻下单，信号消失且连续T秒没有再次出现则恢复持仓的策略：

Vars
   Numeric N; //下单手数
   Numeric T; //时间间隔
   Numeric SH; //平仓参数
   Numeric MA3; //3周期均线
   Numeric MA5; //5周期均线
   Numeric MA10; //10周期均线
   Numeric KCP; //K线位置
   Numeric SIGID; //指令序号
   Numeric NOW; //当前时间
   Numeric BIDP; //买一价
   Numeric ASKP; //卖一价
   Numeric BRP; //多头可用持仓
   Numeric SRP; //空头可用持仓
   Numeric OPFLG; //模型处理标志
   Numeric BKDFLG; //买开处理标志
   Numeric SKDFLG; //卖开处理标志
   Numeric BPDFLG; //买平处理标志
   Numeric SPDFLG; //卖平处理标志
   Global_Numeric SIGIDA; //记录指令序号
   Global_Numeric KCPA; //记录K线位置
   Global_Numeric KCPB; //记录K线位置

   Global_Numeric SIGF; //信号类型标志
   Global_Numeric SIGCF; //当前信号类型
   Global_Numeric SIGCN; //信号出现次数
   Global_Numeric SIGXN; //信号消失次数
   Global_Numeric SIGXT; //信号消失时间
   Global_Numeric SIGFLG; //信号处理标志
   Global_Numeric BKID; //买开委托
   Global_Numeric SKID; //卖开委托
   Global_Numeric BPID; //买平委托
   Global_Numeric SPID; //卖平委托
   Global_Numeric BKFLG; //买开标志
   Global_Numeric SKFLG; //卖开标志
   Global_Numeric BPFLG; //买平标志
   Global_Numeric SPFLG; //卖平标志
   Global_Numeric BKM; //买开委托手数
   Global_Numeric SKM; //卖开委托手数
   Global_Numeric BPM; //买平委托手数
   Global_Numeric SPM; //卖平委托手数
Setting
   SignalNoTrading:1; //出信号不下单
Begin
//------------------------处理开启------------------------//
   If(A_IsExchangeOpen() == 1) //如果是开盘状态
   {
      If(BarStatus() == 2) //如果不带入历史值
      {
         If(RunStart() == 1) //如果已初始化成功
         {
            OPFLG = 1; //开启模型处理
         }
      }
   }
//------------------------变量赋值------------------------//
   If(OPFLG == 1) //变量赋值
   {
      N = 2; //下单手数
      T = 10; //时间间隔
      KCP = CurrentBar; //K线位置
      NOW = CurrentTime(); //当前时间
      BIDP = Price("Bid1"); //买一价
      ASKP = Price("Ask1"); //卖一价
      BRP = F_BuyRemainPosition(); //多头可用持仓
      SRP = F_SellRemainPosition(); //空头可用持仓
      If(A_IsSHCode() == 1) //如果是上期所合约
      {
         SH = Enum_ExitToday; //平仓参数
      }
      Else //如果非上期所合约
      {
         SH = Enum_Exit; //平仓参数
      }
   }
//------------------------信号发出------------------------//
   If(1) //信号发出
   {
      MA3 = Ma(Close,3); //3周期均线
      MA5 = Ma(Close,5); //5周期均线
      MA10 = Ma(Close,10); //10周期均线
      PlotLine("Ma3",Ma3); //3周期均线
      PlotLine("Ma5",Ma5); //5周期均线
      PlotLine("Ma10",Ma10); //10周期均线
      If(Cross(Ma5,Ma10) == 1 && MarketPosition == 0) //如果满足做多条件
      {
         BK; //发出做多信号
      }
      Else If(CrossDown(Ma3,Ma10) == 1 && MarketPosition == 1) //如果满足平多条件
      {
         SP; //发出平多信号
      }
      Else If(CrossDown(Ma5,Ma10) == 1 && MarketPosition == 0) //如果满足做空条件
      {
         SK; //发出做空信号
      }
      Else If(Cross(Ma3,Ma10) == 1 && MarketPosition == -1) //如果满足平空条件
      {
         BP; //发出平空信号
      }
   }
//------------------------信号处理------------------------//
   If(OPFLG == 1) //信号处理
   {
      If(KCP != KCPB) //如果是新K线
      {
         If(SIGCN > 0) //如果上根K线出现信号
         {
            Commentary("【上根K线信号出现次数：" + Text(SIGCN) + "次！】");
            Commentary("【上根K线信号消失次数：" + Text(SIGXN) + "次！】");
            If(SIGFLG == 2) //如果信号已消失
            {
            Commentary("【距离信号消失时间：" + Text(TimeDiff(SIGXT,NOW)) + "秒！】");
            }
         }
         SIGCN = 0; //信号出现次数
         SIGXN = 0; //信号消失次数
         KCPB = KCP; //记录K线位置
      }
      SIGID = F_CurrentSigIndex; //指令序号

      If(SIGID != 0) //如果当笔行情发出指令
      {
         If(SIGID != SIGIDA || KCP != KCPA) //如果当前信号是未处理过的新信号
         {
            SIGIDA = SIGID; //记录指令序号
            KCPA = KCP; //记录K线位置
            If(F_CurrentSig == Sig_BK) //如果信号类型为BK
            {
            Commentary("【BK信号！】");
            BKDFLG = 1; //开启BK信号买开处理
            SIGF = 1; //BK信号已发出
            }
            Else If(F_CurrentSig == Sig_SP) //如果信号类型为SP
            {
            Commentary("【SP信号！】");
            SPDFLG = 1; //开启SP信号卖平处理
            SIGF = 2; //SP信号已发出
            }
            Else If(F_CurrentSig == Sig_SK) //如果信号类型为SK
            {
            Commentary("【SK信号！】");
            SKDFLG = 1; //开启SK信号卖开处理
            SIGF = 3; //SK信号已发出
            }
            Else If(F_CurrentSig == Sig_BP) //如果信号类型为BP
            {
            Commentary("【BP信号！】");
            BPDFLG = 1; //开启BP信号买平处理
            SIGF = 4; //BP信号已发出
            }
            SIGCN = SIGCN + 1; //信号出现次数
         }
      }
      If(KCP == KCPA) //如果是当根K线
      {
         If(SIGCF != SIGF) //如果是新的信号类型
         {
            SIGFLG = 1; //信号已发出
            SIGCF = SIGF; //当前信号类型
         }
         If(SIGFLG == 1) //如果信号已发出
         {
            If(F_CurrentSig == 0) //如果信号消失
            {
            If(SIGCF == 1) //如果当前是BK信号
            {
            Commentary("【BK信号消失！】");
            }
            Else If(SIGCF == 2) //如果当前是SP信号
            {
            Commentary("【SP信号消失！】");
            }
            Else If(SIGCF == 3) //如果当前是SK信号
            {
            Commentary("【SK信号消失！】");
            }
            Else If(SIGCF == 4) //如果当前是BP信号
            {
            Commentary("【BP信号消失！】");
            }
            SIGIDA = 0; //记录指令序号归0
            SIGXT = NOW; //信号消失时间
            SIGXN =             SIGXN + 1; //信号消失次数
            SIGFLG = 2; //信号已消失
            }
         }
      }
      If(SIGFLG == 2) //如果信号已消失
      {
         If(TimeDiff(SIGXT,NOW) <= T) //如果时间间隔T秒内
         {
            If(F_CurrentSig > 0) //如果信号出现
            {
            If(SIGCF == 1) //如果当前是BK信号
            {
            Commentary("【BK信号重现！】");
            }
            Else If(SIGCF == 2) //如果当前是SP信号
            {
            Commentary("【SP信号重现！】");
            }
            Else If(SIGCF == 3) //如果当前是SK信号
            {
            Commentary("【SK信号重现！】");
            }
            Else If(SIGCF == 4) //如果当前是BP信号
            {
            Commentary("【BP信号重现！】");
            }
            Commentary("【距离信号消失时间：" + Text(TimeDiff(SIGXT,NOW)) + "秒！】");
            SIGFLG = 1; //信号已发出
            }
         }
         Else If(TimeDiff(SIGXT,NOW) > T) //如果时间间隔T秒
         {
            If(SIGCF == 1) //如果当前是BK信号
            {
            Commentary("【BK信号取消！】");
            SPDFLG = 2; //开启BK信号卖平处理
            }
            Else If(SIGCF == 2) //如果当前是SP信号
            {
            Commentary("【SP信号取消！】");
            BKDFLG = 2; //开启SP信号买开处理
            }
            Else If(SIGCF == 3) //如果当前是SK信号
            {
            Commentary("【SK信号取消！】");
            BPDFLG = 2; //开启SK信号买平处理
            }
            Else If(SIGCF == 4) //如果当前是BP信号
            {
            Commentary("【BP信号取消！】");
            SKDFLG = 2; //开启BP信号卖开处理
            }
            Commentary("【距离信号消失时间：" + Text(TimeDiff(SIGXT,NOW)) + "秒！】");
            SIGFLG = 0; //信号已取消
         }
      }
   }
//------------------------成交判断------------------------//
   If(OPFLG == 1) //成交判断
   {
      If(BKFLG > 0) //如果有买开委托
      {
         If(F_OrderStatus(BKID) == Enum_Filled) //如果买开委托成交
         {
            If(BKFLG == 1) //如果是BK信号买开委托
            {
            Commentary("【BK信号：买开委托成交！】");
            }
            Else If(BKFLG == 2) //如果是SP信号买开委托
            {
            Commentary("【SP信号：买开委托成交！】");
            }
            BKFLG = 0; //买开标志归0
         }
      }
      If(SPFLG > 0) //如果有卖平委托
      {
         If(F_OrderStatus(SPID) == Enum_Filled) //如果卖平委托成交
         {
            If(SPFLG == 1) //如果是SP信号卖平委托
            {
            Commentary("【SP信号：卖平委托成交！】");
            }
            Else If(SPFLG == 2) //如果是BK信号卖平委托
            {
            Commentary("【BK信号：卖平委托成交！】");
            }
            SPFLG = 0; //卖平标志归0
         }
      }
      If(SKFLG > 0) //如果有卖开委托
      {
         If(F_OrderStatus(SKID) == Enum_Filled) //如果卖开委托成交
         {
            If(SKFLG == 1) //如果是SK信号卖开委托
            {
            Commentary("【SK信号：卖开委托成交！】");
            }
            Else If(SKFLG == 2) //如果是BP信号卖开委托
            {
            Commentary("【BP信号：卖开委托成交！】");
            }
            SKFLG = 0; //卖开标志归0
         }
      }
      If(BPFLG > 0) //如果有买平委托
      {
         If(F_OrderStatus(BPID) == Enum_Filled) //如果买平委托成交
         {
            If(BPFLG == 1) //如果是BP信号买平委托
            {
            Commentary("【BP信号：买平委托成交！】");
            }
            Else If(BPFLG == 2) //如果是SK信号买平委托
            {
            Commentary("【SK信号：买平委托成交！】");
            }
            BPFLG = 0; //买平标志归0
         }
      }
   }
//------------------------委托处理------------------------//
   If(OPFLG == 1) //委托处理
   {
      If(BKDFLG > 0) //如果已开启买开处理
      {
         If(BKFLG == 0) //如果没有买开委托
         {
            BKM = N - BRP; //买开委托手数
            If(BKM > 0) //如果买开委托手数大于0
            {
            If(BKDFLG == 1) //如果是BK信号买开
            {
            Commentary("【BK信号：买开委托发出！】");
            }
            Else If(BKDFLG == 2) //如果是SP信号买开
            {
            Commentary("【SP信号：买开委托发出！】");
            }
            BKID = A_SendOrder(Enum_Buy,Enum_Entry,BKM,ASKP); //发出买开委托
            BKFLG = BKDFLG; //已发出买开委托
            }
         }
      }
      If(SPDFLG > 0) //如果已开启卖平处理
      {
         If(SPFLG == 0) //如果没有卖平委托
         {
            If(BRP > 0) //如果有多头可用持仓
            {
            SPM = BRP; //卖平委托手数
            If(SPDFLG == 1) //如果是SP信号卖平
            {
            Commentary("【SP信号：卖平委托发出！】");
            }
            Else If(SPDFLG == 2) //如果是BK信号卖平
            {
            Commentary("【BK信号：卖平委托发出！】");
            }
            SPID = A_SendOrder(Enum_Sell,SH,SPM,BIDP); //发出卖平委托
            SPFLG = SPDFLG; //已发出卖平委托
            }
         }
      }
      If(SKDFLG > 0) //如果已开启卖开处理
      {
         If(SKFLG == 0) //如果没有卖开委托
         {
            SKM = N - SRP; //卖开委托手数
            If(SKM > 0) //如果卖开委托手数大于0
            {
            If(SKDFLG == 1) //如果是SK信号卖开
            {
            Commentary("【SK信号：卖开委托发出！】");
            }
            Else If(SKDFLG == 2) //如果是BP信号卖开
            {
            Commentary("【BP信号：卖开委托发出！】");
            }
            SKID = A_SendOrder(Enum_Sell,Enum_Entry,SKM,BIDP); //发出卖开委托
            SKFLG = SKDFLG; //已发出卖开委托
            }
         }
      }
      If(BPDFLG > 0) //如果已开启买平处理
      {
         If(BPFLG == 0) //如果没有买平委托
         {
            If(SRP > 0) //如果有空头可用持仓
            {
            BPM = SRP; //买平委托手数
            If(BPDFLG == 1) //如果是BP信号买平
            {
            Commentary("【BP信号：买平委托发出！】");
            }
            Else If(BPDFLG == 2) //如果是SK信号买平
            {
            Commentary("【SK信号：买平委托发出！】");
            }
            BPID = A_SendOrder(Enum_Buy,SH,BPM,ASKP); //发出买平委托
            BPFLG = BPDFLG; //已发出买平委托
            }
         }
      }
   }
End

该策略可以记录上一根k线信号出现和消失的次数及信号消失的时间。据此可以帮助交易者了解该策略信号消失的频率，并通过调整信号的确认时间，来减小恢复持仓的成本。

策略运行：

随着量化交易资金规模逐渐增大，在交易过程中，很有可能出现一次下单手数过多导致无法成交或直接将价格打穿的情况。

对量化交易策略附加智能分批算法，可在下单时由系统自动拆分成合适的小单进行分批委托，避免影响趋势。同时可配合滑点控制算法，当价差过大时自动放弃后续委托，起到控制摩擦成本的目的。

例如：

当出现买入信号时，我们可以使用对手盘的挂单量计算每批手数，每次委托手数为对手盘挂单量的20%，委托发出3秒后撤掉未成交挂单，并按照新的价格重新委托，直到全部成交。同时设定10个最小变动价位的滑点范围，超出范围自动撤单并停止后续交易。

源码如下：
Data
   COD:"cu2005"; //合约编码
Vars
   Numeric N; //下单手数
   Numeric KN; //单笔限制手数
   Numeric M; //价位倍数
   Numeric T; //时间间隔
   Numeric P; //数值比例
   Numeric NOW; //当前时间
   Numeric NEWP; //最新价
   Numeric ASKP; //卖一价
   Numeric ASKV; //卖一量
   Numeric MINP; //最小变动价位
   Numeric OPFLG; //模型处理标志
   Global_Numeric BCFLG; //多头处理标志
   Global_Numeric BKDFLG; //买开处理标志
   Global_Numeric BKID; //买开委托
   Global_Numeric BKFLG; //买开标志
   Global_Numeric BKDEL; //买开撤单标志
   Global_Numeric BKSM; //买开委托总手数
   Global_Numeric BKNP; //买开最新价
   Global_Numeric BKM; //买开委托手数
   Global_Numeric BKP; //买开委托价格
   Global_Numeric BKT; //买开委托时间
Begin
//------------------------处理开启------------------------//
If(A_IsExchangeOpen() == 1) //如果是开盘状态
{
   OPFLG = 1; //开启模型处理
}
//------------------------变量赋值------------------------//
If(OPFLG == 1) //变量赋值
{
   N = 5000; //下单手数
   KN = 20; //单笔限制手数
   M = 10; //价位倍数
   T = 3; //时间间隔
   P = 0.2; //数值比例
   NOW = CurrentTime(); //当前时间
   NEWP = Price("New"); //最新价
   ASKP = Price("Ask1"); //卖一价
   ASKV = Price("AskVol1"); //卖一量
   MINP = Price("MinPrice"); //最小变动价位
}
//------------------------成交判断------------------------//
If(OPFLG == 1) //成交判断
{
   If(BKFLG == 1) //如果有买开委托
   {
      If(F_OrderStatus(BKID) == Enum_Filled) //如果买开委托成交
      {
         Commentary("【多头开仓：买开委托成交！】");
         If(BKSM == 0) //如果没有剩余买开手数
         {
            Commentary("【多头开仓：买开委托完成！】");
            BCFLG = 3; //已完成多头开仓
         }
         BKFLG = 0; //买开标志归0
         BKDEL = 0; //买开撤单标志归0
      }
      Else If(F_OrderStatus(BKID) == Enum_Canceled) //如果买开委托已撤
      {
         Commentary("【多头开仓：买开委托已撤！】");
         If(BKDEL == 1) //如果是追价撤单
         {
            If(F_OrderFilledLot(BKID) > 0) //如果买开委托部分成交
            {
               BKM = BKM - F_OrderFilledLot(BKID); //买开委托手数
            }
            If(BKM > 0) //如果买开委托手数大于0
            {
               BKP = ASKP; //买开委托价格
               Commentary("【多头开仓：买开委托追价！】");
               BKID = A_SendOrder(Enum_Buy,Enum_Entry,BKM,BKP); //发出买开委托
               BKT = NOW; //买开委托时间
            }
            }
            Else If(BKDEL == 2 || BKDEL == 3 || BKDEL == 4) //如果是多头开仓撤单
            {
               BKFLG = 0; //买开标志归0
            }
            BKDEL = 0; //买开撤单标志归0
      }
      Else If(F_OrderStatus(BKID) == Enum_Declared || F_OrderStatus(BKID) == Enum_FillPart) //如果买开委托挂单
      {
            If(BKDEL == 0) //如果未撤单
            {
            If(TimeDiff(BKT,NOW) >= T) //如果时间间隔T秒
            {
               Commentary("【多头开仓：买开委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(BKID)); //撤掉买开委托挂单
               BKDEL = 1; //已发出撤掉买开委托挂单
               }
            }
            Else If(BKDEL == 3) //如果是多头开仓撤单
            {
            Commentary("【多头开仓：买开委托撤单！】");
            F_DeleteOrder(F_OrderContractNo(BKID)); //撤掉买开委托挂单
            BKDEL = 4; //多头开仓撤掉买开委托挂单
         }
      }
   }
}
//------------------------多头处理-----------------------//
If(OPFLG == 1) //多头处理
{
   If(BCFLG == 0) //如果未执行多头开仓
   {
      BKSM = N; //买开总手数
      BKNP = NEWP; //买开最新价
      BKDFLG = 1; //开启买开处理
      BCFLG = 1; //已发出多头开仓
   }
   Else If(BCFLG == 1) //如果已发出多头开仓
   {
      If(Abs(NEWP - BKNP) > M * MINP) //如果滑点超过M个价位
      {
         Commentary("【多头开仓：滑点超过" + Text(M) + "点！】");
         If(BKFLG == 1) //如果有买开委托
         {
            If(BKDEL == 0) //如果未撤单
            {
               If(F_OrderStatus(BKID) == Enum_Declared || F_OrderStatus(BKID) == Enum_FillPart) //如果买开委托挂单
               {
               Commentary("【多头开仓：买开委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(BKID)); //撤掉买开委托挂单
               BKDEL = 2; //多头开仓撤掉买开委托挂单
               }
               Else //如果买开委托未挂单
               {
                  BKDEL = 3; //多头开仓撤掉买开委托挂单
               }
            }
            Else //如果已发出撤单
            {
               BKDEL = 3; //多头开仓撤掉买开委托挂单
            }
         }
         BKDFLG = 0; //买开处理标志归0
            BCFLG = 2; //已发出多头撤单
      }
   }
   If(BCFLG == 2) //如果已发出多头撤单

   {
      If(BKFLG == 0) //如果没有买开委托
      {
         Commentary("【多头开仓：买开委托取消！】");
         BCFLG = 3; //已完成多头开仓
      }
   }
}
//------------------------委托处理------------------------//
If(OPFLG == 1) //委托处理
{
   If(BKDFLG == 1) //如果已开启买开处理
   {
      If(BKFLG == 0) //如果没有买开委托
      {
         BKM = Min1(Floor(P * ASKV),KN,BKSM); //买开委托手数
         If(BKM > 0) //如果买开委托手数大于0
         {
            BKP = ASKP; //买开委托价格
            Commentary("【多头开仓：买开委托发出！】");
            BKID = A_SendOrder(Enum_Buy,Enum_Entry,BKM,BKP); //发出买开委托
            BKSM = BKSM - BKM; //买开总手数
            BKT = NOW; //买开委托时间
            BKFLG = 1; //已发出买开委托
         }
         If(BKSM == 0) //如果没有剩余买开手数
         {
            BKDFLG = 0; //买开处理标志归0
         }
      }
   }
}
End

模型的成交滑点已经越来越受到交易者的重视，在实际交易过程中，我们往往会用到追价下单，而单一的追价模式，遇到极端行情会无限制的撤单重发，导致成交滑点不断增大，那么我们是否可以尝试给追价设定一个范围，在保证正常交易的前提下，尽可能的减少滑点呢？

下面这个策略，我们采用了对价委托连续追价，并限定了当价格偏离初始价格过大时不再追价的方式。且在停止追价后，对后续交易进行细化处理：如果是开仓委托，则撤单终止交易；如果是平仓委托，则最后一次委托采用市价，保证尽快离场。

代码如下：

Vars
   Numeric N; //下单手数
   Numeric T; //时间间隔
   Numeric W; //委托价位倍数
   Numeric PLM; //偏离价位倍数
   Numeric SH; //平仓参数
   Numeric MA3; //3周期均线
   Numeric MA5; //5周期均线
   Numeric MA10; //10周期均线
   Numeric KCP; //K线位置
   Numeric SIGID; //指令序号
   Numeric NOW; //当前时间
   Numeric NEWP; //最新价
   Numeric BIDP; //买一价
   Numeric ASKP; //卖一价
   Numeric RLP; //涨停价
   Numeric FLP; //跌停价
   Numeric MINP; //最小变动价位
   Numeric BRP; //多头可用持仓
   Numeric SRP; //空头可用持仓
   Numeric OPFLG; //模型处理标志
   Numeric BKDFLG; //买开处理标志
   Numeric SKDFLG; //卖开处理标志
   Numeric BPDFLG; //买平处理标志
   Numeric SPDFLG; //卖平处理标志
   Global_Numeric SIGIDA; //记录指令序号
   Global_Numeric KCPA; //记录K线位置
   Global_Numeric BKID; //买开委托
   Global_Numeric SKID; //卖开委托
   Global_Numeric BPID; //买平委托
   Global_Numeric SPID; //卖平委托
   Global_Numeric BKFLG; //买开标志
   Global_Numeric SKFLG; //卖开标志
   Global_Numeric BPFLG; //买平标志
   Global_Numeric SPFLG; //卖平标志
   Global_Numeric BKDEL; //买开撤单标志
   Global_Numeric SKDEL; //卖开撤单标志
   Global_Numeric BPDEL; //买平撤单标志
   Global_Numeric SPDEL; //卖平撤单标志
   Global_Numeric BKCP; //买开初始价格
   Global_Numeric SKCP; //卖开初始价格
   Global_Numeric BPCP; //买平初始价格
   Global_Numeric SPCP; //卖平初始价格
   Global_Numeric BKM; //买开委托手数
   Global_Numeric SKM; //卖开委托手数
   Global_Numeric BPM; //买平委托手数
   Global_Numeric SPM; //卖平委托手数
   Global_Numeric BKP; //买开委托价格
   Global_Numeric SKP; //卖开委托价格
   Global_Numeric BPP; //买平委托价格
   Global_Numeric SPP; //卖平委托价格
   Global_Numeric BKT; //买开委托时间
   Global_Numeric SKT; //卖开委托时间
   Global_Numeric BPT; //买平委托时间
   Global_Numeric SPT; //卖平委托时间
Setting
   SignalNoTrading:1; //出信号不下单
Begin
//------------------------处理开启------------------------//
   If(A_IsExchangeOpen() == 1) //如果是开盘状态
   {
      If(BarStatus() == 2) //如果不带入历史值
      {
         If(RunStart() == 1) //如果已初始化成功
         {
            OPFLG = 1; //开启模型处理
         }
      }
   }
//------------------------变量赋值------------------------//
   If(OPFLG == 1) //变量赋值
   {
      N = 2; //下单手数
      T = 5; //时间间隔
      PLM = 3; //偏离价位倍数
      KCP = CurrentBar; //K线位置
      NOW = CurrentTime(); //当前时间
      NEWP = Price("New"); //最新价
      BIDP = Price("Bid1"); //买一价
      ASKP = Price("Ask1"); //卖一价
      RLP = Price("RiseLimit"); //涨停价
      FLP = Price("FallLimit"); //跌停价
      MINP = Price("MinPrice"); //最小变动价位
      BRP = F_BuyRemainPosition(); //多头可用持仓
      SRP = F_SellRemainPosition(); //空头可用持仓
      If(A_IsSHCode() == 1) //如果是上期所合约
      {
         SH = Enum_ExitToday; //平仓参数
      }
      Else //如果非上期所合约
      {
         SH = Enum_Exit; //平仓参数
      }
   }
//------------------------信号发出------------------------//
   If(1) //信号发出
   {
      MA3 = Ma(Close,3); //3周期均线
      MA5 = Ma(Close,5); //5周期均线
      MA10 = Ma(Close,10); //10周期均线
      PlotLine("Ma3",Ma3); //3周期均线
      PlotLine("Ma5",Ma5); //5周期均线
      PlotLine("Ma10",Ma10); //10周期均线
      If(Ref(Cross(Ma5,Ma10),1) == 1 && MarketPosition == 0) //如果满足做多条件
      {
         BK; //发出做多信号
      }
      Else If(Ref(CrossDown(Ma3,Ma10),1) == 1 && MarketPosition == 1) //如果满足平多条件
      {
         SP; //发出平多信号
      }
      Else If(Ref(CrossDown(Ma5,Ma10),1) == 1 && MarketPosition == 0) //如果满足做空条件
      {
         SK; //发出做空信号
      }
      Else If(Ref(Cross(Ma3,Ma10),1) == 1 && MarketPosition == -1) //如果满足平空条件
      {
         BP; //发出平空信号
      }
   }
//------------------------信号处理------------------------//
   If(OPFLG == 1) //信号处理
   {
      SIGID = F_CurrentSigIndex; //指令序号
      If(SIGID != 0) //如果当笔行情发出指令
      {
         If(SIGID != SIGIDA || KCP != KCPA) //如果当前信号是未处理过的新信号
         {
            SIGIDA = SIGID; //记录指令序号
            KCPA = KCP; //记录K线位置
            If(F_CurrentSig == Sig_BK) //如果信号类型为BK
            {
               Commentary("【BK信号！】");
               BKDFLG = 1; //开启买开处理
            }
            Else If(F_CurrentSig == Sig_SP) //如果信号类型为SP
            {
               Commentary("【SP信号！】");
               SPDFLG = 1; //开启卖平处理
            }
            Else If(F_CurrentSig == Sig_SK) //如果信号类型为SK
            {
               Commentary("【SK信号！】");
               SKDFLG = 1; //开启卖开处理
            }
            Else If(F_CurrentSig == Sig_BP) //如果信号类型为BP
            {
               Commentary("【BP信号！】");
               BPDFLG = 1; //开启买平处理
            }
         }
      }
   }
//------------------------成交判断------------------------//
   If(OPFLG == 1) //成交判断
   {
      If(BKFLG == 1) //如果有买开委托
      {
         If(F_OrderStatus(BKID) == Enum_Filled) //如果买开委托成交
         {
            Commentary("【BK信号：买开委托成交！】");
            BKFLG = 0; //买开标志归0
            BKDEL = 0; //买开撤单标志归0
         }
         Else If(F_OrderStatus(BKID) == Enum_Canceled) //如果买开委托已撤
         {
            Commentary("【BK信号：买开委托已撤！】");
            If(BKDEL == 1) //如果是价格偏离过大撤单
            {
               BKFLG = 0; //买开标志归0
            }
            Else If(BKDEL == 2) //如果是时间间隔T秒追价
            {

            If(F_OrderFilledLot(BKID) > 0) //如果买开委托部分成交
            {
               BKM = BKM - F_OrderFilledLot(BKID); //买开委托手数
            }
            If(BKM > 0) //如果买开委托手数大于0
            {
               BKP = ASKP; //买开委托价格
               Commentary("【BK信号：买开委托追价！】");
               BKID = A_SendOrder(Enum_Buy,Enum_Entry,BKM,BKP); //发出买开委托
               BKT = NOW; //买开委托时间
            }
            }
            BKDEL = 0; //买开撤单标志归0
         }
         Else If(F_OrderStatus(BKID) == Enum_Declared || F_OrderStatus(BKID) == Enum_FillPart) //如果买开委托挂单
         {
            If(BKDEL == 0) //如果未撤单
            {
            If(Abs(NEWP - BKCP) > PLM * MINP) //如果价格偏离过大
            {
               Commentary("【BK信号：价格偏离过大！】");
               Commentary("【BK信号：买开委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(BKID)); //撤掉买开委托挂单
               BKDEL = 1; //已发出撤掉买开委托挂单
            }
            Else If(TimeDiff(BKT,NOW) >= T) //如果时间间隔T秒
            {
               Commentary("【BK信号：买开委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(BKID)); //撤掉买开委托挂单
               BKDEL = 2; //已发出撤掉买开委托挂单
            }
            }
         }
      }
      If(SPFLG == 1) //如果有卖平委托
      {
         If(F_OrderStatus(SPID) == Enum_Filled) //如果卖平委托成交
         {
            Commentary("【SP信号：卖平委托成交！】");
            SPFLG = 0; //卖平标志归0
            SPDEL = 0; //卖平撤单标志归0
         }
         Else If(F_OrderStatus(SPID) == Enum_Canceled) //如果卖平委托已撤
         {
            Commentary("【SP信号：卖平委托已撤！】");
            If(F_OrderFilledLot(SPID) > 0) //如果卖平委托部分成交
            {
               SPM = SPM - F_OrderFilledLot(SPID); //卖平委托手数
            }
            If(BRP > 0 && SPM > 0 && SPM <= BRP) //如果卖平委托手数不超过多头可用持仓
            {
            If(SPDEL == 1) //如果是价格偏离过大追价
            {
               SPP = FLP; //卖平委托价格
            }
            Else If(SPDEL == 2) //如果是时间间隔T秒追价
            {
               SPP = BIDP; //卖平委托价格
               SPT = NOW; //卖平委托时间
               SPDEL = 0; //卖平撤单标志归0
            }
            Commentary("【SP信号：卖平委托追价！】");
            SPID = A_SendOrder(Enum_Sell,SH,SPM,SPP); //发出卖平委托
            }
         }
         Else If(F_OrderStatus(SPID) == Enum_Declared || F_OrderStatus(SPID) == Enum_FillPart) //如果卖平委托挂单
         {
            If(SPDEL == 0) //如果未撤单
            {
            If(Abs(NEWP - SPCP) > PLM * MINP) //如果价格偏离过大
            {
               Commentary("【SP信号：价格偏离过大！】");
               Commentary("【SP信号：卖平委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(SPID)); //撤掉卖平委托挂单
               SPDEL = 1; //已发出撤掉卖平委托挂单
            }             Else If(TimeDiff(SPT,NOW) >= T) //如果时间间隔T秒
            {
               Commentary("【SP信号：卖平委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(SPID)); //撤掉卖平委托挂单
               SPDEL = 2; //已发出撤掉卖平委托挂单
            }
            }
         }
      }
      If(SKFLG == 1) //如果有卖开委托
      {
         If(F_OrderStatus(SKID) == Enum_Filled) //如果卖开委托成交
         {
            Commentary("【SK信号：卖开委托成交！】");
            SKFLG = 0; //卖开标志归0
            SKDEL = 0; //卖开撤单标志归0
         }
         Else If(F_OrderStatus(SKID) == Enum_Canceled) //如果卖开委托已撤
         {
            Commentary("【SK信号：卖开委托已撤！】");
            If(SKDEL == 1) //如果是价格偏离过大撤单
            {
               SKFLG = 0; //卖开标志归0
            }
            Else If(SKDEL == 2) //如果是时间间隔T秒追价
            {
            If(F_OrderFilledLot(SKID) > 0) //如果卖开委托部分成交
            {
               SKM = SKM - F_OrderFilledLot(SKID); //卖开委托手数
            }
            If(SKM > 0) //如果卖开委托手数大于0
            {
               SKP = BIDP; //卖开委托价格
               Commentary("【SK信号：卖开委托追价！】");
               SKID = A_SendOrder(Enum_Sell,Enum_Entry,SKM,SKP); //发出卖开委托
               SKT = NOW; //卖开委托时间
            }
            }
            SKDEL = 0; //卖开撤单标志归0
         }
         Else If(F_OrderStatus(SKID) == Enum_Declared || F_OrderStatus(SKID) == Enum_FillPart) //如果卖开委托挂单
         {
            If(SKDEL == 0) //如果未撤单
            {
            If(Abs(NEWP - SKCP) > PLM * MINP) //如果价格偏离过大
            {
               Commentary("【SK信号：价格偏离过大！】");
               Commentary("【SK信号：卖开委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(SKID)); //撤掉卖开委托挂单
               SKDEL = 1; //已发出撤掉卖开委托挂单
            }
            Else If(TimeDiff(SKT,NOW) >= T) //如果时间间隔T秒
            {
               Commentary("【SK信号：卖开委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(SKID)); //撤掉卖开委托挂单
               SKDEL = 2; //已发出撤掉卖开委托挂单
            }
            }
         }
      }
      If(BPFLG == 1) //如果有买平委托
      {
         If(F_OrderStatus(BPID) == Enum_Filled) //如果买平委托成交
         {
            Commentary("【BP信号：买平委托成交！】");
            BPFLG = 0; //买平标志归0
            BPDEL = 0; //买平撤单标志归0
         }
         Else If(F_OrderStatus(BPID) == Enum_Canceled) //如果买平委托已撤
         {
            Commentary("【BP信号：买平委托已撤！】");
            If(F_OrderFilledLot(BPID) > 0) //如果买平委托部分成交
            {
               BPM = BPM - F_OrderFilledLot(BPID); //买平委托手数
            }
            If(SRP > 0 && BPM > 0 && BPM <= SRP) //如果买平委托手数不超过空头可用持仓
            {
            If(BPDEL == 1) //如果是价格偏离过大追价
            {
               BPP = RLP; //买平委托价格
            }
            Else If(BPDEL == 2) //如果是时间间隔T秒追价
            {
               BPP = ASKP; //买平委托价格
               BPT = NOW; //买平委托时间
               BPDEL = 0; //买平撤单标志归0
            }
            Commentary("【BP信号：买平委托追价！】");
            BPID = A_SendOrder(Enum_Buy,SH,BPM,BPP); //发出买平委托
            }
         }
         Else If(F_OrderStatus(BPID) == Enum_Declared || F_OrderStatus(BPID) == Enum_FillPart) //如果买平委托挂单
         {
            If(BPDEL == 0) //如果未撤单
            {
            If(Abs(NEWP - BPCP) > PLM * MINP) //如果价格偏离过大
            {
               Commentary("【BP信号：价格偏离过大！】");
               Commentary("【BP信号：买平委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(BPID)); //撤掉买平委托挂单
               BPDEL = 1; //已发出撤掉买平委托挂单
            }
            Else If(TimeDiff(BPT,NOW) >= T) //如果时间间隔T秒
            {
               Commentary("【BP信号：买平委托撤单！】");
               F_DeleteOrder(F_OrderContractNo(BPID)); //撤掉买平委托挂单
               BPDEL = 2; //已发出撤掉买平委托挂单
            }
         }
      }
   }
}
//------------------------委托处理------------------------//
   If(OPFLG == 1) //委托处理
   {
      If(BKDFLG == 1) //如果已开启买开处理
      {
         If(BKFLG == 0) //如果没有买开委托
         {
            BKM = N; //买开委托手数
            BKP = ASKP; //买开委托价格
            BKCP = BKP; //买开初始价格
            Commentary("【BK信号：买开委托发出！】");
            BKID = A_SendOrder(Enum_Buy,Enum_Entry,BKM,BKP); //发出买开委托
            BKT = NOW; //买开委托时间
            BKFLG = 1; //已发出买开委托
         }
      }
      If(SPDFLG == 1) //如果已开启卖平处理
      {
         If(SPFLG == 0) //如果没有卖平委托
         {
            If(BRP > 0) //如果有多头可用持仓
            {
            SPM = BRP; //卖平委托手数
            SPP = BIDP; //卖平委托价格
            SPCP = SPP; //卖平初始价格
            Commentary("【SP信号：卖平委托发出！】");
            SPID = A_SendOrder(Enum_Sell,SH,SPM,SPP); //发出卖平委托
            SPT = NOW; //卖平委托时间
            SPFLG = 1; //已发出卖平委托
            }
         }
      }
      If(SKDFLG == 1) //如果已开启卖开处理
      {
         If(SKFLG == 0) //如果没有卖开委托
         {
            SKM = N; //卖开委托手数
            SKP = BIDP; //卖开委托价格
            SKCP = SKP; //卖开初始价格
            Commentary("【SK信号：卖开委托发出！】");
            SKID = A_SendOrder(Enum_Sell,Enum_Entry,SKM,SKP); //发出卖开委托
            SKT = NOW; //卖开委托时间
            SKFLG = 1; //已发出卖开委托
         }
      }
      If(BPDFLG == 1) //如果已开启买平处理
      {
         If(BPFLG == 0) //如果没有买平委托
         {
            If(SRP > 0) //如果有空头可用持仓
            {
            BPM = SRP; //买平委托手数
            BPP = ASKP; //买平委托价格
            BPCP = BPP; //买平初始价格
            Commentary("【BP信号：买平委托发出！】");
            BPID = A_SendOrder(Enum_Buy,SH,BPM,BPP); //发出买平委托
            BPT = NOW; //买平委托时间
            BPFLG = 1; //已发出买平委托
            }
         }
      }
   }
End

运行情况：

软件中会提供几种默认止盈止损策略，但有时还是无法完全满足用户的多样性需要，算法交易模型的函数可取到盘口价格和持仓合约的信息（持仓价格、数量、和盈亏等），通过编写算法交易模型可定制属于您自己的止盈止损策略。

跟踪止盈是软件默认提供的策略，但如果希望在盈利达到一定值时再启动跟踪止盈策略，就无法实现了。那么在开仓后，算法交易模型就会开始取盘口价格和持仓价格实时监测，满足了条件会自动发平仓委托。源码如下：

//止盈止损
Data
    data0:"m1709";
Vars
    Global_Numeric N;//下单手数
    Global_Numeric M1; //价位倍数1
    Global_Numeric M2; //价位倍数2
    Global_Numeric M3; //价位倍数3
    Global_Numeric BID; //买一价
    Global_Numeric ASK; //卖一价
    Global_Numeric NEWP; //最新价
    Global_Numeric MINP; //最小变动价位
    Global_Numeric BKC; //做多条件
    Global_Numeric BKID; //买开委托
    Global_Numeric BKFLG; //买开标志
    Global_Numeric BKAP; //买开委托成交均价
    Global_Numeric BHP; //多头最高价
    Global_Numeric SPID; //卖平委托
    Global_Numeric SPFLG; //卖平标志
    Global_Numeric BRP; //多头可用持仓
    Global_Numeric BZYFLG; //多头止盈标志
Begin
    N = 2; //下单手数
    M1 = 3; //价位倍数1
    M2 = 1; //价位倍数2
    M3 = 3; //价位倍数3
    BKC = 1; //做多条件
    BID = Price("Bid1"); //买一价
    ASK = Price("Ask1"); //卖一价
    NEWP = Price("New"); //最新价
    MINP = Price("MinPrice");//最小变动价位
    BRP = F_BuyRemainPosition(); //多头可用持仓

   if(A_IsExchangeOpen() == 1) //如果当前状态是开盘
    {
       //----------------------成交判断--------------------//

      if(BKFLG == 1) //如果有买开委托
       {
          if(F_OrderStatus(BKID) == Enum_Filled) //如果买开委托成交
          {
             Commentary("【多头开仓：买开委托成交！】");
             BKAP = F_OrderFilledPrice(BKID); //买开委托成交均价
             BKFLG = 2; //买开委托已成交
          }
       }

      if(SPFLG > 0) //如果有卖平委托
       {
          if(F_OrderStatus(SPID) == Enum_Filled) //如果卖平委托成交
          {
             if(SPFLG == 1) //如果是多头止盈卖平委托
             {
                Commentary("【多头止盈：卖平委托成交！】");
             }
             else if(SPFLG == 2) //如果是多头止损卖平委托
             {
                Commentary("【多头止损：卖平委托成交！】");
             }
             BKFLG = 0; //买开标志归0
             SPFLG = 0; //卖平标志归0
             BZYFLG = 0; //多头止盈标志归0
          }
       }

      //----------------------委托处理--------------------//

      if(BKFLG == 0) //如果没有买开委托
       {
          if(BKC == 1) //如果满足做多条件
          {
             Commentary("【多头开仓：买开委托发出！】");
             BKID = A_SendOrder(Enum_Buy,Enum_Entry,N,ASK); //以对价发出N手的买开委托
             BKFLG = 1; //已发出买开委托
          }
       }

      if(BKFLG == 2 && SPFLG == 0) //如果买开委托已成交，且没有卖平委托
       {
          if(BZYFLG == 0) //如果多头止盈未开启
          {
             if(NEWP >= BKAP + M1 * MINP) //如果最新价大于等于买开委托成交均价加M1个价位
             {
                Commentary("【多头止盈：多头止盈开启！】");
                BHP = NEWP; //多头最高价设为最新价
                BZYFLG = 1; //多头止盈开启
             }
          }
          else if(BZYFLG == 1) //如果多头止盈已开启
          {
             BHP = max(NEWP,BHP); //多头最高价
             if(NEWP <= BHP - M2 * MINP) //如果最新价小于等于多头最高价减M2个价位
             {
                if(BRP > 0) //如果有多头可用持仓
                {
                   Commentary("【多头止盈：卖平委托发出！】");
                   SPID = A_SendOrder(Enum_Sell,Enum_Exit,BRP,BID); //以对价发出多头可用持仓手数的卖平委托
                   SPFLG = 1; //已发出多头止盈卖平委托
                   BZYFLG = 2; //多头止盈已卖平
                }
             }
          }
          if(BZYFLG != 2) //如果多头止盈未卖平
          {
             if(NEWP <= BKAP - M3 * MINP) //如果最新价小于等于买开委托成交均价减M3个价位
             {
                Commentary("【多头止损：卖平委托发出！】");
                SPID = A_SendOrder(Enum_Sell,Enum_Exit,BRP,BID); //以对价发出多头可用持仓手数的卖平委托
                SPFLG = 2; //已发出多头止损卖平委托
             }
          }
       }
    }
End

算法交易模型执行效果如下图所示，开仓之后满足止损平仓条件，会自动发出平仓委托：

1、什么是期权定价公式

Black-Scholes-Merton期权定价模型（Black-Scholes-Merton Option Pricing Model），即布莱克—斯克尔斯期权定价模型。

B-S-M定价公式：C=S·N(d1)-X·exp(-r·T)·N(d2)

其中:

d1=[ln(S/X)+(r+σ^2/2)T]/(σ√T) d2=d1-σ·√T

C—期权初始合理价格 X—期权执行价格

S—所交易金融资产现价T—期权有效期

r—连续复利计无风险利率

σ—股票连续复利（对数）回报率的年度波动率（标准差）

N(d1)，N(d2）—正态分布变量的累积概率分布函数，在此应当说明两点：

第一，该模型中无风险利率必须是连续复利形式。一个简单的或不连续的无风险利率(设为r0)一般是一年计息一次，而r要求为连续复利利率。r0必须转化为r方能代入上式计算。

两者换算关系为：r=LN(1+r0)或r0=exp(r)-1例如r0=0.06，则r=LN(1+0.06)=0.0583，即100以583%的连续复利投资第二年将获106，该结果与直接用r0=0.06计算的答案一致。

第二，期权有效期T的相对数表示，即期权有效天数与一年365天的比值。如果期权有效期为100天，则T=100/365=0.274。

2、年化波动率及BS公式函数计算

①计算年化波动率：

记录收盘价：CallOptions.PutOptions

计算对数Ln（今日收盘价/昨日收盘价）

计算N天的标准差：如N天标准差=STD（）

计算N天的波动率：N天的标准差*SQRT（252）

计算年化的波动率：N天波动率/SQRT(2N)

②推导理论价格计算案例

例如：某股票市价为3.84元，无风险利率为6%，年波动率为15%，求工商银行行权价为3.6元、期限为半年的欧式认购期权和认沽期权价格，其中：期限内不支付红利。

此例中S＝3.84，K＝3.6，r=0.06，σ=0.15，T=0.5。

计算过程可分为三步：

第一步，先计算出和。

第二步，计算和。由标准正态分布表可查的

则可得

第三步，将上述结果及已知条件代入B-S公式，股票欧式认购期权价格为：

欧式认沽期权价格为：

3、B-S-M模型失效或者可能误差的原因：

①模型对平值期权的估价令人满意，特别是对剩余有效期限超过两月，且不支付红利者效果更好一点。

②对于高度增值或减值的期权，模型的估价有较大偏差，会高估减值期权而低估增值期权。

③对临近到期日的期权的估价存在一定的误差。

④离散度过高或过低的情况下，会低估低离散度的买入期权，高估高离散度的买方期权。

⑤模型基于对市场部分情况的假设条件过于严苛，这与现实情况有所差别，可能会影响到模型的可靠性。

4、根据以上推导过程，编写策略模型计算期权理论价格，形成套利策略如下：

     D1 = (Ln(New_F / ExercisePrice) + (R/10 + 0.5 * Power(HistoryVolatility_F,2)) * RTS) / (HistoryVolatility_F * Power(RTS,0.5));//求期权理论价格的中间值
     D2 = D1 - HistoryVolatility_F * Power(RTS,0.5);//求期权理论价格的中间值

     TheoreticalPrice_C = New_F * NormDist(D1) - ExercisePrice * Exp(-1 * (R / 10) * RTS) * NormDist(D2);//根据B-S-M公式计算看涨期权理论价格
     TheoreticalPrice_P = ExercisePrice * Exp(-1 * (R / 10) * RTS) * (1 - NormDist(D2)) - New_F * (1 - NormDist(D1));//根据B-S-M公式计算看跌期权理论价格

     New_C = datac.Price("New");//看涨期权的最新价
     New_P = dataf.Price("New");//看跌期权的最新价

     BuyRemainPosition_C = datac.F_BuyRemainPosition();//看涨期权多头可用持仓
     BuyRemainPosition_P = datap.F_BuyRemainPosition();//看跌期权多头可用持仓
     BuyRemainPosition_F = dataf.F_BuyRemainPosition();//标的合约多头可用持仓
     SellRemainPosition_F = dataf.F_SellRemainPosition();//标的合约空头可用持仓

     If((TimeDiff(Date,datac.Price("ExpirationDate")) <= 5 || TimeDiff(Date,datap.Price("ExpirationDate")) <= 5) && (GetGlobalVar(0) == 1 || GetGlobalVar(1) == 1))
    //看涨期权或看跌期权行权日前五天
     {
             If(BuyRemainPosition_C > 0)//看涨期权有多头可用持仓
             {
                    datac.A_SendOrder(Enum_sell,Enum_Exit,BuyRemainPosition_C,datac.Price("Bid"));//对价卖平看涨期权可用多仓
             }

            If(BuyRemainPosition_P > 0)//看跌期权有多头可用持仓
             {
                    datap.A_SendOrder(Enum_Sell,Enum_Exit,BuyRemainPosition_P,datap.Price("Bid"));//对价卖平看跌期权可用多仓
             }

            If(BuyRemainPosition_F > 0)//标的合约有空头可用持仓
             {
                    dataf.A_SendOrder(Enum_Buy,Enum_Exit,BuyRemainPosition_F,dataf.Price("Ask"));//对价买平标的合约可用空仓
             }

            If(SellRemainPosition_F > 0)//标的合约有多头可用持仓
             {
                    dataf.A_SendOrder(Enum_Sell,Enum_Exit,SellRemainPosition_F,dataf.Price("Bid"));//对价卖平标的合约可用多仓
             }

            SetGlobalVar(0,0);
             SetGlobalVar(1,0);
     }

    Else
    {
       If(New_C < TheoreticalPrice_C * 0.5 && datac.Price("Stdderiation") < HistoryVolatility_C && BuyRemainPosition_C == 0 && SellRemainPosition_F == 0 && GetGlobalVar(0) == 0)
       //看涨期权的最新价低于看涨期权理论价格的50%，并且看涨期权的隐含波动率低于历史波动率，并且看涨期权没有多头持仓，对应标的合约没有空头持仓
       {
               datac.A_SendOrder(Enum_Buy,Enum_Entry,1,datac.Price("Ask"));//对价买开看涨期权1手
               dataf.A_SendOrder(Enum_Sell,Enum_Entry,1,dataf.Price("Bid"));//对价卖开标的合约1手
               SetGlobalVar(0,1);
       }

      If(TheoreticalPrice_P > New_P * 0.5 && datap.Price("Stdderiation") > HistoryVolatility_P && BuyRemainPosition_P == 0 && BuyRemainPosition_F == 0 && GetGlobalVar(1) == 0)
       //看跌期权理论价格高于看跌期权最新价的50%，并且看跌期权隐含波动率高于历史波动率，并且看跌期权没有多头持仓，对应标的合约没有多头持仓
       {
               datap.A_SendOrder(Enum_Buy,Enum_Entry,1,datap.Price("Ask"));//对价买开看跌期权1手
               dataf.A_SendOrder(Enum_buy,Enum_Entry,1,dataf.Price("Ask"));//对价买开标的合约1手
               SetGlobalVar(1,1);
       }
    }

End

套利是一种高胜率低收益的交易模式，所以交易滑点对整体收益的影响更加明显，我们可以通过算法交易，来制定多种套利下单的精细控制方式。

比如我们可以计算数据的均线和N倍标准差来确定套利交易的上轨和下轨，用于做多和平多。然后根据合约的活跃程度，设定委托的先后顺序，在优先保证不瘸腿的前提下，尽量减少成交滑点。

代码如下：

Data
   CODA:"m2001"; //第一腿合约A
   CODB:"m1909"; //第二腿合约B
Vars
   Numeric N; //下单手数
   Numeric X; //循环变量
   Numeric UDP; //上下轨比例
   Numeric SHA; //A平仓参数
   Numeric SHB; //B平仓参数
   Numeric NEWPA; //A最新价
   Numeric NEWPB; //B最新价
   Numeric BIDPA; //A买一价
   Numeric ASKPA; //A卖一价
   Numeric BIDPB; //B买一价
   Numeric ASKPB; //B卖一价
   Numeric BIDVB; //B买一量
   Numeric ASKVB; //B卖一量
   Numeric BSVB; //B买一量和
   Numeric ASVB; //B卖一量和
   Numeric MAA; //A平均值
   Numeric MAB; //B平均值
   Numeric SDA; //A标准差
   Numeric SDB; //B标准差
   Numeric UPLA; //A上轨
   Numeric UPLB; //B上轨
   Numeric DNLA; //A下轨
   Numeric DNLB; //B下轨
   Numeric TKNA; //A数据区长度
   Numeric TKNB; //B数据区长度
   Numeric BRPA; //A多头可用持仓
   Numeric SRPB; //B空头可用持仓
   Numeric OPFLG; //模型处理标志
   Numeric BKDFLGA; //A买开处理标志
   Numeric SPDFLGA; //A卖平处理标志
   Numeric SKDFLGB; //B卖开处理标志
   Numeric BPDFLGB; //B买平处理标志
   Var_TickData TKDA; //A数据区
   Var_TickData TKDB; //B数据区
   NumericArray TKPA; //A数据价格
   NumericArray TKPB; //B数据价格
   Global_Numeric BCFLG; //多头处理标志
   Global_Numeric BKIDA; //A买开委托
   Global_Numeric SPIDA; //A卖平委托
   Global_Numeric BKFLGA; //A买开标志
   Global_Numeric SPFLGA; //A卖平标志
   Global_Numeric SKIDB; //B卖开委托
   Global_Numeric BPIDB; //B买平委托
   Global_Numeric SKFLGB; //B卖开标志
   Global_Numeric BPFLGB; //B买平标志
Begin
//------------------------处理开启------------------------//
If(CODA.A_IsExchangeOpen() == 1) //如果A是开盘状态
{
   If(CODB.A_IsExchangeOpen() == 1) //如果B是开盘状态
   {
      OPFLG = 1; //开启模型处理
   }
}
//------------------------变量赋值------------------------//
If(OPFLG == 1) //变量赋值
{
   N = 2; //下单手数
   UDP = 1.645; //上下轨比例
   NEWPA = CODA.Price("New"); //A最新价
   NEWPB = CODB.Price("New"); //B最新价
   BIDPA = CODA.Price("Bid1"); //A买一价
   ASKPA = CODA.Price("Ask1"); //A卖一价
   BIDPB = CODB.Price("Bid1"); //B买一价
   ASKPB = CODB.Price("Ask1"); //B卖一价
   BIDVB = CODB.Price("BidVol1");//B买一量
   ASKVB = CODB.Price("AskVol1");//B卖一量
   TKDA = Def_TickData("m2001",1,20);//A数据区
   TKDB = Def_TickData("m1909",1,20);//B数据区
   BRPA = CODA.F_BuyRemainPosition(); //A多头可用持仓
   SRPB = CODB.F_SellRemainPosition(); //B空头可用持仓
   If(CODA.A_IsSHCode() == 1) //如果A是上期所合约
   {
      SHA = Enum_ExitToday; //A平仓参数
   }
   Else //如果A非上期所合约
   {
      SHA = Enum_Exit; //A平仓参数
   }
   If(CODB.A_IsSHCode() == 1) //如果B是上期所合约
   {
      SHB = Enum_ExitToday; //B平仓参数
   }
   Else //如果B非上期所合约
   {
      SHB = Enum_Exit; //B平仓参数
   }
   If(TKDA.State == 1) //如果A数据区有效
   {
      TKNA = TKDA.Num; //A数据区长度
      For X = 0 To TKNA - 1 //遍历A数据区
      {
         TKPA[X] = TKDA[X].TickPrice; //A数据价格
      }
   }
   If(TKDB.State == 1) //如果B数据区有效
   {
      TKNB = TKDB.Num; //B数据区长度
      For X = 0 To TKNB - 1 //遍历B数据区
      {
         TKPB[X] = TKDB[X].TickPrice; //B数据价格
      }
      For X = TKNB - 3 To TKNB - 1 //遍历B数据区
      {
         BSVB = BSVB + TKDB[X].BidVol1;//B买一量和
         ASVB = ASVB + TKDB[X].AskVol1;//B卖一量和
      }
   }
   MAA = AverageArray(TKPA); //A平均值
   MAB = AverageArray(TKPB); //B平均值
   SDA = StandardDevArray(TKPA,1); //A标准差
   SDB = StandardDevArray(TKPB,1); //B标准差
   UPLA = MAA + UDP * SDA;//A上轨
   DNLA = MAA - UDP * SDA;//A下轨
   UPLB = MAB + UDP * SDB;//B上轨
   DNLB = MAB - UDP * SDB;//B下轨
}
//------------------------成交判断------------------------//
If(OPFLG == 1) //成交判断
{
   If(BKFLGA == 1) //如果有A买开委托
   {
      If(F_OrderStatus(BKIDA) == Enum_Filled) //如果A买开委托成交
      {
         Commentary("【多头开仓：A买开委托成交！】");
         BCFLG = 2; //已完成多头开仓
         BKFLGA = 0; //A买开标志归0
      }
   }
   If(SKFLGB == 1) //如果有B卖开委托
   {
      If(F_OrderStatus(SKIDB) == Enum_Filled) //如果B卖开委托成交
      {
         Commentary("【多头开仓：B卖开委托成交！】");
         BKDFLGA = 1; //开启A买开处理
         SKFLGB = 0; //B卖开标志归0
      }
   }
   If(SPFLGA == 1) //如果有A卖平委托
   {
      If(F_OrderStatus(SPIDA) == Enum_Filled) //如果A卖平委托成交
      {
         Commentary("【多头平仓：A卖平委托成交！】");
         BCFLG = 0; //多头处理标志归0
         SPFLGA = 0; //A卖平标志归0
      }
   }
   If(BPFLGB == 1) //如果有B买平委托
   {
      If(F_OrderStatus(BPIDB) == Enum_Filled) //如果B买平委托成交
      {
         Commentary("【多头平仓：B买平委托成交！】");
         SPDFLGA = 1; //开启A卖平处理
         BPFLGB = 0; //B买平标志归0
      }
   }
}
//------------------------套利处理------------------------//
If(OPFLG == 1) //套利处理
{
   If(BCFLG == 0) //如果未执行多头开仓
   {
      If((NEWPA > UPLA && NEWPB > UPLB) || (NEWPA < DNLA && NEWPB < DNLB)) //如果满足多头开仓条件
      {
         If(BIDVB >= ASKVB / 3 && BSVB < ASVB * 2) //如果满足多头开仓条件
         {
            Commentary("【多头开仓：满足开仓条件！】");
            SKDFLGB = 1; //开启B卖开处理
            BCFLG = 1; //已执行多头开仓
         }
      }
   }
   Else If(BCFLG == 2) //如果已完成多头开仓
   {
      If((NEWPA > DNLA && NEWPA < UPLA) && (NEWPB > DNLB && NEWPB < UPLB)) //如果满足多头平仓条件
      {
         Commentary("【多头平仓：满足平仓条件！】");
         BPDFLGB = 1; //开启B买平处理
         BCFLG = 3; //已执行多头平仓
      }
   }
}
//------------------------委托处理------------------------//
If(OPFLG == 1) //委托处理
{
   If(BKDFLGA == 1) //如果已开启A买开处理
   {
      If(BKFLGA == 0) //如果没有A买开委托
      {
         Commentary("【多头开仓：A买开委托发出！】");
         BKIDA = CODA.A_SendOrder(Enum_Buy,Enum_Entry,N,ASKPA); //发出A买开委托
         BKFLGA = 1; //已发出A买开委托
      }
   }
   If(SKDFLGB == 1) //如果已开启B卖开处理
   {
      If(SKFLGB == 0) //如果没有B卖开委托
      {
         Commentary("【多头开仓：B卖开委托发出！】");
         SKIDB = CODB.A_SendOrder(Enum_Sell,Enum_Entry,N,BIDPB); //发出B卖开委托
         SKFLGB = 1; //已发出B卖开委托
      }
   }
   If(SPDFLGA == 1) //如果已开启A卖平处理
   {
      If(BRPA > 0) //如果有A多头可用持仓
      {
         Commentary("【多头平仓：A卖平委托发出！】");
         SPIDA = CODA.A_SendOrder(Enum_Sell,SHA,BRPA,BIDPA); //发出A卖平委托
         SPFLGA = 1; //已发出A卖平委托
      }
   }
   If(BPDFLGB == 1) //如果已开启B买平处理
   {
      If(SRPB > 0) //如果有B空头可用持仓
      {
         Commentary("【多头平仓：B买平委托发出！】");
         BPIDB = CODB.A_SendOrder(Enum_Buy,SHB,SRPB,ASKPB); //发出B买平委托
         BPFLGB = 1; //已发出B买平委托
      }
   }
}
End

运行效果：

很多交易者在套利交易过程中，往往更重视入场策略，通过设定不同的委托方式保证交易成功，但是任何一种委托方式，都有可能面临交易过程中价差偏移的风险，那么如何规避这种风险呢？我们不妨尝试制定一套退场策略。

在套利分批下单过程中，一旦出现价差偏离超过可承受滑点范围后，马上终止交易、暂停后续批次委托，并且根据实际情况，处理单边持仓。当单边持仓亏损时，马上进行平仓止损，降低瘸腿风险。当单边持仓盈利时，则对另一腿合约进行追价委托，尽快配成套利对，用单边的盈利弥补价差偏离的成本。

代码如下：

Data
   CODA:"m2001"; //第一腿合约A
   CODB:"m1909"; //第二腿合约B
Vars
   Numeric N; //下单手数
   Numeric T; //时间间隔
   Numeric PLM; //偏离价位倍数
   Numeric SHA; //A平仓参数
   Numeric SHB; //B平仓参数
   Numeric KCP; //开仓条件价差
   Numeric PCP; //平仓条件价差
   Numeric NOW; //当前时间
   Numeric NPC; //最新价差
   Numeric NEWPA; //A最新价
   Numeric NEWPB; //B最新价
   Numeric BIDPA; //A买一价
   Numeric ASKPA; //A卖一价
   Numeric BIDPB; //B买一价
   Numeric ASKPB; //B卖一价
   Numeric ASKVA; //A卖一量
   Numeric BIDVB; //B买一量
   Numeric MINPA; //A最小变动价位
   Numeric BPLA; //A多头持仓盈亏
   Numeric SPLB; //B空头持仓盈亏
   Numeric BRPA; //A多头可用持仓
   Numeric SRPB; //B空头可用持仓
   Numeric OPFLG; //模型处理标志
   Numeric BKDFLGA; //A买开处理标志
   Numeric SPDFLGA; //A卖平处理标志
   Numeric SKDFLGB; //B卖开处理标志
   Numeric BPDFLGB; //B买平处理标志
   Global_Numeric NPCA; //记录价差
   Global_Numeric BCFLG; //多头处理标志
   Global_Numeric CDFLG; //撤单处理标志
   Global_Numeric BKIDA; //A买开委托
   Global_Numeric SPIDA; //A卖平委托
   Global_Numeric BKFLGA; //A买开标志
   Global_Numeric SPFLGA; //A卖平标志
   Global_Numeric BKDELA; //A买开撤单标志
   Global_Numeric BKSMA; //A买开委托总手数
   Global_Numeric BKMA; //A买开委托手数
   Global_Numeric SPMA; //A卖平委托手数
   Global_Numeric BKTA; //A买开委托时间
   Global_Numeric SKIDB; //B卖开委托
   Global_Numeric BPIDB; //B买平委托
   Global_Numeric SKFLGB; //B卖开标志
   Global_Numeric BPFLGB; //B买平标志
   Global_Numeric SKDELB; //B卖开撤单标志
   Global_Numeric SKSMB; //B卖开委托总手数
   Global_Numeric SKMB; //B卖开委托手数
   Global_Numeric BPMB; //B买平委托手数
   Global_Numeric SKTB; //B卖开委托时间
Begin
//------------------------处理开启------------------------//
   If(CODA.A_IsExchangeOpen() == 1) //如果A是开盘状态
   {
      If(CODB.A_IsExchangeOpen() == 1) //如果B是开盘状态
      {
         OPFLG = 1; //开启模型处理
      }
   }
//------------------------变量赋值------------------------//
   If(OPFLG == 1) //变量赋值
   {
      N = 20; //下单手数
      T = 5; //时间间隔
      PLM = 3; //偏离价位倍数
      KCP = 5; //开仓条件价差
      PCP = 10; //平仓条件价差
      NOW = CurrentTime(); //当前时间
      NEWPA = CODA.Price("New"); //A最新价
      NEWPB = CODB.Price("New"); //B最新价
      BIDPA = CODA.Price("Bid1"); //A买一价
      ASKPA = CODA.Price("Ask1"); //A卖一价
      BIDPB = CODB.Price("Bid1"); //B买一价
      ASKPB = CODB.Price("Ask1"); //B卖一价
      ASKVA = CODA.Price("AskVol1"); //A卖一量
      BIDVB = CODB.Price("BidVol1"); //B买一量
      MINPA = CODA.Price("MinPrice"); //A最小变动价位
      NPC = NEWPA - NEWPB; //最新价差
      BPLA = CODA.F_BuyProfitLoss(); //A多头持仓盈亏
      SPLB = CODB.F_SellProfitLoss(); //B空头持仓盈亏
      BRPA = CODA.F_BuyRemainPosition(); //A多头可用持仓
      SRPB = CODB.F_SellRemainPosition(); //B空头可用持仓
      If(CODA.A_IsSHCode() == 1) //如果A是上期所合约
      {
         SHA = Enum_ExitToday; //A平仓参数
      }
      Else //如果A非上期所合约
      {
         SHA = Enum_Exit; //A平仓参数
      }
      If(CODB.A_IsSHCode() == 1) //如果B是上期所合约
      {
         SHB = Enum_ExitToday; //B平仓参数
      }
      Else //如果B非上期所合约
      {
         SHB = Enum_Exit; //B平仓参数
      }
   }
//------------------------成交判断------------------------//
   If(OPFLG == 1) //成交判断
   {
      If(BKFLGA == 1) //如果有A买开委托
      {
         If(F_OrderStatus(BKIDA) == Enum_Filled) //如果A买开委托成交
         {
         Commentary("【多头开仓：A买开委托成交！】");
         If(BKDELA == 0 || BKDELA == 1) //如果非撤单处理撤单
         {
         If(BKSMA > 0) //如果有剩余A买开委托手数
         {
         BKDFLGA = 1; //开启A买开处理
         }
         }
         Else If(BKDELA == 2) //如果是撤单处理撤单
         {
         BPDFLGB = 2; //开启B买平处理
         }
         BKFLGA = 0; //A买开标志归0
         BKDELA = 0; //A买开撤单标志归0
         }
         Else If(F_OrderStatus(BKIDA) == Enum_Canceled) //如果A买开委托已撤
         {
         Commentary("【多头开仓：A买开委托已撤！】");
         If(BKDELA == 1) //如果是追价处理撤单
         {
         If(F_OrderFilledLot(BKIDA) > 0) //如果A买开委托部分成交
         {
         BKMA = BKMA - F_OrderFilledLot(BKIDA); //A买开委托手数
         }
         If(BKMA > 0) //如果A买开委托手数大于0
         {
         Commentary("【多头开仓：A买开委托追价！】");
         BKIDA = CODA.A_SendOrder(Enum_Buy,Enum_Entry,BKMA,ASKPA); //发出A买开委托
         BKTA = NOW; //A买开委托时间
         }
         }
         Else If(BKDELA == 2) //如果是撤单处理撤单
         {
         BPDFLGB = 2; //开启B买平处理
         BKFLGA = 0; //A买开标志归0
         }
         BKDELA = 0; //A买开撤单标志归0
      }
      Else If(F_OrderStatus(BKIDA) == Enum_Declared || F_OrderStatus(BKIDA) == Enum_FillPart) //如果A买开委托挂单
      {
         If(BKDELA == 0) //如果未撤单
         {
         If(CDFLG == 1 && TimeDiff(BKTA,NOW) >= T) //如果已开启追价处理，且时间间隔T秒
         {
            Commentary("【多头开仓：A买开委托撤单！】");
            CODA.F_DeleteOrder(F_OrderContractNo(BKIDA)); //撤掉A买开委托挂单
            BKDELA = 1; //已发出撤掉A买开委托挂单
         }
         Else If(CDFLG == 2) //如果已开启撤单处理
         {
            Commentary("【多头开仓：A买开委托撤单！】");
            CODA.F_DeleteOrder(F_OrderContractNo(BKIDA)); //撤掉A买开委托挂单
            BKDELA = 2; //已发出撤掉A买开委托挂单
         }
         }
      }
      }
   If(SKFLGB == 1) //如果有B卖开委托
   {
      If(F_OrderStatus(SKIDB) == Enum_Filled) //如果B卖开委托成交
      {
         Commentary("【多头开仓：B卖开委托成交！】");
            If(SKDELB == 0 || SKDELB == 1) //如果非撤单处理撤单
         {
            If(SKSMB > 0) //如果有剩余B卖开委托手数
            {
            SKDFLGB = 1; //开启B卖开处理
            }
         }
         Else If(SKDELB == 2) //如果是撤单处理撤单
         {
            SPDFLGA = 2; //开启A卖平处理
         }
         SKFLGB = 0; //B卖开标志归0
         SKDELB = 0; //B卖开撤单标志归0
      }
      Else If(F_OrderStatus(SKIDB) == Enum_Canceled) //如果B卖开委托已撤
      {
         Commentary("【多头开仓：B卖开委托已撤！】");
         If(SKDELB == 1) //如果是追价处理撤单
         {
            If(F_OrderFilledLot(SKIDB) > 0) //如果B卖开委托部分成交
            {
            SKMB = SKMB - F_OrderFilledLot(SKIDB); //B卖开委托手数
            }
            If(SKMB > 0) //如果B卖开委托手数大于0
            {
            Commentary("【多头开仓：B卖开委托追价！】");
               SKIDB = CODB.A_SendOrder(Enum_Sell,Enum_Entry,SKMB,BIDPB); //发出B卖开委托
            SKTB = NOW; //B卖开委托时间
            }
         }
         Else If(SKDELB == 2) //如果是撤单处理撤单
         {
            SPDFLGA = 2; //开启A卖平处理
            SKFLGB = 0; //B卖开标志归0
         }
         SKDELB = 0; //B卖开撤单标志归0
      }
      Else If(F_OrderStatus(SKIDB) == Enum_Declared || F_OrderStatus(SKIDB) == Enum_FillPart) //如果B卖开委托挂单
      {
         If(SKDELB == 0) //如果未撤单
         {
            If(CDFLG == 1 && TimeDiff(SKTB,NOW) >= T) //如果已开启追价处理，且时间间隔T秒
            {
            Commentary("【多头开仓：B卖开委托撤单！】");
            CODB.F_DeleteOrder(F_OrderContractNo(SKIDB)); //撤掉B卖开委托挂单
            SKDELB = 1; //已发出撤掉B卖开委托挂单
            }
            Else If(CDFLG == 2) //如果已开启撤单处理
            {
            Commentary("【多头开仓：B卖开委托撤单！】");
            CODB.F_DeleteOrder(F_OrderContractNo(SKIDB)); //撤掉B卖开委托挂单
            SKDELB = 2; //已发出撤掉B卖开委托挂单
            }
         }
      }
      }
      If(SPFLGA == 1) //如果有A卖平委托
      {
      If(F_OrderStatus(SPIDA) == Enum_Filled) //如果A卖平委托成交
         {
         Commentary("【多头平仓：A卖平委托成交！】");
         SPFLGA = 0; //A卖平标志归0
         }
      }
      If(BPFLGB == 1) //如果有B买平委托
      {
         If(F_OrderStatus(BPIDB) == Enum_Filled) //如果B买平委托成交
         {
         Commentary("【多头平仓：B买平委托成交！】");
         BPFLGB = 0; //B买平标志归0
         }
      }
   }
//------------------------套利处理------------------------//
   If(OPFLG == 1) //套利处理
   {
      If(BCFLG == 0) //如果未执行多头开仓
      {
      If(NPC <= KCP) //如果满足多头开仓条件
      {
         Commentary("【多头开仓：满足开仓条件！】");
         NPCA = NPC; //记录价差
         BKSMA = N; //A买开委托总手数
         SKSMB = N; //B卖开委托总手数
         BKDFLGA = 1; //开启A买开处理
         SKDFLGB = 1; //开启B卖开处理
         CDFLG = 0; //撤单处理标志归0
         BCFLG = 1; //已执行多头开仓
      }
      }
      Else If(BCFLG == 1) //如果已执行多头开仓
      {
         If((BKFLGA == 0 && BKSMA == 0) && (SKFLGB == 0 && SKSMB == 0)) //如果已完成多头开仓
         {
         Commentary("【多头开仓：多头开仓完成！】");
         BCFLG = 2; //已完成多头开仓
         }
         Else If(BKFLGA == 0 && BKSMA == 0) //如果A已完成多头开仓
         {
         If(Abs(NPC - NPCA) > PLM * MINPA) //如果价差偏离过大
         {
         If(BPLA > 0) //如果A多头持仓盈利
         {
         CDFLG = 1; //开启追价处理
         }
         Else If(BPLA < 0) //如果A多头持仓亏损
         {
         CDFLG = 2; //开启撤单处理
         }
         }
      }
      Else If(SKFLGB == 0 && SKSMB == 0) //如果B已完成多头开仓
      {
         If(Abs(NPC - NPCA) > PLM * MINPA) //如果价差偏离过大
         {
         If(SPLB > 0) //如果B空头持仓盈利
         {
         CDFLG = 1; //开启追价处理
         }
         Else If(SPLB < 0) //如果B空头持仓亏损
         {
         CDFLG = 2; //开启撤单处理
         }
         }
      }
   }
   If(BCFLG == 2) //如果已完成多头开仓
   {
      If(NPC >= PCP) //如果满足多头平仓条件
      {
         Commentary("【多头平仓：满足平仓条件！】");
         SPDFLGA = 1; //开启A卖平处理
         BPDFLGB = 1; //开启B买平处理
         BCFLG = 3; //已执行多头平仓
         }
      }
   }
//------------------------委托处理------------------------//
   If(OPFLG == 1) //委托处理
   {
      If(BKDFLGA == 1) //如果已开启A买开处理
      {
         If(BKFLGA == 0) //如果没有A买开委托
         {
            BKMA = Max(Min(BKSMA,ASKVA),1); //A买开委托手数
            BKSMA =             BKSMA - BKMA; //A买开委托总手数
            Commentary("【委托手数：" + Text(BKMA) + "手！】");
            Commentary("【剩余手数：" + Text(BKSMA) + "手！】");
            Commentary("【多头开仓：A买开委托发出！】");
            BKIDA = CODA.A_SendOrder(Enum_Buy,Enum_Entry,BKMA,ASKPA); //发出A买开委托
            BKTA = NOW; //A买开委托时间
            BKFLGA = 1; //已发出A买开委托
         }
      }
      If(SKDFLGB == 1) //如果已开启B卖开处理
      {
         If(SKFLGB == 0) //如果没有B卖开委托
         {
            SKMB = Max(Min(SKSMB,BIDVB),1); //B卖开委托手数
            SKSMB = SKSMB - SKMB; //B卖开委托总手数
            Commentary("【委托手数：" + Text(SKMB) + "手！】");
            Commentary("【剩余手数：" + Text(SKSMB) + "手！】");
            Commentary("【多头开仓：B卖开委托发出！】");
            SKIDB = CODB.A_SendOrder(Enum_Sell,Enum_Entry,SKMB,BIDPB); //发出B卖开委托
            SKTB = NOW; //B卖开委托时间
            SKFLGB = 1; //已发出B卖开委托
         }
      }
      If(SPDFLGA > 0) //如果已开启A卖平处理
      {
         If(SPFLGA == 0) //如果没有A卖平委托
         {
            If(BRPA > 0) //如果有A多头可用持仓
            {
            If(SPDFLGA == 1) //如果是多头平仓卖平
            {
             SPMA = BRPA; //A卖平委托手数
            }
            Else If(SPDFLGA == 2) //如果是单腿平仓卖平
            {
            SPMA = BRPA - SRPB; //A卖平委托手数
            }
            If(SPMA > 0) //如果A卖平委托手数大于0
            {
            Commentary("【多头平仓：A卖平委托发出！】");
            SPIDA = CODA.A_SendOrder(Enum_Sell,SHA,SPMA,BIDPA); //发出A卖平委托
            SPFLGA = 1; //已发出A卖平委托
            }
            }
         }
      }
      If(BPDFLGB > 0) //如果已开启B买平处理
      {
         If(BPFLGB == 0) //如果没有B买平委托
            {
            If(SRPB > 0) //如果有B空头可用持仓
            {
            If(BPDFLGB == 1) //如果是多头平仓买平
            {
            BPMB = SRPB; //B买平委托手数
               }
               Else If(BPDFLGB == 2) //如果是单腿平仓买平
            {
               BPMB = SRPB - BRPA; //B买平委托手数
            }
            If(BPMB > 0) //如果B买平委托手数大于0
            {
            Commentary("【多头平仓：B买平委托发出！】");
            BPIDB = CODB.A_SendOrder(Enum_Buy,SHB,BPMB,ASKPB); //发出B买平委托
               BPFLGB = 1; //已发出B买平委托
            }
            }
         }
      }
   }
End

运行效果：