(原创)原版海龟交易系统-源码

米小兔

修改:加仓判断条件改为以最高价或最低价循环判断满足加仓条件,实现一根k线满足多次加仓条件;

1. Params
   
2.         Numeric Direction(0);                   // 多空信号过滤条件,值为0不过滤,值为1只做多,值为1只做空;
   
3.     Numeric RiskRatio(1);                   // % Risk Per N ( 0 - 100)
   
4.     Numeric LengthAtr(20);                  // 平均波动周期 ATR Length
   
5.     Numeric LengthFast(20);                 // 短周期 BreakOut Length
   
6.     Numeric LengthSlow(55);                 // 长周期 FailSafe Length
   
7.     Numeric LengthExit(10);                 // 离市周期 Trailing Exit Length
   
8.     Bool LastProfitableTradeFilter(True);   // 使用入市过滤条件
   
9. Vars
   
10.         Numeric MinPoint;                       // 最小变动单位
    
11.     NumericSeries N;                        // N 值
    
12.     NumericSeries TotalEquity;              // 按最新收盘价计算出的总资产
    
13.     NumericSeries TurtleUnits;              // 交易单位
    
14.     NumericSeries DonchianFastUpper;        // 短周期唐奇安通道上轨,长度LengthFast;
    
15.     NumericSeries DonchianFastLower;        // 短周期唐奇安通道下轨,长度LengthFast;
    
16.     NumericSeries DonchianSlowUpper;        // 长周期唐奇安通道上轨,长度LengthSlow;
    
17.     NumericSeries DonchianSlowLower;        // 长周期唐奇安通道下轨,长度LengthSlow;
    
18.     NumericSeries DonchianExitUpper;        // 离市时判断需要的N周期最高价,长度LengthExit;
    
19.     NumericSeries DonchianExitLower;        // 离市时判断需要的N周期最低价,长度LengthExit;
    
20.     NumericSeries MyPrice;
    
21.     NumericSeries MyExitPrice;              // 平仓价格
    
22.         NumericSeries preEntryPrice(0);               // 前一次开仓的价格
    
23.         BoolSeries PreBreakoutFailure(false);        // 前一次突破是否失败
    
24.         Bool SendOrderThisBar(False);                  // 当前Bar有过交易
    
25.         NumericSeries AtrAve;                   // 记录日线级别长度为lengthAtr的平均真实波幅;
    
26.         NumericSeries DayHigh;                  // 一天中的最高价;
    
27.         NumericSeries DayLow;                   // 一天中的最低价;
    
28.         Numeric i;                              // 循环计算所需指针;
    
29.         NumericSeries Atr(0);                   // 当天的ATR
    
30.         Numeric AtrIndex(0);                    // 存储真实波幅的全局变量的环的索引值;
    
31.         NumericSeries DayCount(0);              // 交易日数;
    
32.         NumericSeries CloseD_1;                 // 上一个交易日收盘价,过度CloseD(1);
    
33.         NumericSeries MyBarsSinceToday;         // 过度BarsSinceToday;
    
34. Begin
    
35.         MinPoint = MinMove*PriceScale;
    
36.         MyBarsSinceToday = BarsSinceToday;
    
37.         CloseD_1 = CloseD(1);
    
38.        
    
39.         if(BarsSinceToday==0)
    
