1. //------------------------------------------------------------------------
   
2. // MtParabolicSAR，跨周期拋物線轉向ParabolicSAR函數
   
3. // 返回 當前bar的“周期索引”，比如當前在1分鐘周期里，折算成15分鐘周期的話，從凌晨00:00分鐘開始，第1根bar是1，第2根bar是2......第15根bar是15，第16根bar又變成1，......
   
4. // 除了函數本身的返回值，還通過oParCl、oParOpen、oPosition、oTransition這四個引用參數把對應Bar的停損值、對應Bar的停損值下一根的停損值、對應Bar建議的持倉狀態（1 - 多頭，-1 - 空頭）、對應Bar的狀態是否發生反轉（1 或 -1 為反轉，0 為保持不變）
   
5. // 版本 20140511_183500
   
6. //------------------------------------------------------------------------
   
7. 
   
8. Params
   
9.     Numeric TimeFrame(1440);        //目標時間周期參數，參數說明參見MtBar
   
10.     Numeric BarsBack(1);            //目標時間周期BAR偏移參數，說明見MtBar函數
    
11.     Numeric AfStep(0.02);
    
12.     Numeric AfLimit(0.2);
    
13.     NumericRef oParClose;
    
14.     NumericRef oParOpen;
    
15.     NumericRef oPosition;
    
16.     NumericRef oTransition;
    
17. 
    
18. Vars
    
19.     NumericSeries barCnt;
    
20.     NumericSeries CurBar;
    
21.     NumericSeries barCntSum;
    
22.     NumericSeries HighHT;
    
23.     NumericSeries LowHT;
    
24.     Numeric CurTime;
    
25.     Numeric PreTime;
    
26.     bool condition(false);
    
27.     Numeric n;
    
28.     Numeric i;
    
29. 
    
30. 
    
31.     NumericSeries Af(0);   
    
32.     NumericSeries ParOpen(0);
    
33.     NumericSeries ParClose(0);
    
34.     NumericSeries Position(0);  
    
35.     NumericSeries HHValue(0);
    
36.     NumericSeries LLValue(0);
    
37.     NumericSeries Transition(0);
    
38.      
    
39. Begin
    
40.     if(TimeFrame == 40320) {                                        //月線
    
41.         CurTime = Month;
    
42.         PreTime = Month[1];
    
43.     } else if(TimeFrame == 10080) {                                 //周線
    
44.         CurTime = IntPart(DateDiff(19700105, TrueDate(0)) / 7);
    
45.         PreTime = IntPart(DateDiff(19700105, TrueDate(1)) / 7);
    
46.     } else {                                                        //其他時間周期
    
47.         CurTime = IntPart((DateDiff(19700105, TrueDate(0)) * 1440 + Hour * 60 + Minute) / TimeFrame);
    
48.         PreTime = IntPart((DateDiff(19700105, TrueDate(1)) * 1440 + Hour[1] * 60 + Minute[1]) / TimeFrame);
    
49.     }
    
50. 
    
51.     condition = CurTime != PreTime;
    
52. 
    
