Phase Adaptive_v1.0

1. //+------------------------------------------------------------------+
   
2. //|                                     Phase Adaptive_v1.0 600+.mq4 |
   
3. //|                                Copyright © 2016, TrendLaboratory |
   
4. //|            http://finance.groups.yahoo.com/group/TrendLaboratory |
   
5. //|                                   E-mail: igorad2003@yahoo.co.uk |
   
6. //+------------------------------------------------------------------+
   
7. #property copyright "Copyright © 2016, TrendLaboratory"
   
8. #property link      "http://finance.groups.yahoo.com/group/TrendLaboratory"
   
9. #property link      "http://newdigital-world.com/forum.php"
   
10. 
    
11. 
    
12. #property indicator_separate_window
    
13. #property indicator_buffers   1
    
14. #property indicator_color1    clrDeepSkyBlue
    
15. #property indicator_width1    2
    
16. 
    
17. #property indicator_level1    90
    
18. #property indicator_level2    180
    
19. #property indicator_level3    270
    
20. 
    
21. #property indicator_minimum   0
    
22. #property indicator_maximum   360   
    
23. 
    
24. enum ENUM_PRICE
    
25. {
    
26.    close,               // Close
    
27.    open,                // Open
    
28.    high,                // High
    
29.    low,                 // Low
    
30.    median,              // Median
    
31.    typical,             // Typical
    
32.    weightedClose,       // Weighted Close
    
33.    heikenAshiClose,     // Heiken Ashi Close
    
34.    heikenAshiOpen,      // Heiken Ashi Open
    
35.    heikenAshiHigh,      // Heiken Ashi High   
    
36.    heikenAshiLow,       // Heiken Ashi Low
    
37.    heikenAshiMedian,    // Heiken Ashi Median
    
38.    heikenAshiTypical,   // Heiken Ashi Typical
    
39.    heikenAshiWeighted   // Heiken Ashi Weighted Close   
    
40. };
    
41. 
    
42. #define pi 3.14159265358979323846
    
43. 
    
44. 
    
45. 
    
46. //---- input parameters
    
47. input ENUM_TIMEFRAMES   TimeFrame            =     0;       // Timeframe
    
48. input ENUM_PRICE        Price                =     0;       // Price
    
49. input double            CyclePeriod          =    15;       // Cycle Period Ratio
    
50. input bool              AdaptiveModeOn       = false;       // Adaptive Mode On/Off
    
51. input double            Alpha                =  0.07;       // Cycle Smoothing Factor(eg. 0.07)
    
52. input int               MedianPeriod         =     5;       // Period of Moving Median
    
53. input int               DCsmooth             =     5;       // Period of Dominant Cycle Smoothing
    
54. 
    
55. 
    
56. 
    
57. //---- buffers
    
58. double phase[];
    
59. double iprice[];
    
60. 
    
61. int      timeframe, draw_begin;
    
62. string   TF, IndicatorName;
    
63. //+------------------------------------------------------------------+
    
64. //| Custom indicator initialization function                         |
    
65. //+------------------------------------------------------------------+
    
66. int init()
    
67. {
    
68.    timeframe = TimeFrame;
    
69.    if(timeframe <= Period()) timeframe = Period();
    
70.    TF = tf(timeframe);
    
71.    
    
72.    IndicatorDigits(5);
    
73.    //---- indicators
    
74.    IndicatorBuffers(2);
    
75.    SetIndexBuffer(0, phase); SetIndexStyle(0,DRAW_LINE);
    
76.    SetIndexBuffer(1,iprice);
    
77. //----
    
78.    IndicatorName = WindowExpertName();
    
79.    IndicatorShortName(IndicatorName+"["+TF+"]("+Price+","+DoubleToStr(CyclePeriod,2)+")");
    
80.    SetIndexLabel(0,"Phase");
    
81.    
    
82. //----   
    
83.    draw_begin = MathMax(2,Bars - iBars(NULL,timeframe)*timeframe/Period() + 50);
    
84. 
    
85.    SetIndexDrawBegin(0,draw_begin);
    
86.    
    
87.    return(0);
    
88. }
    