40.         {
    
41.                 DayCount = DayCount + 1;  //记录交易日数;
    
42.                 DayHigh = High;
    
43.                 DayLow = Low;
    
44.                
    
45.                 //从第二个交易日开始记录;
    
46.                 if(DayCount>=2)  
    
47.                 {                       
    
48.                         // 前一日真实波幅;
    
49.                         Atr = max(max(Abs(DayHigh[1]-CloseD_1),Abs(DayLow[1]-CloseD_1)),DayHigh[1]-DayLow[1]);  
    
50.                        
    
51.                         // 存储前一天的Atr到全局变量环0-19;
    
52.                         AtrIndex =  (DayCount-2)%LengthAtr;
    
53.                         SetGlobalVar(AtrIndex,Atr[1]);
    
54.                 }
    
55.                
    
56.                 // 从第LengthAtr+1个交易日开始计算;
    
57.                 if(DayCount>=LengthAtr+1)  
    
58.                 {
    
59.                         // 计算日线级别长度为LengthAtr的平均真实波幅;
    
60.                         AtrAve = 0 ;
    
61.                         for i=0 to LengthAtr-1
    
62.                         {
    
63.                                 AtrAve = AtrAve +  getGlobalVar(i);
    
64.                         }
    
65.                         AtrAve = AtrAve/LengthAtr;
    
66.                         N = IntPart(AtrAve);
    
67.                        
    
68.                         DonchianFastUpper = Highest(DayHigh[1],(LengthAtr-0.1)*(MyBarsSinceToday[1]+1));
    
69.                         DonchianFastLower = Lowest(DayLow[1],(LengthAtr-0.1)*(MyBarsSinceToday[1]+1));
    
70.                        
    
71.                         DonchianSlowUpper = Highest(DayHigh[1],(LengthSlow-0.1)*(MyBarsSinceToday[1]+1));
    
72.                         DonchianSlowLower = Lowest(DayLow[1],(LengthSlow-0.1)*(MyBarsSinceToday[1]+1));
    
73.                        
    
74.                         DonchianExitUpper = Highest(DayHigh[1],(LengthExit-0.1)*(MyBarsSinceToday[1]));
    
75.                         DonchianExitLower = Lowest(DayLow[1],(LengthExit-0.1)*(MyBarsSinceToday[1]));
    
76.                 }
    
77.                
    
78.                 //账户最新资产 = 按当前Bar开盘价计算的可用资金 + 持仓保证金 ;
    
79.                 TotalEquity = Portfolio_CurrentCapital() + Portfolio_UsedMargin();
    
80.                 //标准单位头寸 = (本金*风险比例)/价值波动率
    
81.                 TurtleUnits = (TotalEquity*RiskRatio/100) /(N * ContractUnit()*BigPointValue());
    
82.                 TurtleUnits = IntPart(TurtleUnits); // 对小数取整
    
83.                 // PlotString("Units","Units="+Text(TurtleUnits),High+(High-Low),white);
    
84.                 // PlotString("N","N="+Text(N),Low-(High-Low)/2,white);
    
85.         }
    
86.         Else
    
87.         {
    
88.                 DayHigh = Max(DayHigh,High);
    
89.                 DayLow = Min(DayLow,Low);
    
90.         }
    
91. 
    
92.         If(MarketPosition==0 and TurtleUnits>=1)
    
93.         {
    
94.                 // 首次入市1:带过滤条件的,如果过滤条件为真,则需要前一笔交易是否是突破失败;
    
95.                 if(LastProfitableTradeFilter==false Or PreBreakoutFailure )
    
96.                 {
    
97.                         //开多1:突破短周期唐奇安通道上轨;
    
98.                         If(High>DonchianFastUpper and Direction!=-1)
    
99.                         {
    
100.                                 MyPrice = Max(Open,DonchianFastUpper)+MinPoint;
     
101.                                 preEntryPrice = MyPrice;
     
102.                                 Buy(TurtleUnits,MyPrice);
     
103.                                 MyExitPrice = MyPrice - 2*N;
     
104.                                 SendOrderThisBar = true;
     
105.                         }
     
106.                        
     
107.                         //开空1:突破短周期唐奇安通道下轨;
     
108.                         if(Low<DonchianFastLower and Direction!=1)
     
109.                         {
     
110.                                 MyPrice = Min(Open,DonchianFastLower)-MinPoint;
     
111.                                 preEntryPrice = MyPrice;
     
112.                                 SellShort(TurtleUnits,MyPrice);
     
113.                                 MyExitPrice = MyPrice + 2*N;
     
114.                                 SendOrderThisBar = true;
     
115.                         }
     
116.                 }
     
117.                
     
118.                 // 首次入市2:过滤条件之外的,长周期唐奇安通道突破开仓;
     
119.                 //开多2:突破长周期唐奇安通道上轨;
     
120.                 else
     
121.                 {
     
122.                         if(CrossOver(High,DonchianSlowUpper) and Direction!=-1)
     
123.                         {
     
124.                                 MyPrice = Max(Open,DonchianSlowUpper)+MinPoint;
     
125.                                 preEntryPrice = MyPrice;
     
126.                                 Buy(TurtleUnits,MyPrice);
     
127.                                 MyExitPrice = MyPrice - 2*N;
     
128.                                 SendOrderThisBar = true;
     
129.                         }
     
130.                         //开空2:突破长周期唐奇安通道下轨;
     
131.                         if(CrossUnder(Low,DonchianSlowLower) and Direction!=1)
     
132.                         {
     
133.                                 MyPrice = Min(Open,DonchianSlowLower)+MinPoint;
     
134.                                 preEntryPrice = MyPrice;
     
135.                                 SellShort(TurtleUnits,MyPrice);
     
136.                                 MyExitPrice = MyPrice + 2*N;
     
137.                                 SendOrderThisBar = true;
     
138.                         }
     
139.                 }
     
140.         }
     
141.        
     
142.         // 当持有多单;
     
143.         if(MarketPosition==1)
     