53.     if(CurrentBar == 0) {                       //如果是第一根Bar, CurBar=0
    
54.         barCnt = 0;
    
55.         CurBar = 0;
    
56.         HighHT = High[1];
    
57.         LowHT = Low[1];
    
58.         
    
59.         Position = 1;
    
60.         Transition = 1;
    
61.         Af = AfStep;
    
62.         HHValue = HighHT;
    
63.         LLValue = LowHT;
    
64.         ParClose = LLValue;
    
65.         ParOpen = ParClose + Af * (HHValue - ParClose);
    
66.         if(ParOpen > LowHT) {
    
67.             ParOpen = LowHT;
    
68.         }
    
69.     } else {
    
70.         if(condition) {                         //如果在目標周期下，屬于另一根K線，則CurBar加1
    
71.             barCnt = 1;
    
72.             CurBar = CurBar[1] + 1;
    
73.             HighHT = High[1];
    
74.             LowHT = Low[1];
    
75.             for n = 2 to TimeFrame {
    
76.                 HighHT = Max(HighHT, High[n]);
    
77.                 LowHT = Min(LowHT, Low[n]);
    
78.             }
    
79.         } else {                                //如果在目標周期下，屬于同一根K線，則CurBar不變，但最高價和最低價要記錄價格的變化，成交量要累加
    
80.             barCnt = barCnt[1] + 1;
    
81.             CurBar = CurBar[1];
    
82.             HighHT = Max(HighHT[1], High);
    
83.             LowHT = Min(LowHT[1], Low);
    
84.         }
    
85.         
    
86.         HHValue = Max(HHValue[1], HighHT);
    
87.         LLValue = Min(LLValue[1], LowHT);
    
88. 
    
89.         if(CurBar == 0) {
    
90.             Position = 1;
    
91.             Transition = 1;
    
92.             Af = AfStep;
    
93.             ParClose = LLValue;
    
94.             ParOpen = ParClose + Af * (HHValue - ParClose);
    
95.             if(ParOpen > LowHT) {
    
96.                 ParOpen = LowHT;
    
97.             }
    
98.         } else {        
    
99.             if(condition) {                       //正好切換到目標周期的下一根k線
    
100.                 Transition = 0;
     
101. 
     
102.                 if(Position[TimeFrame] == 1) {
     
103.                     if(LowHT <= ParOpen[TimeFrame]) {
     
104.                         Position = -1;
     
105.                         Transition = -1;              
     
106.                         ParClose = HHValue;
     
107.                         HHValue = HighHT;
     
108.                         LLValue  = LowHT;
     
109.             
     
110.                         Af = AfStep;
     
111.                         ParOpen = ParClose + Af * (LLValue - ParClose);
     
112.                            
     
113.                         if(ParOpen < HighHT) {
     
114.                             ParOpen = HighHT;
     
115.                         }
     
116.                         
     
117.                         if(ParOpen < HighHT[TimeFrame]) {
     
118.                             ParOpen = HighHT[TimeFrame];
     
119.                         }
     
120.                     } else {
     
121.                         Position = Position[TimeFrame];
     
122.                         ParClose = ParOpen[TimeFrame];                    
     
123.                         if(HHValue > HHValue[TimeFrame] && Af[TimeFrame] < AfLimit) {
     
124.                             if(Af[TimeFrame] + AfStep > AfLimit) {
     
125.                                 Af = AfLimit;
     
126.                             } else {
     
127.                                 Af = Af[TimeFrame] + AfStep;
     
128.                             }               
     
129.                         } else {
     
130.                             Af = Af[TimeFrame];
     
131.                         }   
     
132.                         ParOpen = ParClose + Af * (HHValue - ParClose);               
     
133.             
     
134.                         if(ParOpen > LowHT) {
     
135.                             ParOpen = LowHT;
     
136.                         }
     
137.                         
     
138.                         if(ParOpen > LowHT[TimeFrame]) {
     
139.                             ParOpen = LowHT[TimeFrame];
     
140.                         }
     
141.                     }
     
142.                 } else {
     
143.                     if(HighHT >= ParOpen[TimeFrame]) {
     
144.                         Position = 1;
     
145.                         Transition = 1;
     
146.                         
     
147.                         ParClose = LLValue;
     
148.                         HHValue = HighHT;
     
149.                         LLValue  = LowHT;
     
150.                         
     
151.                         Af = AfStep;
     
152.                         ParOpen = ParClose + Af * (HHValue - ParClose);
     
153.                         if(ParOpen > LowHT) {
     
154.                             ParOpen = LowHT;
     
155.                         }
     
156.                         
     
157.                         if(ParOpen > LowHT[TimeFrame]) {
     
158.                             ParOpen = LowHT[TimeFrame];
     
159.                         }
     
160.                     } else {
     
161.                         Position = Position[TimeFrame];
     
162.                         ParClose = ParOpen[TimeFrame];
     
163.                            
     
164.                         if(LLValue < LLValue[TimeFrame] && Af[TimeFrame] < AfLimit) {
     
165.                             if(Af[TimeFrame] + AfStep > AfLimit) {
     
166.                                 Af = AfLimit;
     
167.                             } else {
     
168.                                 Af = Af[TimeFrame] + AfStep;
     
169.                             }
     
170.                         } else {
     
171.                             Af = Af[TimeFrame];
     
172.                         }
     
173.                         ParOpen = ParClose + Af * (LLValue - ParClose);
     
174.             
     
175.                         if(ParOpen < HighHT) {
     
176.                             ParOpen = HighHT;
     
177.                         }
     
178.                         
     
179.                         if(ParOpen < HighHT[TimeFrame]) {
     
180.                             ParOpen = HighHT[TimeFrame];
     
181.                         }
     
182.                     }
     
183.                 }   
     
184.             }
     
185.         }
     
186.     }
     
