一个系统交易的实例：夹板

skywalker

夹板在实盘中是一个很常见的运用，用于吃住震荡行情。它有个上轨和一个下轨，行情突破上轨就做空；突破下轨就做多，在上下轨之间来回吃。如图：


代码如下：

1. 
   
2. /* *******************************************************************************************
   
3. 1、行情从UpperLine和LowerLine之间开始进入
   
4. 2、大于等于UpperLine开空仓，小于等于LowerLine开多仓
   
5. 3、从开仓点继续偏离StopInterval止损(意味着最多亏StopInterval)
   
6. 4、止损一次之后不再开仓
   
7. 5、下午14:55收盘前平仓
   
8. 6、运用在TICK图上
   
9. ******************************************************************************************** */
   
10. Params
    
11.        Numeric   upperLine(100);
    
12.        Numeric   lowerLine(100);
    
13.        Numeric   StopInterval(150);
    
14. 
    
15.        Numeric    firstLots(4);    // 手数(仅为正数)
    
16.        Numeric    today(26);     // 日期(5月22日，则填入22)
    
17. 
    
18. Vars
    
19.        Numeric   tem;
    
20. 
    
21.        Numeric   needPosition;   // 当前需要建立的头寸（正数为多头，负数为空头，零为全部平光）
    
22.        Numeric   needPrice;    // 建立头寸时下单的价格
    
23.        NumericSeries  wantStopLong;   // 多头止损的位置
    
24.        NumericSeries  wantStopShort;   // 空头止损的位置
    
25. 
    
26. Begin
    
27.        if(currentBar == 0)
    
28.        {
    
29.             // 初始化序列变量
    
30.             wantStopLong = -1;
    
31.             wantStopShort = -1;
    
32.        }Else
    
33.        {
    
34.             wantStopLong = wantStopLong[1];  
    
35.             wantStopShort = wantStopShort[1];  
    
36.        }
    
37.        if(day != today)
    
38.        {
    
39.             // 过滤非指定日期的BAR
    
40.             return ;
    
41.        }
    
42. 
    
43.        // 计算多、空头止损的位置
    
44.        wantStopLong = lowerLine - stopInterval;  
    
45.        wantStopShort = upperLine + stopInterval;
    
46. 
    
47. 
    
48.        // 把计算好的值输出来看看(这是调试的重要技巧！！！！！)
    
49.        Commentary("wantStopLong:"+Text(wantStopLong));
    
50.        Commentary("wantStopShort:"+Text(wantStopShort));
    
51.        tem = 0;
    
52.        if(NumLosTrades == 0) // 当日从来没有止损过，开始准备计算。开平仓的方法都包装在OpenCoverFor2Lines函数中
    
53.        {
    
54.             // OpenCoverFor2Lines函数包装了开平仓算法，其用意如下：
    
55.             // 1、返回值为零表示不做任何头寸操作，非零表示要操作
    
56.             // 2、返回值为非零时，needPosition写入了当前要建立的头寸大小和方向，needPrice写入了以什么价格去建立该头寸
    
57.             tem = OpenCoverFor2Lines(MarketPosition(),firstLots,upperLine,lowerLine,wantStopShort,wantStopLong,needPosition,needPrice);
    
58.        }
    
59. 
    
60.        Commentary("needPosition:"+Text(needPosition));
    
61.        Commentary("needPrice:"+Text(needPrice));
    
62. 
    
63.        if(tem == 0)
    
64.        {
    
65.             // 不操作任何东西，返回！
    
66.             return ;
    
67.        }
    
68.        if(MarketPosition == 0)
    
69.        {
    
70.             if(needPosition > 0)
    
71.             {
    
72.                  // 当前无仓，开始建立多头
    
73.                  buy(abs(needPosition),needPrice);
    
74.             }Else
    
75.             {
    
76.                  // 当前无仓，开始建立空头
    
77.                  SellShort(abs(needPosition),needPrice);
    
78.             }
    
79.             return ;
    
80.        }
    
81.        if(MarketPosition > 0)
    
82.        {
    
83.             if(needPosition < 0)
    
84.             {
    
85.                  // 当前多头，要求反转为空头
    
86.                  SellShort(abs(needPosition),needPrice);
    
87.             }Else
    
88.             {
    
89.                  // 当前多头，要求平仓
    
90.                  Sell(0,needPrice);
    
91.             }
    
92.         return ;
    
93.        }
    
94.        if(MarketPosition < 0)
    
95.        {
    
96.             if(needPosition > 0)
    
97.             {
    
98.                  // 当前空头，要求反转为多头
    
99.                  buy(abs(needPosition),needPrice);
    
100.             }Else
     
101.             {
     
102.                  // 当前空头，要求平仓
     
103.                  BuyToCover(0,needPrice);
     
104.             }
     
105.        }
     
106.        return 0;
     
107. End
     
108. 
     

复制代码

skywalker

1. // 返回值： 1：有所动作，0：没有动作
   