144.         {
     
145.                 //离市:价格反向穿越离市的唐奇安通道;
     
146.                 if(CrossUnder(Low,DonchianExitLower))
     
147.                 {
     
148.                         MyPrice = Min(Open,DonchianExitLower)-MinPoint;
     
149.                         Sell(0,MyPrice);
     
150.                         PreBreakoutFailure = False;  //假突破值为假;
     
151.                         // PlotBool("突破",PreBreakoutFailure,High,white);
     
152.                 }
     
153.                 Else
     
154.                 {
     
155.                         //加仓:如果开盘价就大于最近一次开仓价+0.5*N,则以开盘价发单;
     
156.                         if(Open>LastEntryPrice+0.5*N and TurtleUnits>=1)
     
157.                         {
     
158.                                 MyPrice = Open;
     
159.                                 preEntryPrice = MyPrice;
     
160.                                 Buy(TurtleUnits,MyPrice);
     
161.                                 SendOrderThisBar = true;
     
162.                         }
     
163.                         // 以最高价为标准，判断能进行几次增仓
     
164.                         while(High >= preEntryPrice + 0.5*N)
     
165.                         {
     
166.                                 MyPrice = preEntryPrice + 0.5 * N;
     
167.                                 preEntryPrice = MyPrice;
     
168.                                 Buy(TurtleUnits,MyPrice);
     
169.                                 SendOrderThisBar = True;                                       
     
170.                         }
     
171.                         //止损:价格反向穿越最近一次开仓价格-2N;
     
172.                         if(Low<LastEntryPrice-2*N)
     
173.                         {
     
174.                                 MyPrice = Min(Open,LastEntryPrice-2*N)-MinPoint;
     
175.                                 Sell(0,MyPrice);
     
176.                                 PreBreakoutFailure = True;  //假突破值为真;
     
177.                                 // PlotBool("突破",PreBreakoutFailure,High,white);
     
178.                         }
     
179.                 }
     
180.         }
     
181.         // 当持有空单;
     
182.         else if(MarketPosition==-1)
     
183.         {
     
184.                 // 离市:价格反向穿越离市的唐奇安通道;
     
185.                 if(CrossOver(High,DonchianExitUpper))
     
186.                 {
     
187.                         MyPrice = Max(Open,DonchianExitUpper)+MinPoint;
     
188.                         BuyToCover(0,MyPrice);
     
189.                         PreBreakoutFailure = False;  //假突破值为假;
     
190.                         // PlotBool("突破",PreBreakoutFailure,High,white);
     
191.                 }
     
192.                 Else
     
193.                 {
     
194.                         // 加仓:与最近一次开仓价格间隔0.5*N开仓;
     
195.                         if(Open<LastEntryPrice-0.5*N and TurtleUnits>=1)
     
196.                         {
     
197.                                 MyPrice = Open;
     
198.                                 preEntryPrice = MyPrice;
     
199.                                 SellShort(TurtleUnits,MyPrice);
     
200.                                 SendOrderThisBar = true;
     
201.                         }
     
202.                         // 以最低价为标准，判断能进行几次增仓
     
203.                         while(Low <= preEntryPrice - 0.5*N)
     
204.                         {
     
205.                                 MyPrice = preEntryPrice - 0.5 * N;
     
206.                                 preEntryPrice = MyPrice;
     
207.                                 SellShort(TurtleUnits,MyPrice);
     
208.                                 SendOrderThisBar = True;
     
209.                         }
     
210.                         // 止损:价格反向穿越最近一次开仓价格+2N;
     
211.                         if(High>LastEntryPrice+2*N)
     
212.                         {
     
213.                                 MyPrice = Max(Open,LastEntryPrice+2*N)+MinPoint;
     
214.                                 BuyToCover(0,MyPrice);
     
215.                                 PreBreakoutFailure = True;  //假突破值为真;
     
216.                                 // PlotBool("突破",PreBreakoutFailure,High,white);
     
217.                         }
     
218.                 }
     
219.         }
     
220.        
     
221.         PlotNumeric("DonchianFastUpper",DonchianFastUpper);
     
222.         PlotNumeric("DonchianFastLower",DonchianFastLower);
     
223.         PlotNumeric("DonchianSlowUpper",DonchianSlowUpper);
     
224.         PlotNumeric("DonchianSlowLower",DonchianSlowLower);
     
225.         PlotNumeric("DonchianExitUpper",DonchianExitUpper);
     
226.         PlotNumeric("DonchianExitLower",DonchianExitLower);       
     
227.        
     
228.         // Commentary("点值="+Text(ContractUnit()*BigPointValue()));
     
229.         Commentary("TotalEquity="+Text(TotalEquity));
     
230.         Commentary("N="+Text(N));
     
231.         Commentary("Units="+Text(TurtleUnits));
     
232.         // Commentary("Atr="+Text(Atr));
     
233.         // Commentary("AtrAve="+Text(AtrAve));
     
234.         // PlotNumeric("AtrAve",AtrAve);
     
235.         Commentary("DayCount="+Text(DayCount));
     
