Services & Features
ProRealCode - Trading & Coding with ProRealTime™
The ProRealTime™ community on the web! Officially sharing ProRealTime knowledge to Worldwide users since 2015!
More from ProRealCode
ProRealCode - Trading & Coding with ProRealTime™
Need Assistance?
Follow our form easy steps to get help
Forums
Get Help
Need Assistance?
Follow our form easy steps to get help
Help
Get Help
Need Assistance?
Follow our form easy steps to get help
Recently Searched:
No recent search
Use the above field to search the website.
errore di programmazione
- ProRealTime Forum
- Forum ProRealTime Italiano
- ProOrder: Trading Automatico & Backtesting
- errore di programmazione
Viewing 1 post (of 1 total)
-
AuthorPosts
-
//--------- EXPLANATION ---------------------------------------------------------------- // "Machine learning strategy " of best crossing strategy of 69 different averages // The strategy is simple // if first average crosses above second avarage, go buy long // and vice versa first average crosses under second avarage, sell short // To protect the position, a stop loss (TSL) is set TSL = round(100/10000*close) // Exit the position in the afternoon at 16:00 hr (Defparam flatafter = 160000) // This program is limmited to only one trade per day OTD = Barindex - TradeIndex(1) > IntradayBarIndex, TradeIndex(3) would allow 2 openingstrades per day, TradeIndex(5) would allow 3 trades per day, and so on. // Opening trades only between 8:00 and 11:30, for American trades other times can be set. // There are 69 different types of averages, (listed below), which are used to cross each other (MAType crossing MATypeV2) //To limit Zigzagging of the averages due to market noise, an exponential average of 30 is added before the crossing condition is measured(wAFR = exponentialaverage[30](AFR) and wAFRv2 = exponentialaverage[30](AFRv2)) // To limit the possibilities, the period is set for all average types to 15 (Period = 15, Period2 = 15), you may adjust the period used // You can experiment with a different stop or a trailing stop // Be aware that if you use this "machine learning" on a small set of data, the outcome will be overoptimized and you will find a different optimised set for a different small set of data. // The code is extremely long (> 7.000 lines, due to defining 69 and 69 different averages. The crossing strategy can be found at the last rows ! I was not aware this is possible in PRT //------------------------------------------------------------------------- DEFPARAM cumulateOrders = False // Cumulating positions deactivate DEFPARAM FLATAFTER = 160000 //close the position at 16:00 (day trading) /could be switched of 16 once StartE = 80000 //start time for opening positions once StartL = 113000 //ending time for opening positions (only trading in the morning) once N = 1 // number of contracts once Period = 15 //period1 // // set fixed to limit possible combinations of optimisations once Period2 = 15 // period2 second set of 69 averages // // set fixed to limit possible combinations of optimisations Series = (open+high+low+Close)/4 // kind of close of a bar Seriesv2 = (open+high+low+Close)/4 // kind of close of a bar OTD = Barindex - TradeIndex(1) > IntradayBarIndex // limits the (opening) trades till 1 per day (OTD One Trade per Day) TSL = round(100/10000*close) // dynamic trailing stop loss 1 % ///69 averages to be compared with the same 69 avarages to select best cross over combination// //---------------------------------------// // AFR - Average Filter Regression // // // // Contact: laurenzo(at)gargamail(dot)net // //---------------------------------------// //0. Ahrens Moving Average// // 1. Adjustable Lag FIR // // 2. Arnaud Legoux Moving Average // // 3. 2-Pole Butterworth Smoothing Filter // // 4. 3-Pole Butterworth Smoothing Filter // // 5. Corrected Moving Average by A.Uhl // // 6. d9 Unscented Kalman Filter (Responsiveness Version) // // 7. d9 Unscented Kalman Filter // // 8. Double Exponential Moving Average // // 9. Exponential Least Square Moving Average // // 10. Exponential Moving Average // // 11. Elastic Volume Weighted Moving Average // // 12. Fast Adaptive Trend Line // // 13. Fractional-Bar Quick Moving Average // // 14. Fractal Adaptive Moving Average // // 15. Generalized DEMA // // 16. 1-Pole Gaussian Filter // // 17. 2-Pole Gaussian Filter // // 18. 3-Pole Gaussian Filter // // 19. 4-Pole Gaussian Filter // // 20. Hull Moving Average // // 21. IE/2 Combination of LSMA and ILRS // // 22. Integral of Linear Regression Slope // // 23. iTrend by John Ehlers // // 24. Jurik Moving Average (Responsiveness Version) // // 25. Jurik Moving Average // // 26. Kaufman Adaptive Moving Average // // 27. Kalman Filter by John Ehlers // // 28. Kalman Filter (Responsiveness Version) // // 29. Kalman Filter // // 30. Leader Exponential Moving Average // // 31. Laguerre Filter by John Ehlers // // 32. Least Square Moving Average // // 33. McGinley Dynamic // // 34. Middle High Low Range Moving Average // // 35. McNicholl Moving Average // // 36. Non Lag Moving Average (Responsiveness Version) // // 37. Non Lag Moving Average // // 38. One More Average // // 39. Pentuple Exponential Moving Average // // 40. Parabolic Weighted Moving Average // // 41. Quadruple Exponential Moving Average // // 42. Regularized EMA by Chris Satchwell // // 43. Reference Fast Trend Line // // 44. Reference Slow Trend Line // // 45. Slow Adaptive Trend Line // // 46. Simple Moving Average // // 47. 2-Pole Super Smoothing Filter // // 48. 3-Pole Super Smoothing Filter // // 49. Smoothed Simple Moving Average // // 50. Sine Weighted Moving Average // // 51. T3 Moving Average // // 52. Triple Exponential Moving Average // // 53. Triangular Moving Average // // 54. Time Series Average // // 55. Variable Index Dynamic Average // // 56. Variable Moving Average // // 57. Volume Weighted Average Price // // 58. Wilder Moving Average // // 59. Weighted Least Square Moving Average // // 60. Weighted Moving Average // // 61. Zero Lag BMT // // 62. Zero Lag Double Exponential Moving Average // // 63. Zero Lag FIR Filter // // 64. Zero Lag IIR Filter // // 65. Zero Lag John Ehlers // // 66. Zero Lag Weighted BMT // // 67. Range based AV high + STD - low - STD // 68. Average highest [period] and lowest[period] // 69 DEMA adjusted by itself //------------------------------// // AHMA - Ahrens Moving Average // //------------------------------// IF MAType = 0 THEN Period = MAX(Period, 1) IF BarIndex < Period THEN AFR = Series ELSE AFR = AFR[1] + ((Series - ((AFR[1] + AFR[Period]) / 2)) / Period) ENDIF ENDIF //----------------------------// // ALFIR - Adjustable Lag FIR // //----------------------------// IF MAType = 1 THEN // Lag = 0.7 ({-2.5...2.5}) Lag = 0.7 AFR = (Series + (2 + Lag) * Series[1] + (3 + Lag) * Series[2] + 3 * Series[3] + (2 - Lag) * Series[4] + (1 - Lag) * Series[5] + (0 - Lag) * Series[6]) / (12 - Lag) ENDIF //-------------------------------------// // ALMA - Arnaud Legoux Moving Average // //-------------------------------------// IF MAType = 2 THEN Period = MAX(Period, 1) // Sigma = 6 ({0..30}) // Offset = 0.85 ({0..1}) Sigma = 6 Offset = 0.85 m = ROUND(Offset * (Period - 1)) s = Period / Sigma WtdSum = 0 CumWt = 0 FOR k = 0 TO Period - 1 DO Wtd = EXP(-((k - m) * (k - m)) / (2 * s * s)) WtdSum = WtdSum + Wtd * Series[Period - 1 - k] CumWt = CumWt + Wtd NEXT IF CumWt <= 0 THEN AFR = Series ELSE AFR = WtdSum / CumWt ENDIF ENDIF //---------------------------------------------// // BSF2P - 2-Pole Butterworth Smoothing Filter // //---------------------------------------------// IF MAType = 3 THEN Period = MAX(Period, 1) a1 = EXP(-1.414 * 3.14159 / Period) b1 = 2 * a1 * COS(1.414 * 180 / Period) coef2 = b1 coef3 = -a1 * a1 coef1 = (1 - b1 + a1 * a1) / 4 IF BarIndex < 2 THEN AFR = Series ELSE AFR = coef1 * (Series + 2 * Series[1] + Series[2]) + coef2 * AFR[1] + coef3 * AFR[2] ENDIF ENDIF //---------------------------------------------// // BSF3P - 3-Pole Butterworth Smoothing Filter // //---------------------------------------------// IF MAType = 4 THEN Period = MAX(Period, 1) a1 = EXP(-3.14159 / Period) b1 = 2 * a1 * COS(1.738 * 180 / Period) c1 = a1 * a1 coef2 = b1 + c1 coef3 = -(c1 + b1 * c1) coef4 = c1 * c1 coef1 = (1 - b1 + c1) * (1 - c1) / 8 IF BarIndex < 3 THEN AFR = Series ELSE AFR = coef1 * (Series + 3 * Series[1] + 3 * Series[2] + Series[3]) + coef2 * AFR[1] + coef3 * AFR[2] + coef4 * AFR[3] ENDIF ENDIF //-----------------------------------------// // CMA - Corrected Moving Average by A.Uhl // //-----------------------------------------// IF MAType = 5 THEN Period = MAX(Period, 1) IF BarIndex < Period THEN AFR = Series ELSE MA = Average[Period](Series) v1 = SQUARE(STD[Period](Series)) v2 = SQUARE(AFR[1] - MA) IF v2 < v1 OR v2 = 0 THEN K = 0 ELSE K = 1 - v1 / v2 ENDIF AFR = AFR[1] + K * (MA - AFR[1]) ENDIF ENDIF //-------------------------------------------------------------// // d9UKF - d9 Unscented Kalman Filter (Responsiveness Version) // //-------------------------------------------------------------// IF MAType = 6 THEN // Init Period = MAX(Period, 2) // longAvgWindow = 65 ({40..200}) longAvgWindow = 65 // permissivity = {0..3} permissivity = 2 windowLength = 0.5 * (Period - 1) // FIX LOG - LOG(SQRT(windowLength)) / LOG(2) + 2 lengthParam = (LOG(SQRT(windowLength)) / LOG(10)) / (LOG(2) / LOG(10)) + 2 IF (lengthParam < 0) THEN lengthParam = 0 ENDIF expFactor = lengthParam - 2 IF (expFactor < 0.5) THEN expFactor = 0.5 ENDIF sigma = SQRT(windowLength) * lengthParam beta = sigma / (sigma + 1) data = Average[1](Series) // AverageVMA(Input, 1, 1)[0]; //SMA(Input, 1)[0]; IF (BarIndex < 10) THEN vxCum = 0 hInterval = data lInterval = data Filt0 = data Filt1 = data AFR = data ELSE uDelta = data - hInterval[1] uAbs = ABS(uDelta) lDelta = data - lInterval[1] lAbs = ABS(lDelta) IF (uAbs > lAbs) THEN vx = uAbs ELSIF (uAbs < lAbs) THEN vx = lAbs ELSIF (uAbs = lAbs) THEN vx = 0 ENDIF vxCum = vxCum[1] + 0.1 * (vx - vx[10]) IF (BarIndex <= longAvgWindow + 1) THEN avgVx = avgVx[1] + 2.0 * (vxCum - avgVx[1]) / (longAvgWindow + 1) ELSE // SMA(_vxCum, _longAvgWindow) avgVx = Average[longAvgWindow](vxCum) // SMA(_vxCum, _longAvgWindow) ENDIF IF (avgVx > 0) THEN vxCoeff = vx / avgVx ENDIF // FIX Power - Power(lengthParam, 1.0 / expFactor) IF (EXP((1.0 / expFactor) * LOG(lengthParam))) THEN vxCoeff = EXP((1.0 / expFactor) * LOG(lengthParam)) ENDIF IF (vxCoeff < 1) THEN vxCoeff = 1 ENDIF // FIX Power - Power(vxCoeff, expFactor) vExp = EXP((expFactor) * LOG(vxCoeff)) // FIX Power - Power(beta, SQRT(vExp)) kV = EXP(SQRT(vExp) * LOG(beta)) IF (uDelta > 0) THEN hInterval = data ELSE hInterval = data - kV * uDelta ENDIF IF (lDelta < 0) THEN lInterval = data ELSE lInterval = data - kV * lDelta ENDIF gamma = 0.45 * (Period - 1) / (0.45 * (Period - 1) + 2) // FIX Power - Power(gamma, vExp) alpha = EXP((vExp) * LOG(gamma)) Filt0 = (1 - alpha) * data + alpha * Filt0[1] Det0 = (data - Filt0[0]) * (1 - gamma) + gamma * Det0[1] Filt1 = Filt0[0] + permissivity * Det0[0] Det1 = (Filt1[0] - AFR[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1] AFR = AFR[1] + Det1[0] ENDIF ENDIF //------------------------------------// // d9UKF - d9 Unscented Kalman Filter // //------------------------------------// IF MAType = 7 THEN // Init Period = MAX(Period, 2) // longAvgWindow = {40..200} longAvgWindow = 65 // permissivity = {0..3} permissivity = 1.25 windowLength = 0.5 * (Period - 1) // FIX LOG - LOG(SQRT(windowLength)) / LOG(2) + 2 lengthParam = (LOG(SQRT(windowLength)) / LOG(10)) / (LOG(2) / LOG(10)) + 2 IF (lengthParam < 0) THEN lengthParam = 0 ENDIF expFactor = lengthParam - 2 IF (expFactor < 0.5) THEN expFactor = 0.5 ENDIF sigma = SQRT(windowLength) * lengthParam beta = sigma / (sigma + 1) data = Average[1](Series) // AverageVMA(Input, 1, 1)[0]; //SMA(Input, 1)[0]; IF (BarIndex < 10) THEN vxCum = 0 hInterval = data lInterval = data Filt0 = data Filt1 = data AFR = data ELSE uDelta = data - hInterval[1] uAbs = ABS(uDelta) lDelta = data - lInterval[1] lAbs = ABS(lDelta) IF (uAbs > lAbs) THEN vx = uAbs ELSIF (uAbs < lAbs) THEN vx = lAbs ELSIF (uAbs = lAbs) THEN vx = 0 ENDIF vxCum = vxCum[1] + 0.1 * (vx - vx[10]) IF (BarIndex <= longAvgWindow + 1) THEN avgVx = avgVx[1] + 2.0 * (vxCum - avgVx[1]) / (longAvgWindow + 1) ELSE // SMA(_vxCum, _longAvgWindow) avgVx = Average[longAvgWindow](vxCum) // SMA(_vxCum, _longAvgWindow) ENDIF IF (avgVx > 0) THEN vxCoeff = vx / avgVx ENDIF // FIX Power - Power(lengthParam, 1.0 / expFactor) IF (EXP((1.0 / expFactor) * LOG(lengthParam))) THEN vxCoeff = EXP((1.0 / expFactor) * LOG(lengthParam)) ENDIF IF (vxCoeff < 1) THEN vxCoeff = 1 ENDIF // FIX Power - Power(vxCoeff, expFactor) vExp = EXP((expFactor) * LOG(vxCoeff)) // FIX Power - Power(beta, SQRT(vExp)) kV = EXP(SQRT(vExp) * LOG(beta)) IF (uDelta > 0) THEN hInterval = data ELSE hInterval = data - kV * uDelta ENDIF IF (lDelta < 0) THEN lInterval = data ELSE lInterval = data - kV * lDelta ENDIF gamma = 0.45 * (Period - 1) / (0.45 * (Period - 1) + 2) // FIX Power - Power(gamma, vExp) alpha = EXP((vExp) * LOG(gamma)) Filt0 = (1 - alpha) * data + alpha * Filt0[1] Det0 = (data - Filt0[0]) * (1 - gamma) + gamma * Det0[1] Filt1 = Filt0[0] + permissivity * Det0[0] Det1 = (Filt1[0] - AFR[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1] AFR = AFR[1] + Det1[0] ENDIF ENDIF //------------------------------------------// // DEMA - Double Exponential Moving Average // //------------------------------------------// IF MAType = 8 THEN Period = MAX(Period, 1) AFR = DEMA[Period](Series) ENDIF //-------------------------------------------------// // ELSMA - Exponential Least Square Moving Average // //-------------------------------------------------// IF MAType = 9 THEN Period = MAX(Period, 1) // NumBars = 4 NumBars = 4 LR = LinearRegression[NumBars](Series) AFR = ExponentialAverage[Period](LR) ENDIF //----------------------------------// // EMA - Exponential Moving Average // //----------------------------------// IF MAType = 10 THEN Period = MAX(Period, 1) AFR = ExponentialAverage[Period](Series) ENDIF //------------------------------------------------// // EVWMA - Elastic Volume Weighted Moving Average // //------------------------------------------------// IF MAType = 11 THEN Period = MAX(Period, 1) IF BarIndex < Period THEN AFR = Series ELSE SumVol = summation[Period](Volume) IF SumVol = 0 THEN SumVol = 1 ENDIF AFR = ((SumVol - Volume) * AFR + Volume * Series) / SumVol ENDIF ENDIF //---------------------------------// // FATL - Fast Adaptive Trend Line // //---------------------------------// IF MAType = 12 THEN AFR = 0.4360409450*Series[0]+0.3658689069*Series[1]+0.2460452079*Series[2]+0.1104506886*Series[3]-0.0054034585*Series[4]-0.0760367731*Series[5]-0.0933058722*Series[6]-0.0670110374*Series[7]-0.0190795053*Series[8]+0.0259609206*Series[9]+0.0502044896*Series[10]+0.0477818607*Series[11]+0.0249252327*Series[12]-0.0047706151*Series[13]-0.0272432537*Series[14]-0.0338917071*Series[15]-0.0244141482*Series[16]-0.0055774838*Series[17]+0.0128149838*Series[18]+0.0226522218*Series[19]+0.0208778257*Series[20]+0.0100299086*Series[21]-0.0036771622*Series[22]-0.0136744850*Series[23]-0.0160483392*Series[24]-0.0108597376*Series[25]-0.0016060704*Series[26]+0.0069480557*Series[27]+0.0110573605*Series[28]+0.0095711419*Series[29]+0.0040444064*Series[30]-0.0023824623*Series[31]-0.0067093714*Series[32]-0.0072003400*Series[33]-0.0047717710*Series[34]+0.0005541115*Series[35]+0.0007860160*Series[36]+0.0130129076*Series[37]+0.0040364019*Series[38] ENDIF //---------------------------------------------// // FBQMA - Fractional-Bar Quick Moving Average // //---------------------------------------------// IF MAType = 13 THEN Period = MAX(Period, 1) Peak = Period / 3 Num = 0 Denom = 0 FOR j = 1 TO (Period + 1) DO IF j <= Peak THEN DataArray = j / Peak ELSE DataArray = (Period + 1 - j) / (Period + 1 - Peak) Num = Num + Series[j - 1] * DataArray Denom = Denom + DataArray ENDIF NEXT IF Denom <= 0 THEN AFR = Series ELSE AFR = Num / Denom ENDIF ENDIF //-----------------------------------------// // FRAMA - Fractal Adaptive Moving Average // //-----------------------------------------// IF MAType = 14 THEN Period = MAX(Period, 1) N3 = (highest[Period](High) - lowest[Period](Low)) / Period mH = High L = Low FOR count = 0 TO (Period / 2) - 1 DO count = ROUND(count) IF High[count] > mH THEN mH = High[count] ENDIF IF Low[count] < L THEN L = Low[count] ENDIF NEXT N1 = (mH - L) / (Period / 2) HH = High[ROUND(Period / 2)] LL = Low[ROUND(Period / 2)] FOR count = Period / 2 TO Period - 1 DO count = ROUND(count) IF High[count] > HH THEN HH = High[count] ENDIF IF Low[count] < LL THEN LL = Low[count] ENDIF NEXT N2 = (HH - LL) / (Period / 2) IF N1 > 0 AND N2 > 0 AND N3 > 0 THEN // FIX LOG Dimen = ((LOG(N1 + N2) / LOG(10)) - (LOG(N3) / LOG(10))) / (LOG(2) / LOG(10)) ENDIF alpha = EXP(-4.6 * (Dimen - 1)) IF alpha < 0.01 THEN alpha = 0.01 ELSIF alpha > 1 THEN alpha = 1 ENDIF IF BarIndex < Period THEN AFR = Series ELSE AFR = alpha * Series + (1 - alpha) * AFR[1] ENDIF ENDIF //--------------------------// // GDEMA - Generalized DEMA // //--------------------------// IF MAType = 15 THEN Period = MAX(Period, 1) // VFactor = 0.7 ({-2.5..2.5}) VFactor = 0.7 EMA0 = ExponentialAverage[Period](Series) EMA1 = ExponentialAverage[Period](EMA0) AFR = EMA0 * (1 + VFactor) - EMA1 * VFactor ENDIF //-------------------------------// // GF1P - 1-Pole Gaussian Filter // //-------------------------------// IF MAType = 16 THEN Period = MAX(Period, 2) IF BarIndex = 0 THEN w = 2 * 3.141592654 / Period w = 180 * w / 3.141592654 b = (1 - COS(w)) / (1.41421 - 1) aa = -b + SQRT(b * b + 2 * b) a1 = 1 - aa y1 = Series ENDIF y = aa * Series + a1 * y1 y1 = y AFR = y ENDIF //-------------------------------// // GF2P - 2-Pole Gaussian Filter // //-------------------------------// IF MAType = 17 THEN Period = MAX(Period, 2) IF BarIndex = 0 THEN w = 2 * 3.141592654 / Period w = 180 * w / 3.141592654 b = (1 - COS(w)) / (1.41421 - 1) aa = -b + SQRT(b * b + 2 * b) a1 = 1 - aa a12 = a1 * a1 a2 = aa * aa y1 = Series y2 = y1 ENDIF y = a2 * Series + 2 * a1 * y1 - a12 * y2 y2 = y1 y1 = y AFR = y ENDIF //-------------------------------// // GF3P - 3-Pole Gaussian Filter // //-------------------------------// IF MAType = 18 THEN Period = MAX(Period, 2) IF BarIndex = 0 THEN w = 2 * 3.141592654 / Period w = 180 * w / 3.141592654 b = (1 - COS(w)) / (1.25992 - 1) aa = -b + SQRT(b * b + 2 * b) a1 = 1 - aa a12 = a1 * a1 a13 = a1 * a1 * a1 a3 = aa * aa * aa y1 = Series y2 = y1 y3 = y2 ENDIF y = a3 * Series + 3 * a1 * y1 - 3 * a12 * y2 + a13 * y3 y3 = y2 y2 = y1 y1 = y AFR = y ENDIF //-------------------------------// // GF4P - 4-Pole Gaussian Filter // //-------------------------------// IF MAType = 19 THEN Period = MAX(Period, 2) IF BarIndex = 0 THEN w = 2 * 3.141592654 / Period w = 180 * w / 3.141592654 b = (1 - COS(w)) / (1.18920 - 1) aa = -b + SQRT(b * b + 2 * b) a1 = 1 - aa a12 = a1 * a1 a13 = a1 * a1 * a1 a14 = a12 * a12 a2 = aa * aa a4 = a2 * a2 y1 = Series y2 = y1 y3 = y2 y4 = y3 ENDIF y = a4 * Series + 4 * a1 * y1 - 6 * a12 * y2 + 4 * a13 *y3 - a14 * y4 y4 = y3 y3 = y2 y2 = y1 y1 = y AFR = y ENDIF //---------------------------// // HMA - Hull Moving Average // //---------------------------// IF MAType = 20 THEN Period = MAX(Period, 1) AFR = WeightedAverage[ROUND(SQRT(Period))](2 * WeightedAverage[ROUND(Period / 2)](Series) - WeightedAverage[Period](Series)) ENDIF //-------------------------------------// // IE/2 - Combination of LSMA and ILRS // //-------------------------------------// IF MAType = 21 THEN Period = MAX(Period, 2) LR = LinearRegression[Period](Series) LRS = LinearRegressionSlope[Period](Series) SMA = Average[Period](Series) AFR = (LR + LRS + SMA) / 2 ENDIF //--------------------------------------------// // ILRS - Integral of Linear Regression Slope // //--------------------------------------------// IF MAType = 22 THEN Period = MAX(Period, 2) SumBars = Period * (Period - 1) * 0.5 SumSqrBars = Period * (Period - 1) * Period * (2 * Period - 1) / 6 IF (BarIndex < Period) then AFR = Series ELSE Sum1 = 0 SumY = 0 MA = Average[1](Series) FOR i = 0 TO Period - 1 DO Sum1 = Sum1 + (i * MA[i]) SumY = SumY + MA[i] NEXT Num1 = Period * Sum1 - SumBars * SumY Num2 = SumBars * SumBars - Period * SumSqrBars AFR = Num1 / Num2 + Average[Period](Series) ENDIF ENDIF //--------------------------------// // iTrend - iTrend by John Ehlers // //--------------------------------// IF MAType = 23 THEN // alpha = 0.0025 {0.0025..0.2} alpha = 0.005 IF BarIndex < 2 THEN AFR = Series ELSE i1 = (alpha - alpha * alpha / 4) * Series i2 = 0.5 * alpha * alpha * Series[1] i3 = (alpha - 0.75 * alpha * alpha) * Series[2] i4 = 2 * (1 - alpha) * AFR[1] i5 = (1 - alpha) * (1 - alpha) * AFR[2] AFR = i1 + i2 - i3 + i4 - i5 ENDIF ENDIF //-----------------------------------------------------// // JMA - Jurik Moving Average (Responsiveness Version) // //-----------------------------------------------------// IF MAType = 24 THEN Period = MAX(Period, 1) // Pow = 5 ({ 1..10 }) // R = 1.5 ({0.5..2.5}) Pow = 5 R = 1 beta = 0.45 * (Period - 1) / (0.45 * (Period - 1) + 2) IF Pow = 1 THEN alpha = beta ELSIF Pow = 2 THEN alpha = beta * beta ELSIF Pow = 3 THEN alpha = beta * beta * beta ELSIF Pow = 4 THEN alpha = beta * beta * beta * beta ELSIF Pow = 5 THEN alpha = beta * beta * beta * beta * beta ELSIF Pow = 6 THEN alpha = beta * beta * beta * beta * beta * beta ELSIF Pow = 7 THEN alpha = beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 8 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 9 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 10 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta * beta ENDIF IF BarIndex = 0 THEN Filt0 = Series Filt1 = Series AFR = Series ELSE Filt0 = (1 - alpha) * Series + alpha * Filt0[1] Det0 = (Series - Filt0[0]) * (1 - beta) + beta * Det0[1] Filt1 = Filt0[0] + R * Det0[0] Det1 = (Filt1[0] - AFR[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1] AFR = AFR[1] + Det1[0] ENDIF ENDIF //----------------------------// // JMA - Jurik Moving Average // //----------------------------// IF MAType = 25 THEN Period = MAX(Period, 1) // Pow = 5 ({ 1..10 }) // R = 1.5 ({0.5..2.5}) Pow = 4 R = 1 beta = 0.45 * (Period - 1) / (0.45 * (Period - 1) + 2) IF Pow = 1 THEN alpha = beta ELSIF Pow = 2 THEN alpha = beta * beta ELSIF Pow = 3 THEN alpha = beta * beta * beta ELSIF Pow = 4 THEN alpha = beta * beta * beta * beta ELSIF Pow = 5 THEN alpha = beta * beta * beta * beta * beta ELSIF Pow = 6 THEN alpha = beta * beta * beta * beta * beta * beta ELSIF Pow = 7 THEN alpha = beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 8 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 9 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 10 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta * beta ENDIF IF BarIndex = 0 THEN Filt0 = Series Filt1 = Series AFR = Series ELSE Filt0 = (1 - alpha) * Series + alpha * Filt0[1] Det0 = (Series - Filt0[0]) * (1 - beta) + beta * Det0[1] Filt1 = Filt0[0] + R * Det0[0] Det1 = (Filt1[0] - AFR[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1] AFR = AFR[1] + Det1[0] ENDIF ENDIF //----------------------------------------// // KAMA - Kaufman Adaptive Moving Average // //----------------------------------------// IF MAType = 26 THEN Period = MAX(Period, 4) // FastPeriod = 7 // SlowPeriod = 28 FastPeriod = 7 SlowPeriod = 28 Fastest = 2 / (FastPeriod + 1) Slowest = 2 / (SlowPeriod + 1) IF BarIndex < Period THEN AFR = Series ELSE Num = ABS(Series - Series[Period]) Den = summation[Period](ABS(Series - Series[1])) ER = Num / Den Alpha = SQUARE(ER * (Fastest - Slowest) + Slowest) AFR = (Alpha * Series) + ((1 - Alpha) * AFR[1]) ENDIF ENDIF //-------------------------------------// // KFJE - Kalman Filter by John Ehlers // //-------------------------------------// IF MAType = 27 THEN IF BarIndex < 3 THEN AFR = Series ELSE AFR = 0.33 * (Series + 0.5 * (Series - Series[3])) + 0.67 * AFR[1] ENDIF ENDIF //---------------------------------------------// // KF - Kalman Filter (Responsiveness Version) // //---------------------------------------------// IF MAType = 28 THEN // K = 1000 ({1...2000}) K = 1000 ONCE Pred = Series IF BarIndex = 0 THEN AFR = Series ELSE Smooth = Pred + (Series - Pred) * SQRT((K / 10000) * 2) Velo = Velo + ((K / 10000) * (Series - Pred)) Pred = Smooth + Velo AFR = Pred ENDIF ENDIF //--------------------// // KF - Kalman Filter // //--------------------// IF MAType = 29 THEN // K = 500 ({1...2000}) K = 500 ONCE Pred = Series IF BarIndex = 0 THEN AFR = Series ELSE Smooth = Pred + (Series - Pred) * SQRT((K / 10000) * 2) Velo = Velo + ((K / 10000) * (Series - Pred)) Pred = Smooth + Velo AFR = Pred ENDIF ENDIF //------------------------------------------// // LEMA - Leader Exponential Moving Average // //------------------------------------------// IF MAType = 30 THEN Period = MAX(Period, 1) IF BarIndex = 0 THEN p1 = Series p2 = 0 ELSE alpha = 2 / (Period + 1) p1 = p1[1] + alpha * (Series - p1[1]) p2 = p2[1] + alpha * (Series - p1 - p2[1]) ENDIF AFR = p1 + p2 ENDIF //-------------------------------------// // LF - Laguerre Filter by John Ehlers // //-------------------------------------// IF MAType = 31 THEN // gamma = 0.8 gamma = 0.8 once l0 = Series once l1 = Series once l2 = Series once l3 = Series IF BarIndex = 0 THEN AFR = Series ELSE l0 = (1 - gamma) * Series + gamma * l0[1] l1 = -gamma * l0 + l0[1] + gamma * l1[1] l2 = -gamma * l1 + l1[1] + gamma * l2[1] l3 = -gamma * l2 + l2[1] + gamma * l3[1] AFR = (l0 + 2 * l1 + 2 * l2 + l3) / 6 ENDIF ENDIF //------------------------------------// // LSMA - Least Square Moving Average // //------------------------------------// IF MAType = 32 THEN Period = MAX(Period, 2) AFR = LinearRegression[Period](Series) ENDIF //-----------------------// // MD - McGinley Dynamic // //-----------------------// IF MAType = 33 THEN Period = MAX(Period, 4) IF BarIndex = 0 THEN AFR = Series ELSE Pow = (Series / AFR[1]) * (Series / AFR[1]) * (Series / AFR[1]) * (Series / AFR[1]) AFR = AFR[1] + (Series - AFR[1]) / ((Period / 2) * Pow) ENDIF ENDIF //----------------------------------------------// // MHLMA - Middle High Low Range Moving Average // //----------------------------------------------// IF MAType = 34 THEN Period = MAX(Period, 1) // HLRange = 3 HLRange = 3 HH = highest[HLRange](High) LL = lowest[HLRange](Low) AFR = Average[Period]((HH + LL) / 2) ENDIF //---------------------------------// // MNMA - McNicholl Moving Average // //---------------------------------// IF MAType = 35 THEN Period = MAX(Period, 2) alpha = 2 / (1 + Period) IF BarIndex = 0 THEN p1 = Series p2 = Series ELSE p1 = p1[1] + alpha * (Series - p1[1]) p2 = p2[1] + alpha * (p1 - p2[1]) ENDIF AFR = (((2 - alpha) * p1 - p2) / (1 - alpha)) ENDIF //--------------------------------------------------------// // NLMA - Non Lag Moving Average (Responsiveness Version) // //--------------------------------------------------------// IF MAType = 36 THEN Period = MAX(Period, 1) // Amplitude = 1 (0...1) // Smooth = -1 (-2...2) Amplitude = 1 Smooth = 1 IF Amplitude > 0 THEN Coeff = 3 * 3.1415926535 / Amplitude ELSE Coeff = 3 * 3.1415926535 ENDIF IF Smooth < -2 THEN Smooth = 0 ENDIF vCycle = 4 vWeight = 0 vSum = 0 Phase = Period + Smooth FOR i = 0 TO ((Period * vCycle) + Phase) - 1 DO IF i <= Phase - 1 THEN IF Phase = 1 THEN x = i ELSE x = i / (Phase - 1) ENDIF ELSE x = 1.0 + (i - Phase + 1) * (2.0 * vCycle - 1.0) / (vCycle * Period - 1.0) ENDIF g = Amplitude / (Coeff * x + 1.0) IF x <= 0.5 THEN g = 1.0 ENDIF vSum = vSum + g * COS(180 * x) * Series[i] vWeight = vWeight + g * COS(180 * x) NEXT IF vWeight > 0 THEN AFR = vSum / vWeight ELSE AFR = Series ENDIF ENDIF //-------------------------------// // NLMA - Non Lag Moving Average // //-------------------------------// IF MAType = 37 THEN Period = MAX(Period, 1) // Amplitude = 0 (0...1) // Smooth = 1 (-2...2) Amplitude = 0 Smooth = 1 IF Amplitude > 0 THEN Coeff = 3 * 3.1415926535 / Amplitude ELSE Coeff = 3 * 3.1415926535 ENDIF IF Smooth < -2 THEN Smooth = 0 ENDIF vCycle = 4 vWeight = 0 vSum = 0 Phase = Period + Smooth FOR i = 0 TO ((Period * vCycle) + Phase) - 1 DO IF i <= Phase - 1 THEN IF Phase = 1 THEN x = i ELSE x = i / (Phase - 1) ENDIF ELSE x = 1.0 + (i - Phase + 1) * (2.0 * vCycle - 1.0) / (vCycle * Period - 1.0) ENDIF g = Amplitude / (Coeff * x + 1.0) IF x <= 0.5 THEN g = 1.0 ENDIF vSum = vSum + g * COS(180 * x) * Series[i] vWeight = vWeight + g * COS(180 * x) NEXT IF vWeight > 0 THEN AFR = vSum / vWeight ELSE AFR = Series ENDIF ENDIF //------------------------// // OMA - One More Average // //------------------------// IF MAType = 38 THEN // Sensibility = 1.5 Sensibility = 1.5 Period = MAX(Period, 1) Sensibility = MAX(Sensibility, -1.5) Data = Average[1](Series) averagePeriod = Period IF BarIndex < Period THEN AFR = Series ELSE IF averagePeriod > 1 THEN minPeriod = averagePeriod / 2.0 maxPeriod = minPeriod * 5.0 endPeriod = ROUND(maxPeriod) signal = ABS((Data - Data[endPeriod])) noise = 0.00000000001 FOR k = 1 TO endPeriod DO noise = noise + ABS(Data - Data[k]) averagePeriod = ROUND(((signal / noise) * (maxPeriod - minPeriod)) + minPeriod) NEXT ENDIF alpha = (2.0 + Sensibility) / (1.0 + Sensibility + averagePeriod) e1 = e1 + alpha * (Data - e1) e2 = e2 + alpha * (e1 - e2) v1 = 1.5 * e1 - 0.5 * e2 e3 = e3 + alpha * (v1 - e3) e4 = e4 + alpha * (e3 - e4) v2 = 1.5 * e3 - 0.5 * e4 e5 = e5 + alpha * (v2 - e5) e6 = e6 + alpha * (e5 - e6) AFR = 1.5 * e5 - 0.5 * e6 ENDIF ENDIF //--------------------------------------------// // PEMA - Pentuple Exponential Moving Average // //--------------------------------------------// IF MAType = 39 THEN Period = MAX(Period, 1) MA1 = ExponentialAverage[Period](Series) MA2 = ExponentialAverage[Period](MA1) MA3 = ExponentialAverage[Period](MA2) MA4 = ExponentialAverage[Period](MA3) MA5 = ExponentialAverage[Period](MA4) MA6 = ExponentialAverage[Period](MA5) MA7 = ExponentialAverage[Period](MA6) MA8 = ExponentialAverage[Period](MA7) AFR = (8 * MA1) - (28 * MA2) + (56 * MA3) - (70 * MA4) + (56 * MA5) - (28 * MA6) + (8 * MA7) - MA8 ENDIF //------------------------------------------// // PWMA - Parabolic Weighted Moving Average // //------------------------------------------// IF MAType = 40 THEN Period = MAX(Period, 1) Sum = SumW * Series SumW = Period * Period FOR i = 0 TO Period DO Weight = (Period - i) * (Period - i) SumW = SumW + Weight Sum = Sum + Weight * Series[i] NEXT AFR = Sum / SumW ENDIF //---------------------------------------------// // QEMA - Quadruple Exponential Moving Average // //---------------------------------------------// IF MAType = 41 THEN Period = MAX(Period, 1) MA1 = ExponentialAverage[Period](Series) MA2 = ExponentialAverage[Period](MA1) MA3 = ExponentialAverage[Period](MA2) MA4 = ExponentialAverage[Period](MA3) MA5 = ExponentialAverage[Period](MA4) AFR = (5 * MA1) - (10 * MA2) + (10 * MA3) - (5 * MA4) + MA5 ENDIF //-------------------------------------------// // REMA - Regularized EMA by Chris Satchwell // //-------------------------------------------// IF MAType = 42 THEN // Lambda = 0.5 ({0.5..9}) Lambda = 0.5 Period = MAX(Period, 1) Lambda = MAX(Lambda, 0) IF BarIndex < 2 THEN AFR = Series ELSE AFR = (AFR[1] * (1 + 2 * Lambda) + (2 / (Period + 1)) * (Series - AFR[1]) - Lambda * AFR[2]) / (1 + Lambda) ENDIF ENDIF //----------------------------------// // RFTL - Reference Fast Trend Line // //----------------------------------// IF MAType = 43 THEN AFR = -0.02232324*Series[0]+0.02268676*Series[1]+0.08389067*Series[2]+0.14630380*Series[3]+0.19282649*Series[4]+0.21002638*Series[5]+0.19282649*Series[6]+0.14630380*Series[7]+0.08389067*Series[8]+0.02268676*Series[9]-0.02232324*Series[10]-0.04296564*Series[11]-0.03980614*Series[12]-0.02082171*Series[13]+0.00243636*Series[14]+0.01950580*Series[15]+0.02460929*Series[16]+0.01799295*Series[17]+0.00470540*Series[18]-0.00831985*Series[19]-0.01544722*Series[20]-0.01456262*Series[21]-0.00733980*Series[22]+0.00201852*Series[23]+0.00902504*Series[24]+0.01093067*Series[25]+0.00766099*Series[26]+0.00145478*Series[27]-0.00447175*Series[28]-0.00750446*Series[29]-0.00671646*Series[30]-0.00304016*Series[31]+0.00143433*Series[32]+0.00457475*Series[33]+0.00517589*Series[34]+0.00336708*Series[35]+0.00034406*Series[36]-0.00233637*Series[37]-0.00352280*Series[38]-0.00293522*Series[39]-0.00114249*Series[40]+0.00083536*Series[41]+0.00215524*Series[42]+0.00604133*Series[43]-0.00013046*Series[44] ENDIF //----------------------------------// // RSTL - Reference Slow Trend Line // //----------------------------------// IF MAType = 44 THEN AFR = -0.00514293*Series[0]-0.00398417*Series[1]-0.00262594*Series[2]-0.00107121*Series[3]+0.00066887*Series[4]+0.00258172*Series[5]+0.00465269*Series[6]+0.00686394*Series[7]+0.00919334*Series[8]+0.01161720*Series[9]+0.01411056*Series[10]+0.01664635*Series[11]+0.01919533*Series[12]+0.02172747*Series[13]+0.02421320*Series[14]+0.02662203*Series[15]+0.02892446*Series[16]+0.03109071*Series[17]+0.03309496*Series[18]+0.03490921*Series[19]+0.03651145*Series[20]+0.03788045*Series[21]+0.03899804*Series[22]+0.03984915*Series[23]+0.04042329*Series[24]+0.04071263*Series[25]+0.04071263*Series[26]+0.04042329*Series[27]+0.03984915*Series[28]+0.03899804*Series[29]+0.03788045*Series[30]+0.03651145*Series[31]+0.03490921*Series[32]+0.03309496*Series[33]+0.03109071*Series[34]+0.02892446*Series[35]+0.02662203*Series[36]+0.02421320*Series[37]+0.02172747*Series[38]+0.01919533*Series[39]+0.01664635*Series[40]+0.01411056*Series[41]+0.01161720*Series[42]+0.00919334*Series[43]+0.00686394*Series[44]+0.00465269*Series[45]+0.00258172*Series[46]+0.00066887*Series[47]-0.00107121*Series[48]-0.00262594*Series[49]-0.00398417*Series[50]-0.00514293*Series[51]-0.00609634*Series[52]-0.00684602*Series[53]-0.00739452*Series[54]-0.00774847*Series[55]-0.00791630*Series[56]-0.00790940*Series[57]-0.00774085*Series[58]-0.00742482*Series[59]-0.00697718*Series[60]-0.00641613*Series[61]-0.00576108*Series[62]-0.00502957*Series[63]-0.00423873*Series[64]-0.00340812*Series[65]-0.00255923*Series[66]-0.00170217*Series[67]-0.00085902*Series[68]-0.00004113*Series[69]+0.00073700*Series[70]+0.00146422*Series[71]+0.00213007*Series[72]+0.00272649*Series[73]+0.00324752*Series[74]+0.00368922*Series[75]+0.00405000*Series[76]+0.00433024*Series[77]+0.00453068*Series[78]+0.00465046*Series[79]+0.00469058*Series[80]+0.00466041*Series[81]+0.00457855*Series[82]+0.00442491*Series[83]+0.00423019*Series[84]+0.00399201*Series[85]+0.00372169*Series[86]+0.00342736*Series[87]+0.00311822*Series[88]+0.00280309*Series[89]+0.00249088*Series[90]+0.00219089*Series[91]+0.00191283*Series[92]+0.00166683*Series[93]+0.00146419*Series[94]+0.00131867*Series[95]+0.00124645*Series[96]+0.00126836*Series[97]-0.00401854*Series[98] ENDIF //---------------------------------// // SATL - Slow Adaptive Trend Line // //---------------------------------// IF MAType = 45 THEN AFR = 0.0982862174*Series[0]+0.0975682269*Series[1]+0.0961401078*Series[2]+0.0940230544*Series[3]+0.0912437090*Series[4]+0.0878391006*Series[5]+0.0838544303*Series[6]+0.0793406350*Series[7]+0.0743569346*Series[8]+0.0689666682*Series[9]+0.0632381578*Series[10]+0.0572428925*Series[11]+0.0510534242*Series[12]+0.0447468229*Series[13]+0.0383959950*Series[14]+0.0320735368*Series[15]+0.0258537721*Series[16]+0.0198005183*Series[17]+0.0139807863*Series[18]+0.0084512448*Series[19]+0.0032639979*Series[20]-0.0015350359*Series[21]-0.0059060082*Series[22]-0.0098190256*Series[23]-0.0132507215*Series[24]-0.0161875265*Series[25]-0.0186164872*Series[26]-0.0205446727*Series[27]-0.0219739146*Series[28]-0.0229204861*Series[29]-0.0234080863*Series[30]-0.0234566315*Series[31]-0.0231017777*Series[32]-0.0223796900*Series[33]-0.0213300463*Series[34]-0.0199924534*Series[35]-0.0184126992*Series[36]-0.0166377699*Series[37]-0.0147139428*Series[38]-0.0126796776*Series[39]-0.0105938331*Series[40]-0.0084736770*Series[41]-0.0063841850*Series[42]-0.0043466731*Series[43]-0.0023956944*Series[44]-0.0005535180*Series[45]+0.0011421469*Series[46]+0.0026845693*Series[47]+0.0040471369*Series[48]+0.0052380201*Series[49]+0.0062194591*Series[50]+0.0070340085*Series[51]+0.0076266453*Series[52]+0.0080376628*Series[53]+0.0083037666*Series[54]+0.0083694798*Series[55]+0.0082901022*Series[56]+0.0080741359*Series[57]+0.0077543820*Series[58]+0.0073260526*Series[59]+0.0068163569*Series[60]+0.0062325477*Series[61]+0.0056078229*Series[62]+0.0049516078*Series[63]+0.0161380976*Series[64] ENDIF //-----------------------------// // SMA - Simple Moving Average // //-----------------------------// IF MAType = 46 THEN Period = MAX(Period, 1) AFR = Average[Period](Series) ENDIF //---------------------------------------// // SSF2P - 2-Pole Super Smoothing Filter // //---------------------------------------// IF MAType = 47 THEN Period = MAX(Period, 1) a1 = EXP(-1.414 * 3.14159 / Period) b1 = 2 * a1 * COS(1.414 * 180 / Period) coef2 = b1 coef3 = -a1 * a1 coef1 = 1 - coef2 - coef3 IF BarIndex < 2 THEN AFR = Series ELSE AFR = coef1 * Series + coef2 * AFR[1] + coef3 * AFR[2] ENDIF ENDIF //---------------------------------------// // SSF3P - 3-Pole Super Smoothing Filter // //---------------------------------------// IF MAType = 48 THEN Period = MAX(Period, 1) a1 = EXP(-3.14159 / Period) b1 = 2 * a1 * COS(1.738 * 180 / Period) c1 = a1 * a1 coef2 = b1 + c1 coef3 = -(c1 + b1 * c1) coef4 = c1 * c1 coef1 = 1 - coef2 - coef3 - coef4 IF BarIndex < 3 THEN AFR = Series ELSE AFR = coef1 * Series + coef2 * AFR[1] + coef3 * AFR[2] + coef4 * AFR[3] ENDIF ENDIF //---------------------------------------// // SSMA - Smoothed Simple Moving Average // //---------------------------------------// IF MAType = 49 THEN Period = MAX(Period, 1) IF BarIndex = 0 THEN AFR = Series ELSE AFR = AFR[1] + (Series - AFR[1]) / Period ENDIF ENDIF //-------------------------------------// // SWMA - Sine Weighted Moving Average // //-------------------------------------// IF MAType = 50 THEN Period = MAX(Period, 1) Sum = 0 CSum = 0 FOR j = 0 TO Period - 1 DO Sum = Sum + Series[j] * SIN(90 * (1 - j / Period)) CSum = CSum + SIN(90 * (1 - j / Period)) NEXT IF CSum <= 0 THEN AFR = Series ELSE AFR = Sum / CSum ENDIF ENDIF //--------------------------// // T3MA - T3 Moving Average // //--------------------------// IF MAType = 51 THEN Period = MAX(Period, 1) // Hot = 0.7 ({-1.5..1.5}) Hot = 0.7 e1 = ExponentialAverage[Period](Series) e2 = ExponentialAverage[Period](e1) e3 = ExponentialAverage[Period](e2) e4 = ExponentialAverage[Period](e3) e5 = ExponentialAverage[Period](e4) e6 = ExponentialAverage[Period](e5) b = Hot b2 = (b * b) b3 = (b * b * b) c1 = -b3 c2 = (3 * b2) + (3 * b3) c3 = (-6 * b2) - (3 * b) - (3 * b3) c4 = 1 + (3 * b) + b3 + (3 * b2) AFR = c1 * e6 + c2 * e5 + c3 * e4 + c4 * e3 ENDIF //------------------------------------------// // TEMA - Triple Exponential Moving Average // //------------------------------------------// IF MAType = 52 THEN Period = MAX(Period, 1) AFR = TEMA[Period](Series) ENDIF //---------------------------------// // TMA - Triangular Moving Average // //---------------------------------// IF MAType = 53 THEN Period = MAX(Period, 1) AFR = TriangularAverage[Period](Series) ENDIF //---------------------------// // TSA - Time Series Average // //---------------------------// IF MAType = 54 THEN Period = MAX(Period, 1) AFR = TimeSeriesAverage[Period](Series) ENDIF //----------------------------------------// // VIDYA - Variable Index Dynamic Average // //----------------------------------------// IF MAType = 55 THEN Period = MAX(Period, 4) // Smooth = 5 Smooth = 5 ONCE SC = 2 / (Smooth + 1) AbsCMO = (ABS(Chandle[Period](Series))) / 100 IF BarIndex < Period THEN AFR = Series ELSE AFR = (SC * AbsCMO * Series) + (1 - (SC * AbsCMO)) * AFR ENDIF ENDIF //-------------------------------// // VMA - Variable Moving Average // //-------------------------------// IF MAType = 56 THEN Period = MAX(Period, 4) IF BarIndex < Period THEN AFR = Series ELSE k = 1.0 / Period pdm = MAX((Series - Series[1]), 0) mdm = MAX((Series[1] - Series), 0) pdmS = ((1 - k) * (pdmS[1]) + k * pdm) mdmS = ((1 - k) * (mdmS[1]) + k * mdm) s = pdmS + mdmS pdi = pdmS / s mdi = mdmS / s pdiS = ((1 - k) * (pdiS[1]) + k * pdi) mdiS = ((1 - k) * (mdiS[1]) + k * mdi) d = ABS(pdiS - mdiS) s1 = pdiS + mdiS iS = ((1 - k) * (iS[1]) + k * d / s1) hhv = highest[Period](iS) llv = lowest[Period](iS) d1 = hhv - llv vI = (iS - llv) / d1 AFR = (1 - k * vI) * (AFR[1]) + k * vI * Series ENDIF ENDIF //--------------------------------------// // VWAP - Volume Weighted Average Price // //--------------------------------------// IF MAType = 57 THEN Period = MAX(Period, 1) SumVol = summation[Period](Volume) IF SumVol = 0 THEN SumVol = 1 ENDIF AFR = summation[Period](Series * Volume) / summation[Period](Volume) ENDIF //------------------------------// // WIMA - Wilder Moving Average // //------------------------------// IF MAType = 58 THEN Period = MAX(Period, 1) AFR = WilderAverage[Period](Series) ENDIF //----------------------------------------------// // WLSMA - Weighted Least Square Moving Average // //----------------------------------------------// IF MAType = 59 THEN Period = MAX(Period, 1) // NumBars = 4 NumBars = 4 LR = LinearRegression[NumBars](Series) AFR = WeightedAverage[Period](LR) ENDIF //-------------------------------// // WMA - Weighted Moving Average // //-------------------------------// IF MAType = 60 THEN Period = MAX(Period, 1) AFR = WeightedAverage[Period](Series) ENDIF //----------------------// // ZLBMT - Zero Lag BMT // //----------------------// IF MAType = 61 THEN Period = MAX(Period, 1) EMA0 = ExponentialAverage[Period](Series) EMA1 = ExponentialAverage[Period](EMA0) AFR = EMA0 + (EMA0 - EMA1) ENDIF //-----------------------------------------------------// // ZLDEMA - Zero Lag Double Exponential Moving Average // //-----------------------------------------------------// IF MAType = 62 THEN Period = MAX(Period, 1) DEMA0 = DEMA[Period](Series) DEMA1 = DEMA[Period](DEMA0) AFR = DEMA0 + (DEMA0 - DEMA1) ENDIF //----------------------------// // ZLFF - Zero Lag FIR Filter // //----------------------------// IF MAType = 63 THEN AFR = (Series + 2 * Series[1] + 3 * Series[2] + 3 * Series[3] + 2 * Series[4] + Series[5]) / 12 ENDIF //----------------------------// // ZLIF - Zero Lag IIR Filter // //----------------------------// IF MAType = 64 THEN Period = MAX(Period, 1) k = 2 / (Period + 1) x = ROUND((Period - 1) / 2) IF BarIndex <= MAX(x, 0) THEN AFR = Series ELSE AFR = k * (2 * Series - Series[x]) + (1 - k) * AFR[1] ENDIF ENDIF //-----------------------------// // ZLJE - Zero Lag John Ehlers // //-----------------------------// IF MAType = 65 THEN Period = MAX(Period, 2) alpha = 2 / (1 + Period) per = ROUND((Period - 1) / 2) IF BarIndex < per THEN AFR = Series ELSE AFR = AFR[1] + alpha * (2 * Series - Series[per] - AFR[1]) ENDIF ENDIF //--------------------------------// // ZLWBMT - Zero Lag Weighted BMT // //--------------------------------// IF MAType = 66 THEN Period = MAX(Period, 1) WMA0 = WeightedAverage[Period](Series) WMA1 = WeightedAverage[Period](WMA0) AFR = WMA0 + (WMA0 - WMA1) ENDIF //-----------------------------------------// // Range based AV high + STD - low - STD // //-----------------------------------------// IF MAType = 67 THEN Type = 1 //exponential average NxStd = 1 //Standard dev multiplier AvH= Average[Period,Type](high) + NxStd * STD[Period](high) //higher green line HIGH + Std AvL= Average[Period,Type](low) + NxStd * STD[Period](low) //lower green line LOW + Std Av= Average[Period,Type](close) AvHL= Average[Period,Type](high) - NxStd * STD[Period](high) //higher red line HIGH - Std AvLL= Average[Period,Type](low) - NxStd * STD[Period](low) //lower red line LOW - Std AFR = average[Period,Type]((close +AvH + AvL + Av + AvHL + AvLL)/6) endif //--------------------------------// // Average lowest plus highest // //--------------------------------// IF MAType = 68 THEN Period = MAX(Period, 1) AFR = (lowest[Period](series) + highest[Period](series))/2 ENDIF //--------------------------------// // 69 DEMA adjusted by itself // //--------------------------------// IF MAType = 69 THEN Period = MAX(Period, 1) AFR = 2 * DEMA[Period](Series) - DEMA[Period](DEMA[Period](Series)) ENDIF ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //---------------------------------------// // AFRV2 - Average Filter Regression // // // // Contact: laurenzo(at)gargamail(dot)net // //---------------------------------------// // 0. Ahrens Moving Average // // 1. Adjustable Lag FIR // // 2. Arnaud Legoux Moving Average // // 3. 2-Pole Butterworth Smoothing Filter // // 4. 3-Pole Butterworth Smoothing Filter // // 5. Corrected Moving Average by A.Uhl // // 6. d9 Unscented Kalman Filter (Responsiveness Version) // // 7. d9 Unscented Kalman Filter // // 8. Double Exponential Moving Average // // 9. Exponential Least Square Moving Average // // 10. Exponential Moving Average // // 11. Elastic Volume Weighted Moving Average // // 12. Fast Adaptive Trend Line // // 13. Fractional-Bar Quick Moving Average // // 14. Fractal Adaptive Moving Average // // 15. Generalized DEMA // // 16. 1-Pole Gaussian Filter // // 17. 2-Pole Gaussian Filter // // 18. 3-Pole Gaussian Filter // // 19. 4-Pole Gaussian Filter // // 20. Hull Moving Average // // 21. IE/2 Combination of LSMA and ILRS // // 22. Integral of Linear Regression Slope // // 23. iTrend by John Ehlers // // 24. Jurik Moving Average (Responsiveness Version) // // 25. Jurik Moving Average // // 26. Kaufman Adaptive Moving Average // // 27. Kalman Filter by John Ehlers // // 28. Kalman Filter (Responsiveness Version) // // 29. Kalman Filter // // 30. Leader Exponential Moving Average // // 31. Laguerre Filter by John Ehlers // // 32. Least Square Moving Average // // 33. McGinley Dynamic // // 34. Middle High Low Range Moving Average // // 35. McNicholl Moving Average // // 36. Non Lag Moving Average (Responsiveness Version) // // 37. Non Lag Moving Average // // 38. One More Average // // 39. Pentuple Exponential Moving Average // // 40. Parabolic Weighted Moving Average // // 41. Quadruple Exponential Moving Average // // 42. Regularized EMA by Chris Satchwell // // 43. Reference Fast Trend Line // // 44. Reference Slow Trend Line // // 45. Slow Adaptive Trend Line // // 46. Simple Moving Average // // 47. 2-Pole Super Smoothing Filter // // 48. 3-Pole Super Smoothing Filter // // 49. Smoothed Simple Moving Average // // 50. Sine Weighted Moving Average // // 51. T3 Moving Average // // 52. Triple Exponential Moving Average // // 53. Triangular Moving Average // // 54. Time Seriesv2 Average // // 55. Variable Index Dynamic Average // // 56. Variable Moving Average // // 57. Volume Weighted Average Price // // 58. Wilder Moving Average // // 59. Weighted Least Square Moving Average // // 60. Weighted Moving Average // // 61. Zero Lag BMT // // 62. Zero Lag Double Exponential Moving Average // // 63. Zero Lag FIR Filter // // 64. Zero Lag IIR Filter // // 65. Zero Lag John Ehlers // // 66. Zero Lag Weighted BMT // // 67. Range based AV high + STD - low - STD // 69 DEMA adjusted by itself //------------------------------// // AHMA - Ahrens Moving Average // //------------------------------// IF MATypev2 = 0 THEN Period2 = MAX(Period2, 1) IF BarIndex < Period2 THEN AFRV2 = Seriesv2 ELSE AFRV2 = AFRV2[1] + ((Seriesv2 - ((AFRV2[1] + AFRV2[Period2]) / 2)) / Period2) ENDIF ENDIF //----------------------------// // ALFIR - Adjustable Lag FIR // //----------------------------// IF MATypev2 = 1 THEN // Lag = 0.7 ({-2.5...2.5}) Lag = 0.7 AFRV2 = (Seriesv2 + (2 + Lag) * Seriesv2[1] + (3 + Lag) * Seriesv2[2] + 3 * Seriesv2[3] + (2 - Lag) * Seriesv2[4] + (1 - Lag) * Seriesv2[5] + (0 - Lag) * Seriesv2[6]) / (12 - Lag) ENDIF //-------------------------------------// // ALMA - Arnaud Legoux Moving Average // //-------------------------------------// IF MATypev2 = 2 THEN Period2 = MAX(Period2, 1) // Sigma = 6 ({0..30}) // Offset = 0.85 ({0..1}) Sigma = 6 Offset = 0.85 m = ROUND(Offset * (Period2 - 1)) s = Period2 / Sigma WtdSum = 0 CumWt = 0 FOR k = 0 TO Period2 - 1 DO Wtd = EXP(-((k - m) * (k - m)) / (2 * s * s)) WtdSum = WtdSum + Wtd * Seriesv2[Period2 - 1 - k] CumWt = CumWt + Wtd NEXT IF CumWt <= 0 THEN AFRV2 = Seriesv2 ELSE AFRV2 = WtdSum / CumWt ENDIF ENDIF //---------------------------------------------// // BSF2P - 2-Pole Butterworth Smoothing Filter // //---------------------------------------------// IF MATypev2 = 3 THEN Period2 = MAX(Period2, 1) a1 = EXP(-1.414 * 3.14159 / Period2) b1 = 2 * a1 * COS(1.414 * 180 / Period2) coef2 = b1 coef3 = -a1 * a1 coef1 = (1 - b1 + a1 * a1) / 4 IF BarIndex < 2 THEN AFRV2 = Seriesv2 ELSE AFRV2 = coef1 * (Seriesv2 + 2 * Seriesv2[1] + Seriesv2[2]) + coef2 * AFRV2[1] + coef3 * AFRV2[2] ENDIF ENDIF //---------------------------------------------// // BSF3P - 3-Pole Butterworth Smoothing Filter // //---------------------------------------------// IF MATypev2 = 4 THEN Period2 = MAX(Period2, 1) a1 = EXP(-3.14159 / Period2) b1 = 2 * a1 * COS(1.738 * 180 / Period2) c1 = a1 * a1 coef2 = b1 + c1 coef3 = -(c1 + b1 * c1) coef4 = c1 * c1 coef1 = (1 - b1 + c1) * (1 - c1) / 8 IF BarIndex < 3 THEN AFRV2 = Seriesv2 ELSE AFRV2 = coef1 * (Seriesv2 + 3 * Seriesv2[1] + 3 * Seriesv2[2] + Seriesv2[3]) + coef2 * AFRV2[1] + coef3 * AFRV2[2] + coef4 * AFRV2[3] ENDIF ENDIF //-----------------------------------------// // CMA - Corrected Moving Average by A.Uhl // //-----------------------------------------// IF MATypev2 = 5 THEN Period2 = MAX(Period2, 1) IF BarIndex < Period2 THEN AFRV2 = Seriesv2 ELSE MA = Average[Period2](Seriesv2) v1 = SQUARE(STD[Period2](Seriesv2)) v2 = SQUARE(AFRV2[1] - MA) IF v2 < v1 OR v2 = 0 THEN K = 0 ELSE K = 1 - v1 / v2 ENDIF AFRV2 = AFRV2[1] + K * (MA - AFRV2[1]) ENDIF ENDIF //-------------------------------------------------------------// // d9UKF - d9 Unscented Kalman Filter (Responsiveness Version) // //-------------------------------------------------------------// IF MATypev2 = 6 THEN // Init Period2 = MAX(Period2, 2) // longAvgWindow = 65 ({40..200}) longAvgWindow = 65 // permissivity = {0..3} permissivity = 2 windowLength = 0.5 * (Period2 - 1) // FIX LOG - LOG(SQRT(windowLength)) / LOG(2) + 2 lengthParam = (LOG(SQRT(windowLength)) / LOG(10)) / (LOG(2) / LOG(10)) + 2 IF (lengthParam < 0) THEN lengthParam = 0 ENDIF expFactor = lengthParam - 2 IF (expFactor < 0.5) THEN expFactor = 0.5 ENDIF sigma = SQRT(windowLength) * lengthParam beta = sigma / (sigma + 1) data = Average[1](Seriesv2) // AverageVMA(Input, 1, 1)[0]; //SMA(Input, 1)[0]; IF (BarIndex < 10) THEN vxCum = 0 hInterval = data lInterval = data Filt0 = data Filt1 = data AFRV2 = data ELSE uDelta = data - hInterval[1] uAbs = ABS(uDelta) lDelta = data - lInterval[1] lAbs = ABS(lDelta) IF (uAbs > lAbs) THEN vx = uAbs ELSIF (uAbs < lAbs) THEN vx = lAbs ELSIF (uAbs = lAbs) THEN vx = 0 ENDIF vxCum = vxCum[1] + 0.1 * (vx - vx[10]) IF (BarIndex <= longAvgWindow + 1) THEN avgVx = avgVx[1] + 2.0 * (vxCum - avgVx[1]) / (longAvgWindow + 1) ELSE // SMA(_vxCum, _longAvgWindow) avgVx = Average[longAvgWindow](vxCum) // SMA(_vxCum, _longAvgWindow) ENDIF IF (avgVx > 0) THEN vxCoeff = vx / avgVx ENDIF // FIX Power - Power(lengthParam, 1.0 / expFactor) IF (EXP((1.0 / expFactor) * LOG(lengthParam))) THEN vxCoeff = EXP((1.0 / expFactor) * LOG(lengthParam)) ENDIF IF (vxCoeff < 1) THEN vxCoeff = 1 ENDIF // FIX Power - Power(vxCoeff, expFactor) vExp = EXP((expFactor) * LOG(vxCoeff)) // FIX Power - Power(beta, SQRT(vExp)) kV = EXP(SQRT(vExp) * LOG(beta)) IF (uDelta > 0) THEN hInterval = data ELSE hInterval = data - kV * uDelta ENDIF IF (lDelta < 0) THEN lInterval = data ELSE lInterval = data - kV * lDelta ENDIF gamma = 0.45 * (Period2 - 1) / (0.45 * (Period2 - 1) + 2) // FIX Power - Power(gamma, vExp) alpha = EXP((vExp) * LOG(gamma)) Filt0 = (1 - alpha) * data + alpha * Filt0[1] Det0 = (data - Filt0[0]) * (1 - gamma) + gamma * Det0[1] Filt1 = Filt0[0] + permissivity * Det0[0] Det1 = (Filt1[0] - AFRV2[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1] AFRV2 = AFRV2[1] + Det1[0] ENDIF ENDIF //------------------------------------// // d9UKF - d9 Unscented Kalman Filter // //------------------------------------// IF MATypev2 = 7 THEN // Init Period2 = MAX(Period2, 2) // longAvgWindow = {40..200} longAvgWindow = 65 // permissivity = {0..3} permissivity = 1.25 windowLength = 0.5 * (Period2 - 1) // FIX LOG - LOG(SQRT(windowLength)) / LOG(2) + 2 lengthParam = (LOG(SQRT(windowLength)) / LOG(10)) / (LOG(2) / LOG(10)) + 2 IF (lengthParam < 0) THEN lengthParam = 0 ENDIF expFactor = lengthParam - 2 IF (expFactor < 0.5) THEN expFactor = 0.5 ENDIF sigma = SQRT(windowLength) * lengthParam beta = sigma / (sigma + 1) data = Average[1](Seriesv2) // AverageVMA(Input, 1, 1)[0]; //SMA(Input, 1)[0]; IF (BarIndex < 10) THEN vxCum = 0 hInterval = data lInterval = data Filt0 = data Filt1 = data AFRV2 = data ELSE uDelta = data - hInterval[1] uAbs = ABS(uDelta) lDelta = data - lInterval[1] lAbs = ABS(lDelta) IF (uAbs > lAbs) THEN vx = uAbs ELSIF (uAbs < lAbs) THEN vx = lAbs ELSIF (uAbs = lAbs) THEN vx = 0 ENDIF vxCum = vxCum[1] + 0.1 * (vx - vx[10]) IF (BarIndex <= longAvgWindow + 1) THEN avgVx = avgVx[1] + 2.0 * (vxCum - avgVx[1]) / (longAvgWindow + 1) ELSE // SMA(_vxCum, _longAvgWindow) avgVx = Average[longAvgWindow](vxCum) // SMA(_vxCum, _longAvgWindow) ENDIF IF (avgVx > 0) THEN vxCoeff = vx / avgVx ENDIF // FIX Power - Power(lengthParam, 1.0 / expFactor) IF (EXP((1.0 / expFactor) * LOG(lengthParam))) THEN vxCoeff = EXP((1.0 / expFactor) * LOG(lengthParam)) ENDIF IF (vxCoeff < 1) THEN vxCoeff = 1 ENDIF // FIX Power - Power(vxCoeff, expFactor) vExp = EXP((expFactor) * LOG(vxCoeff)) // FIX Power - Power(beta, SQRT(vExp)) kV = EXP(SQRT(vExp) * LOG(beta)) IF (uDelta > 0) THEN hInterval = data ELSE hInterval = data - kV * uDelta ENDIF IF (lDelta < 0) THEN lInterval = data ELSE lInterval = data - kV * lDelta ENDIF gamma = 0.45 * (Period2 - 1) / (0.45 * (Period2 - 1) + 2) // FIX Power - Power(gamma, vExp) alpha = EXP((vExp) * LOG(gamma)) Filt0 = (1 - alpha) * data + alpha * Filt0[1] Det0 = (data - Filt0[0]) * (1 - gamma) + gamma * Det0[1] Filt1 = Filt0[0] + permissivity * Det0[0] Det1 = (Filt1[0] - AFRV2[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1] AFRV2 = AFRV2[1] + Det1[0] ENDIF ENDIF //------------------------------------------// // DEMA - Double Exponential Moving Average // //------------------------------------------// IF MATypev2 = 8 THEN Period2 = MAX(Period2, 1) AFRV2 = DEMA[Period2](Seriesv2) ENDIF //-------------------------------------------------// // ELSMA - Exponential Least Square Moving Average // //-------------------------------------------------// IF MATypev2 = 9 THEN Period2 = MAX(Period2, 1) // NumBars = 4 NumBars = 4 LR = LinearRegression[NumBars](Seriesv2) AFRV2 = ExponentialAverage[Period2](LR) ENDIF //----------------------------------// // EMA - Exponential Moving Average // //----------------------------------// IF MATypev2 = 10 THEN Period2 = MAX(Period2, 1) AFRV2 = ExponentialAverage[Period2](Seriesv2) ENDIF //------------------------------------------------// // EVWMA - Elastic Volume Weighted Moving Average // //------------------------------------------------// IF MATypev2 = 11 THEN Period2 = MAX(Period2, 1) IF BarIndex < Period2 THEN AFRV2 = Seriesv2 ELSE SumVol = summation[Period2](Volume) IF SumVol = 0 THEN SumVol = 1 ENDIF AFRV2 = ((SumVol - Volume) * AFRV2 + Volume * Seriesv2) / SumVol ENDIF ENDIF //---------------------------------// // FATL - Fast Adaptive Trend Line // //---------------------------------// IF MATypev2 = 12 THEN AFRV2 = 0.4360409450*Seriesv2[0]+0.3658689069*Seriesv2[1]+0.2460452079*Seriesv2[2]+0.1104506886*Seriesv2[3]-0.0054034585*Seriesv2[4]-0.0760367731*Seriesv2[5]-0.0933058722*Seriesv2[6]-0.0670110374*Seriesv2[7]-0.0190795053*Seriesv2[8]+0.0259609206*Seriesv2[9]+0.0502044896*Seriesv2[10]+0.0477818607*Seriesv2[11]+0.0249252327*Seriesv2[12]-0.0047706151*Seriesv2[13]-0.0272432537*Seriesv2[14]-0.0338917071*Seriesv2[15]-0.0244141482*Seriesv2[16]-0.0055774838*Seriesv2[17]+0.0128149838*Seriesv2[18]+0.0226522218*Seriesv2[19]+0.0208778257*Seriesv2[20]+0.0100299086*Seriesv2[21]-0.0036771622*Seriesv2[22]-0.0136744850*Seriesv2[23]-0.0160483392*Seriesv2[24]-0.0108597376*Seriesv2[25]-0.0016060704*Seriesv2[26]+0.0069480557*Seriesv2[27]+0.0110573605*Seriesv2[28]+0.0095711419*Seriesv2[29]+0.0040444064*Seriesv2[30]-0.0023824623*Seriesv2[31]-0.0067093714*Seriesv2[32]-0.0072003400*Seriesv2[33]-0.0047717710*Seriesv2[34]+0.0005541115*Seriesv2[35]+0.0007860160*Seriesv2[36]+0.0130129076*Seriesv2[37]+0.0040364019*Seriesv2[38] ENDIF //---------------------------------------------// // FBQMA - Fractional-Bar Quick Moving Average // //---------------------------------------------// IF MATypev2 = 13 THEN Period2 = MAX(Period2, 1) Peak = Period2 / 3 Num = 0 Denom = 0 FOR j = 1 TO (Period2 + 1) DO IF j <= Peak THEN DataArray = j / Peak ELSE DataArray = (Period2 + 1 - j) / (Period2 + 1 - Peak) Num = Num + Seriesv2[j - 1] * DataArray Denom = Denom + DataArray ENDIF NEXT IF Denom <= 0 THEN AFRV2 = Seriesv2 ELSE AFRV2 = Num / Denom ENDIF ENDIF //-----------------------------------------// // FRAMA - Fractal Adaptive Moving Average // //-----------------------------------------// IF MATypev2 = 14 THEN Period2 = MAX(Period2, 1) N3 = (highest[Period2](High) - lowest[Period2](Low)) / Period2 mH = High L = Low FOR count = 0 TO (Period2 / 2) - 1 DO count = ROUND(count) IF High[count] > mH THEN mH = High[count] ENDIF IF Low[count] < L THEN L = Low[count] ENDIF NEXT N1 = (mH - L) / (Period2 / 2) HH = High[ROUND(Period2 / 2)] LL = Low[ROUND(Period2 / 2)] FOR count = Period2 / 2 TO Period2 - 1 DO count = ROUND(count) IF High[count] > HH THEN HH = High[count] ENDIF IF Low[count] < LL THEN LL = Low[count] ENDIF NEXT N2 = (HH - LL) / (Period2 / 2) IF N1 > 0 AND N2 > 0 AND N3 > 0 THEN // FIX LOG Dimen = ((LOG(N1 + N2) / LOG(10)) - (LOG(N3) / LOG(10))) / (LOG(2) / LOG(10)) ENDIF alpha = EXP(-4.6 * (Dimen - 1)) IF alpha < 0.01 THEN alpha = 0.01 ELSIF alpha > 1 THEN alpha = 1 ENDIF IF BarIndex < Period2 THEN AFRV2 = Seriesv2 ELSE AFRV2 = alpha * Seriesv2 + (1 - alpha) * AFRV2[1] ENDIF ENDIF //--------------------------// // GDEMA - Generalized DEMA // //--------------------------// IF MATypev2 = 15 THEN Period2 = MAX(Period2, 1) // VFactor = 0.7 ({-2.5..2.5}) VFactor = 0.7 EMA0 = ExponentialAverage[Period2](Seriesv2) EMA1 = ExponentialAverage[Period2](EMA0) AFRV2 = EMA0 * (1 + VFactor) - EMA1 * VFactor ENDIF //-------------------------------// // GF1P - 1-Pole Gaussian Filter // //-------------------------------// IF MATypev2 = 16 THEN Period2 = MAX(Period2, 2) IF BarIndex = 0 THEN w = 2 * 3.141592654 / Period2 w = 180 * w / 3.141592654 b = (1 - COS(w)) / (1.41421 - 1) aa = -b + SQRT(b * b + 2 * b) a1 = 1 - aa y1 = Seriesv2 ENDIF y = aa * Seriesv2 + a1 * y1 y1 = y AFRV2 = y ENDIF //-------------------------------// // GF2P - 2-Pole Gaussian Filter // //-------------------------------// IF MATypev2 = 17 THEN Period2 = MAX(Period2, 2) IF BarIndex = 0 THEN w = 2 * 3.141592654 / Period2 w = 180 * w / 3.141592654 b = (1 - COS(w)) / (1.41421 - 1) aa = -b + SQRT(b * b + 2 * b) a1 = 1 - aa a12 = a1 * a1 a2 = aa * aa y1 = Seriesv2 y2 = y1 ENDIF y = a2 * Seriesv2 + 2 * a1 * y1 - a12 * y2 y2 = y1 y1 = y AFRV2 = y ENDIF //-------------------------------// // GF3P - 3-Pole Gaussian Filter // //-------------------------------// IF MATypev2 = 18 THEN Period2 = MAX(Period2, 2) IF BarIndex = 0 THEN w = 2 * 3.141592654 / Period2 w = 180 * w / 3.141592654 b = (1 - COS(w)) / (1.25992 - 1) aa = -b + SQRT(b * b + 2 * b) a1 = 1 - aa a12 = a1 * a1 a13 = a1 * a1 * a1 a3 = aa * aa * aa y1 = Seriesv2 y2 = y1 y3 = y2 ENDIF y = a3 * Seriesv2 + 3 * a1 * y1 - 3 * a12 * y2 + a13 * y3 y3 = y2 y2 = y1 y1 = y AFRV2 = y ENDIF //-------------------------------// // GF4P - 4-Pole Gaussian Filter // //-------------------------------// IF MATypev2 = 19 THEN Period2 = MAX(Period2, 2) IF BarIndex = 0 THEN w = 2 * 3.141592654 / Period2 w = 180 * w / 3.141592654 b = (1 - COS(w)) / (1.18920 - 1) aa = -b + SQRT(b * b + 2 * b) a1 = 1 - aa a12 = a1 * a1 a13 = a1 * a1 * a1 a14 = a12 * a12 a2 = aa * aa a4 = a2 * a2 y1 = Seriesv2 y2 = y1 y3 = y2 y4 = y3 ENDIF y = a4 * Seriesv2 + 4 * a1 * y1 - 6 * a12 * y2 + 4 * a13 *y3 - a14 * y4 y4 = y3 y3 = y2 y2 = y1 y1 = y AFRV2 = y ENDIF //---------------------------// // HMA - Hull Moving Average // //---------------------------// IF MATypev2 = 20 THEN Period2 = MAX(Period2, 1) AFRV2 = WeightedAverage[ROUND(SQRT(Period2))](2 * WeightedAverage[ROUND(Period2 / 2)](Seriesv2) - WeightedAverage[Period2](Seriesv2)) ENDIF //-------------------------------------// // IE/2 - Combination of LSMA and ILRS // //-------------------------------------// IF MATypev2 = 21 THEN Period2 = MAX(Period2, 2) LR = LinearRegression[Period2](Seriesv2) LRS = LinearRegressionSlope[Period2](Seriesv2) SMA = Average[Period2](Seriesv2) AFRV2 = (LR + LRS + SMA) / 2 ENDIF //--------------------------------------------// // ILRS - Integral of Linear Regression Slope // //--------------------------------------------// IF MATypev2 = 22 THEN Period2 = MAX(Period2, 2) SumBars = Period2 * (Period2 - 1) * 0.5 SumSqrBars = Period2 * (Period2 - 1) * Period2 * (2 * Period2 - 1) / 6 IF (BarIndex < Period2) then AFRV2 = Seriesv2 ELSE Sum1 = 0 SumY = 0 MA = Average[1](Seriesv2) FOR i = 0 TO Period2 - 1 DO Sum1 = Sum1 + (i * MA[i]) SumY = SumY + MA[i] NEXT Num1 = Period2 * Sum1 - SumBars * SumY Num2 = SumBars * SumBars - Period2 * SumSqrBars AFRV2 = Num1 / Num2 + Average[Period2](Seriesv2) ENDIF ENDIF //--------------------------------// // iTrend - iTrend by John Ehlers // //--------------------------------// IF MATypev2 = 23 THEN // alpha = 0.0025 {0.0025..0.2} alpha = 0.005 IF BarIndex < 2 THEN AFRV2 = Seriesv2 ELSE i1 = (alpha - alpha * alpha / 4) * Seriesv2 i2 = 0.5 * alpha * alpha * Seriesv2[1] i3 = (alpha - 0.75 * alpha * alpha) * Seriesv2[2] i4 = 2 * (1 - alpha) * AFRV2[1] i5 = (1 - alpha) * (1 - alpha) * AFRV2[2] AFRV2 = i1 + i2 - i3 + i4 - i5 ENDIF ENDIF //-----------------------------------------------------// // JMA - Jurik Moving Average (Responsiveness Version) // //-----------------------------------------------------// IF MATypev2 = 24 THEN Period2 = MAX(Period2, 1) // Pow = 5 ({ 1..10 }) // R = 1.5 ({0.5..2.5}) Pow = 5 R = 1 beta = 0.45 * (Period2 - 1) / (0.45 * (Period2 - 1) + 2) IF Pow = 1 THEN alpha = beta ELSIF Pow = 2 THEN alpha = beta * beta ELSIF Pow = 3 THEN alpha = beta * beta * beta ELSIF Pow = 4 THEN alpha = beta * beta * beta * beta ELSIF Pow = 5 THEN alpha = beta * beta * beta * beta * beta ELSIF Pow = 6 THEN alpha = beta * beta * beta * beta * beta * beta ELSIF Pow = 7 THEN alpha = beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 8 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 9 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 10 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta * beta ENDIF IF BarIndex = 0 THEN Filt0 = Seriesv2 Filt1 = Seriesv2 AFRV2 = Seriesv2 ELSE Filt0 = (1 - alpha) * Seriesv2 + alpha * Filt0[1] Det0 = (Seriesv2 - Filt0[0]) * (1 - beta) + beta * Det0[1] Filt1 = Filt0[0] + R * Det0[0] Det1 = (Filt1[0] - AFRV2[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1] AFRV2 = AFRV2[1] + Det1[0] ENDIF ENDIF //----------------------------// // JMA - Jurik Moving Average // //----------------------------// IF MATypev2 = 25 THEN Period2 = MAX(Period2, 1) // Pow = 5 ({ 1..10 }) // R = 1.5 ({0.5..2.5}) Pow = 4 R = 1 beta = 0.45 * (Period2 - 1) / (0.45 * (Period2 - 1) + 2) IF Pow = 1 THEN alpha = beta ELSIF Pow = 2 THEN alpha = beta * beta ELSIF Pow = 3 THEN alpha = beta * beta * beta ELSIF Pow = 4 THEN alpha = beta * beta * beta * beta ELSIF Pow = 5 THEN alpha = beta * beta * beta * beta * beta ELSIF Pow = 6 THEN alpha = beta * beta * beta * beta * beta * beta ELSIF Pow = 7 THEN alpha = beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 8 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 9 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta * beta ELSIF Pow = 10 THEN alpha = beta * beta * beta * beta * beta * beta * beta * beta * beta ENDIF IF BarIndex = 0 THEN Filt0 = Seriesv2 Filt1 = Seriesv2 AFRV2 = Seriesv2 ELSE Filt0 = (1 - alpha) * Seriesv2 + alpha * Filt0[1] Det0 = (Seriesv2 - Filt0[0]) * (1 - beta) + beta * Det0[1] Filt1 = Filt0[0] + R * Det0[0] Det1 = (Filt1[0] - AFRV2[1]) * ((1 - alpha) * (1 - alpha)) + (alpha * alpha) * Det1[1] AFRV2 = AFRV2[1] + Det1[0] ENDIF ENDIF //----------------------------------------// // KAMA - Kaufman Adaptive Moving Average // //----------------------------------------// IF MATypev2 = 26 THEN Period2 = MAX(Period2, 4) // FastPeriod2 = 7 // SlowPeriod2 = 28 FastPeriod2 = 7 SlowPeriod2 = 28 Fastest = 2 / (FastPeriod2 + 1) Slowest = 2 / (SlowPeriod2 + 1) IF BarIndex < Period2 THEN AFRV2 = Seriesv2 ELSE Num = ABS(Seriesv2 - Seriesv2[Period2]) Den = summation[Period2](ABS(Seriesv2 - Seriesv2[1])) ER = Num / Den Alpha = SQUARE(ER * (Fastest - Slowest) + Slowest) AFRV2 = (Alpha * Seriesv2) + ((1 - Alpha) * AFRV2[1]) ENDIF ENDIF //-------------------------------------// // KFJE - Kalman Filter by John Ehlers // //-------------------------------------// IF MATypev2 = 27 THEN IF BarIndex < 3 THEN AFRV2 = Seriesv2 ELSE AFRV2 = 0.33 * (Seriesv2 + 0.5 * (Seriesv2 - Seriesv2[3])) + 0.67 * AFRV2[1] ENDIF ENDIF //---------------------------------------------// // KF - Kalman Filter (Responsiveness Version) // //---------------------------------------------// IF MATypev2 = 28 THEN // K = 1000 ({1...2000}) K = 1000 ONCE Pred = Seriesv2 IF BarIndex = 0 THEN AFRV2 = Seriesv2 ELSE Smooth = Pred + (Seriesv2 - Pred) * SQRT((K / 10000) * 2) Velo = Velo + ((K / 10000) * (Seriesv2 - Pred)) Pred = Smooth + Velo AFRV2 = Pred ENDIF ENDIF //--------------------// // KF - Kalman Filter // //--------------------// IF MATypev2 = 29 THEN // K = 500 ({1...2000}) K = 500 ONCE Pred = Seriesv2 IF BarIndex = 0 THEN AFRV2 = Seriesv2 ELSE Smooth = Pred + (Seriesv2 - Pred) * SQRT((K / 10000) * 2) Velo = Velo + ((K / 10000) * (Seriesv2 - Pred)) Pred = Smooth + Velo AFRV2 = Pred ENDIF ENDIF //------------------------------------------// // LEMA - Leader Exponential Moving Average // //------------------------------------------// IF MATypev2 = 30 THEN Period2 = MAX(Period2, 1) IF BarIndex = 0 THEN p1 = Seriesv2 p2 = 0 ELSE alpha = 2 / (Period2 + 1) p1 = p1[1] + alpha * (Seriesv2 - p1[1]) p2 = p2[1] + alpha * (Seriesv2 - p1 - p2[1]) ENDIF AFRV2 = p1 + p2 ENDIF //-------------------------------------// // LF - Laguerre Filter by John Ehlers // //-------------------------------------// IF MATypev2 = 31 THEN // gamma = 0.8 gamma = 0.8 once l0 = Seriesv2 once l1 = Seriesv2 once l2 = Seriesv2 once l3 = Seriesv2 IF BarIndex = 0 THEN AFRV2 = Seriesv2 ELSE l0 = (1 - gamma) * Seriesv2 + gamma * l0[1] l1 = -gamma * l0 + l0[1] + gamma * l1[1] l2 = -gamma * l1 + l1[1] + gamma * l2[1] l3 = -gamma * l2 + l2[1] + gamma * l3[1] AFRV2 = (l0 + 2 * l1 + 2 * l2 + l3) / 6 ENDIF ENDIF //------------------------------------// // LSMA - Least Square Moving Average // //------------------------------------// IF MATypev2 = 32 THEN Period2 = MAX(Period2, 2) AFRV2 = LinearRegression[Period2](Seriesv2) ENDIF //-----------------------// // MD - McGinley Dynamic // //-----------------------// IF MATypev2 = 33 THEN Period2 = MAX(Period2, 4) IF BarIndex = 0 THEN AFRV2 = Seriesv2 ELSE Pow = (Seriesv2 / AFRV2[1]) * (Seriesv2 / AFRV2[1]) * (Seriesv2 / AFRV2[1]) * (Seriesv2 / AFRV2[1]) AFRV2 = AFRV2[1] + (Seriesv2 - AFRV2[1]) / ((Period2 / 2) * Pow) ENDIF ENDIF //----------------------------------------------// // MHLMA - Middle High Low Range Moving Average // //----------------------------------------------// IF MATypev2 = 34 THEN Period2 = MAX(Period2, 1) // HLRange = 3 HLRange = 3 HH = highest[HLRange](High) LL = lowest[HLRange](Low) AFRV2 = Average[Period2]((HH + LL) / 2) ENDIF //---------------------------------// // MNMA - McNicholl Moving Average // //---------------------------------// IF MATypev2 = 35 THEN Period2 = MAX(Period2, 2) alpha = 2 / (1 + Period2) IF BarIndex = 0 THEN p1 = Seriesv2 p2 = Seriesv2 ELSE p1 = p1[1] + alpha * (Seriesv2 - p1[1]) p2 = p2[1] + alpha * (p1 - p2[1]) ENDIF AFRV2 = (((2 - alpha) * p1 - p2) / (1 - alpha)) ENDIF //--------------------------------------------------------// // NLMA - Non Lag Moving Average (Responsiveness Version) // //--------------------------------------------------------// IF MATypev2 = 36 THEN Period2 = MAX(Period2, 1) // Amplitude = 1 (0...1) // Smooth = -1 (-2...2) Amplitude = 1 Smooth = 1 IF Amplitude > 0 THEN Coeff = 3 * 3.1415926535 / Amplitude ELSE Coeff = 3 * 3.1415926535 ENDIF IF Smooth < -2 THEN Smooth = 0 ENDIF vCycle = 4 vWeight = 0 vSum = 0 Phase = Period2 + Smooth FOR i = 0 TO ((Period2 * vCycle) + Phase) - 1 DO IF i <= Phase - 1 THEN IF Phase = 1 THEN x = i ELSE x = i / (Phase - 1) ENDIF ELSE x = 1.0 + (i - Phase + 1) * (2.0 * vCycle - 1.0) / (vCycle * Period2 - 1.0) ENDIF g = Amplitude / (Coeff * x + 1.0) IF x <= 0.5 THEN g = 1.0 ENDIF vSum = vSum + g * COS(180 * x) * Seriesv2[i] vWeight = vWeight + g * COS(180 * x) NEXT IF vWeight > 0 THEN AFRV2 = vSum / vWeight ELSE AFRV2 = Seriesv2 ENDIF ENDIF //-------------------------------// // NLMA - Non Lag Moving Average // //-------------------------------// IF MATypev2 = 37 THEN Period2 = MAX(Period2, 1) // Amplitude = 0 (0...1) // Smooth = 1 (-2...2) Amplitude = 0 Smooth = 1 IF Amplitude > 0 THEN Coeff = 3 * 3.1415926535 / Amplitude ELSE Coeff = 3 * 3.1415926535 ENDIF IF Smooth < -2 THEN Smooth = 0 ENDIF vCycle = 4 vWeight = 0 vSum = 0 Phase = Period2 + Smooth FOR i = 0 TO ((Period2 * vCycle) + Phase) - 1 DO IF i <= Phase - 1 THEN IF Phase = 1 THEN x = i ELSE x = i / (Phase - 1) ENDIF ELSE x = 1.0 + (i - Phase + 1) * (2.0 * vCycle - 1.0) / (vCycle * Period2 - 1.0) ENDIF g = Amplitude / (Coeff * x + 1.0) IF x <= 0.5 THEN g = 1.0 ENDIF vSum = vSum + g * COS(180 * x) * Seriesv2[i] vWeight = vWeight + g * COS(180 * x) NEXT IF vWeight > 0 THEN AFRV2 = vSum / vWeight ELSE AFRV2 = Seriesv2 ENDIF ENDIF //------------------------// // OMA - One More Average // //------------------------// IF MATypev2 = 38 THEN // Sensibility = 1.5 Sensibility = 1.5 Period2 = MAX(Period2, 1) Sensibility = MAX(Sensibility, -1.5) Data = Average[1](Seriesv2) averagePeriod2 = Period2 IF BarIndex < Period2 THEN AFRV2 = Seriesv2 ELSE IF averagePeriod2 > 1 THEN minPeriod2 = averagePeriod2 / 2.0 maxPeriod2 = minPeriod2 * 5.0 endPeriod2 = ROUND(maxPeriod2) signal = ABS((Data - Data[endPeriod2])) noise = 0.00000000001 FOR k = 1 TO endPeriod2 DO noise = noise + ABS(Data - Data[k]) averagePeriod2 = ROUND(((signal / noise) * (maxPeriod2 - minPeriod2)) + minPeriod2) NEXT ENDIF alpha = (2.0 + Sensibility) / (1.0 + Sensibility + averagePeriod2) e1 = e1 + alpha * (Data - e1) e2 = e2 + alpha * (e1 - e2) v1 = 1.5 * e1 - 0.5 * e2 e3 = e3 + alpha * (v1 - e3) e4 = e4 + alpha * (e3 - e4) v2 = 1.5 * e3 - 0.5 * e4 e5 = e5 + alpha * (v2 - e5) e6 = e6 + alpha * (e5 - e6) AFRV2 = 1.5 * e5 - 0.5 * e6 ENDIF ENDIF //--------------------------------------------// // PEMA - Pentuple Exponential Moving Average // //--------------------------------------------// IF MATypev2 = 39 THEN Period2 = MAX(Period2, 1) MA1 = ExponentialAverage[Period2](Seriesv2) MA2 = ExponentialAverage[Period2](MA1) MA3 = ExponentialAverage[Period2](MA2) MA4 = ExponentialAverage[Period2](MA3) MA5 = ExponentialAverage[Period2](MA4) MA6 = ExponentialAverage[Period2](MA5) MA7 = ExponentialAverage[Period2](MA6) MA8 = ExponentialAverage[Period2](MA7) AFRV2 = (8 * MA1) - (28 * MA2) + (56 * MA3) - (70 * MA4) + (56 * MA5) - (28 * MA6) + (8 * MA7) - MA8 ENDIF //------------------------------------------// // PWMA - Parabolic Weighted Moving Average // //------------------------------------------// IF MATypev2 = 40 THEN Period2 = MAX(Period2, 1) Sum = SumW * Seriesv2 SumW = Period2 * Period2 FOR i = 0 TO Period2 DO Weight = (Period2 - i) * (Period2 - i) SumW = SumW + Weight Sum = Sum + Weight * Seriesv2[i] NEXT AFRV2 = Sum / SumW ENDIF //---------------------------------------------// // QEMA - Quadruple Exponential Moving Average // //---------------------------------------------// IF MATypev2 = 41 THEN Period2 = MAX(Period2, 1) MA1 = ExponentialAverage[Period2](Seriesv2) MA2 = ExponentialAverage[Period2](MA1) MA3 = ExponentialAverage[Period2](MA2) MA4 = ExponentialAverage[Period2](MA3) MA5 = ExponentialAverage[Period2](MA4) AFRV2 = (5 * MA1) - (10 * MA2) + (10 * MA3) - (5 * MA4) + MA5 ENDIF //-------------------------------------------// // REMA - Regularized EMA by Chris Satchwell // //-------------------------------------------// IF MATypev2 = 42 THEN // Lambda = 0.5 ({0.5..9}) Lambda = 0.5 Period2 = MAX(Period2, 1) Lambda = MAX(Lambda, 0) IF BarIndex < 2 THEN AFRV2 = Seriesv2 ELSE AFRV2 = (AFRV2[1] * (1 + 2 * Lambda) + (2 / (Period2 + 1)) * (Seriesv2 - AFRV2[1]) - Lambda * AFRV2[2]) / (1 + Lambda) ENDIF ENDIF //----------------------------------// // RFTL - Reference Fast Trend Line // //----------------------------------// IF MATypev2 = 43 THEN AFRV2 = -0.02232324*Seriesv2[0]+0.02268676*Seriesv2[1]+0.08389067*Seriesv2[2]+0.14630380*Seriesv2[3]+0.19282649*Seriesv2[4]+0.21002638*Seriesv2[5]+0.19282649*Seriesv2[6]+0.14630380*Seriesv2[7]+0.08389067*Seriesv2[8]+0.02268676*Seriesv2[9]-0.02232324*Seriesv2[10]-0.04296564*Seriesv2[11]-0.03980614*Seriesv2[12]-0.02082171*Seriesv2[13]+0.00243636*Seriesv2[14]+0.01950580*Seriesv2[15]+0.02460929*Seriesv2[16]+0.01799295*Seriesv2[17]+0.00470540*Seriesv2[18]-0.00831985*Seriesv2[19]-0.01544722*Seriesv2[20]-0.01456262*Seriesv2[21]-0.00733980*Seriesv2[22]+0.00201852*Seriesv2[23]+0.00902504*Seriesv2[24]+0.01093067*Seriesv2[25]+0.00766099*Seriesv2[26]+0.00145478*Seriesv2[27]-0.00447175*Seriesv2[28]-0.00750446*Seriesv2[29]-0.00671646*Seriesv2[30]-0.00304016*Seriesv2[31]+0.00143433*Seriesv2[32]+0.00457475*Seriesv2[33]+0.00517589*Seriesv2[34]+0.00336708*Seriesv2[35]+0.00034406*Seriesv2[36]-0.00233637*Seriesv2[37]-0.00352280*Seriesv2[38]-0.00293522*Seriesv2[39]-0.00114249*Seriesv2[40]+0.00083536*Seriesv2[41]+0.00215524*Seriesv2[42]+0.00604133*Seriesv2[43]-0.00013046*Seriesv2[44] ENDIF //----------------------------------// // RSTL - Reference Slow Trend Line // //----------------------------------// IF MATypev2 = 44 THEN AFRV2 = -0.00514293*Seriesv2[0]-0.00398417*Seriesv2[1]-0.00262594*Seriesv2[2]-0.00107121*Seriesv2[3]+0.00066887*Seriesv2[4]+0.00258172*Seriesv2[5]+0.00465269*Seriesv2[6]+0.00686394*Seriesv2[7]+0.00919334*Seriesv2[8]+0.01161720*Seriesv2[9]+0.01411056*Seriesv2[10]+0.01664635*Seriesv2[11]+0.01919533*Seriesv2[12]+0.02172747*Seriesv2[13]+0.02421320*Seriesv2[14]+0.02662203*Seriesv2[15]+0.02892446*Seriesv2[16]+0.03109071*Seriesv2[17]+0.03309496*Seriesv2[18]+0.03490921*Seriesv2[19]+0.03651145*Seriesv2[20]+0.03788045*Seriesv2[21]+0.03899804*Seriesv2[22]+0.03984915*Seriesv2[23]+0.04042329*Seriesv2[24]+0.04071263*Seriesv2[25]+0.04071263*Seriesv2[26]+0.04042329*Seriesv2[27]+0.03984915*Seriesv2[28]+0.03899804*Seriesv2[29]+0.03788045*Seriesv2[30]+0.03651145*Seriesv2[31]+0.03490921*Seriesv2[32]+0.03309496*Seriesv2[33]+0.03109071*Seriesv2[34]+0.02892446*Seriesv2[35]+0.02662203*Seriesv2[36]+0.02421320*Seriesv2[37]+0.02172747*Seriesv2[38]+0.01919533*Seriesv2[39]+0.01664635*Seriesv2[40]+0.01411056*Seriesv2[41]+0.01161720*Seriesv2[42]+0.00919334*Seriesv2[43]+0.00686394*Seriesv2[44]+0.00465269*Seriesv2[45]+0.00258172*Seriesv2[46]+0.00066887*Seriesv2[47]-0.00107121*Seriesv2[48]-0.00262594*Seriesv2[49]-0.00398417*Seriesv2[50]-0.00514293*Seriesv2[51]-0.00609634*Seriesv2[52]-0.00684602*Seriesv2[53]-0.00739452*Seriesv2[54]-0.00774847*Seriesv2[55]-0.00791630*Seriesv2[56]-0.00790940*Seriesv2[57]-0.00774085*Seriesv2[58]-0.00742482*Seriesv2[59]-0.00697718*Seriesv2[60]-0.00641613*Seriesv2[61]-0.00576108*Seriesv2[62]-0.00502957*Seriesv2[63]-0.00423873*Seriesv2[64]-0.00340812*Seriesv2[65]-0.00255923*Seriesv2[66]-0.00170217*Seriesv2[67]-0.00085902*Seriesv2[68]-0.00004113*Seriesv2[69]+0.00073700*Seriesv2[70]+0.00146422*Seriesv2[71]+0.00213007*Seriesv2[72]+0.00272649*Seriesv2[73]+0.00324752*Seriesv2[74]+0.00368922*Seriesv2[75]+0.00405000*Seriesv2[76]+0.00433024*Seriesv2[77]+0.00453068*Seriesv2[78]+0.00465046*Seriesv2[79]+0.00469058*Seriesv2[80]+0.00466041*Seriesv2[81]+0.00457855*Seriesv2[82]+0.00442491*Seriesv2[83]+0.00423019*Seriesv2[84]+0.00399201*Seriesv2[85]+0.00372169*Seriesv2[86]+0.00342736*Seriesv2[87]+0.00311822*Seriesv2[88]+0.00280309*Seriesv2[89]+0.00249088*Seriesv2[90]+0.00219089*Seriesv2[91]+0.00191283*Seriesv2[92]+0.00166683*Seriesv2[93]+0.00146419*Seriesv2[94]+0.00131867*Seriesv2[95]+0.00124645*Seriesv2[96]+0.00126836*Seriesv2[97]-0.00401854*Seriesv2[98] ENDIF //---------------------------------// // SATL - Slow Adaptive Trend Line // //---------------------------------// IF MATypev2 = 45 THEN AFRV2 = 0.0982862174*Seriesv2[0]+0.0975682269*Seriesv2[1]+0.0961401078*Seriesv2[2]+0.0940230544*Seriesv2[3]+0.0912437090*Seriesv2[4]+0.0878391006*Seriesv2[5]+0.0838544303*Seriesv2[6]+0.0793406350*Seriesv2[7]+0.0743569346*Seriesv2[8]+0.0689666682*Seriesv2[9]+0.0632381578*Seriesv2[10]+0.0572428925*Seriesv2[11]+0.0510534242*Seriesv2[12]+0.0447468229*Seriesv2[13]+0.0383959950*Seriesv2[14]+0.0320735368*Seriesv2[15]+0.0258537721*Seriesv2[16]+0.0198005183*Seriesv2[17]+0.0139807863*Seriesv2[18]+0.0084512448*Seriesv2[19]+0.0032639979*Seriesv2[20]-0.0015350359*Seriesv2[21]-0.0059060082*Seriesv2[22]-0.0098190256*Seriesv2[23]-0.0132507215*Seriesv2[24]-0.0161875265*Seriesv2[25]-0.0186164872*Seriesv2[26]-0.0205446727*Seriesv2[27]-0.0219739146*Seriesv2[28]-0.0229204861*Seriesv2[29]-0.0234080863*Seriesv2[30]-0.0234566315*Seriesv2[31]-0.0231017777*Seriesv2[32]-0.0223796900*Seriesv2[33]-0.0213300463*Seriesv2[34]-0.0199924534*Seriesv2[35]-0.0184126992*Seriesv2[36]-0.0166377699*Seriesv2[37]-0.0147139428*Seriesv2[38]-0.0126796776*Seriesv2[39]-0.0105938331*Seriesv2[40]-0.0084736770*Seriesv2[41]-0.0063841850*Seriesv2[42]-0.0043466731*Seriesv2[43]-0.0023956944*Seriesv2[44]-0.0005535180*Seriesv2[45]+0.0011421469*Seriesv2[46]+0.0026845693*Seriesv2[47]+0.0040471369*Seriesv2[48]+0.0052380201*Seriesv2[49]+0.0062194591*Seriesv2[50]+0.0070340085*Seriesv2[51]+0.0076266453*Seriesv2[52]+0.0080376628*Seriesv2[53]+0.0083037666*Seriesv2[54]+0.0083694798*Seriesv2[55]+0.0082901022*Seriesv2[56]+0.0080741359*Seriesv2[57]+0.0077543820*Seriesv2[58]+0.0073260526*Seriesv2[59]+0.0068163569*Seriesv2[60]+0.0062325477*Seriesv2[61]+0.0056078229*Seriesv2[62]+0.0049516078*Seriesv2[63]+0.0161380976*Seriesv2[64] ENDIF //-----------------------------// // SMA - Simple Moving Average // //-----------------------------// IF MATypev2 = 46 THEN Period2 = MAX(Period2, 1) AFRV2 = Average[Period2](Seriesv2) ENDIF //---------------------------------------// // SSF2P - 2-Pole Super Smoothing Filter // //---------------------------------------// IF MATypev2 = 47 THEN Period2 = MAX(Period2, 1) a1 = EXP(-1.414 * 3.14159 / Period2) b1 = 2 * a1 * COS(1.414 * 180 / Period2) coef2 = b1 coef3 = -a1 * a1 coef1 = 1 - coef2 - coef3 IF BarIndex < 2 THEN AFRV2 = Seriesv2 ELSE AFRV2 = coef1 * Seriesv2 + coef2 * AFRV2[1] + coef3 * AFRV2[2] ENDIF ENDIF //---------------------------------------// // SSF3P - 3-Pole Super Smoothing Filter // //---------------------------------------// IF MATypev2 = 48 THEN Period2 = MAX(Period2, 1) a1 = EXP(-3.14159 / Period2) b1 = 2 * a1 * COS(1.738 * 180 / Period2) c1 = a1 * a1 coef2 = b1 + c1 coef3 = -(c1 + b1 * c1) coef4 = c1 * c1 coef1 = 1 - coef2 - coef3 - coef4 IF BarIndex < 3 THEN AFRV2 = Seriesv2 ELSE AFRV2 = coef1 * Seriesv2 + coef2 * AFRV2[1] + coef3 * AFRV2[2] + coef4 * AFRV2[3] ENDIF ENDIF //---------------------------------------// // SSMA - Smoothed Simple Moving Average // //---------------------------------------// IF MATypev2 = 49 THEN Period2 = MAX(Period2, 1) IF BarIndex = 0 THEN AFRV2 = Seriesv2 ELSE AFRV2 = AFRV2[1] + (Seriesv2 - AFRV2[1]) / Period2 ENDIF ENDIF //-------------------------------------// // SWMA - Sine Weighted Moving Average // //-------------------------------------// IF MATypev2 = 50 THEN Period2 = MAX(Period2, 1) Sum = 0 CSum = 0 FOR j = 0 TO Period2 - 1 DO Sum = Sum + Seriesv2[j] * SIN(90 * (1 - j / Period2)) CSum = CSum + SIN(90 * (1 - j / Period2)) NEXT IF CSum <= 0 THEN AFRV2 = Seriesv2 ELSE AFRV2 = Sum / CSum ENDIF ENDIF //--------------------------// // T3MA - T3 Moving Average // //--------------------------// IF MATypev2 = 51 THEN Period2 = MAX(Period2, 1) // Hot = 0.7 ({-1.5..1.5}) Hot = 0.7 e1 = ExponentialAverage[Period2](Seriesv2) e2 = ExponentialAverage[Period2](e1) e3 = ExponentialAverage[Period2](e2) e4 = ExponentialAverage[Period2](e3) e5 = ExponentialAverage[Period2](e4) e6 = ExponentialAverage[Period2](e5) b = Hot b2 = (b * b) b3 = (b * b * b) c1 = -b3 c2 = (3 * b2) + (3 * b3) c3 = (-6 * b2) - (3 * b) - (3 * b3) c4 = 1 + (3 * b) + b3 + (3 * b2) AFRV2 = c1 * e6 + c2 * e5 + c3 * e4 + c4 * e3 ENDIF //------------------------------------------// // TEMA - Triple Exponential Moving Average // //------------------------------------------// IF MATypev2 = 52 THEN Period2 = MAX(Period2, 1) AFRV2 = TEMA[Period2](Seriesv2) ENDIF //---------------------------------// // TMA - Triangular Moving Average // //---------------------------------// IF MATypev2 = 53 THEN Period2 = MAX(Period2, 1) AFRV2 = TriangularAverage[Period2](Seriesv2) ENDIF //---------------------------// // TSA - Time Seriesv2 Average // //---------------------------// IF MATypev2 = 54 THEN Period2 = MAX(Period2, 1) AFRV2 = TimeSeriesAverage[Period2](Seriesv2) ENDIF //----------------------------------------// // VIDYA - Variable Index Dynamic Average // //----------------------------------------// IF MATypev2 = 55 THEN Period2 = MAX(Period2, 4) // Smooth = 5 Smooth = 5 ONCE SC = 2 / (Smooth + 1) AbsCMO = (ABS(Chandle[Period2](Seriesv2))) / 100 IF BarIndex < Period2 THEN AFRV2 = Seriesv2 ELSE AFRV2 = (SC * AbsCMO * Seriesv2) + (1 - (SC * AbsCMO)) * AFRV2 ENDIF ENDIF //-------------------------------// // VMA - Variable Moving Average // //-------------------------------// IF MATypev2 = 56 THEN Period2 = MAX(Period2, 4) IF BarIndex < Period2 THEN AFRV2 = Seriesv2 ELSE k = 1.0 / Period2 pdm = MAX((Seriesv2 - Seriesv2[1]), 0) mdm = MAX((Seriesv2[1] - Seriesv2), 0) pdmS = ((1 - k) * (pdmS[1]) + k * pdm) mdmS = ((1 - k) * (mdmS[1]) + k * mdm) s = pdmS + mdmS pdi = pdmS / s mdi = mdmS / s pdiS = ((1 - k) * (pdiS[1]) + k * pdi) mdiS = ((1 - k) * (mdiS[1]) + k * mdi) d = ABS(pdiS - mdiS) s1 = pdiS + mdiS iS = ((1 - k) * (iS[1]) + k * d / s1) hhv = highest[Period2](iS) llv = lowest[Period2](iS) d1 = hhv - llv vI = (iS - llv) / d1 AFRV2 = (1 - k * vI) * (AFRV2[1]) + k * vI * Seriesv2 ENDIF ENDIF //--------------------------------------// // VWAP - Volume Weighted Average Price // //--------------------------------------// IF MATypev2 = 57 THEN Period2 = MAX(Period2, 1) SumVol = summation[Period2](Volume) IF SumVol = 0 THEN SumVol = 1 ENDIF AFRV2 = summation[Period2](Seriesv2 * Volume) / summation[Period2](Volume) ENDIF //------------------------------// // WIMA - Wilder Moving Average // //------------------------------// IF MATypev2 = 58 THEN Period2 = MAX(Period2, 1) AFRV2 = WilderAverage[Period2](Seriesv2) ENDIF //----------------------------------------------// // WLSMA - Weighted Least Square Moving Average // //----------------------------------------------// IF MATypev2 = 59 THEN Period2 = MAX(Period2, 1) // NumBars = 4 NumBars = 4 LR = LinearRegression[NumBars](Seriesv2) AFRV2 = WeightedAverage[Period2](LR) ENDIF //-------------------------------// // WMA - Weighted Moving Average // //-------------------------------// IF MATypev2 = 60 THEN Period2 = MAX(Period2, 1) AFRV2 = WeightedAverage[Period2](Seriesv2) ENDIF //----------------------// // ZLBMT - Zero Lag BMT // //----------------------// IF MATypev2 = 61 THEN Period2 = MAX(Period2, 1) EMA0 = ExponentialAverage[Period2](Seriesv2) EMA1 = ExponentialAverage[Period2](EMA0) AFRV2 = EMA0 + (EMA0 - EMA1) ENDIF //-----------------------------------------------------// // ZLDEMA - Zero Lag Double Exponential Moving Average // //-----------------------------------------------------// IF MATypev2 = 62 THEN Period2 = MAX(Period2, 1) DEMA0 = DEMA[Period2](Seriesv2) DEMA1 = DEMA[Period2](DEMA0) AFRV2 = DEMA0 + (DEMA0 - DEMA1) ENDIF //----------------------------// // ZLFF - Zero Lag FIR Filter // //----------------------------// IF MATypev2 = 63 THEN AFRV2 = (Seriesv2 + 2 * Seriesv2[1] + 3 * Seriesv2[2] + 3 * Seriesv2[3] + 2 * Seriesv2[4] + Seriesv2[5]) / 12 ENDIF //----------------------------// // ZLIF - Zero Lag IIR Filter // //----------------------------// IF MATypev2 = 64 THEN Period2 = MAX(Period2, 1) k = 2 / (Period2 + 1) x = ROUND((Period2 - 1) / 2) IF BarIndex <= MAX(x, 0) THEN AFRV2 = Seriesv2 ELSE AFRV2 = k * (2 * Seriesv2 - Seriesv2[x]) + (1 - k) * AFRV2[1] ENDIF ENDIF //-----------------------------// // ZLJE - Zero Lag John Ehlers // //-----------------------------// IF MATypev2 = 65 THEN Period2 = MAX(Period2, 2) alpha = 2 / (1 + Period2) per = ROUND((Period2 - 1) / 2) IF BarIndex < per THEN AFRV2 = Seriesv2 ELSE AFRV2 = AFRV2[1] + alpha * (2 * Seriesv2 - Seriesv2[per] - AFRV2[1]) ENDIF ENDIF //--------------------------------// // ZLWBMT - Zero Lag Weighted BMT // //--------------------------------// IF MATypev2 = 66 THEN Period2 = MAX(Period2, 1) WMA0 = WeightedAverage[Period2](Seriesv2) WMA1 = WeightedAverage[Period2](WMA0) AFRV2 = WMA0 + (WMA0 - WMA1) ENDIF //-----------------------------------------// // Range based AV high + STD - low - STD // //-----------------------------------------// IF MATypev2 = 67 THEN Type = 1 //exponential average NxStd = 1 //Standard dev multiplier AvH= Average[Period2,Type](high) + NxStd * STD[Period2](high) //higher green line HIGH + Std AvL= Average[Period2,Type](low) + NxStd * STD[Period2](low) //lower green line LOW + Std Av= Average[Period2,Type](close) AvHL= Average[Period2,Type](high) - NxStd * STD[Period2](high) //higher red line HIGH - Std AvLL= Average[Period2,Type](low) - NxStd * STD[Period2](low) //lower red line LOW - Std AFRV2 = average[Period2,Type]((close +AvH + AvL + Av + AvHL + AvLL)/6) endif //--------------------------------// // Average lowest plus highest // //--------------------------------// IF MATypev2 = 68 THEN Period2 = MAX(Period2, 1) AFRV2 = (lowest[Period2](seriesv2) + highest[Period2](seriesv2))/2 ENDIF //--------------------------------// // 69 DEMA adjusted by itself // //--------------------------------// IF MATypev2 = 69 THEN Period2 = MAX(Period2, 1) AFRV2 = 2 * DEMA[Period2](Seriesv2) - DEMA[Period2](DEMA[Period2](Series)) ENDIF ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////// wAFR = exponentialaverage[30](AFR) ///for smoothing the AFR, to reduce market noice wAFRv2 = exponentialaverage[30](AFRv2) ///for smoothing the AFRv2, to reduce market noice if time >= StartE And time <= StartL and OTD then //and not onmarket then IF wAFR > wAFRv2 and wAFR[1] < wAFRv2[1] then buy N shares AT MARKET SET STOP PLOSS TSL //SET STOP PTRAILING TSL //SET TARGET PPROFIT TSL else if wAFR < wAFRv2 and wAFR[1] > wAFRv2[1] then sellshort N shares at market SET STOP PLOSS TSL //SET STOP PTRAILING TSL //SET TARGET PPROFIT TSL endif endif endif -
AuthorPosts
Viewing 1 post (of 1 total)
- You must be logged in to reply to this topic.
New
Stuck on this ProBuilder code?
Describe what this topic is trying to build, in plain English, and ProRealAI writes the ProRealTime™ indicator, screener or system for you.
errore di programmazione
ProOrder: Trading Automatico & Backtesting
New Reply
Author
Summary
This topic contains 1 voice and has 0 replies.
Topic Details
| Forum: | ProOrder: Trading Automatico & Backtesting |
| Language: | Italian |
| Started: | 12/27/2020 |
| Status: | Active |
| Attachments: | No files |
Loading...
About personal data collected
The information collected on this form is stored in a computer file by ProRealCode to create and access your ProRealCode profile. This data is kept in a secure database for the duration of the member's membership. They will be kept as long as you use our services and will be automatically deleted after 3 years of inactivity. Your personal data is used to create your private profile on ProRealCode. This data is maintained by SAS ProRealCode, 407 rue Freycinet, 59151 Arleux, France. If you subscribe to our newsletters, your email address is provided to our service provider "MailChimp" located in the United States, with whom we have signed a confidentiality agreement. This company is also compliant with the EU/Swiss Privacy Shield, and the GDPR. For any request for correction or deletion concerning your data, you can directly contact the ProRealCode team by email at privacy@prorealcode.com If you would like to lodge a complaint regarding the use of your personal data, you can contact your data protection supervisory authority.
Get Assistance
Assistance Type
Your Need
Proposed Solutions
Do you like cookies? 🍪 We use cookies to ensure you get the best experience on our website.
(Learn more)