187.    
     
188.     //上面的程序，在每根小周期的K線上，記錄了它所屬的大時間周期下的開高低收等值的變化。
     
189.     //接下來，要把在大的時間周期級別上，屬于同一根K線的開高低收這些數據，記錄在這一組小周期K線的最后一根上。
     
190.     barCntSum = barCnt;
     
191. 
     
192.     if(BarsBack == 0) {             //如果Bar偏移參數為0，則取每根小周期K線上保留的大時間周期截止到這根小周期K線為止的BAR數據
     
193.         barCntSum = 0;
     
194.     } else if(BarsBack == 1) {      //如果Bar偏移參數為1，則取大時間周期的上一根K線的BAr數據
     
195.         barCntSum = barCnt;
     
196.     } else {                        //如果BAR偏移參數為其他，則取大時間周期的指定偏移后的那根K線的BAR數據
     
197.         for i = 2 to BarsBack {
     
198.             barCntSum = barCntSum + barCnt[barCntSum];
     
199.         }
     
200.     }
     
201. 
     
202.     //最后將相應的K線數據作為引用參數返回
     
203.     oParClose = ParClose[barCntSum];
     
204.     oParOpen = ParOpen[barCntSum];
     
205.     oPosition = Position[barCntSum];
     
206.     oTransition = Transition[barCntSum];
     
207.    
     
208.     Return true;
     
209. End

duck_arrow 發表于 2014-5-13 15:12
群主我用rb的日線跟此函數timeframe1440進行了對比發現不匹配

1. //------------------------------------------------------------------------
   
2. // 西門 ParabolicSAR_ximen
   
3. // 描述 求拋物線轉向，修正系統默認用當前bar會導致閃爍的問題，采用[1]來做判斷依據，比系統默認函數更精確
   
4. // 返回 True 或 false。除了函數本身的返回值，還通過oParCl、oParOpen、oPosition、oTransition這四個引用參數把對應Bar的停損值、對應Bar的停損值下一根的停損值、對應Bar建議的持倉狀態（1 - 多頭，-1 - 空頭）、對應Bar的狀態是否發生反轉（1 或 -1 為反轉，0 為保持不變）
   
5. // 版本 20140511
   
6. //------------------------------------------------------------------------
   
7. 
   
8. 
   
9. Params
   
10.     Numeric AfStep(0.02);
    
11.     Numeric AfLimit(0.2);
    
12.     NumericRef oParClose;
    
13.     NumericRef oParOpen;
    
14.     NumericRef oPosition;
    
15.     NumericRef oTransition;
    
16.    
    
17. Vars
    
18.     NumericSeries HighHT;
    
19.     NumericSeries LowHT;
    
20. 
    
21.     NumericSeries Af(0);   
    
22.     NumericSeries ParOpen(0);
    
23.     NumericSeries ParClose(0);
    
24.     NumericSeries Position(0);  
    
25.     NumericSeries HHValue(0);
    
26.     NumericSeries LLValue(0);
    
27.     NumericSeries Transition(0);
    
28. 
    
29. Begin               
    