236.         Commentary("MyBarsSinceToday="+Text(MyBarsSinceToday[1]+1));
     
237.        
     
238. 
     
239.        
     
240. End

复制代码

米小兔

又改进了一个版本,为了实盘更方便设置.
        版本:ITF_TurtleRules_V105
        修改(基于V104)
修改目的: 方便实盘时候的资产和仓位设置,实现了不受开始时间点左侧的交易信号的影响;
1)        增加日期参数DateStart(20080101),此日的开盘将资金初始化为Capital;
2)        增加初始本金参数Capital(1000000),不使用全局变量里面的本金设置;

米小兔

1. //------------------------------------------------------------------------
   
2. // 简称: ITF_TurtleRules_V105
   
3. // 名称: TurtleRules_V105
   
4. // 类别: 公式应用
   
5. // 类型: 用户应用
   
6. // 输出:
   
7. //------------------------------------------------------------------------
   
8. 
   
9. Params
   
10.         Numeric Capital(1000000);               // 初始资金;
    
11.         Numeric DateStart(20120101);            // 此日的开盘将资金初始化为Capital;
    
12.         Numeric Direction(0);                   // 多空信号过滤条件,值为0不过滤,值为1只做多,值为1只做空;
    
13.     Numeric RiskRatio(1);                   // % Risk Per N ( 0 - 100)
    
14.     Numeric LengthAtr(20);                  // 平均波动周期 ATR Length
    
15.     Numeric LengthFast(20);                 // 短周期 BreakOut Length
    
16.     Numeric LengthSlow(55);                 // 长周期 FailSafe Length
    
17.     Numeric LengthExit(10);                 // 离市周期 Trailing Exit Length
    
18.     Bool LastProfitableTradeFilter(True);   // 使用入市过滤条件
    
19. Vars
    
20.         Numeric MinPoint;                       // 最小变动单位
    
21.     NumericSeries N;                        // N 值
    
22.     NumericSeries TotalEquity;              // 按最新收盘价计算出的总资产
    
23.     NumericSeries TurtleUnits;              // 交易单位
    
24.     NumericSeries DonchianFastUpper;        // 短周期唐奇安通道上轨,长度LengthFast;
    
25.     NumericSeries DonchianFastLower;        // 短周期唐奇安通道下轨,长度LengthFast;
    
26.     NumericSeries DonchianSlowUpper;        // 长周期唐奇安通道上轨,长度LengthSlow;
    
27.     NumericSeries DonchianSlowLower;        // 长周期唐奇安通道下轨,长度LengthSlow;
    
28.     NumericSeries DonchianExitUpper;        // 离市时判断需要的N周期最高价,长度LengthExit;
    
29.     NumericSeries DonchianExitLower;        // 离市时判断需要的N周期最低价,长度LengthExit;
    
30.     NumericSeries MyPrice;
    
31.     NumericSeries MyExitPrice;              // 平仓价格
    
32.         NumericSeries preEntryPrice(0);               // 前一次开仓的价格
    
33.         BoolSeries PreBreakoutFailure(false);        // 前一次突破是否失败
    
34.         Bool SendOrderThisBar(False);                  // 当前Bar有过交易
    
35.         NumericSeries AtrAve;                   // 记录日线级别长度为lengthAtr的平均真实波幅;
    
36.         NumericSeries DayHigh;                  // 一天中的最高价;
    
37.         NumericSeries DayLow;                   // 一天中的最低价;
    
38.         Numeric i;                              // 循环计算所需指针;
    
39.         NumericSeries Atr(0);                   // 当天的ATR
    
40.         Numeric AtrIndex(0);                    // 存储真实波幅的全局变量的环的索引值;
    
41.         NumericSeries DayCount(0);              // 交易日数;
    
42.         NumericSeries CloseD_1;                 // 上一个交易日收盘价,过度CloseD(1);
    
43.         NumericSeries MyBarsSinceToday;         // 过度BarsSinceToday;
    
44.         NumericSeries CapitalCurrent;           // 调整资产规模后的最新资产;
    
45.         NumericSeries CapitalPeak;              // 调整资产规模后的最新资产峰值;
    
46.         NumericSeries ProfitClosing;            // 平仓盈亏;
    
47.         NumericSeries LotsTotal(0);             // 持仓手数;
    
48.         NumericSeries MyAvgEntryPrice;          // 持仓均价;
    
49.         NumericSeries TimesOverWeight(0);       // 加仓次数记录;
    
50. Begin
    
51.         MinPoint = MinMove*PriceScale;
    
52.         MyBarsSinceToday = BarsSinceToday;
    
53.         CloseD_1 = CloseD(1);
    
54.        
    
55.         if(BarsSinceToday==0)
    
