Heikin-Ashi Smoothed with option to change MA types

CryptoJoncis · study · 996 行 · 点赞 2,735 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=3
//Author CryptoJoncis
//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.
 
 
//References:
// https://www.sierrachart.com/index.php?page=doc/StudiesReference.php&ID=314&Name=Heikin-Ashi_Smoothed
// https://www.investopedia.com/trading/heikin-ashi-better-candlestick/
// http://www.binarytribune.com/forex-trading-indicators/t3-moving-average-indicator/
// https://www.investopedia.com/ask/answers/121814/what-double-exponential-moving-average-dema-formula-and-how-it-calculated.asp
// https://www.stockfetcher.com/forums/Filter-Exchange/ALMA-Arnaud-Legoux-Moving-Average/143514
// https://www.mql5.com/en/forum/173057
// https://www.incrediblecharts.com/indicators/hull-moving-average.php#hull-moving-average-formula
// http://help.cqg.com/cqgic/default.htm#!Documents/adaptivemovingaverageama.htm
// https://www.tradingview.com/script/oV2PnTXz-FRAMA-Ehlers-true-modified-calculation/
// https://www.tradingview.com/script/9UAOEHWh-Fractal-Adaptive-Moving-Average/
// https://uk.tradingview.com/script/hdrf0fXV-Variable-Index-Dynamic-Average-VIDYA/
// http://www.blastchart.com/Community/IndicatorGuide/Indicators/VIDYA.aspx
 
study("Heikin-Ashi Smoothed with option to change MA types", shorttitle="HA Smoothed CryptoJoncis", 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)

← 返回列表