MT4智能交易编程示例 SAR指标

MT4智能交易

MT4智能交易编程示例 SAR指标

1. #property copyright   "路路发智能交易研发中心"
   
2. #property link        "http://www.ea668.com"
   
3. #property description "Parabolic Stop-And-Reversal system"
   
4. #property strict
   
5. 
   
6. //--- indicator settings
   
7. #property indicator_chart_window
   
8. #property indicator_buffers 1
   
9. #property indicator_color1  Lime
   
10. //--- input parameters
    
11. input double InpSARStep=0.02;    // Step
    
12. input double InpSARMaximum=0.2;  // Maximum
    
13. //---- buffers
    
14. double       ExtSARBuffer[];
    
15. //--- global variables
    
16. double       ExtSarStep;
    
17. double       ExtSarMaximum;
    
18. int          ExtLastReverse;
    
19. bool         ExtDirectionLong;
    
20. double       ExtLastStep,ExtLastEP,ExtLastSAR;
    
21. double       ExtLastHigh,ExtLastLow;
    
22. //+------------------------------------------------------------------+
    
23. //| Custom indicator initialization function                         |
    
24. //+------------------------------------------------------------------+
    
25. void OnInit()
    
26.   {
    
27. //--- checking input data
    
28.    if(InpSARStep<0.0)
    
29.      {
    
30.       ExtSarStep=0.02;
    
31.       Print("Input parametr InpSARStep has incorrect value. Indicator will use value ",
    
32.             ExtSarStep," for calculations.");
    
33.      }
    
34.    else
    
35.       ExtSarStep=InpSARStep;
    
36.    if(InpSARMaximum<0.0)
    
37.      {
    
38.       ExtSarMaximum=0.2;
    
39.       Print("Input parametr InpSARMaximum has incorrect value. Indicator will use value ",
    
40.             ExtSarMaximum," for calculations.");
    
41.      }
    
42.    else
    
43.       ExtSarMaximum=InpSARMaximum;
    
44. //--- drawing settings
    
45.    IndicatorDigits(Digits);
    
46.    SetIndexStyle(0,DRAW_ARROW);
    
47.    SetIndexArrow(0,159);
    
48. //---- indicator buffers
    
49.    SetIndexBuffer(0,ExtSARBuffer);
    
50. //--- set short name
    
51.    IndicatorShortName("SAR("+DoubleToString(ExtSarStep,2)+","+DoubleToString(ExtSarMaximum,2)+")");
    
52. //--- set global variables
    
53.    ExtLastReverse=0;
    
54.    ExtDirectionLong=false;
    
55.    ExtLastStep=ExtLastEP=ExtLastSAR=0.0;
    
56.    ExtLastHigh=ExtLastLow=0.0;
    
57. //----
    
58.   }
    
59. //+------------------------------------------------------------------+
    
60. //| Parabolic SAR                                                    |
    
61. //+------------------------------------------------------------------+
    
62. int OnCalculate(const int rates_total,
    
63.                 const int prev_calculated,
    
64.                 const datetime &time[],
    
65.                 const double &open[],
    
66.                 const double &high[],
    
67.                 const double &low[],
    
68.                 const double &close[],
    
69.                 const long& tick_volume[],
    
70.                 const long& volume[],
    
71.                 const int& spread[])
    