56.         {
    
57.                 DayCount = DayCount + 1;  //记录交易日数;
    
58.                 DayHigh = High;
    
59.                 DayLow = Low;
    
60.                
    
61.                 //从第二个交易日开始记录;
    
62.                 if(DayCount>=2)  
    
63.                 {                       
    
64.                         // 前一日真实波幅;
    
65.                         Atr = max(max(Abs(DayHigh[1]-CloseD_1),Abs(DayLow[1]-CloseD_1)),DayHigh[1]-DayLow[1]);  
    
66.                        
    
67.                         // 存储前一天的Atr到全局变量环0-19;
    
68.                         AtrIndex =  (DayCount-2)%LengthAtr;
    
69.                         SetGlobalVar(AtrIndex,Atr[1]);
    
70.                 }
    
71.                  
    
72.                 // 从第LengthAtr+1个交易日开始计算;
    
73.                 if(DayCount>=LengthAtr+1)  
    
74.                 {
    
75.                         // 计算日线级别长度为LengthAtr的平均真实波幅;
    
76.                         AtrAve = 0 ;
    
77.                         for i=0 to LengthAtr-1
    
78.                         {
    
79.                                 AtrAve = AtrAve +  getGlobalVar(i);
    
80.                         }
    
81.                         AtrAve = AtrAve/LengthAtr;
    
82.                         N = IntPart(AtrAve);
    
83.                        
    
84.                         DonchianFastUpper = Highest(DayHigh[1],(LengthAtr-0.1)*(MyBarsSinceToday[1]+1));
    
85.                         DonchianFastLower = Lowest(DayLow[1],(LengthAtr-0.1)*(MyBarsSinceToday[1]+1));
    
86.                        
    
87.                         DonchianSlowUpper = Highest(DayHigh[1],(LengthSlow-0.1)*(MyBarsSinceToday[1]+1));
    
88.                         DonchianSlowLower = Lowest(DayLow[1],(LengthSlow-0.1)*(MyBarsSinceToday[1]+1));
    
89.                        
    
90.                         DonchianExitUpper = Highest(DayHigh[1],(LengthExit-0.1)*(MyBarsSinceToday[1]));
    
91.                         DonchianExitLower = Lowest(DayLow[1],(LengthExit-0.1)*(MyBarsSinceToday[1]));
    
92.                 }
    
93.                
    
94.                 // 资产规模调整;
    
95.                 // 如果有设置初始本金的开始时间;
    
96.                 if(Date==DateStart and DateStart!=0 and Date!=Date[1])
    
97.                 {
    
98.                         CapitalCurrent = Capital;  // 调整资产规模后的最新资产;
    
99.                         Commentary("标识:第99行");
    
100.                 }
     
101.                 // 如果没有设置初始本金的开始时间;
     
102.                 else if(DateStart==0 or (BarStatus==0 and Date>DateStart) )
     
103.                 {
     
104.                         CapitalCurrent = Capital;
     
105.                         Commentary("标识:第105行");
     
106.                 }
     
107.                
     
108.                 CapitalPeak = Max(Max(Capital,CapitalCurrent[1]),CapitalCurrent+ProfitClosing);  // 调整资产规模后的最新资产峰值;
     
109.                
     
110.                 //标准单位头寸 = (最新资产*风险比例)/价值波动率
     
111.                 TurtleUnits = (CapitalCurrent*RiskRatio/100) /(N * ContractUnit()*BigPointValue());
     
112.                 TurtleUnits = IntPart(TurtleUnits); // 对小数取整
     
113.                 // PlotString("Units","Units="+Text(TurtleUnits),High+(High-Low),white);
     
114.                 // PlotString("N","N="+Text(N),Low-(High-Low)/2,white);
     
115.         }
     
116.         Else
     
117.         {
     
118.                 DayHigh = Max(DayHigh,High);
     
119.                 DayLow = Min(DayLow,Low);
     
120.         }
     
121. 
     
122.         If(MarketPosition==0 and TurtleUnits>=1 and DonchianFastUpper>0)
     