30.     if(CurrentBar == 0) {
    
31.                 HighHT = High;
    
32.                 LowHT = Low;
    
33.                
    
34.         Position = 1;
    
35.         Transition = 1;
    
36.         Af = AfStep;
    
37.         HHValue = HighHT;
    
38.         LLValue = LowHT;
    
39.         ParClose = LLValue;
    
40.         ParOpen = ParClose + Af * ( HHValue - ParClose);
    
41.         if(ParOpen > LowHT) {
    
42.             ParOpen = LowHT;
    
43.         }
    
44.     } else {
    
45.                 HighHT = High[1];
    
46.                 LowHT = Low[1];
    
47.                
    
48.                 HHValue = Max(HHValue[1], HighHT);
    
49.                 LLValue = Min(LLValue[1], LowHT);
    
50. 
    
51.         Transition = 0;
    
52. 
    
53.         if(Position[1] == 1) {
    
54.             if(LowHT <= ParOpen[1]) {
    
55.                 Position = -1;
    
56.                 Transition = -1;              
    
57.                 ParClose = HHValue;
    
58.                 HHValue = HighHT;
    
59.                 LLValue  = LowHT;
    
60.    
    
61.                 Af = AfStep;
    
62.                 ParOpen = ParClose + Af * (LLValue - ParClose);
    
63.                     
    
64.                 if(ParOpen < HighHT) {
    
65.                     ParOpen = HighHT;
    
66.                 }
    
67.                
    
68.                 if(ParOpen < HighHT[1]) {
    
69.                     ParOpen = HighHT[1];
    
70.                 }
    
71.             } else {
    
72.                 Position = Position[1];
    
73.                 ParClose = ParOpen[1];                    
    
74.                 if(HHValue > HHValue[1] && Af[1] < AfLimit) {
    
75.                     if(Af[1] + AfStep > AfLimit) {
    
76.                         Af = AfLimit;
    
77.                     } else {
    
78.                         Af = Af[1] + AfStep;
    
79.                     }               
    
80.                 } else {
    
81.                     Af = Af[1];
    
82.                 }   
    
83.                 ParOpen = ParClose + Af * (HHValue - ParClose);               
    
84.    
    
85.                 if(ParOpen > LowHT) {
    
86.                     ParOpen = LowHT;
    
87.                 }
    
88.                
    
89.                 if(ParOpen > LowHT[1]) {
    
90.                     ParOpen = LowHT[1];
    
91.                 }
    
92.             }
    
93.         } else {
    
94.             if(HighHT >= ParOpen[1]) {
    
95.                 Position = 1;
    
96.                 Transition = 1;
    
97.                
    
98.                 ParClose = LLValue;
    
99.                 HHValue = HighHT;
    
100.                 LLValue  = LowHT;
     
101.                
     
102.                 Af = AfStep;
     
103.                 ParOpen = ParClose + Af * (HHValue - ParClose);
     
104.                 if(ParOpen > LowHT) {
     
105.                     ParOpen = LowHT;
     
106.                 }
     
107.                
     
108.                 if(ParOpen > LowHT[1]) {
     
109.                     ParOpen = LowHT[1];
     
110.                 }
     
111.             } else {
     
112.                 Position = Position[1];
     
113.                 ParClose = ParOpen[1];
     
114.                     
     
115.                 if(LLValue < LLValue[1] && Af[1] < AfLimit) {
     
116.                     if(Af[1] + AfStep > AfLimit) {
     
117.                         Af = AfLimit;
     
118.                     } else {
     
119.                         Af = Af[1] + AfStep;
     
120.                     }
     
121.                 } else {
     
122.                     Af = Af[1];
     
123.                 }
     
124.                 ParOpen = ParClose + Af * (LLValue - ParClose);
     
125.    
     
126.                 if(ParOpen < HighHT) {
     
127.                     ParOpen = HighHT;
     
128.                 }
     
129.                
     
130.                 if(ParOpen < HighHT[1]) {
     
131.                     ParOpen = HighHT[1];
     
132.                 }
     
133.             }
     
134.         }  
     
135.     }   
     
136.    
     
137.     oParClose = ParClose;
     
138.     oParOpen = ParOpen;
     
139.     oPosition = Position;
     
140.     oTransition = Transition;
     
141. 
     
142.     Return True;
     
143. End

1. Params
   
2. 
   
3. Vars       
   
4.         Numeric oParCl;
   
5.         Numeric oParOp;
   
6.         Numeric oPosition;
   
7.         Numeric oTransition;
   
8.        
   
9. begin
   
10.         ParabolicSAR_ximen(0.02, 0.2, oParCl, oParOp, oPosition, oTransition);
    
11.          
    
12.         Commentary("oParCl:" + Text(oParCl));
    
13.         Commentary("oParOp:" + Text(oParOp));
    
14.         Commentary("oPosition:" + Text(oPosition));
    
15.         Commentary("oTransition:" + Text(oTransition));
    
16. End