72.   {
    
73.    bool   dir_long;
    
74.    double last_high,last_low,ep,sar,step;
    
75.    int    i;
    
76. //--- check for minimum rates count
    
77.    if(rates_total<3)
    
78.       return(0);
    
79. //--- counting from 0 to rates_total
    
80.    ArraySetAsSeries(ExtSARBuffer,false);
    
81.    ArraySetAsSeries(high,false);
    
82.    ArraySetAsSeries(low,false);
    
83. //--- detect current position for calculations
    
84.    i=prev_calculated-1;
    
85. //--- calculations from start?
    
86.    if(i<1)
    
87.      {
    
88.       ExtLastReverse=0;
    
89.       dir_long=true;
    
90.       step=ExtSarStep;
    
91.       last_high=-10000000.0;
    
92.       last_low=10000000.0;
    
93.       sar=0;
    
94.       i=1;
    
95.       while(i<rates_total-1)
    
96.         {
    
97.          ExtLastReverse=i;
    
98.          if(last_low>low[i])
    
99.             last_low=low[i];
    
100.          if(last_high<high[i])
     
101.             last_high=high[i];
     
102.          if(high[i]>high[i-1] && low[i]>low[i-1])
     
103.             break;
     
104.          if(high[i]<high[i-1] && low[i]<low[i-1])
     
105.            {
     
106.             dir_long=false;
     
107.             break;
     
108.            }
     
109.          i++;
     
110.         }
     
111.       //--- initialize with zero
     
112.       ArrayInitialize(ExtSARBuffer,0.0);
     
113.       //--- go check
     
114.       if(dir_long)
     
115.         {
     
116.          ExtSARBuffer[i]=low[i-1];
     
117.          ep=high[i];
     
118.         }
     
119.       else
     
120.         {
     
121.          ExtSARBuffer[i]=high[i-1];
     
122.          ep=low[i];
     
123.         }
     
124.       i++;
     
125.      }
     
126.    else
     
127.      {
     
128.       //--- calculations to be continued. restore last values
     
129.       i=ExtLastReverse;
     
130.       step=ExtLastStep;
     
131.       dir_long=ExtDirectionLong;
     
132.       last_high=ExtLastHigh;
     
133.       last_low=ExtLastLow;
     
134.       ep=ExtLastEP;
     
135.       sar=ExtLastSAR;
     
136.      }
     
137. //---main cycle
     
138.    while(i<rates_total)
     
139.      {
     
140.       //--- check for reverse
     
141.       if(dir_long && low[i]<ExtSARBuffer[i-1])
     
142.         {
     
143.          SaveLastReverse(i,true,step,low[i],last_high,ep,sar);
     
144.          step=ExtSarStep;
     
145.          dir_long=false;
     
146.          ep=low[i];
     
147.          last_low=low[i];
     
148.          ExtSARBuffer[i++]=last_high;
     
149.          continue;
     
150.         }
     
151.       if(!dir_long && high[i]>ExtSARBuffer[i-1])
     
152.         {
     
153.          SaveLastReverse(i,false,step,last_low,high[i],ep,sar);
     
154.          step=ExtSarStep;
     
155.          dir_long=true;
     
156.          ep=high[i];
     
157.          last_high=high[i];
     
158.          ExtSARBuffer[i++]=last_low;
     
159.          continue;
     
160.         }
     
161.       //---
     
162.       sar=ExtSARBuffer[i-1]+step*(ep-ExtSARBuffer[i-1]);
     
163.       //--- LONG?
     
164.       if(dir_long)
     
165.         {
     
166.          if(ep<high[i])
     
167.            {
     
168.             if((step+ExtSarStep)<=ExtSarMaximum)
     
169.                step+=ExtSarStep;
     
170.            }
     
171.          if(high[i]<high[i-1] && i==2)
     
172.             sar=ExtSARBuffer[i-1];
     
173.          if(sar>low[i-1])
     
174.             sar=low[i-1];
     
175.          if(sar>low[i-2])
     
176.             sar=low[i-2];
     
177.          if(sar>low[i])
     
178.            {
     
179.             SaveLastReverse(i,true,step,low[i],last_high,ep,sar);
     
180.             step=ExtSarStep; dir_long=false; ep=low[i];
     
181.             last_low=low[i];
     
182.             ExtSARBuffer[i++]=last_high;
     
183.             continue;
     
184.            }
     
185.          if(ep<high[i])
     
186.             ep=last_high=high[i];
     
187.         }
     
188.       else // SHORT
     
189.         {
     
190.          if(ep>low[i])
     
191.            {
     
192.             if((step+ExtSarStep)<=ExtSarMaximum)
     
193.                step+=ExtSarStep;
     
194.            }
     
195.          if(low[i]<low[i-1] && i==2)
     
196.             sar=ExtSARBuffer[i-1];
     
197.          if(sar<high[i-1])
     
198.             sar=high[i-1];
     
199.          if(sar<high[i-2])
     
200.             sar=high[i-2];
     
201.          if(sar<high[i])
     
202.            {
     
203.             SaveLastReverse(i,false,step,last_low,high[i],ep,sar);
     
204.             step=ExtSarStep;
     
205.             dir_long=true;
     
206.             ep=high[i];
     
207.             last_high=high[i];
     
208.             ExtSARBuffer[i++]=last_low;
     
209.             continue;
     
210.            }
     
211.          if(ep>low[i])
     
212.             ep=last_low=low[i];
     
213.         }
     
214.       ExtSARBuffer[i++]=sar;
     
215.      }
     
216. //---- OnCalculate done. Return new prev_calculated.
     
217.    return(rates_total);
     
218.   }
     
219. //+------------------------------------------------------------------+
     
220. //|  save last values to continue further calculations               |
     
221. //+------------------------------------------------------------------+
     
222. void SaveLastReverse(int reverse,bool dir,double step,double last_low,double last_high,double ep,double sar)
     
223.   {
     
224.    ExtLastReverse=reverse;
     
225.    if(ExtLastReverse<2)
     
226.       ExtLastReverse=2;
     
227.    ExtDirectionLong=dir;
     
228.    ExtLastStep=step;
     
229.    ExtLastLow=last_low;
     
230.    ExtLastHigh=last_high;
     
231.    ExtLastEP=ep;
     
232.    ExtLastSAR=sar;
     
233.   }
     
234. //+------------------------------------------------------------------+
     

复制代码