123.         {
     
124.                 // 首次入市1:带过滤条件的,如果过滤条件为真,则需要前一笔交易是否是突破失败;
     
125.                 if(LastProfitableTradeFilter==false Or PreBreakoutFailure )
     
126.                 {
     
127.                         //开多1:突破短周期唐奇安通道上轨;
     
128.                         If(High>DonchianFastUpper and Direction!=-1)
     
129.                         {
     
130.                                 MyPrice = Max(Open,DonchianFastUpper)+MinPoint;
     
131.                                 preEntryPrice = MyPrice;
     
132.                                 Buy(TurtleUnits,MyPrice);
     
133.                                 MyExitPrice = MyPrice - 2*N;
     
134.                                 SendOrderThisBar = true;
     
135.                                 MyAvgEntryPrice = AvgEntryPrice;
     
136.                                 LotsTotal = TurtleUnits;
     
137.                                 TimesOverWeight = 1;
     
138.                         }
     
139.                        
     
140.                         //开空1:突破短周期唐奇安通道下轨;
     
141.                         if(Low<DonchianFastLower and Direction!=1)
     
142.                         {
     
143.                                 MyPrice = Min(Open,DonchianFastLower)-MinPoint;
     
144.                                 preEntryPrice = MyPrice;
     
145.                                 SellShort(TurtleUnits,MyPrice);
     
146.                                 MyExitPrice = MyPrice + 2*N;
     
147.                                 SendOrderThisBar = true;
     
148.                                 MyAvgEntryPrice = AvgEntryPrice;
     
149.                                 LotsTotal = TurtleUnits;
     
150.                                 TimesOverWeight = 1;
     
151.                         }
     
152.                 }
     
153.                
     
154.                 // 首次入市2:过滤条件之外的,长周期唐奇安通道突破开仓;
     
155.                 //开多2:突破长周期唐奇安通道上轨;
     
156.                 else
     
157.                 {
     
158.                         if(CrossOver(High,DonchianSlowUpper) and Direction!=-1)
     
159.                         {
     
160.                                 MyPrice = Max(Open,DonchianSlowUpper)+MinPoint;
     
161.                                 preEntryPrice = MyPrice;
     
162.                                 Buy(TurtleUnits,MyPrice);
     
163.                                 MyExitPrice = MyPrice - 2*N;
     
164.                                 SendOrderThisBar = true;
     
165.                                 MyAvgEntryPrice = AvgEntryPrice;
     
166.                                 LotsTotal = TurtleUnits;
     
167.                                 TimesOverWeight = 1;
     
168.                         }
     
169.                         //开空2:突破长周期唐奇安通道下轨;
     
170.                         if(CrossUnder(Low,DonchianSlowLower) and Direction!=1)
     
171.                         {
     
172.                                 MyPrice = Min(Open,DonchianSlowLower)+MinPoint;
     
173.                                 preEntryPrice = MyPrice;
     
174.                                 SellShort(TurtleUnits,MyPrice);
     
175.                                 MyExitPrice = MyPrice + 2*N;
     
176.                                 SendOrderThisBar = true;
     
177.                                 MyAvgEntryPrice = AvgEntryPrice;
     
178.                                 LotsTotal = TurtleUnits;
     
179.                                 TimesOverWeight = 1;
     
180.                         }
     
181.                 }
     
182.         }
     
183.        
     
184.         // 当持有多单;
     
185.         if(MarketPosition==1 and TimesOverWeight>0)
     
186.         {
     
187.                 //离市:价格反向穿越离市的唐奇安通道;
     
188.                 if(CrossUnder(Low,DonchianExitLower))
     
189.                 {
     
190.                         MyPrice = Min(Open,DonchianExitLower)-MinPoint;
     
191.                         Sell(0,MyPrice);
     
192.                         PreBreakoutFailure = False;  //假突破值为假;
     
193.                         // PlotBool("突破",PreBreakoutFailure,High,white);
     
194.                         ProfitClosing = (MyPrice - MyAvgEntryPrice)*LotsTotal*ContractUnit()*BigPointValue();
     
195.                         CapitalCurrent = CapitalCurrent + ProfitClosing;
     
196.                         TimesOverWeight = 0;
     
197.                         LotsTotal = 0;
     
198.                 }
     
199.                 Else
     
200.                 {
     
201.                         // 加仓:如果开盘价就大于最近一次开仓价+0.5*N,则以开盘价发单;
     
202.                         if(Open>LastEntryPrice+0.5*N and TurtleUnits>=1 and TimesOverWeight<4)
     
203.                         {
     
204.                                 MyPrice = Open;
     
205.                                 preEntryPrice = MyPrice;
     
206.                                 Buy(TurtleUnits,MyPrice);
     
207.                                 SendOrderThisBar = true;
     
208.                                 MyAvgEntryPrice = AvgEntryPrice;
     
209.                                 LotsTotal = LotsTotal + TurtleUnits;
     
210.                                 TimesOverWeight = TimesOverWeight + 1;
     
211.                         }
     
212.                         // 以最高价为标准，判断能进行几次增仓
     
213.                         while(High >= preEntryPrice + 0.5*N and TimesOverWeight<4)
     
214.                         {
     
215.                                 MyPrice = preEntryPrice + 0.5 * N;
     
216.                                 preEntryPrice = MyPrice;
     
217.                                 Buy(TurtleUnits,MyPrice);
     
218.                                 SendOrderThisBar = True;
     
219.                                 MyAvgEntryPrice = AvgEntryPrice;
     
220.                                 LotsTotal = LotsTotal + TurtleUnits;
     
221.                                 TimesOverWeight = TimesOverWeight + 1;
     
222.                         }
     
223.                        
     
224.                         // 止损:价格反向穿越最近一次开仓价格-2N;
     
225.                         if(Low<LastEntryPrice-2*N)
     
226.                         {
     
227.                                 MyPrice = Min(Open,LastEntryPrice-2*N)-MinPoint;
     
228.                                 Sell(0,MyPrice);
     
229.                                 PreBreakoutFailure = True;  //假突破值为真;
     
230.                                 // PlotBool("突破",PreBreakoutFailure,High,white);
     
231.                                 ProfitClosing = (MyPrice - MyAvgEntryPrice)*LotsTotal*ContractUnit()*BigPointValue();
     
232.                                 CapitalCurrent = CapitalCurrent + ProfitClosing;
     
233.                                 TimesOverWeight = 0;
     
234.                                 LotsTotal = 0;
     
235.                         }
     
236.                 }
     
237.         }