89. 
    
90. int deinit()
    
91. {
    
92.    return(0);
    
93. }
    
94. //+------------------------------------------------------------------+
    
95. //| Phase Adaptive_v1.0 600+                                         |
    
96. //+------------------------------------------------------------------+
    
97. int start()
    
98. {
    
99.    int   shift, limit, counted_bars=IndicatorCounted();
    
100.    
     
101. //----
     
102.    if(counted_bars > 0) limit = Bars - counted_bars - 1;
     
103.    if(counted_bars < 0) return(0);
     
104.    if(counted_bars < 1)
     
105.    {
     
106.    limit = Bars - 1;   
     
107.       for(int i=limit;i>=0;i--)
     
108.       {
     
109.       phase[i] = EMPTY_VALUE;
     
110.       }
     
111.    }   
     
112.    
     
113.    if(timeframe != Period())
     
114.         {
     
115.    limit = MathMax(limit,timeframe/Period());   
     
116.       
     
117.       for(shift = 0;shift < limit;shift++)
     
118.       {       
     
119.       int y = iBarShift(NULL,timeframe,Time[shift]);
     
120.       
     
121.       phase[shift] = iCustom(NULL,TimeFrame,IndicatorName,0,Price,CyclePeriod,AdaptiveModeOn,Alpha,MedianPeriod,DCsmooth,0,y);  
     
122.       }
     
123.        
     
124.         return(0);
     
125.         }
     
126.         else _adaptivePhase(limit);
     
127.        
     
128.        
     
129. //----
     
130.    return(0);
     
131. }
     
132. //+------------------------------------------------------------------+
     
133. void _adaptivePhase(int limit)
     
134. {   
     
135.    double   ;
     
136.    
     
137.    
     
138.    for(int shift=limit;shift>=0;shift--)
     
139.    {
     
140.       if(Price <= 6) iprice[shift] = iMA(NULL,0,1,0,0,(int)Price,shift);   
     
141.       else
     
142.       if(Price > 6 && Price <= 13) iprice[shift] = HeikenAshi(0,(int)Price-7,shift);
     
143.       
     
144.    if(AdaptiveModeOn)
     
145.    {
     
146.    double cyclelen = cyclePeriod(iprice,Alpha,MedianPeriod,DCsmooth,shift);  
     
147.    int domcycle    = MathMax(1,MathFloor(CyclePeriod*cyclelen));
     
148.    }
     
149.    else domcycle   = MathMax(1,MathFloor(CyclePeriod));
     
150.    
     
151.    double realPart = 0;
     
152.    double imagPart = 0;
     
153.    
     
154.       for(int i=0;i<domcycle;i++)
     
155.       {
     
156.          if(domcycle > 0)
     
157.          {
     
158.          double weight = iprice[shift+i];
     
159.          realPart += MathCos(2*pi*i/domcycle)*weight;
     
160.          imagPart += MathSin(2*pi*i/domcycle)*weight;
     
161.          }
     
162.       }
     
163.       
     
164.    if(MathAbs(realPart) > 0.001) phase[shift] = MathArctan(imagPart/realPart); else phase[shift] = 0.5*pi*Sign(imagPart);
     
165.    
     
166.    if(realPart < 0) phase[shift] = phase[shift] + pi;
     
167.    phase[shift] = phase[shift] + pi/2;   
     
168.    
     
169.    if(phase[shift] <    0) phase[shift] = phase[shift] + 2*pi;
     
170.    if(phase[shift] > 2*pi) phase[shift] = phase[shift] - 2*pi;   
     
171.    
     
172.    phase[shift] = 180*phase[shift]/pi;
     
173.    }
     
174. }
     
175. 
     
176. 
     
177. 
     
178. 
     
179. double Sign(double value)
     
180. {
     
181.    if(value > 0) return( 1);
     
182.    if(value < 0) return(-1);
     
183.   
     
184.    return(0);
     
185. }        
     
186. 
     
187.                
     
188. 
     
189. double   DeltaPhase[], aPrice[4], smooth[3], cycle[7], Q1[2], I1[2], iPeriod[2], cPeriod[4];
     