2. // 返回值为非零时，把当前要建立的头寸大小和方向写入needPosition，把以什么价格去建立该头寸写入needPrice
   
3. // 返回值： 1：有所动作，0：没有动作
   
4. // 返回值为非零时，把当前要建立的头寸大小和方向写入needPosition，把以什么价格去建立该头寸写入needPrice
   
5. 
   
6. Params
   
7.         Numeric         currentPosition(0);                // 当前头寸，可正可负
   
8.         Numeric        firstLots(0);
   
9. 
   
10.         Numeric         wantShort(120);                // 开空仓位置
    
11.         Numeric         wantLong(8);                         // 开多仓位置
    
12.        
    
13.         Numeric        wantStopShort(0);                // 空头止损的位置
    
14.         Numeric        wantStopLong(0);                // 多头止损的位置
    
15. 
    
16.        
    
17.         // 注意：以下两个都是引用变量！！！！
    
18.         NumericRef        needPosition;    // 经过计算后的当前头寸，正数：建立多仓，负数：建立空仓，零：平光所有头寸
    
19.         NumericRef needPrice;              // 建立needPosition时的价格
    
20.        
    
21. Vars
    
22.         Numeric                         tem;
    
23.        
    
24. Begin
    
25. 
    
26.         // 14:55:00平掉当日所有头寸
    
27.         if(time >= 0.1455 && currentPosition != 0)
    
28.         {
    
29.                 needPosition = 0;
    
30.                 needPrice = close ;
    
31.                 return 1;
    
32.         }
    
33.         if(currentPosition == 0)
    
34.         {
    
35.                 // 无仓，准备侍机开仓
    
36.                 if(close <= wantLong)
    
37.                 {
    
38.                         // 多头
    
39.                         needPosition = firstLots;
    
40.                         needPrice = wantLong;
    
41.                         return 1;
    
42.                 }
    
43.                 if(close >= wantShort)
    
44.                 {
    
45.                         // 空头
    
46.                         needPosition = -1 * firstLots;
    
47.                         needPrice = wantShort;
    
48.                         return 1;
    
49.                
    
50.                 }
    
51.                 return 0;
    
52.         }
    
53.        
    
54.         if(currentPosition > 0)
    
55.         {
    
56.                 // 持多仓，准备止损或反转
    
57.                 if(close >= wantShort)
    
58.                 {
    
59.                         // 反转
    
60.                         needPosition = -1 * firstLots;
    
61.                         needPrice = wantShort;
    
62.                         return 1;
    
63.                 }
    
64.                
    
65.                 if(close <= wantStopLong)
    
66.                 {
    
67.                         // 止损
    
68.                         needPosition = 0;
    
69.                         needPrice = wantStopLong;
    
70.                         return 1;
    
71.                        
    
72.                 }
    
73.                 return 0;
    
74.         }
    
75.         if(currentPosition < 0)
    
76.         {
    
77.                 // 持空仓，准备止损或反转
    
78.                 if(close <= wantLong)
    
79.                 {
    
80.                         // 反转
    
81.                         needPosition = firstLots;
    
82.                         needPrice = wantLong;
    
83.                         return 1;
    
84.                 }
    
85.                
    
86.                 if(close >= wantStopShort)
    
87.                 {
    
88.                         // 止损
    
89.                         needPosition = 0;
    
90.                         needPrice = wantStopShort;
    
91.                         return 1;
    
92.                        
    
93.                 }
    
94.                 return 0;
    
95.         }
    
96.           return 0;
    
97. End

复制代码

[ 本帖最后由 skywalker 于 2008-5-24 14:05 编辑 ]

skywalker

夹板的公式导入文件：

skywalker

初学者一定要认真体会OpenCoverFor2Lines函数，为什么需要把开平仓算法包装到函数里。夹板是个半自动的系统，因为上下轨都需要作为参数输入。当你要转换成全自动系统的时候，那么上下轨就需要根据行情动态计算出来。把计算出来的值作为参数输入OpenCoverFor2Lines函数即可，如此程序就可以方便地拓展而不需要大改动。甚至你还可以再做一个函数用于动态计算上下轨。

[ 本帖最后由 skywalker 于 2008-5-24 15:15 编辑 ]

skywalker

1. if(currentBar == 0)
   
2. {
   
3.     // 初始化序列变量
   
4.     wantStopLong = -1;
   
5.     wantStopShort = -1;
   
6. }Else
   
7. {
   
8.     wantStopLong = wantStopLong[1];  
   
9.     wantStopShort = wantStopShort[1];  
   
10. }

复制代码

上一段代码是使用序列变量时的常见用法，非常重要的用法。

[ 本帖最后由 skywalker 于 2008-5-24 14:25 编辑 ]

maodong

这种结构值得借鉴，好。

stevenx8

得认真学习了

cqzzbszz

谢谢！一定好好学习

糊涂

我觉得这个系统实战意义不大，原因我已经在未来函数中介绍了

guotie

学习一下。。。thx