复制代码

米小兔

1.         // 当持有多单;
   
2.         if(MarketPosition==1 and TimesOverWeight>0)
   
3.         {
   
4.                 //离市:价格反向穿越离市的唐奇安通道;
   
5.                 if(CrossUnder(Low,DonchianExitLower))
   
6.                 {
   
7.                         MyPrice = Min(Open,DonchianExitLower)-MinPoint;
   
8.                         Sell(0,MyPrice);
   
9.                         PreBreakoutFailure = False;  //假突破值为假;
   
10.                         // PlotBool("突破",PreBreakoutFailure,High,white);
    
11.                         ProfitClosing = (MyPrice - MyAvgEntryPrice)*LotsTotal*ContractUnit()*BigPointValue();
    
12.                         CapitalCurrent = CapitalCurrent + ProfitClosing;
    
13.                         TimesOverWeight = 0;
    
14.                         LotsTotal = 0;
    
15.                 }
    
16.                 Else
    
17.                 {
    
18.                         // 加仓:如果开盘价就大于最近一次开仓价+0.5*N,则以开盘价发单;
    
19.                         if(Open>LastEntryPrice+0.5*N and TurtleUnits>=1 and TimesOverWeight<4)
    
20.                         {
    
21.                                 MyPrice = Open;
    
22.                                 preEntryPrice = MyPrice;
    
23.                                 Buy(TurtleUnits,MyPrice);
    
24.                                 SendOrderThisBar = true;
    
25.                                 MyAvgEntryPrice = AvgEntryPrice;
    
26.                                 LotsTotal = LotsTotal + TurtleUnits;
    
27.                                 TimesOverWeight = TimesOverWeight + 1;
    
28.                         }
    
29.                         // 以最高价为标准，判断能进行几次增仓
    
30.                         while(High >= preEntryPrice + 0.5*N and TimesOverWeight<4)
    
31.                         {
    
32.                                 MyPrice = preEntryPrice + 0.5 * N;
    
33.                                 preEntryPrice = MyPrice;
    
34.                                 Buy(TurtleUnits,MyPrice);
    
35.                                 SendOrderThisBar = True;
    
36.                                 MyAvgEntryPrice = AvgEntryPrice;
    
37.                                 LotsTotal = LotsTotal + TurtleUnits;
    
38.                                 TimesOverWeight = TimesOverWeight + 1;
    
39.                         }
    
40.                        
    
41.                         // 止损:价格反向穿越最近一次开仓价格-2N;
    
42.                         if(Low<LastEntryPrice-2*N)
    
43.                         {
    
44.                                 MyPrice = Min(Open,LastEntryPrice-2*N)-MinPoint;
    
45.                                 Sell(0,MyPrice);
    
46.                                 PreBreakoutFailure = True;  //假突破值为真;
    
47.                                 // PlotBool("突破",PreBreakoutFailure,High,white);
    
48.                                 ProfitClosing = (MyPrice - MyAvgEntryPrice)*LotsTotal*ContractUnit()*BigPointValue();
    
49.                                 CapitalCurrent = CapitalCurrent + ProfitClosing;
    
50.                                 TimesOverWeight = 0;
    
51.                                 LotsTotal = 0;
    
52.                         }
    
53.                 }
    
54.         }
    
55.         // 当持有空单;
    
56.         else if(MarketPosition==-1 and TimesOverWeight>0)
    