190. datetime prevcptime;
     
191. 
     
192. double cyclePeriod(double& price[],double alpha,int median,int dcsmooth,int bar)
     
193. {      
     
194.    double DC, MedianDelta = 0;
     
195.    
     
196.    
     
197.    if(ArraySize(DeltaPhase) != Bars)
     
198.    {
     
199.    ArraySetAsSeries(DeltaPhase,false);
     
200.    ArrayResize(DeltaPhase,Bars);
     
201.    ArraySetAsSeries(DeltaPhase,true);
     
202.    }   
     
203.         
     
204.       if(prevcptime != Time[bar])
     
205.       {
     
206.          for(int i=6;i>=1;i--)
     
207.          {
     
208.          cycle[i] = cycle[i-1];
     
209.             if(i < 4)
     
210.             {
     
211.             aPrice[i]  = aPrice[i-1];
     
212.             cPeriod[i] = cPeriod[i-1];
     
213.             }
     
214.          if(i < 3) smooth[i] = smooth[i-1];
     
215.          }
     
216.       I1[1] = I1[0];
     
217.       Q1[1] = Q1[0];
     
218.       iPeriod[1] = iPeriod[0];
     
219.       
     
220.       prevcptime = Time[bar];
     
221.       }   
     
222. 
     
223.    aPrice[0] = price[bar];   
     
224.          
     
225.    if(bar < Bars - 3) smooth[0] = (aPrice[0] + 2*aPrice[1] + 2*aPrice[2] + aPrice[3])/6;
     
226.         cycle[0] = (1 - 0.5*alpha)*(1 - 0.5*alpha)*(smooth[0] - 2*smooth[1] + smooth[2]) + 2*(1-alpha)*cycle[1] - (1-alpha)*(1-alpha)*cycle[2];
     
227.         if(bar > Bars - 7) cycle[0] = (aPrice[0] - 2*aPrice[1] + aPrice[2])/4;  
     
228.           
     
229.           
     
230.    Q1[0] = (0.0962*cycle[0] + 0.5769*cycle[2] - 0.5769*cycle[4] - 0.0962*cycle[6])*(0.5 + 0.08*iPeriod[1]);
     
231.    I1[0] = cycle[3];  
     
232.        
     
233.         if(bar < Bars- median)
     
234.         {
     
235.         if(Q1[0] != 0 && Q1[1] != 0) DeltaPhase[bar] = (I1[0]/Q1[0] - I1[1]/Q1[1])/(1 + I1[0]*I1[1]/(Q1[0]*Q1[1]));               
     
236.    if(DeltaPhase[bar] < 0.1) DeltaPhase[bar] = 0.1;  
     
237.    if(DeltaPhase[bar] > 1.1) DeltaPhase[bar] = 1.1;
     
238.    MedianDelta = MedianOnArray(DeltaPhase,median,bar);
     
239.    
     
240.       if(MedianDelta == 0) DC = 15; else DC = 6.28318/MedianDelta + 0.5;
     
241.        
     
242.    iPeriod[0] = 0.33*DC + (1 - 2.0/(dcsmooth + 1))*iPeriod[1];
     
243.    cPeriod[0] = 0.15*iPeriod[0] + 0.85*cPeriod[1];
     
244.    }
     
245.    
     
246.    if(cPeriod[3] == 0) return(0);     
     
247.    return(cPeriod[0]);
     
248. }   
     
249. 
     
250. 
     
251. double MedianOnArray(double& price[],int per,int bar)
     
252. {
     
253.    double median, array[];
     
254.    ArrayResize(array,per);
     
255.    
     
256.    for(int i=0;i<per;i++) array[i] = price[bar+i];
     
257.    ArraySort(array,WHOLE_ARRAY,0,MODE_DESCEND);
     
258.    
     
259.    int num = (int)MathRound((per - 1)*0.5);
     
260.    if(MathMod(per,2) > 0) median = array[num]; else median = 0.5*(array[num] + array[num+1]);
     
261.    
     
262.    return(median);
     
263. }
     
264. 
     
