I need to transform this tradingview indicator to mt4 indicator and add some modifications. It is a smooth heikin ashi indicator, but it needs some modifications. Modifications: * in the chart the indicator must be shown as a line, from the center of the candle to the next center of the indicator candle. (i must choose the color of the line) * must be added a deviation option: must be able to choose what deviation between 1 and 0 * the indicator must work with three timeframes (must be added): - time frame 1 options: m5, m15, m30, H1, H4, d1 w1 - time frame 2 options: m5, m15, m30, H1, H4, d1 w1 - time frame 3 options: m5, m15, m30, H1, H4, d1 w1 * must be added a new low panel. - the panel will show just a color, if the price is under the line in all timeframes the color will be red, if the price is over the line in all timeframes the color will be red, if in one or two timeframes is over the price and in the other timeframes is under the price the color will be black. * for paint the color is at the moment not at the close of the candle. The indicator must be bug free and work in all the timeframes and all pairs. //@version=3 //Author Pilicoin //Heikin-Ashi Smoothed //The Heikin-Ashi Smoothed study is based upon the standard Heikin-Ashi study with additional moving average calculations. The following is the calculation formula for the bars: // 1. The current bar Open, High, Low, Close values are smoothed individually by using the moving average type specified by the Moving Average Type 1 Input with a length/period specified by the Moving Average Period 1 Input. // 2. The Heikin-Ashi bar Open, High, Low, Close values are set using the smoothed values from step 1. This is performed using the standard Heikin-Ashi formula. // 3. The final Heikin-Ashi Open, High, Low, Close values are calculated by doing a second smoothing of the bar values from step 2 by using the moving average type specified by the Moving Average Type 2 Input with a length/period specified by the Moving Average Period 2 Input. // Heikin-Ashi bars are calculated: // 1. Close = (Open + High + Low + Close) / 4 // This is the average price of the current bar. // 2. Open = (Open of Previous Bar + Close of Previous Bar) / 2 // This is the midpoint of the previous bar. // 3. High = Max of (High, Open, Close) // Highest value of the three. // 4. Low = Min of (Low, Open, Close) // Lowest value of the three. study("Heikin-Ashi Smoothed with option to change MA types", shorttitle="HA Smoothed Pilicoin", overlay=true) // Assigning Open, High, Low, Close from Heikin-Ashi. HA_open_default = security(heikinashi(tickerid), period, open) HA_high_default = security(heikinashi(tickerid), period, high) HA_low_default = security(heikinashi(tickerid), period, low) HA_close_default = security(heikinashi(tickerid), period, close) Moving_average_Type_1 = input(defval="T3", title="Type of first Moving Average", options=["TRIMA","VIDYA","FAMA","AMA","HMA","TEMA","SMMA","WMA","EMA","SMA","T3","DEMA","ALMA","LSMA","DEFAULT"]) Lenght_of_Moving_average_Type_1 = input(defval=8, title="Lenght of first Moving Average (If FRAMA, lenght must be even number)", minval=1, type=integer) Moving_average_Type_2 = input(defval="T3", title="Type of first Moving Average", options=["TRIMA","VIDYA","FAMA","AMA","HMA","TEMA","SMMA","WMA","EMA","SMA","T3","DEMA","ALMA","LSMA","DEFAULT"]) Lenght_of_Moving_average_Type_2 = input(defval=8, title="Lenght of Second Moving Average (If FRAMA, lenght must be even number)", minval=1, type=integer) Exponential = 2.7182818284590452353602874713527 single_smoothed = input(defval=false, title="Tick the box for only single smooth of Heikin-ashi (normal formula is: HA smoothed with ma, created HA from smoothed values and then smoothed again to create HA once more.)") //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Tillson Moving Average as type 1 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //For best results use 0.7 or 0.618 Vfact_type_1 = input(defval=0.82, minval=0.01,step=0.01, title="Volume Factor of T3 for 1st Moving Average (If T3 is chosen as first one)") //Calculations for all Type one T3 c1x = -Vfact_type_1*Vfact_type_1*Vfact_type_1 c2x = 3*Vfact_type_1*Vfact_type_1 + 3*Vfact_type_1*Vfact_type_1*Vfact_type_1 c3x = -6*Vfact_type_1*Vfact_type_1 -3*Vfact_type_1 -3*Vfact_type_1*Vfact_type_1*Vfact_type_1 c4x = 1 + 3*Vfact_type_1 + Vfact_type_1*Vfact_type_1*Vfact_type_1 + 3*Vfact_type_1*Vfact_type_1 // Asigning open candle First_EMA_open = ema(HA_open_default, Lenght_of_Moving_average_Type_1) Second_EMA_open = ema(First_EMA_open, Lenght_of_Moving_average_Type_1) Third_EMA_open = ema(Second_EMA_open, Lenght_of_Moving_average_Type_1) Fourth_EMA_open = ema(Third_EMA_open, Lenght_of_Moving_average_Type_1) Fifth_EMA_open = ema(Fourth_EMA_open, Lenght_of_Moving_average_Type_1) Sixth_EMA_open = ema(Fifth_EMA_open, Lenght_of_Moving_average_Type_1) //Assigning EMAS to T3 Moving average T3_open = c1x * Sixth_EMA_open + c2x * Fifth_EMA_open + c3x * Fourth_EMA_open + c4x * Third_EMA_open // Asigning high candle First_EMA_high = ema(HA_high_default, Lenght_of_Moving_average_Type_1) Second_EMA_high = ema(First_EMA_high, Lenght_of_Moving_average_Type_1) Third_EMA_high = ema(Second_EMA_high, Lenght_of_Moving_average_Type_1) Fourth_EMA_high = ema(Third_EMA_high, Lenght_of_Moving_average_Type_1) Fifth_EMA_high = ema(Fourth_EMA_high, Lenght_of_Moving_average_Type_1) Sixth_EMA_high = ema(Fifth_EMA_high, Lenght_of_Moving_average_Type_1) //Assigning EMAS to T3 Moving average T3_high = c1x * Sixth_EMA_high + c2x * Fifth_EMA_high + c3x * Fourth_EMA_high + c4x * Third_EMA_high // Asigning low candle First_EMA_low = ema(HA_low_default, Lenght_of_Moving_average_Type_1) Second_EMA_low = ema(First_EMA_low, Lenght_of_Moving_average_Type_1) Third_EMA_low = ema(Second_EMA_low, Lenght_of_Moving_average_Type_1) Fourth_EMA_low = ema(Third_EMA_low, Lenght_of_Moving_average_Type_1) Fifth_EMA_low = ema(Fourth_EMA_low, Lenght_of_Moving_average_Type_1) Sixth_EMA_low = ema(Fifth_EMA_low, Lenght_of_Moving_average_Type_1) //Assigning EMAS to T3 Moving average T3_low = c1x * Sixth_EMA_low + c2x * Fifth_EMA_low + c3x * Fourth_EMA_low + c4x * Third_EMA_low // Asigning close candle First_EMA_close = ema(HA_close_default, Lenght_of_Moving_average_Type_1) Second_EMA_close = ema(First_EMA_close, Lenght_of_Moving_average_Type_1) Third_EMA_close = ema(Second_EMA_close, Lenght_of_Moving_average_Type_1) Fourth_EMA_close = ema(Third_EMA_close, Lenght_of_Moving_average_Type_1) Fifth_EMA_close = ema(Fourth_EMA_close, Lenght_of_Moving_average_Type_1) Sixth_EMA_close = ema(Fifth_EMA_close, Lenght_of_Moving_average_Type_1) //Assigning EMAS to T3 Moving average T3_close = c1x * Sixth_EMA_close + c2x * Fifth_EMA_close + c3x * Fourth_EMA_close + c4x * Third_EMA_close ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Double Exponential Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Asigning open candle Double_Moving_Average_Exponential_nr_1_open = ema(HA_open_default, Lenght_of_Moving_average_Type_1) Double_Moving_Average_Exponential_nr_2_open = ema(Double_Moving_Average_Exponential_nr_1_open,Lenght_of_Moving_average_Type_1) Double_Moving_Average_Exponential_open = (2 * Double_Moving_Average_Exponential_nr_1_open - Double_Moving_Average_Exponential_nr_2_open) // Asigning high candle Double_Moving_Average_Exponential_nr_1_high = ema(HA_high_default, Lenght_of_Moving_average_Type_1) Double_Moving_Average_Exponential_nr_2_high = ema(Double_Moving_Average_Exponential_nr_1_high,Lenght_of_Moving_average_Type_1) Double_Moving_Average_Exponential_high = (2 * Double_Moving_Average_Exponential_nr_1_high - Double_Moving_Average_Exponential_nr_2_high) // Asigning low candle Double_Moving_Average_Exponential_nr_1_low = ema(HA_low_default, Lenght_of_Moving_average_Type_1) Double_Moving_Average_Exponential_nr_2_low = ema(Double_Moving_Average_Exponential_nr_1_low,Lenght_of_Moving_average_Type_1) Double_Moving_Average_Exponential_low = (2 * Double_Moving_Average_Exponential_nr_1_low - Double_Moving_Average_Exponential_nr_2_low) // Asigning close candle Double_Moving_Average_Exponential_nr_1_close = ema(HA_close_default, Lenght_of_Moving_average_Type_1) Double_Moving_Average_Exponential_nr_2_close = ema(Double_Moving_Average_Exponential_nr_1_close,Lenght_of_Moving_average_Type_1) Double_Moving_Average_Exponential_close = (2 * Double_Moving_Average_Exponential_nr_1_close - Double_Moving_Average_Exponential_nr_2_close) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Arnaud_Legoux_Moving_Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// offset_of_ALMA = input(0.85, title="Offset of Arnaud Legoux Moving Average type 1 if used", type=float) sigma_of_ALMA = input(6, title="Sigma of Arnaud Legoux Moving Average type 1 if used", type=float) Arnaud_Legoux_Moving_Average_open = alma(HA_open_default,Lenght_of_Moving_average_Type_1,offset_of_ALMA,sigma_of_ALMA) Arnaud_Legoux_Moving_Average_high = alma(HA_high_default,Lenght_of_Moving_average_Type_1,offset_of_ALMA,sigma_of_ALMA) Arnaud_Legoux_Moving_Average_low = alma(HA_low_default,Lenght_of_Moving_average_Type_1,offset_of_ALMA,sigma_of_ALMA) Arnaud_Legoux_Moving_Average_close = alma(HA_close_default,Lenght_of_Moving_average_Type_1,offset_of_ALMA,sigma_of_ALMA) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Least Squares Moving Average 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Least_Squares_Moving_Average_offset = input(defval=0, minval=-100, title="Least Squares Moving Average offset as type 1 ") Least_Squares_Moving_Average_open = linreg(HA_open_default, Lenght_of_Moving_average_Type_1, Least_Squares_Moving_Average_offset) Least_Squares_Moving_Average_high = linreg(HA_high_default, Lenght_of_Moving_average_Type_1, Least_Squares_Moving_Average_offset) Least_Squares_Moving_Average_low = linreg(HA_low_default, Lenght_of_Moving_average_Type_1, Least_Squares_Moving_Average_offset) Least_Squares_Moving_Average_close = linreg(HA_close_default, Lenght_of_Moving_average_Type_1, Least_Squares_Moving_Average_offset) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Simple Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Moving_Average_open = sma(HA_open_default, Lenght_of_Moving_average_Type_1) Moving_Average_high = sma(HA_high_default, Lenght_of_Moving_average_Type_1) Moving_Average_low = sma(HA_low_default, Lenght_of_Moving_average_Type_1) Moving_Average_close = sma(HA_close_default, Lenght_of_Moving_average_Type_1) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Exponential Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// eMoving_Average_open = ema(HA_open_default, Lenght_of_Moving_average_Type_1) eMoving_Average_high = ema(HA_high_default, Lenght_of_Moving_average_Type_1) eMoving_Average_low = ema(HA_low_default, Lenght_of_Moving_average_Type_1) eMoving_Average_close = ema(HA_close_default, Lenght_of_Moving_average_Type_1) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Weighted Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// wMoving_Average_open = wma(HA_open_default, Lenght_of_Moving_average_Type_1) wMoving_Average_high = wma(HA_high_default, Lenght_of_Moving_average_Type_1) wMoving_Average_low = wma(HA_low_default, Lenght_of_Moving_average_Type_1) wMoving_Average_close = wma(HA_close_default, Lenght_of_Moving_average_Type_1) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Smoothed Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// smma_open = 0.0 smma_open := na(smma_open[1]) ? sma(HA_open_default, Lenght_of_Moving_average_Type_1) : (smma_open[1] * (Lenght_of_Moving_average_Type_1 - 1) + HA_open_default) / Lenght_of_Moving_average_Type_1 smma_high = 0.0 smma_high := na(smma_high[1]) ? sma(HA_high_default, Lenght_of_Moving_average_Type_1) : (smma_high[1] * (Lenght_of_Moving_average_Type_1 - 1) + HA_high_default) / Lenght_of_Moving_average_Type_1 smma_low = 0.0 smma_low := na(smma_low[1]) ? sma(HA_low_default, Lenght_of_Moving_average_Type_1) : (smma_low[1] * (Lenght_of_Moving_average_Type_1 - 1) + HA_low_default) / Lenght_of_Moving_average_Type_1 smma_close = 0.0 smma_close := na(smma_close[1]) ? sma(HA_close_default, Lenght_of_Moving_average_Type_1) : (smma_close[1] * (Lenght_of_Moving_average_Type_1 - 1) + HA_close_default) / Lenght_of_Moving_average_Type_1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Triple Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Triple_EMA_1 = ema(HA_open_default, Lenght_of_Moving_average_Type_1) Triple_EMA_2 = ema(Triple_EMA_1, Lenght_of_Moving_average_Type_1) Triple_EMA_3 = ema(Triple_EMA_2, Lenght_of_Moving_average_Type_1) Triple_EMA_4 = ema(HA_high_default, Lenght_of_Moving_average_Type_1) Triple_EMA_5 = ema(Triple_EMA_4, Lenght_of_Moving_average_Type_1) Triple_EMA_6 = ema(Triple_EMA_5, Lenght_of_Moving_average_Type_1) Triple_EMA_7 = ema(HA_low_default, Lenght_of_Moving_average_Type_1) Triple_EMA_8 = ema(Triple_EMA_7, Lenght_of_Moving_average_Type_1) Triple_EMA_9 = ema(Triple_EMA_8, Lenght_of_Moving_average_Type_1) Triple_EMA_10 = ema(HA_close_default, Lenght_of_Moving_average_Type_1) Triple_EMA_11 = ema(Triple_EMA_10, Lenght_of_Moving_average_Type_1) Triple_EMA_12 = ema(Triple_EMA_11, Lenght_of_Moving_average_Type_1) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Hull Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Hull_Moving_Average_lenght_sqrt_open = sqrt(Lenght_of_Moving_average_Type_1) Hull_Moving_Average_lenght_rounded_open = round(Hull_Moving_Average_lenght_sqrt_open) Hull_Moving_Average_1_open = wma(HA_open_default, Lenght_of_Moving_average_Type_1) Hull_Moving_Average_2_open = wma(HA_open_default, (Lenght_of_Moving_average_Type_1 / 2)) Hull_Moving_Average_3_open = (2 * Hull_Moving_Average_2_open) - Hull_Moving_Average_1_open Hull_Moving_Average_open = wma(Hull_Moving_Average_3_open, Hull_Moving_Average_lenght_rounded_open) Hull_Moving_Average_lenght_sqrt_high = sqrt(Lenght_of_Moving_average_Type_1) Hull_Moving_Average_lenght_rounded_high = round(Hull_Moving_Average_lenght_sqrt_high) Hull_Moving_Average_1_high = wma(HA_high_default, Lenght_of_Moving_average_Type_1) Hull_Moving_Average_2_high = wma(HA_high_default, (Lenght_of_Moving_average_Type_1 / 2)) Hull_Moving_Average_3_high = (2 * Hull_Moving_Average_2_high) - Hull_Moving_Average_1_high Hull_Moving_Average_high = wma(Hull_Moving_Average_3_high, Hull_Moving_Average_lenght_rounded_high) Hull_Moving_Average_lenght_sqrt_low = sqrt(Lenght_of_Moving_average_Type_1) Hull_Moving_Average_lenght_rounded_low = round(Hull_Moving_Average_lenght_sqrt_low) Hull_Moving_Average_1_low = wma(HA_low_default, Lenght_of_Moving_average_Type_1) Hull_Moving_Average_2_low = wma(HA_low_default, (Lenght_of_Moving_average_Type_1 / 2)) Hull_Moving_Average_3_low = (2 * Hull_Moving_Average_2_low) - Hull_Moving_Average_1_low Hull_Moving_Average_low = wma(Hull_Moving_Average_3_low, Hull_Moving_Average_lenght_rounded_low) Hull_Moving_Average_lenght_sqrt_close = sqrt(Lenght_of_Moving_average_Type_1) Hull_Moving_Average_lenght_rounded_close = round(Hull_Moving_Average_lenght_sqrt_close) Hull_Moving_Average_1_close = wma(HA_close_default, Lenght_of_Moving_average_Type_1) Hull_Moving_Average_2_close = wma(HA_close_default, (Lenght_of_Moving_average_Type_1 / 2)) Hull_Moving_Average_3_close = (2 * Hull_Moving_Average_2_close) - Hull_Moving_Average_1_close Hull_Moving_Average_close = wma(Hull_Moving_Average_3_close, Hull_Moving_Average_lenght_rounded_close) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Adaptive Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// AMA_Weight_value_1 = input(0.181, title="Smoothe constant of AMA as type 1") Adaptive_moving_average_open = 0.0 Adaptive_moving_average_open := na(Adaptive_moving_average_open[1]) ? HA_open_default * (AMA_Weight_value_1*AMA_Weight_value_1) + (1 - (AMA_Weight_value_1*AMA_Weight_value_1)) : HA_open_default * (AMA_Weight_value_1*AMA_Weight_value_1) + (1 - (AMA_Weight_value_1*AMA_Weight_value_1)) * Adaptive_moving_average_open[1] Adaptive_moving_average_high = 0.0 Adaptive_moving_average_high := na(Adaptive_moving_average_high[1]) ? HA_high_default * (AMA_Weight_value_1*AMA_Weight_value_1) + (1 - (AMA_Weight_value_1*AMA_Weight_value_1)) : HA_high_default * (AMA_Weight_value_1*AMA_Weight_value_1) + (1 - (AMA_Weight_value_1*AMA_Weight_value_1)) * Adaptive_moving_average_high[1] Adaptive_moving_average_low = 0.0 Adaptive_moving_average_low := na(Adaptive_moving_average_low[1]) ? HA_low_default * (AMA_Weight_value_1*AMA_Weight_value_1) + (1 - (AMA_Weight_value_1*AMA_Weight_value_1)) : HA_low_default * (AMA_Weight_value_1*AMA_Weight_value_1) + (1 - (AMA_Weight_value_1*AMA_Weight_value_1)) * Adaptive_moving_average_low[1] Adaptive_moving_average_close = 0.0 Adaptive_moving_average_close := na(Adaptive_moving_average_close[1]) ? HA_close_default * (AMA_Weight_value_1*AMA_Weight_value_1) + (1 - (AMA_Weight_value_1*AMA_Weight_value_1)) : HA_close_default * (AMA_Weight_value_1*AMA_Weight_value_1) + (1 - (AMA_Weight_value_1*AMA_Weight_value_1)) * Adaptive_moving_average_close[1] ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Fractal Adaptive Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Big thanks to nemozny and Shizaru for sharing their code from which I was able to add this FRAMA to this study. Really, big thank you guys. // open Fractal_Adaptive_Moving_Average_input2 = input(1, title="Should be left 1 for the best results (FRAMA as type 1)") Fractal_Adaptive_Moving_Average_input3 = input(168, title="Try and experiment with this value (FRAMA as type 1)") Fractal_Adaptive_Moving_Average_lenght_part2_open = Lenght_of_Moving_average_Type_1 / 2 Natural_Logorithm_workaround_open = log(2 / (Fractal_Adaptive_Moving_Average_input3 + 1)) / log(Exponential) Highest_price_nr1_open = highest(HA_high_default ,Fractal_Adaptive_Moving_Average_lenght_part2_open) Lowest_price_nr1_open = lowest(HA_low_default,Fractal_Adaptive_Moving_Average_lenght_part2_open) Native_price_1_open = (Highest_price_nr1_open-Lowest_price_nr1_open)/Fractal_Adaptive_Moving_Average_lenght_part2_open Highest_price_nr2_open = highest(HA_high_default,Fractal_Adaptive_Moving_Average_lenght_part2_open)[Fractal_Adaptive_Moving_Average_lenght_part2_open] Lowest_price_nr2_open = lowest(HA_low_default,Fractal_Adaptive_Moving_Average_lenght_part2_open)[Fractal_Adaptive_Moving_Average_lenght_part2_open] Native_price_2_open = (Highest_price_nr2_open-Lowest_price_nr2_open)/Fractal_Adaptive_Moving_Average_lenght_part2_open Highest_price_nr3_open = highest(HA_high_default,Lenght_of_Moving_average_Type_1) Lowest_price_nr3_open = lowest(HA_low_default,Lenght_of_Moving_average_Type_1) Native_price_3_open = (Highest_price_nr3_open-Lowest_price_nr3_open)/Lenght_of_Moving_average_Type_1 Fractal_Dimension_1_open = (log(Native_price_1_open+Native_price_2_open)-log(Native_price_3_open))/log(2) Fractal_Dimension_2_open = iff(Native_price_1_open>0 and Native_price_2_open>0 and Native_price_3_open>0,Fractal_Dimension_1_open,nz(Fractal_Dimension_1_open[1])) factor_of_exponential_smoothing_1_open = exp(Natural_Logorithm_workaround_open*(Fractal_Dimension_2_open-1)) factor_of_exponential_smoothing_old_open = factor_of_exponential_smoothing_1_open>1?1:(factor_of_exponential_smoothing_1_open<0.01?0.01:factor_of_exponential_smoothing_1_open) Native_price_old_open = (2-factor_of_exponential_smoothing_old_open)/factor_of_exponential_smoothing_old_open Native_price_open = (((Fractal_Adaptive_Moving_Average_input3-Fractal_Adaptive_Moving_Average_input2)*(Native_price_old_open-1))/(Fractal_Adaptive_Moving_Average_input3-1))+Fractal_Adaptive_Moving_Average_input2 factor_of_exponential_smoothing_2_open = 2/(Native_price_open+1) factor_of_exponential_smoothing_open = factor_of_exponential_smoothing_2_open<2/(Fractal_Adaptive_Moving_Average_input3+1)?2/(Fractal_Adaptive_Moving_Average_input3+1):(factor_of_exponential_smoothing_2_open>1?1:factor_of_exponential_smoothing_2_open) Fractal_Adaptive_Moving_Average_open = 0.0 Fractal_Adaptive_Moving_Average_open := (1-factor_of_exponential_smoothing_open)*nz(Fractal_Adaptive_Moving_Average_open[1]) + factor_of_exponential_smoothing_open*HA_open_default //high Fractal_Adaptive_Moving_Average_lenght_part2_high = Lenght_of_Moving_average_Type_1 / 2 Natural_Logorithm_workaround_high = log(2 / (Fractal_Adaptive_Moving_Average_input3 + 1)) / log(Exponential) Highest_price_nr1_high = highest(HA_high_default ,Fractal_Adaptive_Moving_Average_lenght_part2_high) Lowest_price_nr1_high = lowest(HA_low_default,Fractal_Adaptive_Moving_Average_lenght_part2_high) Native_price_1_high = (Highest_price_nr1_high-Lowest_price_nr1_high)/Fractal_Adaptive_Moving_Average_lenght_part2_high Highest_price_nr2_high = highest(HA_high_default,Fractal_Adaptive_Moving_Average_lenght_part2_high)[Fractal_Adaptive_Moving_Average_lenght_part2_high] Lowest_price_nr2_high = lowest(HA_low_default,Fractal_Adaptive_Moving_Average_lenght_part2_high)[Fractal_Adaptive_Moving_Average_lenght_part2_high] Native_price_2_high = (Highest_price_nr2_high-Lowest_price_nr2_high)/Fractal_Adaptive_Moving_Average_lenght_part2_high Highest_price_nr3_high = highest(HA_high_default,Lenght_of_Moving_average_Type_1) Lowest_price_nr3_high = lowest(HA_low_default,Lenght_of_Moving_average_Type_1) Native_price_3_high = (Highest_price_nr3_high-Lowest_price_nr3_high)/Lenght_of_Moving_average_Type_1 Fractal_Dimension_1_high = (log(Native_price_1_high+Native_price_2_high)-log(Native_price_3_high))/log(2) Fractal_Dimension_2_high = iff(Native_price_1_high>0 and Native_price_2_high>0 and Native_price_3_high>0,Fractal_Dimension_1_high,nz(Fractal_Dimension_1_high[1])) factor_of_exponential_smoothing_1_high = exp(Natural_Logorithm_workaround_high*(Fractal_Dimension_2_high-1)) factor_of_exponential_smoothing_old_high = factor_of_exponential_smoothing_1_high>1?1:(factor_of_exponential_smoothing_1_high<0.01?0.01:factor_of_exponential_smoothing_1_high) Native_price_old_high = (2-factor_of_exponential_smoothing_old_high)/factor_of_exponential_smoothing_old_high Native_price_high = (((Fractal_Adaptive_Moving_Average_input3-Fractal_Adaptive_Moving_Average_input2)*(Native_price_old_high-1))/(Fractal_Adaptive_Moving_Average_input3-1))+Fractal_Adaptive_Moving_Average_input2 factor_of_exponential_smoothing_2_high = 2/(Native_price_high+1) factor_of_exponential_smoothing_high = factor_of_exponential_smoothing_2_high<2/(Fractal_Adaptive_Moving_Average_input3+1)?2/(Fractal_Adaptive_Moving_Average_input3+1):(factor_of_exponential_smoothing_2_high>1?1:factor_of_exponential_smoothing_2_high) Fractal_Adaptive_Moving_Average_high = 0.0 Fractal_Adaptive_Moving_Average_high := (1-factor_of_exponential_smoothing_high)*nz(Fractal_Adaptive_Moving_Average_high[1]) + factor_of_exponential_smoothing_high*HA_high_default // low Fractal_Adaptive_Moving_Average_lenght_part2_low = Lenght_of_Moving_average_Type_1 / 2 Natural_Logorithm_workaround_low = log(2 / (Fractal_Adaptive_Moving_Average_input3 + 1)) / log(Exponential) Highest_price_nr1_low = highest(HA_high_default ,Fractal_Adaptive_Moving_Average_lenght_part2_low) Lowest_price_nr1_low = lowest(HA_low_default,Fractal_Adaptive_Moving_Average_lenght_part2_low) Native_price_1_low = (Highest_price_nr1_low-Lowest_price_nr1_low)/Fractal_Adaptive_Moving_Average_lenght_part2_low Highest_price_nr2_low = highest(HA_high_default,Fractal_Adaptive_Moving_Average_lenght_part2_low)[Fractal_Adaptive_Moving_Average_lenght_part2_low] Lowest_price_nr2_low = lowest(HA_low_default,Fractal_Adaptive_Moving_Average_lenght_part2_low)[Fractal_Adaptive_Moving_Average_lenght_part2_low] Native_price_2_low = (Highest_price_nr2_low-Lowest_price_nr2_low)/Fractal_Adaptive_Moving_Average_lenght_part2_low Highest_price_nr3_low = highest(HA_high_default,Lenght_of_Moving_average_Type_1) Lowest_price_nr3_low = lowest(HA_low_default,Lenght_of_Moving_average_Type_1) Native_price_3_low = (Highest_price_nr3_low-Lowest_price_nr3_low)/Lenght_of_Moving_average_Type_1 Fractal_Dimension_1_low = (log(Native_price_1_low+Lowest_price_nr2_low)-log(Native_price_3_low))/log(2) Fractal_Dimension_2_low = iff(Native_price_1_low>0 and Lowest_price_nr2_low>0 and Native_price_3_low>0,Fractal_Dimension_1_low,nz(Fractal_Dimension_1_low[1])) factor_of_exponential_smoothing_1_low = exp(Natural_Logorithm_workaround_low*(Fractal_Dimension_2_low-1)) factor_of_exponential_smoothing_old_low = factor_of_exponential_smoothing_1_low>1?1:(factor_of_exponential_smoothing_1_low<0.01?0.01:factor_of_exponential_smoothing_1_low) Native_price_old_low = (2-factor_of_exponential_smoothing_old_low)/factor_of_exponential_smoothing_old_low Native_price_low = (((Fractal_Adaptive_Moving_Average_input3-Fractal_Adaptive_Moving_Average_input2)*(Native_price_old_low-1))/(Fractal_Adaptive_Moving_Average_input3-1))+Fractal_Adaptive_Moving_Average_input2 factor_of_exponential_smoothing_2_low = 2/(Native_price_low+1) factor_of_exponential_smoothing_low = factor_of_exponential_smoothing_2_low<2/(Fractal_Adaptive_Moving_Average_input3+1)?2/(Fractal_Adaptive_Moving_Average_input3+1):(factor_of_exponential_smoothing_2_low>1?1:factor_of_exponential_smoothing_2_low) Fractal_Adaptive_Moving_Average_low = 0.0 Fractal_Adaptive_Moving_Average_low := (1-factor_of_exponential_smoothing_low)*nz(Fractal_Adaptive_Moving_Average_low[1]) + factor_of_exponential_smoothing_low*HA_low_default // close Fractal_Adaptive_Moving_Average_lenght_part2__close = Lenght_of_Moving_average_Type_1 / 2 Natural_Logorithm_workaround__close = log(2 / (Fractal_Adaptive_Moving_Average_input3 + 1)) / log(Exponential) Highest_price_nr1__close = highest(HA_high_default ,Fractal_Adaptive_Moving_Average_lenght_part2__close) Lowest_price_nr1__close = lowest(HA_low_default,Fractal_Adaptive_Moving_Average_lenght_part2__close) Native_price_1__close = (Highest_price_nr1__close-Lowest_price_nr1__close)/Fractal_Adaptive_Moving_Average_lenght_part2__close Highest_price_nr2_close = highest(HA_high_default,Fractal_Adaptive_Moving_Average_lenght_part2__close)[Fractal_Adaptive_Moving_Average_lenght_part2__close] Lowest_price_nr2_close = lowest(HA_low_default,Fractal_Adaptive_Moving_Average_lenght_part2__close)[Fractal_Adaptive_Moving_Average_lenght_part2__close] Native_price_2_close = (Highest_price_nr2_close-Lowest_price_nr2_close)/Fractal_Adaptive_Moving_Average_lenght_part2__close Highest_price_nr3_close = highest(HA_high_default,Lenght_of_Moving_average_Type_1) Lowest_price_nr3_close = lowest(HA_low_default,Lenght_of_Moving_average_Type_1) Native_price_3_close = (Highest_price_nr3_close-Lowest_price_nr3_close)/Lenght_of_Moving_average_Type_1 Fractal_Dimension_1_close = (log(Native_price_1__close+Native_price_2_close)-log(Native_price_3_close))/log(2) Fractal_Dimension_2_close = iff(Native_price_1__close>0 and Native_price_2_close>0 and Native_price_3_close>0,Fractal_Dimension_1_close,nz(Fractal_Dimension_1_close[1])) factor_of_exponential_smoothing_1_close = exp(Natural_Logorithm_workaround__close*(Fractal_Dimension_2_close-1)) factor_of_exponential_smoothing_old_close = factor_of_exponential_smoothing_1_close>1?1:(factor_of_exponential_smoothing_1_close<0.01?0.01:factor_of_exponential_smoothing_1_close) Native_price_old_close = (2-factor_of_exponential_smoothing_old_close)/factor_of_exponential_smoothing_old_close Native_price_close = (((Fractal_Adaptive_Moving_Average_input3-Fractal_Adaptive_Moving_Average_input2)*(Native_price_old_close-1))/(Fractal_Adaptive_Moving_Average_input3-1))+Fractal_Adaptive_Moving_Average_input2 factor_of_exponential_smoothing_2_close = 2/(Native_price_close+1) factor_of_exponential_smoothing_close = factor_of_exponential_smoothing_2_close<2/(Fractal_Adaptive_Moving_Average_input3+1)?2/(Fractal_Adaptive_Moving_Average_input3+1):(factor_of_exponential_smoothing_2_close>1?1:factor_of_exponential_smoothing_2_close) Fractal_Adaptive_Moving_Average_close = 0.0 Fractal_Adaptive_Moving_Average_close := (1-factor_of_exponential_smoothing_close)*nz(Fractal_Adaptive_Moving_Average_close[1]) + factor_of_exponential_smoothing_close*HA_close_default ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Variable Index Dynamic Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Copyright (c) 2018-present, Alex Orekhov (everget) // Variable Index Dynamic Average indicator script may be freely distributed under the MIT license. // Thanks everget for sharing this script. // OPEN // Chande Momentum Oscillator f1_open(m_open) => m_open >= 0.0 ? m_open : 0.0 f2_open(m_open) => m_open >= 0.0 ? 0.0 : -m_open Difference_open = change(HA_open_default) Sum_of_UP_open = sum(f1_open(Difference_open), Lenght_of_Moving_average_Type_1) Sum_of_DOWN_open = sum(f2_open(Difference_open), Lenght_of_Moving_average_Type_1) CMO_open = (Sum_of_UP_open - Sum_of_DOWN_open) / (Sum_of_UP_open + Sum_of_DOWN_open) factor_open = (2 / (Lenght_of_Moving_average_Type_1 + 1)) VIDYA_open = 0.0 VIDYA_open := HA_open_default * factor_open * abs(CMO_open) + nz(VIDYA_open[1]) * (1 - factor_open * abs(CMO_open)) // high // Chande Momentum Oscillator f1_high(m_high) => m_high >= 0.0 ? m_high : 0.0 f2_high(m_high) => m_high >= 0.0 ? 0.0 : -m_high Difference_high = change(HA_high_default) Sum_of_UP_high = sum(f1_high(Difference_high), Lenght_of_Moving_average_Type_1) Sum_of_DOWN_high = sum(f2_high(Difference_high), Lenght_of_Moving_average_Type_1) CMO_high = (Sum_of_UP_high - Sum_of_DOWN_high) / (Sum_of_UP_high + Sum_of_DOWN_high) factor_high = (2 / (Lenght_of_Moving_average_Type_1 + 1)) VIDYA_high = 0.0 VIDYA_high := HA_high_default * factor_high * abs(CMO_high) + nz(VIDYA_high[1]) * (1 - factor_high * abs(CMO_high)) // low // Chande Momentum Oscillator f1_low(m_low) => m_low >= 0.0 ? m_low : 0.0 f2_low(m_low) => m_low >= 0.0 ? 0.0 : -m_low Difference_low = change(HA_low_default) Sum_of_UP_low = sum(f1_low(Difference_low), Lenght_of_Moving_average_Type_1) Sum_of_DOWN_low = sum(f2_low(Difference_low), Lenght_of_Moving_average_Type_1) CMO_low = (Sum_of_UP_low - Sum_of_DOWN_low) / (Sum_of_UP_low + Sum_of_DOWN_low) factor_low = (2 / (Lenght_of_Moving_average_Type_1 + 1)) VIDYA_low = 0.0 VIDYA_low := HA_low_default * factor_low * abs(CMO_low) + nz(VIDYA_low[1]) * (1 - factor_low * abs(CMO_low)) // close // Chande Momentum Oscillator f1_close(m_close) => m_close >= 0.0 ? m_close : 0.0 f2_close(m_close) => m_close >= 0.0 ? 0.0 : -m_close Difference_close = change(HA_close_default) Sum_of_UP_close = sum(f1_close(Difference_close), Lenght_of_Moving_average_Type_1) Sum_of_DOWN_close = sum(f2_close(Difference_close), Lenght_of_Moving_average_Type_1) CMO_close = (Sum_of_UP_close - Sum_of_DOWN_close) / (Sum_of_UP_close + Sum_of_DOWN_close) factor_close = (2 / (Lenght_of_Moving_average_Type_1 + 1)) VIDYA_close = 0.0 VIDYA_close := HA_close_default * factor_close * abs(CMO_close) + nz(VIDYA_close[1]) * (1 - factor_close * abs(CMO_close)) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Triangular Moving Average as type 1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Triangular_Moving_Average_open = sma(sma(HA_open_default,Lenght_of_Moving_average_Type_1),Lenght_of_Moving_average_Type_1) Triangular_Moving_Average_high = sma(sma(HA_high_default,Lenght_of_Moving_average_Type_1),Lenght_of_Moving_average_Type_1) Triangular_Moving_Average_low = sma(sma(HA_low_default,Lenght_of_Moving_average_Type_1),Lenght_of_Moving_average_Type_1) Triangular_Moving_Average_close = sma(sma(HA_close_default,Lenght_of_Moving_average_Type_1),Lenght_of_Moving_average_Type_1) //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // STAGE 2 calculations: The Heikin-Ashi bar Open, High, Low, Close values are set using the smoothed values from step 1. This is performed using the standard Heikin-Ashi formula. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// HA_open_stage1 = Moving_average_Type_1 == "TRIMA" ? Triangular_Moving_Average_open : Moving_average_Type_1 == "VIDYA" ? VIDYA_open : Moving_average_Type_1 == "FAMA" ? Fractal_Adaptive_Moving_Average_open : Moving_average_Type_1 == "AMA" ? Adaptive_moving_average_open : Moving_average_Type_1 == "HMA" ? Hull_Moving_Average_open : Moving_average_Type_1 == "TEMA" ? Triple_EMA_3 : Moving_average_Type_1 == "SMMA" ? smma_open : Moving_average_Type_1 == "WMA" ? wMoving_Average_open : Moving_average_Type_1 == "EMA" ? eMoving_Average_open : Moving_average_Type_1 == "SMA" ? Moving_Average_open : Moving_average_Type_1 == "LSMA" ? Least_Squares_Moving_Average_open : Moving_average_Type_1 == "T3" ? T3_open : Moving_average_Type_1 == "DEMA" ? Double_Moving_Average_Exponential_open : Moving_average_Type_1 == "ALMA" ? Arnaud_Legoux_Moving_Average_open : Moving_average_Type_1 == "DEFAULT" ? HA_open_default : na HA_high_stage1 = Moving_average_Type_1 == "TRIMA" ? Triangular_Moving_Average_high : Moving_average_Type_1 == "VIDYA" ? VIDYA_high : Moving_average_Type_1 == "FAMA" ? Fractal_Adaptive_Moving_Average_high : Moving_average_Type_1 == "AMA" ? Adaptive_moving_average_high : Moving_average_Type_1 == "HMA" ? Hull_Moving_Average_high : Moving_average_Type_1 == "TEMA" ? Triple_EMA_6 : Moving_average_Type_1 == "SMMA" ? smma_high : Moving_average_Type_1 == "WMA" ? wMoving_Average_high : Moving_average_Type_1 == "EMA" ? eMoving_Average_high : Moving_average_Type_1 == "SMA" ? Moving_Average_high : Moving_average_Type_1 == "LSMA" ? Least_Squares_Moving_Average_high : Moving_average_Type_1 == "T3" ? T3_high : Moving_average_Type_1 == "DEMA" ? Double_Moving_Average_Exponential_high : Moving_average_Type_1 == "ALMA" ? Arnaud_Legoux_Moving_Average_high : Moving_average_Type_1 == "DEFAULT" ? HA_open_default : na HA_low_stage1 = Moving_average_Type_1 == "TRIMA" ? Triangular_Moving_Average_low : Moving_average_Type_1 == "VIDYA" ? VIDYA_low : Moving_average_Type_1 == "FAMA" ? Fractal_Adaptive_Moving_Average_low : Moving_average_Type_1 == "AMA" ? Adaptive_moving_average_low : Moving_average_Type_1 == "HMA" ? Hull_Moving_Average_low : Moving_average_Type_1 == "TEMA" ? Triple_EMA_9 : Moving_average_Type_1 == "SMMA" ? smma_low : Moving_average_Type_1 == "WMA" ? wMoving_Average_low : Moving_average_Type_1 == "EMA" ? eMoving_Average_low : Moving_average_Type_1 == "SMA" ? Moving_Average_low : Moving_average_Type_1 == "LSMA" ? Least_Squares_Moving_Average_low : Moving_average_Type_1 == "T3" ? T3_low : Moving_average_Type_1 == "DEMA" ? Double_Moving_Average_Exponential_low : Moving_average_Type_1 == "ALMA" ? Arnaud_Legoux_Moving_Average_low : Moving_average_Type_1 == "DEFAULT" ? HA_open_default : na HA_close_stage1 =Moving_average_Type_1 == "TRIMA" ? Triangular_Moving_Average_close : Moving_average_Type_1 == "VIDYA" ? VIDYA_close : Moving_average_Type_1 == "FAMA" ? Fractal_Adaptive_Moving_Average_close : Moving_average_Type_1 == "AMA" ? Adaptive_moving_average_close : Moving_average_Type_1 == "HMA" ? Hull_Moving_Average_close : Moving_average_Type_1 == "TEMA" ? Triple_EMA_12 : Moving_average_Type_1 == "SMMA" ? smma_close : Moving_average_Type_1 == "WMA" ? wMoving_Average_close : Moving_average_Type_1 == "EMA" ? eMoving_Average_close : Moving_average_Type_1 == "SMA" ? Moving_Average_close : Moving_average_Type_1 == "LSMA" ? Least_Squares_Moving_Average_close : Moving_average_Type_1 == "T3" ? T3_close : Moving_average_Type_1 == "DEMA" ? Double_Moving_Average_Exponential_close : Moving_average_Type_1 == "ALMA" ? Arnaud_Legoux_Moving_Average_close : Moving_average_Type_1 == "DEFAULT" ? HA_open_default : na // Creating ohlc4 HA_ohlc4 = (HA_open_stage1 + HA_high_stage1 + HA_low_stage1 + HA_close_stage1)/4 // Close = (Open + High + Low + Close) / 4 // Open = (Open of Previous Bar + Close of Previous Bar) / 2 // High = Max of (High, Open, Close) // Low = Min of (Low, Open, Close) HA_close_stage2 = HA_ohlc4 HA_open_stage2 = (HA_open_stage1[1] + HA_close_stage1[1])/2 HA_high_stage2 = max(HA_high_stage1, max(HA_open_stage1,HA_close_stage1)) HA_low_stage2 = min(HA_low_stage1, min(HA_open_stage1,HA_close_stage1)) //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Tillson Moving Average as type 2 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //For best results use 0.7 or 0.618 Vfact_type_2 = input(defval=0.82, minval=0.01,step=0.01, title="Volume Factor of T3 for 2st Moving Average (If T3 is chosen as Second one)") //Calculations for all Type one T3 c1 = -Vfact_type_2*Vfact_type_2*Vfact_type_2 c2 = 3*Vfact_type_2*Vfact_type_2 + 3*Vfact_type_2*Vfact_type_2*Vfact_type_2 c3 = -6*Vfact_type_2*Vfact_type_2 -3*Vfact_type_2 -3*Vfact_type_2*Vfact_type_2*Vfact_type_2 c4 = 1 + 3*Vfact_type_2 + Vfact_type_2*Vfact_type_2*Vfact_type_2 + 3*Vfact_type_2*Vfact_type_2 // Asigning open candle First_EMA_open_2 = ema(HA_open_stage2, Lenght_of_Moving_average_Type_2) Second_EMA_open_2 = ema(First_EMA_open_2, Lenght_of_Moving_average_Type_2) Third_EMA_open_2 = ema(Second_EMA_open_2, Lenght_of_Moving_average_Type_2) Fourth_EMA_open_2 = ema(Third_EMA_open_2, Lenght_of_Moving_average_Type_2) Fifth_EMA_open_2 = ema(Fourth_EMA_open_2, Lenght_of_Moving_average_Type_2) Sixth_EMA_open_2 = ema(Fifth_EMA_open_2, Lenght_of_Moving_average_Type_2) //Assigning EMAS to T3 Moving average T3_open_2 = c1 * Sixth_EMA_open_2 + c2 * Fifth_EMA_open_2 + c3 * Fourth_EMA_open_2 + c4 * Third_EMA_open_2 // Asigning high candle First_EMA_high_2 = ema(HA_high_stage2, Lenght_of_Moving_average_Type_2) Second_EMA_high_2 = ema(First_EMA_high_2, Lenght_of_Moving_average_Type_2) Third_EMA_high_2 = ema(Second_EMA_high_2, Lenght_of_Moving_average_Type_2) Fourth_EMA_high_2 = ema(Third_EMA_high_2, Lenght_of_Moving_average_Type_2) Fifth_EMA_high_2 = ema(Fourth_EMA_high_2, Lenght_of_Moving_average_Type_2) Sixth_EMA_high_2 = ema(Fifth_EMA_high_2, Lenght_of_Moving_average_Type_2) //Assigning EMAS to T3 Moving average T3_high_2 = c1 * Sixth_EMA_high_2 + c2 * Fifth_EMA_high_2 + c3 * Fourth_EMA_high_2 + c4 * Third_EMA_high_2 // Asigning low candle First_EMA_low_2 = ema(HA_low_stage2, Lenght_of_Moving_average_Type_2) Second_EMA_low_2 = ema(First_EMA_low_2, Lenght_of_Moving_average_Type_2) Third_EMA_low_2 = ema(Second_EMA_low_2, Lenght_of_Moving_average_Type_2) Fourth_EMA_low_2 = ema(Third_EMA_low_2, Lenght_of_Moving_average_Type_2) Fifth_EMA_low_2 = ema(Fourth_EMA_low_2, Lenght_of_Moving_average_Type_2) Sixth_EMA_low_2 = ema(Fifth_EMA_low_2, Lenght_of_Moving_average_Type_2) //Assigning EMAS to T3 Moving average T3_low_2 = c1 * Sixth_EMA_low_2 + c2 * Fifth_EMA_low_2 + c3 * Fourth_EMA_low_2 + c4 * Third_EMA_low_2 // Asigning close candle First_EMA_close_2 = ema(HA_close_stage2, Lenght_of_Moving_average_Type_2) Second_EMA_close_2 = ema(First_EMA_close_2, Lenght_of_Moving_average_Type_2) Third_EMA_close_2 = ema(Second_EMA_close_2, Lenght_of_Moving_average_Type_2) Fourth_EMA_close_2 = ema(Third_EMA_close_2, Lenght_of_Moving_average_Type_2) Fifth_EMA_close_2 = ema(Fourth_EMA_close_2, Lenght_of_Moving_average_Type_2) Sixth_EMA_close_2 = ema(Fifth_EMA_close_2, Lenght_of_Moving_average_Type_2) //Assigning EMAS to T3 Moving average T3_close_2 = c1 * Sixth_EMA_close_2 + c2 * Fifth_EMA_close_2 + c3 * Fourth_EMA_close_2 + c4 * Third_EMA_close_2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Double Exponential Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Asigning open candle Double_Moving_Average_Exponential_nr_1_open2 = ema(HA_open_stage2, Lenght_of_Moving_average_Type_2) Double_Moving_Average_Exponential_nr_2_open2 = ema(Double_Moving_Average_Exponential_nr_1_open2,Lenght_of_Moving_average_Type_2) Double_Moving_Average_Exponential_open2 = (2 * Double_Moving_Average_Exponential_nr_1_open2 - Double_Moving_Average_Exponential_nr_2_open2) // Asigning high candle Double_Moving_Average_Exponential_nr_1_high2 = ema(HA_high_stage2, Lenght_of_Moving_average_Type_2) Double_Moving_Average_Exponential_nr_2_high2 = ema(Double_Moving_Average_Exponential_nr_1_high2,Lenght_of_Moving_average_Type_2) Double_Moving_Average_Exponential_high2 = (2 * Double_Moving_Average_Exponential_nr_1_high2 - Double_Moving_Average_Exponential_nr_2_high2) // Asigning low candle Double_Moving_Average_Exponential_nr_1_low2 = ema(HA_low_stage2, Lenght_of_Moving_average_Type_2) Double_Moving_Average_Exponential_nr_2_low2 = ema(Double_Moving_Average_Exponential_nr_1_low2,Lenght_of_Moving_average_Type_2) Double_Moving_Average_Exponential_low2 = (2 * Double_Moving_Average_Exponential_nr_1_low2 - Double_Moving_Average_Exponential_nr_2_low2) // Asigning close candle Double_Moving_Average_Exponential_nr_1_close2 = ema(HA_close_stage2, Lenght_of_Moving_average_Type_2) Double_Moving_Average_Exponential_nr_2_close2 = ema(Double_Moving_Average_Exponential_nr_1_close2,Lenght_of_Moving_average_Type_2) Double_Moving_Average_Exponential_close2 = (2 * Double_Moving_Average_Exponential_nr_1_close2 - Double_Moving_Average_Exponential_nr_2_close2) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Arnaud_Legoux_Moving_Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// offset_of_ALMA2 = input(0.85, title="Offset of Arnaud Legoux Moving Average type 2 if used", type=float) sigma_of_ALMA2 = input(6, title="Sigma of Arnaud Legoux Moving Average type 2 if used", type=float) Arnaud_Legoux_Moving_Average_open2 = alma(HA_open_stage2,Lenght_of_Moving_average_Type_2,offset_of_ALMA2,sigma_of_ALMA2) Arnaud_Legoux_Moving_Average_high2 = alma(HA_high_stage2,Lenght_of_Moving_average_Type_2,offset_of_ALMA2,sigma_of_ALMA2) Arnaud_Legoux_Moving_Average_low2 = alma(HA_low_stage2,Lenght_of_Moving_average_Type_2,offset_of_ALMA2,sigma_of_ALMA2) Arnaud_Legoux_Moving_Average_close2 = alma(HA_close_stage2,Lenght_of_Moving_average_Type_2,offset_of_ALMA2,sigma_of_ALMA2) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Least Squares Moving Average 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Least_Squares_Moving_Average_offset2 = input(defval=0, minval=-100, title="Least Squares Moving Average offset as type 2 ") Least_Squares_Moving_Average_open2 = linreg(HA_open_stage2, Lenght_of_Moving_average_Type_2, Least_Squares_Moving_Average_offset2) Least_Squares_Moving_Average_high2 = linreg(HA_high_stage2, Lenght_of_Moving_average_Type_2, Least_Squares_Moving_Average_offset2) Least_Squares_Moving_Average_low2 = linreg(HA_low_stage2, Lenght_of_Moving_average_Type_2, Least_Squares_Moving_Average_offset2) Least_Squares_Moving_Average_close2 = linreg(HA_close_stage2, Lenght_of_Moving_average_Type_2, Least_Squares_Moving_Average_offset2) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Simple Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Moving_Average_open2 = sma(HA_open_stage2, Lenght_of_Moving_average_Type_2) Moving_Average_high2 = sma(HA_high_stage2, Lenght_of_Moving_average_Type_2) Moving_Average_low2 = sma(HA_low_stage2, Lenght_of_Moving_average_Type_2) Moving_Average_close2 = sma(HA_close_stage2, Lenght_of_Moving_average_Type_2) ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Exponential Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// eMoving_Average_open2 = ema(HA_open_stage2, Lenght_of_Moving_average_Type_2) eMoving_Average_high2 = ema(HA_high_stage2, Lenght_of_Moving_average_Type_2) eMoving_Average_low2 = ema(HA_low_stage2, Lenght_of_Moving_average_Type_2) eMoving_Average_close2 = ema(HA_close_stage2, Lenght_of_Moving_average_Type_2) ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Weighted Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// wMoving_Average_open2 = wma(HA_open_stage2, Lenght_of_Moving_average_Type_2) wMoving_Average_high2 = wma(HA_high_stage2, Lenght_of_Moving_average_Type_2) wMoving_Average_low2 = wma(HA_low_stage2, Lenght_of_Moving_average_Type_2) wMoving_Average_close2 = wma(HA_close_stage2, Lenght_of_Moving_average_Type_2) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Smoothed Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// smma_open2 = 0.0 smma_open2 := na(smma_open2[1]) ? sma(HA_open_stage2, Lenght_of_Moving_average_Type_2) : (smma_open2[1] * (Lenght_of_Moving_average_Type_2 - 1) + HA_open_stage2) / Lenght_of_Moving_average_Type_2 smma_high2 = 0.0 smma_high2 := na(smma_high2[1]) ? sma(HA_high_stage2, Lenght_of_Moving_average_Type_2) : (smma_high2[1] * (Lenght_of_Moving_average_Type_2 - 1) + HA_high_stage2) / Lenght_of_Moving_average_Type_2 smma_low2 = 0.0 smma_low2 := na(smma_low2[1]) ? sma(HA_low_stage2, Lenght_of_Moving_average_Type_2) : (smma_low2[1] * (Lenght_of_Moving_average_Type_2 - 1) + HA_low_stage2) / Lenght_of_Moving_average_Type_2 smma_close2 = 0.0 smma_close2 := na(smma_close2[1]) ? sma(HA_close_stage2, Lenght_of_Moving_average_Type_2) : (smma_close2[1] * (Lenght_of_Moving_average_Type_2 - 1) + HA_close_stage2) / Lenght_of_Moving_average_Type_2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Triple Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// xTriple_EMA_1 = ema(HA_open_stage2, Lenght_of_Moving_average_Type_2) xTriple_EMA_2 = ema(xTriple_EMA_1, Lenght_of_Moving_average_Type_2) xTriple_EMA_3 = ema(xTriple_EMA_2, Lenght_of_Moving_average_Type_2) xTriple_EMA_4 = ema(HA_high_stage2, Lenght_of_Moving_average_Type_2) xTriple_EMA_5 = ema(xTriple_EMA_4, Lenght_of_Moving_average_Type_2) xTriple_EMA_6 = ema(xTriple_EMA_5, Lenght_of_Moving_average_Type_2) xTriple_EMA_7 = ema(HA_low_stage2, Lenght_of_Moving_average_Type_2) xTriple_EMA_8 = ema(xTriple_EMA_7, Lenght_of_Moving_average_Type_2) xTriple_EMA_9 = ema(xTriple_EMA_8, Lenght_of_Moving_average_Type_2) xTriple_EMA_10 = ema(HA_close_stage2, Lenght_of_Moving_average_Type_2) xTriple_EMA_11 = ema(xTriple_EMA_10, Lenght_of_Moving_average_Type_2) xTriple_EMA_12 = ema(xTriple_EMA_11, Lenght_of_Moving_average_Type_2) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Hull Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// eHull_Moving_Average_lenght_sqrt_open = sqrt(Lenght_of_Moving_average_Type_2) eHull_Moving_Average_lenght_rounded_open = round(eHull_Moving_Average_lenght_sqrt_open) eHull_Moving_Average_1_open = wma(HA_open_stage2, Lenght_of_Moving_average_Type_2) eHull_Moving_Average_2_open = wma(HA_open_stage2, (Lenght_of_Moving_average_Type_2 / 2)) eHull_Moving_Average_3_open = (2 * eHull_Moving_Average_2_open) - eHull_Moving_Average_1_open eHull_Moving_Average_open = wma(eHull_Moving_Average_3_open, eHull_Moving_Average_lenght_rounded_open) eHull_Moving_Average_lenght_sqrt_high = sqrt(Lenght_of_Moving_average_Type_2) eHull_Moving_Average_lenght_rounded_high = round(eHull_Moving_Average_lenght_sqrt_high) eHull_Moving_Average_1_high = wma(HA_high_stage2, Lenght_of_Moving_average_Type_2) eHull_Moving_Average_2_high = wma(HA_high_stage2, (Lenght_of_Moving_average_Type_2 / 2)) eHull_Moving_Average_3_high = (2 * eHull_Moving_Average_2_high) - eHull_Moving_Average_1_high eHull_Moving_Average_high = wma(eHull_Moving_Average_3_high, eHull_Moving_Average_lenght_rounded_high) eHull_Moving_Average_lenght_sqrt_low = sqrt(Lenght_of_Moving_average_Type_2) eHull_Moving_Average_lenght_rounded_low = round(eHull_Moving_Average_lenght_sqrt_low) eHull_Moving_Average_1_low = wma(HA_low_stage2, Lenght_of_Moving_average_Type_2) eHull_Moving_Average_2_low = wma(HA_low_stage2, (Lenght_of_Moving_average_Type_2 / 2)) eHull_Moving_Average_3_low = (2 * eHull_Moving_Average_2_low) - eHull_Moving_Average_1_low eHull_Moving_Average_low = wma(eHull_Moving_Average_3_low, eHull_Moving_Average_lenght_rounded_low) eHull_Moving_Average_lenght_sqrt_close = sqrt(Lenght_of_Moving_average_Type_2) eHull_Moving_Average_lenght_rounded_close = round(eHull_Moving_Average_lenght_sqrt_close) eHull_Moving_Average_1_close = wma(HA_close_stage2, Lenght_of_Moving_average_Type_2) eHull_Moving_Average_2_close = wma(HA_close_stage2, (Lenght_of_Moving_average_Type_2 / 2)) eHull_Moving_Average_3_close = (2 * eHull_Moving_Average_2_close) - eHull_Moving_Average_1_close eHull_Moving_Average_close = wma(eHull_Moving_Average_3_close, eHull_Moving_Average_lenght_rounded_close) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Adaptive Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// AMA_Weight_value_2 = input(0.181, title="Smoothe constant of AMA as type 2") eAdaptive_moving_average_open = 0.0 eAdaptive_moving_average_open := na(eAdaptive_moving_average_open[1]) ? HA_open_stage2 * (AMA_Weight_value_2*AMA_Weight_value_2) + (1 - (AMA_Weight_value_2*AMA_Weight_value_2)) : HA_open_stage2 * (AMA_Weight_value_2*AMA_Weight_value_2) + (1 - (AMA_Weight_value_2*AMA_Weight_value_2)) * eAdaptive_moving_average_open[1] eAdaptive_moving_average_high = 0.0 eAdaptive_moving_average_high := na(eAdaptive_moving_average_high[1]) ? HA_high_stage2 * (AMA_Weight_value_2*AMA_Weight_value_2) + (1 - (AMA_Weight_value_2*AMA_Weight_value_2)) : HA_high_stage2 * (AMA_Weight_value_2*AMA_Weight_value_2) + (1 - (AMA_Weight_value_2*AMA_Weight_value_2)) * eAdaptive_moving_average_high[1] eAdaptive_moving_average_low = 0.0 eAdaptive_moving_average_low := na(eAdaptive_moving_average_low[1]) ? HA_low_stage2 * (AMA_Weight_value_2*AMA_Weight_value_2) + (1 - (AMA_Weight_value_2*AMA_Weight_value_2)) : HA_low_stage2 * (AMA_Weight_value_2*AMA_Weight_value_2) + (1 - (AMA_Weight_value_2*AMA_Weight_value_2)) * eAdaptive_moving_average_low[1] eAdaptive_moving_average_close = 0.0 eAdaptive_moving_average_close := na(eAdaptive_moving_average_close[1]) ? HA_close_stage2 * (AMA_Weight_value_2*AMA_Weight_value_2) + (1 - (AMA_Weight_value_2*AMA_Weight_value_2)) : HA_close_stage2 * (AMA_Weight_value_2*AMA_Weight_value_2) + (1 - (AMA_Weight_value_2*AMA_Weight_value_2)) * eAdaptive_moving_average_close[1] ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Fractal Adaptive Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Big thanks to nemozny and Shizaru for sharing their code from which I was able to add this FRAMA to this study. Really, big thank you guys. // open eFractal_Adaptive_Moving_Average_input2 = input(1, title="Should be left 1 for the best results (FRAMA as type 2)") eFractal_Adaptive_Moving_Average_input3 = input(168, title="Try and experiment with this value (FRAMA as type 2)") eFractal_Adaptive_Moving_Average_lenght_part2_open = Lenght_of_Moving_average_Type_2 / 2 eNatural_Logorithm_workaround_open = log(2 / (eFractal_Adaptive_Moving_Average_input3 + 1)) / log(Exponential) eHighest_price_nr1_open = highest(HA_high_stage2, eFractal_Adaptive_Moving_Average_lenght_part2_open) eLowest_price_nr1_open = lowest(HA_low_stage2, eFractal_Adaptive_Moving_Average_lenght_part2_open) eNative_price_1_open = (eHighest_price_nr1_open - Lowest_price_nr1_open)/eFractal_Adaptive_Moving_Average_lenght_part2_open eHighest_price_nr2_open = highest(HA_high_stage2,eFractal_Adaptive_Moving_Average_lenght_part2_open)[eFractal_Adaptive_Moving_Average_lenght_part2_open] eLowest_price_nr2_open = lowest(HA_low_stage2,eFractal_Adaptive_Moving_Average_lenght_part2_open)[eFractal_Adaptive_Moving_Average_lenght_part2_open] eNative_price_2_open = (eHighest_price_nr2_open-eLowest_price_nr2_open)/eFractal_Adaptive_Moving_Average_lenght_part2_open eHighest_price_nr3_open = highest(HA_high_stage2,Lenght_of_Moving_average_Type_2) eLowest_price_nr3_open = lowest(HA_low_stage2,Lenght_of_Moving_average_Type_2) eNative_price_3_open = (eHighest_price_nr3_open-eLowest_price_nr3_open)/Lenght_of_Moving_average_Type_2 eFractal_Dimension_1_open = (log(eNative_price_1_open+eNative_price_2_open)-log(eNative_price_3_open))/log(2) eFractal_Dimension_2_open = iff(eNative_price_1_open>0 and eNative_price_2_open>0 and eNative_price_3_open>0,eFractal_Dimension_1_open,nz(eFractal_Dimension_1_open[1])) efactor_of_exponential_smoothing_1_open = exp(eNatural_Logorithm_workaround_open*(eFractal_Dimension_2_open-1)) efactor_of_exponential_smoothing_old_open = efactor_of_exponential_smoothing_1_open>1?1:(efactor_of_exponential_smoothing_1_open<0.01?0.01:efactor_of_exponential_smoothing_1_open) eNative_price_old_open = (2-efactor_of_exponential_smoothing_old_open)/efactor_of_exponential_smoothing_old_open eNative_price_open = (((eFractal_Adaptive_Moving_Average_input3-eFractal_Adaptive_Moving_Average_input2)*(eNative_price_old_open-1))/(eFractal_Adaptive_Moving_Average_input3-1))+eFractal_Adaptive_Moving_Average_input2 efactor_of_exponential_smoothing_2_open = 2/(eNative_price_open+1) efactor_of_exponential_smoothing_open = efactor_of_exponential_smoothing_2_open<2/(eFractal_Adaptive_Moving_Average_input3+1)?2/(eFractal_Adaptive_Moving_Average_input3+1):(efactor_of_exponential_smoothing_2_open>1?1:efactor_of_exponential_smoothing_2_open) eFractal_Adaptive_Moving_Average_open = 0.0 eFractal_Adaptive_Moving_Average_open := (1-efactor_of_exponential_smoothing_open)*nz(eFractal_Adaptive_Moving_Average_open[1]) + efactor_of_exponential_smoothing_open*HA_open_stage2 //high eFractal_Adaptive_Moving_Average_lenght_part2_high = Lenght_of_Moving_average_Type_2 / 2 eNatural_Logorithm_workaround_high = log(2 / (eFractal_Adaptive_Moving_Average_input3 + 1)) / log(Exponential) eHighest_price_nr1_high = highest(HA_high_stage2 ,eFractal_Adaptive_Moving_Average_lenght_part2_high) eLowest_price_nr1_high = lowest(HA_low_stage2,eFractal_Adaptive_Moving_Average_lenght_part2_high) eNative_price_1_high = (eHighest_price_nr1_high-eLowest_price_nr1_high)/eFractal_Adaptive_Moving_Average_lenght_part2_high eHighest_price_nr2_high = highest(HA_high_stage2,eFractal_Adaptive_Moving_Average_lenght_part2_high)[eFractal_Adaptive_Moving_Average_lenght_part2_high] eLowest_price_nr2_high = lowest(HA_low_stage2,eFractal_Adaptive_Moving_Average_lenght_part2_high)[eFractal_Adaptive_Moving_Average_lenght_part2_high] eNative_price_2_high = (eHighest_price_nr2_high-eLowest_price_nr2_high)/eFractal_Adaptive_Moving_Average_lenght_part2_high eHighest_price_nr3_high = highest(HA_high_stage2,Lenght_of_Moving_average_Type_2) eLowest_price_nr3_high = lowest(HA_low_stage2,Lenght_of_Moving_average_Type_2) eNative_price_3_high = (eHighest_price_nr3_high-eLowest_price_nr3_high)/Lenght_of_Moving_average_Type_2 eFractal_Dimension_1_high = (log(eNative_price_1_high+eNative_price_2_high)-log(eNative_price_3_high))/log(2) eFractal_Dimension_2_high = iff(eNative_price_1_high>0 and eNative_price_2_high>0 and eNative_price_3_high>0,eFractal_Dimension_1_high,nz(eFractal_Dimension_1_high[1])) efactor_of_exponential_smoothing_1_high = exp(eNatural_Logorithm_workaround_high*(eFractal_Dimension_2_high-1)) efactor_of_exponential_smoothing_old_high = efactor_of_exponential_smoothing_1_high>1?1:(efactor_of_exponential_smoothing_1_high<0.01?0.01:efactor_of_exponential_smoothing_1_high) eNative_price_old_high = (2-efactor_of_exponential_smoothing_old_high)/efactor_of_exponential_smoothing_old_high eNative_price_high = (((eFractal_Adaptive_Moving_Average_input3-eFractal_Adaptive_Moving_Average_input2)*(eNative_price_old_high-1))/(eFractal_Adaptive_Moving_Average_input3-1))+eFractal_Adaptive_Moving_Average_input2 efactor_of_exponential_smoothing_2_high = 2/(eNative_price_high+1) efactor_of_exponential_smoothing_high = efactor_of_exponential_smoothing_2_high<2/(eFractal_Adaptive_Moving_Average_input3+1)?2/(eFractal_Adaptive_Moving_Average_input3+1):(efactor_of_exponential_smoothing_2_high>1?1:efactor_of_exponential_smoothing_2_high) eFractal_Adaptive_Moving_Average_high = 0.0 eFractal_Adaptive_Moving_Average_high := (1-efactor_of_exponential_smoothing_high)*nz(eFractal_Adaptive_Moving_Average_high[1]) + efactor_of_exponential_smoothing_high*HA_high_stage2 // low eFractal_Adaptive_Moving_Average_lenght_part2_low = Lenght_of_Moving_average_Type_2 / 2 eNatural_Logorithm_workaround_low = log(2 / (eFractal_Adaptive_Moving_Average_input3 + 1)) / log(Exponential) eHighest_price_nr1_low = highest(HA_high_stage2 ,eFractal_Adaptive_Moving_Average_lenght_part2_low) eLowest_price_nr1_low = lowest(HA_low_stage2,eFractal_Adaptive_Moving_Average_lenght_part2_low) eNative_price_1_low = (eHighest_price_nr1_low-eLowest_price_nr1_low)/eFractal_Adaptive_Moving_Average_lenght_part2_low eHighest_price_nr2_low = highest(HA_high_stage2,eFractal_Adaptive_Moving_Average_lenght_part2_low)[eFractal_Adaptive_Moving_Average_lenght_part2_low] eLowest_price_nr2_low = lowest(HA_low_stage2,eFractal_Adaptive_Moving_Average_lenght_part2_low)[eFractal_Adaptive_Moving_Average_lenght_part2_low] eNative_price_2_low = (eHighest_price_nr2_low-eLowest_price_nr2_low)/eFractal_Adaptive_Moving_Average_lenght_part2_low eHighest_price_nr3_low = highest(HA_high_stage2,Lenght_of_Moving_average_Type_2) eLowest_price_nr3_low = lowest(HA_low_stage2,Lenght_of_Moving_average_Type_2) eNative_price_3_low = (eHighest_price_nr3_low-eLowest_price_nr3_low)/Lenght_of_Moving_average_Type_2 eFractal_Dimension_1_low = (log(eNative_price_1_low+eLowest_price_nr2_low)-log(eNative_price_3_low))/log(2) eFractal_Dimension_2_low = iff(eNative_price_1_low>0 and eLowest_price_nr2_low>0 and eNative_price_3_low>0,eFractal_Dimension_1_low,nz(eFractal_Dimension_1_low[1])) efactor_of_exponential_smoothing_1_low = exp(eNatural_Logorithm_workaround_low*(eFractal_Dimension_2_low-1)) efactor_of_exponential_smoothing_old_low = efactor_of_exponential_smoothing_1_low>1?1:(efactor_of_exponential_smoothing_1_low<0.01?0.01:efactor_of_exponential_smoothing_1_low) eNative_price_old_low = (2-efactor_of_exponential_smoothing_old_low)/efactor_of_exponential_smoothing_old_low eNative_price_low = (((eFractal_Adaptive_Moving_Average_input3-eFractal_Adaptive_Moving_Average_input2)*(eNative_price_old_low-1))/(eFractal_Adaptive_Moving_Average_input3-1))+eFractal_Adaptive_Moving_Average_input2 efactor_of_exponential_smoothing_2_low = 2/(eNative_price_low+1) efactor_of_exponential_smoothing_low = efactor_of_exponential_smoothing_2_low<2/(eFractal_Adaptive_Moving_Average_input3+1)?2/(eFractal_Adaptive_Moving_Average_input3+1):(efactor_of_exponential_smoothing_2_low>1?1:efactor_of_exponential_smoothing_2_low) eFractal_Adaptive_Moving_Average_low = 0.0 eFractal_Adaptive_Moving_Average_low := (1-efactor_of_exponential_smoothing_low)*nz(eFractal_Adaptive_Moving_Average_low[1]) + efactor_of_exponential_smoothing_low*HA_low_stage2 // close eFractal_Adaptive_Moving_Average_lenght_part2__close = Lenght_of_Moving_average_Type_2 / 2 eNatural_Logorithm_workaround__close = log(2 / (eFractal_Adaptive_Moving_Average_input3 + 1)) / log(Exponential) eHighest_price_nr1__close = highest(HA_high_stage2 ,eFractal_Adaptive_Moving_Average_lenght_part2__close) eLowest_price_nr1__close = lowest(HA_low_stage2,eFractal_Adaptive_Moving_Average_lenght_part2__close) eNative_price_1__close = (eHighest_price_nr1__close-eLowest_price_nr1__close)/eFractal_Adaptive_Moving_Average_lenght_part2__close eHighest_price_nr2_close = highest(HA_high_stage2,eFractal_Adaptive_Moving_Average_lenght_part2__close)[eFractal_Adaptive_Moving_Average_lenght_part2__close] eLowest_price_nr2_close = lowest(HA_low_stage2,eFractal_Adaptive_Moving_Average_lenght_part2__close)[eFractal_Adaptive_Moving_Average_lenght_part2__close] eNative_price_2_close = (eHighest_price_nr2_close-eLowest_price_nr2_close)/eFractal_Adaptive_Moving_Average_lenght_part2__close eHighest_price_nr3_close = highest(HA_high_stage2,Lenght_of_Moving_average_Type_2) eLowest_price_nr3_close = lowest(HA_low_stage2,Lenght_of_Moving_average_Type_2) eNative_price_3_close = (eHighest_price_nr3_close-eLowest_price_nr3_close)/Lenght_of_Moving_average_Type_2 eFractal_Dimension_1_close = (log(eNative_price_1__close+Native_price_2_close)-log(eNative_price_3_close))/log(2) eFractal_Dimension_2_close = iff(eNative_price_1__close>0 and eNative_price_2_close>0 and eNative_price_3_close>0,eFractal_Dimension_1_close,nz(eFractal_Dimension_1_close[1])) efactor_of_exponential_smoothing_1_close = exp(eNatural_Logorithm_workaround__close*(eFractal_Dimension_2_close-1)) efactor_of_exponential_smoothing_old_close = efactor_of_exponential_smoothing_1_close>1?1:(efactor_of_exponential_smoothing_1_close<0.01?0.01:efactor_of_exponential_smoothing_1_close) eNative_price_old_close = (2-efactor_of_exponential_smoothing_old_close)/efactor_of_exponential_smoothing_old_close eNative_price_close = (((eFractal_Adaptive_Moving_Average_input3-eFractal_Adaptive_Moving_Average_input2)*(eNative_price_old_close-1))/(eFractal_Adaptive_Moving_Average_input3-1))+eFractal_Adaptive_Moving_Average_input2 efactor_of_exponential_smoothing_2_close = 2/(eNative_price_close+1) efactor_of_exponential_smoothing_close = efactor_of_exponential_smoothing_2_close<2/(eFractal_Adaptive_Moving_Average_input3+1)?2/(eFractal_Adaptive_Moving_Average_input3+1):(efactor_of_exponential_smoothing_2_close>1?1:efactor_of_exponential_smoothing_2_close) eFractal_Adaptive_Moving_Average_close = 0.0 eFractal_Adaptive_Moving_Average_close := (1-efactor_of_exponential_smoothing_close)*nz(eFractal_Adaptive_Moving_Average_close[1]) + efactor_of_exponential_smoothing_close*HA_close_stage2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Variable Index Dynamic Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Copyright (c) 2018-present, Alex Orekhov (everget) // Variable Index Dynamic Average indicator script may be freely distributed under the MIT license. // Thanks everget for sharing this script. // open // Chande Momentum Oscillator ef1_open(em_open) => em_open >= 0.0 ? em_open : 0.0 ef2_open(em_open) => em_open >= 0.0 ? 0.0 : -em_open eDifference_open = change(HA_open_stage2) eSum_of_UP_open = sum(ef1_open(eDifference_open), Lenght_of_Moving_average_Type_2) eSum_of_DOWN_open = sum(ef2_open(eDifference_open), Lenght_of_Moving_average_Type_2) eCMO_open = (eSum_of_UP_open - eSum_of_DOWN_open) / (eSum_of_UP_open + eSum_of_DOWN_open) efactor_open = (2 / (Lenght_of_Moving_average_Type_2 + 1)) eVIDYA_open = 0.0 eVIDYA_open := HA_open_stage2 * efactor_open * abs(eCMO_open) + nz(eVIDYA_open[1]) * (1 - efactor_open * abs(eCMO_open)) // high // Chande Momentum Oscillator ef1_high(em_high) => em_high >= 0.0 ? em_high : 0.0 ef2_high(em_high) => em_high >= 0.0 ? 0.0 : -em_high eDifference_high = change(HA_high_stage2) eSum_of_UP_high = sum(ef1_high(eDifference_high), Lenght_of_Moving_average_Type_2) eSum_of_DOWN_high = sum(ef2_high(eDifference_high), Lenght_of_Moving_average_Type_2) eCMO_high = (eSum_of_UP_high - eSum_of_DOWN_high) / (eSum_of_UP_high + eSum_of_DOWN_high) efactor_high = (2 / (Lenght_of_Moving_average_Type_2 + 1)) eVIDYA_high = 0.0 eVIDYA_high := HA_high_stage2 * efactor_high * abs(eCMO_high) + nz(eVIDYA_high[1]) * (1 - efactor_high * abs(eCMO_high)) // low // Chande Momentum Oscillator ef1_low(em_low) => em_low >= 0.0 ? em_low : 0.0 ef2_low(em_low) => em_low >= 0.0 ? 0.0 : -em_low eDifference_low = change(HA_low_stage2) eSum_of_UP_low = sum(ef1_low(eDifference_low), Lenght_of_Moving_average_Type_2) eSum_of_DOWN_low = sum(ef2_low(eDifference_low), Lenght_of_Moving_average_Type_2) eCMO_low = (eSum_of_UP_low - eSum_of_DOWN_low) / (eSum_of_UP_low + eSum_of_DOWN_low) efactor_low = (2 / (Lenght_of_Moving_average_Type_2 + 1)) eVIDYA_low = 0.0 eVIDYA_low := HA_low_stage2 * efactor_low * abs(eCMO_low) + nz(eVIDYA_low[1]) * (1 - efactor_low * abs(eCMO_low)) // close // Chande Momentum Oscillator ef1_close(em_close) => em_close >= 0.0 ? em_close : 0.0 ef2_close(em_close) => em_close >= 0.0 ? 0.0 : -em_close eDifference_close = change(HA_close_stage2) eSum_of_UP_close = sum(ef1_close(eDifference_close), Lenght_of_Moving_average_Type_2) eSum_of_DOWN_close = sum(ef2_close(eDifference_close), Lenght_of_Moving_average_Type_2) eCMO_close = (eSum_of_UP_close - eSum_of_DOWN_close) / (eSum_of_UP_close + eSum_of_DOWN_close) efactor_close = (2 / (Lenght_of_Moving_average_Type_2 + 1)) eVIDYA_close = 0.0 eVIDYA_close := HA_close_stage2 * efactor_close * abs(eCMO_close) + nz(eVIDYA_close[1]) * (1 - efactor_close * abs(eCMO_close)) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Triangular Moving Average as type 2 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// eTriangular_Moving_Average_open = sma(sma(HA_open_stage2,Lenght_of_Moving_average_Type_2),Lenght_of_Moving_average_Type_2) eTriangular_Moving_Average_high = sma(sma(HA_high_stage2,Lenght_of_Moving_average_Type_2),Lenght_of_Moving_average_Type_2) eTriangular_Moving_Average_low = sma(sma(HA_low_stage2,Lenght_of_Moving_average_Type_2),Lenght_of_Moving_average_Type_2) eTriangular_Moving_Average_close = sma(sma(HA_close_stage2,Lenght_of_Moving_average_Type_2),Lenght_of_Moving_average_Type_2) // STAGE 3 calculations: The final Heikin-Ashi Open, High, Low, Close values are calculated by doing a second smoothing of the bar values from step 2 by using the moving average type specified by the Moving Average Type 2 Input with a length/period specified by the Moving Average Period 2 Input. HA_open_stage_final = Moving_average_Type_2 == "TRIMA" ? eTriangular_Moving_Average_open : Moving_average_Type_2 == "VIDYA" ? eVIDYA_open : Moving_average_Type_2 == "FAMA" ? eFractal_Adaptive_Moving_Average_open : Moving_average_Type_2 == "AMA" ? eAdaptive_moving_average_open : Moving_average_Type_2 == "HMA" ? eHull_Moving_Average_open : Moving_average_Type_2 == "TEMA" ? xTriple_EMA_3 : Moving_average_Type_2 == "SMMA" ? smma_open2 : Moving_average_Type_2 == "WMA" ? wMoving_Average_open2 : Moving_average_Type_2 == "EMA" ? eMoving_Average_open2 : Moving_average_Type_2 == "SMA" ? Moving_Average_open2 : Moving_average_Type_2 == "LSMA" ? Least_Squares_Moving_Average_open2 : Moving_average_Type_2 == "T3" ? T3_open_2 : Moving_average_Type_2 == "DEMA" ? Double_Moving_Average_Exponential_open2 : Moving_average_Type_2 == "ALMA" ? Arnaud_Legoux_Moving_Average_open2 : Moving_average_Type_2 == "DEFAULT" ? HA_open_default : na HA_high_stage_final = Moving_average_Type_2 == "TRIMA" ? eTriangular_Moving_Average_high : Moving_average_Type_2 == "VIDYA" ? eVIDYA_high : Moving_average_Type_2 == "FAMA" ? eFractal_Adaptive_Moving_Average_high : Moving_average_Type_2 == "AMA" ? eAdaptive_moving_average_high : Moving_average_Type_2 == "HMA" ? eHull_Moving_Average_high : Moving_average_Type_2 == "TEMA" ? xTriple_EMA_6 : Moving_average_Type_2 == "SMMA" ? smma_high2 : Moving_average_Type_2 == "WMA" ? wMoving_Average_high2 : Moving_average_Type_2 == "EMA" ? eMoving_Average_high2 : Moving_average_Type_2 == "SMA" ? Moving_Average_high2 : Moving_average_Type_2 == "LSMA" ? Least_Squares_Moving_Average_high2 : Moving_average_Type_2 == "T3" ? T3_high_2 : Moving_average_Type_2 == "DEMA" ? Double_Moving_Average_Exponential_high2 : Moving_average_Type_2 == "ALMA" ? Arnaud_Legoux_Moving_Average_high2 : Moving_average_Type_2 == "DEFAULT" ? HA_high_default : na HA_low_stage_final = Moving_average_Type_2 == "TRIMA" ? eTriangular_Moving_Average_low : Moving_average_Type_2 == "VIDYA" ? eVIDYA_low : Moving_average_Type_2 == "FAMA" ? eFractal_Adaptive_Moving_Average_low : Moving_average_Type_2 == "AMA" ? eAdaptive_moving_average_low : Moving_average_Type_2 == "HMA" ? eHull_Moving_Average_low : Moving_average_Type_2 == "TEMA" ? xTriple_EMA_9 : Moving_average_Type_2 == "SMMA" ? smma_low2 : Moving_average_Type_2 == "WMA" ? wMoving_Average_low2 : Moving_average_Type_2 == "EMA" ? eMoving_Average_low2 : Moving_average_Type_2 == "SMA" ? Moving_Average_low2 : Moving_average_Type_2 == "LSMA" ? Least_Squares_Moving_Average_low2 : Moving_average_Type_2 == "T3" ? T3_low_2 : Moving_average_Type_2 == "DEMA" ? Double_Moving_Average_Exponential_low2 : Moving_average_Type_2 == "ALMA" ? Arnaud_Legoux_Moving_Average_low2 : Moving_average_Type_2 == "DEFAULT" ? HA_low_default : na HA_close_stage_final = Moving_average_Type_2 == "TRIMA" ? eTriangular_Moving_Average_close : Moving_average_Type_2 == "VIDYA" ? eVIDYA_close : Moving_average_Type_2 == "FAMA" ? eFractal_Adaptive_Moving_Average_close : Moving_average_Type_2 == "AMA" ? eAdaptive_moving_average_close : Moving_average_Type_2 == "HMA" ? eHull_Moving_Average_close : Moving_average_Type_2 == "TEMA" ? xTriple_EMA_12 : Moving_average_Type_2 == "SMMA" ? smma_close2 : Moving_average_Type_2 == "WMA" ? wMoving_Average_close2 : Moving_average_Type_2 == "EMA" ? eMoving_Average_close2 : Moving_average_Type_2 == "SMA" ? Moving_Average_close2 : Moving_average_Type_2 == "LSMA" ? Least_Squares_Moving_Average_close2 : Moving_average_Type_2 == "T3" ? T3_close_2 : Moving_average_Type_2 == "DEMA" ? Double_Moving_Average_Exponential_close2 : Moving_average_Type_2 == "ALMA" ? Arnaud_Legoux_Moving_Average_close2 : Moving_average_Type_2 == "DEFAULT" ? HA_close_default : na Open = single_smoothed == false ? HA_open_stage_final : HA_open_stage2 High = single_smoothed == false ? HA_high_stage_final : HA_high_stage2 Low = single_smoothed == false ? HA_low_stage_final : HA_low_stage2 Close = single_smoothed == false ? HA_close_stage_final : HA_close_stage2 plotcandle(Open, High, Low, Close, color = Open < Close ? lime : red, wickcolor=black) alertcondition(Open[1] > Close[1] and Open < Close, title="Heikin-Ashi Smoothed from red to green") alertcondition(Open[1] < Close[1] and Open > Close, title="Heikin-Ashi Smoothed from green to red")