57.         {
    
58.                 // 离市:价格反向穿越离市的唐奇安通道;
    
59.                 if(CrossOver(High,DonchianExitUpper))
    
60.                 {
    
61.                         MyPrice = Max(Open,DonchianExitUpper)+MinPoint;
    
62.                         BuyToCover(0,MyPrice);
    
63.                         PreBreakoutFailure = False;  //假突破值为假;
    
64.                         // PlotBool("突破",PreBreakoutFailure,High,white);
    
65.                         ProfitClosing = (MyAvgEntryPrice - MyPrice)*LotsTotal*ContractUnit()*BigPointValue();
    
66.                         CapitalCurrent = CapitalCurrent + ProfitClosing;
    
67.                         TimesOverWeight = 0;
    
68.                         LotsTotal = 0;
    
69.                 }
    
70.                 Else
    
71.                 {
    
72.                         // 加仓:与最近一次开仓价格间隔0.5*N开仓;
    
73.                         if(Open<LastEntryPrice-0.5*N and TurtleUnits>=1 and TimesOverWeight<4)
    
74.                         {
    
75.                                 MyPrice = Open;
    
76.                                 preEntryPrice = MyPrice;
    
77.                                 SellShort(TurtleUnits,MyPrice);
    
78.                                 SendOrderThisBar = true;
    
79.                                 MyAvgEntryPrice = AvgEntryPrice;
    
80.                                 LotsTotal = LotsTotal + TurtleUnits;
    
81.                                 TimesOverWeight = 0;
    
82.                         }
    
83.                         // 以最低价为标准，判断能进行几次增仓
    
84.                         while(Low <= preEntryPrice - 0.5*N and TimesOverWeight<4)
    
85.                         {
    
86.                                 MyPrice = preEntryPrice - 0.5 * N;
    
87.                                 preEntryPrice = MyPrice;
    
88.                                 SellShort(TurtleUnits,MyPrice);
    
89.                                 SendOrderThisBar = True;
    
90.                                 MyAvgEntryPrice = AvgEntryPrice;
    
91.                                 LotsTotal = LotsTotal + TurtleUnits;
    
92.                                 TimesOverWeight = TimesOverWeight + 1;
    
93.                         }
    
94.                         // 止损:价格反向穿越最近一次开仓价格+2N;
    
95.                         if(High>LastEntryPrice+2*N)
    
96.                         {
    
97.                                 MyPrice = Max(Open,LastEntryPrice+2*N)+MinPoint;
    
98.                                 BuyToCover(0,MyPrice);
    
99.                                 PreBreakoutFailure = True;  //假突破值为真;
    
100.                                 // PlotBool("突破",PreBreakoutFailure,High,white);
     
101.                                 ProfitClosing = (MyAvgEntryPrice - MyPrice)*LotsTotal*ContractUnit()*BigPointValue();
     
102.                                 CapitalCurrent = CapitalCurrent + ProfitClosing;
     
103.                                 TimesOverWeight = 0;
     
104.                                 LotsTotal = 0;
     
105.                         }
     
106.                 }
     
107.         }
     
108.          
     
109.         PlotNumeric("DonchianFastUpper",DonchianFastUpper);
     
110.         PlotNumeric("DonchianFastLower",DonchianFastLower);
     
111.         PlotNumeric("DonchianSlowUpper",DonchianSlowUpper);
     
112.         PlotNumeric("DonchianSlowLower",DonchianSlowLower);
     
113.         PlotNumeric("DonchianExitUpper",DonchianExitUpper);
     
114.         PlotNumeric("DonchianExitLower",DonchianExitLower);       
     
115.        
     
116.         Commentary("点值="+Text(ContractUnit()*BigPointValue()));
     
117.         Commentary("TotalEquity="+Text(TotalEquity));
     
118.         Commentary("N="+Text(N));
     
119.         Commentary("Units="+Text(TurtleUnits));
     
120.         // Commentary("Atr="+Text(Atr));
     
121.         // Commentary("AtrAve="+Text(AtrAve));
     
122.         // PlotNumeric("AtrAve",AtrAve);
     
123.         Commentary("DayCount="+Text(DayCount));
     
124.         Commentary("MyBarsSinceToday="+Text(MyBarsSinceToday[1]+1));
     
125.         Commentary("CapitalCurrent="+Text(CapitalCurrent));
     
126.         Commentary("LotsTotal="+Text(LotsTotal));
     
127.         Commentary("MyAvgEntryPrice="+Text(MyAvgEntryPrice));
     
128.         Commentary("MyPrice="+Text(MyPrice));
     
129.         Commentary("ProfitClosing="+Text(ProfitClosing));
     
130.         Commentary("CurrentBar="+Text(CurrentBar));
     
131. End

复制代码

米小兔

一个帖子的允许的大小太小了,一个策略的源码还要分成两段发,建议tb论坛扩容.

hewei

学习了，感谢分享。

木子云颜

多谢楼主

woomin1985

支持发的源码学习，其它不说什么，楼主在很热心帮大家。

米小兔

谢谢大家支持.
原版本海龟的海龟交易系统,代码基本实现,而且还根据实盘细节处理的需要做了一些小修改.
下一步我准备对海龟交易法则的策略思路部分加以修改,如果大家有些建议意见也可以提出来,讨论,一起改进.

天崖

强烈支持，顶一个