265. 
     
266. 
     
267. // HeikenAshi Price
     
268. double   haClose[2][2], haOpen[2][2], haHigh[2][2], haLow[2][2];
     
269. datetime prevhatime[2];
     
270. 
     
271. double HeikenAshi(int index,int price,int bar)
     
272. {
     
273.    if(prevhatime[index] != Time[bar])
     
274.    {
     
275.    haClose[index][1] = haClose[index][0];
     
276.    haOpen [index][1] = haOpen [index][0];
     
277.    haHigh [index][1] = haHigh [index][0];
     
278.    haLow  [index][1] = haLow  [index][0];
     
279.    prevhatime[index] = Time[bar];
     
280.    }
     
281.    
     
282.    if(bar == Bars - 1)
     
283.    {
     
284.    haClose[index][0] = Close[bar];
     
285.    haOpen [index][0] = Open [bar];
     
286.    haHigh [index][0] = High [bar];
     
287.    haLow  [index][0] = Low  [bar];
     
288.    }
     
289.    else
     
290.    {
     
291.    haClose[index][0] = (Open[bar] + High[bar] + Low[bar] + Close[bar])/4;
     
292.    haOpen [index][0] = (haOpen[index][1] + haClose[index][1])/2;
     
293.    haHigh [index][0] = MathMax(High[bar],MathMax(haOpen[index][0],haClose[index][0]));
     
294.    haLow  [index][0] = MathMin(Low [bar],MathMin(haOpen[index][0],haClose[index][0]));
     
295.    }
     
296.    
     
297.    switch(price)
     
298.    {
     
299.    case  0: return(haClose[index][0]); break;
     
300.    case  1: return(haOpen [index][0]); break;
     
301.    case  2: return(haHigh [index][0]); break;
     
302.    case  3: return(haLow  [index][0]); break;
     
303.    case  4: return((haHigh[index][0] + haLow[index][0])/2); break;
     
304.    case  5: return((haHigh[index][0] + haLow[index][0] +   haClose[index][0])/3); break;
     
305.    case  6: return((haHigh[index][0] + haLow[index][0] + 2*haClose[index][0])/4); break;
     
306.    default: return(haClose[index][0]); break;
     
307.    }
     
308. }     
     
309. 
     
310. 
     
311. string tf(int itimeframe)
     
312. {
     
313.    string result = "";
     
314.    
     
315.    switch(itimeframe)
     
316.    {
     
317.    case PERIOD_M1:   result = "M1" ;
     
318.    case PERIOD_M5:   result = "M5" ;
     
319.    case PERIOD_M15:  result = "M15";
     
320.    case PERIOD_M30:  result = "M30";
     
321.    case PERIOD_H1:   result = "H1" ;
     
322.    case PERIOD_H4:   result = "H4" ;
     
323.    case PERIOD_D1:   result = "D1" ;
     
324.    case PERIOD_W1:   result = "W1" ;
     
325.    case PERIOD_MN1:  result = "MN1";
     
326.    default:          result = "N/A";
     
327.    }
     
328.    
     
329.    if(result == "N/A")
     
330.    {
     
331.    if(itimeframe <  PERIOD_H1 ) result = "M"  + (string)itimeframe;
     
332.    if(itimeframe >= PERIOD_H1 ) result = "H"  + (string)(itimeframe/PERIOD_H1);
     
333.    if(itimeframe >= PERIOD_D1 ) result = "D"  + (string)(itimeframe/PERIOD_D1);
     
334.    if(itimeframe >= PERIOD_W1 ) result = "W"  + (string)(itimeframe/PERIOD_W1);
     
335.    if(itimeframe >= PERIOD_MN1) result = "MN" + (string)(itimeframe/PERIOD_MN1);
     
336.    }
     
337.    
     
338.    return(result);
     
339. }
     
340. 
     

复制代码

Phase Adaptive_v1.0 600u.mq4

2018-3-28 20:51

点击文件名下载附件

路过，支持一下啦

过来看看的

我是个凑数的。。。

难得一见的好帖

小手一抖，积分到手！

学习了，不错

谢谢

谢谢