Luq Technology Project Showcase

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fareidzulkifli
// Link for font change: https://lingojam.com/FontChanger

//@version=5
var title_txt='𝐀𝐝𝐚𝐩𝐭𝐢𝐯𝐞 𝐕𝐚𝐥𝐮𝐞 𝐀𝐫𝐞𝐚 [𝐀𝐕𝐀] 𝐕𝟐.𝟎'
indicator('Adaptive Value Area', shorttitle=title_txt, overlay=true)


//-------------------------------------------------
// Library
//-------------------------------------------------
import fareidzulkifli/MasterLibrary/6       as fn
import fareidzulkifli/ShariahLibrary/2      as shariah

//---------
color           red     = #ff1100
color           green   = #00CD16
color           gold    = #FFCD00

//-------------------------------------------------
// Parameters
//-------------------------------------------------
groupsig="Trailing Stop (Optimized SuperTrend)"
outline = input.bool(true,   title="Show Outline", group="𝐀.𝐕.𝐀.")
ts_type = input.string('No', title="Enable Trailing Stop", options=["No","Signal Only", "Signal and Line"], group=groupsig)

//---------
disp_sts = ts_type=="No" ? false : true
disp_stl = ts_type=="Signal and Line"? true : false

groupsnr        =   "Support & Resistance Zone"
disp_snr        =   input.bool(false,   "Display Levels",               group= groupsnr)
nPiv            =   input.int(3,        "Tracker Size",                 group= groupsnr, minval=2,  maxval=7,  step   = 1)
atrLen          =   14
sensitivity     =   input.int(40,       "S/R Sensitivity",              group= groupsnr, minval=10,  maxval=50,  step   = 1)   
mult            =   input.float(0.3,    "S/R Zone Size",                group= groupsnr, minval=0.1, maxval=0.9, step   = 0.1)
vfs             =   input.bool(true,    "Use Volume Filter",            group= groupsnr, inline="Vol")
vlen            =   input.int(20,       "| Volume Length",              group= groupsnr, inline="Vol",  minval=5,  maxval=50,  step   = 1)

left            =   60 - sensitivity
right           =   60 - sensitivity

bullCol         =   input.color(green,  "Swing Low",                    group= "Zone Style")
bearCol         =   input.color(red,    "Swing High",                   group= "Zone Style")
// histCol         =   input.color(color.orange,    "Historical Zone",     group= "Zone Style")
bgTransp        =   input.int(95,       "Zone Background Transparency", group= "Zone Style")
bordTransp      =   input.int(70,       "Zone Border Transparency",     group= "Zone Style")


alert_cross     =   input.bool(true,    "Price Cross Alert",            group= "Alert")
alert_signal    =   input.bool(true,    "Start/End Alert",              group= "Alert")
//-------------------------------------------------
// Variables
//-------------------------------------------------
int             n       = bar_index
float           src     = hl2

string          signal  = na
float           atr     = ta.atr(20)

//------
// S & R
//------
var pivotHigh   =   array.new_box   (nPiv)
var pivotLows   =   array.new_box   (nPiv)  
var highBull    =   array.new_bool  (nPiv)
var lowsBull    =   array.new_bool  (nPiv)
var bullBorder  =   color.new       (bullCol,       bordTransp)
var bullBgCol   =   color.new       (bullCol,       bgTransp)
var bearBorder  =   color.new       (bearCol,       bordTransp)
var bearBgCol   =   color.new       (bearCol,       bgTransp)

//-------------------------------------------------
// Functions
//-------------------------------------------------
f_lim(i_ref,i_pct)=>
    x=(-1*i_ref)/((i_pct/100)-1)

sma(y)=>ta.sma(close, y)

f_supertrend(Factor, Pd, bool pivotpoint=false, int prd=2, int smooth=12)=>
    float Trailingsl = na
    int Trend = 0

    float ph = ta.pivothigh(prd, prd)
    float pl = ta.pivotlow(prd, prd) 
    
    _atr = ta.atr(Pd)
    float TUp = na
    float TDown = na  
    
    if pivotpoint

        // calculate the Center line using pivot points
        var float center = na
        float lastpp = ph ? ph : pl ? pl : na
        if lastpp
            if na(center)
                center := lastpp
                center
            else
                //weighted calculation
                center := (center * 2 + lastpp) / 3
                center
        
        // upper/lower bands calculation
        Up = fn.supersmoother(center - Factor * _atr, smooth)
        Dn = fn.supersmoother(center + Factor * _atr, smooth)
        
        // get the trend
        TUp         := close[1] > TUp[1] ? math.max(Up, TUp[1]) : Up
        TDown       := close[1] < TDown[1] ? math.min(Dn, TDown[1]) : Dn
        Trend       := close > TDown[1] ? 1 : close < TUp[1] ? -1 : nz(Trend[1], 1)
        Trailingsl  := Trend == 1 ? TUp : TDown
    
    color linecolor = na
    linecolor := Trend == 1 and nz(Trend[1]) == 1 ? green : Trend == -1 and nz(Trend[1]) == -1 ? color.new(color.red,100) : na
    
    
    int stsignal = na
    if Trend == 1 and Trend[1] == -1
        stsignal := 1 //buy
    else if Trend == -1 and Trend[1] == 1
        stsignal := 2 //sell

    [Trailingsl, linecolor, stsignal, Trend]


f_klmf(_src)=>
    p = _src
    //value1 = swma(p-p[1])
    float value1= na
    value1 := 0.2*(p-p[1]) + 0.8*nz(value1[1])
    
    float value2 = na
    value2 := 0.1*(ta.tr) + 0.8*nz(value2[1])
    lambda = math.abs(value1/value2)
    alpha = (-lambda*lambda + math.sqrt(lambda*lambda*lambda*lambda + 16*lambda*lambda))/8
    float klmf = na
    klmf := alpha*p + (1-alpha)*nz(klmf[1])


//------
// S & R
//------
// To revisit in next update
diff_hist   = false
_sethistory(_x, _max)=>
    if  array.size(_x) >= _max and diff_hist==true
        _box         = array.get(_x, _max-1)
        // box.set_bgcolor(_box, color.new(histCol, bgTransp))
        // box.set_border_color(_box, color.new(histCol, bordTransp))

del_hist   = 0
_delhistory(_x, _max)=>
    if  array.size(_x) == _max-1 and del_hist==1
        hist_box         = array.pop(_x)
        box.delete(hist_box)


_arrayLoad(_x, _max, _val) =>  
    array.unshift(_x, _val)   
    if  array.size(_x) > _max
        array.pop(_x)

_getBox(_x,_i)   =>
    _box         = array.get(_x, _i)
    _t           = box.get_top(_box)
    _b           = box.get_bottom(_box)
    [_t, _b]
    
_align(_x,_y)    =>
    for i = 0 to array.size(_x)-1
        [_T, _B] = _getBox(_y, 0)
        [_t, _b] = _getBox(_x, i)
        
        if _T > _b and _T < _t or 
           _B < _t and _B > _b or 
           _T > _t and _B < _b or 
           _B > _b and _T < _t
            
            box.set_top (array.get(_y, 0), _t)
            box.set_bottom (array.get(_y, 0), _b)

_extend(_x) =>
    for i = 0 to array.size(_x)-1
        box.set_right(array.get(_x, i), n+20)

//-------------------------------------------------
// S & R Variables
//-------------------------------------------------
v               =   volume
av              =   ta.sma(v, vlen)
vf              =   vfs and v ? (v > (av*1.)) : true
hlc             =   false
shi             =   hlc ? hlcc4 : high
slo             =   hlc ? hlcc4 : low
pivot_high      =   ta.pivothigh (shi, left, right) 
pivot_low       =   ta.pivotlow (slo, left, right) 

patr            =   ta.atr (atrLen)* mult

HH              =   pivot_high + patr
HL              =   pivot_high - patr
LH              =   pivot_low + patr
LL              =   pivot_low - patr

//-------------------------------------------------
// Indicator
//-------------------------------------------------
len1=fn.clamp(n, 1, 30)
len2=fn.clamp(n, 1, 100)
len3=fn.clamp(n, 1, 200)



// SafeLine
//-------------------------------------------------

src1 = f_klmf(close)    // Shortline and Safe line
src2 = f_klmf(low)      //Stopline

if n<=200
    src1 := close
    src2 := low
    

float stopline  = math.min(fn.kalman(src2, int(len3)), fn.supersmoother(fn.kalman(src1, int(len2)), 1))
float safeline  = math.max(fn.supersmoother(fn.kalman(src1, int(len2)), 1), stopline)
float line1     = math.max(fn.supersmoother(fn.kalman(src1, int(len1)), 1), safeline)

//-------------------------------------------------
// Signal
//-------------------------------------------------
[supertrend, stcol, stsignal, sttrend]=f_supertrend(2, 10, true, 2, 15)

valid=safeline>stopline
showsignal=valid and valid[1]

midstart=false
midend  =false

if showsignal and showsignal[1]==false and sttrend==1 and sttrend[1]==1
    midstart:=true

if showsignal==false and showsignal[1]==true //and sttrend==1 and sttrend[1]==1
    midend:=true


var string lastsignal   = na
bool start_signal       = false
bool end_signal         = false

if (stsignal==1 or midstart)
    start_signal    := true
    lastsignal      := "Start"

if (stsignal==2 or midend) and lastsignal=="Start"
    end_signal      := true
    lastsignal      := "End"

//-------------------------------------------------
// Rendering
//-------------------------------------------------
//--------------------------
var blank=#00000000
l0 = plot(hl2,          color=blank, editable=false)
l1 = plot(line1,        color=outline?color.blue    : blank, editable=false)
l2 = plot(safeline,     color=outline?color.green   : blank, editable=false)
l3 = plot(stopline,     color=red, linewidth=2, editable=false)

col(v1, v2, int transp=90, bool neg=false)=>
    clr=#00000000
    if v1>v2
        clr:=color.new(#00bcd4, transp)
    else if v1<=v2 and neg
        clr:=color.new(red, 100)

fill(l0, l3, col(hl2, stopline, 100, true))
fill(l1, l3, col(line1, stopline, 92))
fill(l2, l3, col(safeline, stopline, 70))

//--------------------------
//Supertrend
plot(disp_stl ? supertrend : na, color=(showsignal?stcol:#00000000), linewidth=2)

plotshape(showsignal and disp_sts and           start_signal ? supertrend : na, title='OST Start', text='Start',   location=location.absolute, style=shape.labelup, size=size.tiny, color=color.new(green, 0), textcolor=color.new(color.white, 0))
plotshape((showsignal or midend) and disp_sts and end_signal ? supertrend : na, title='OST End',   text='End',     location=location.absolute, style=shape.labeldown, size=size.tiny, color=color.new(red, 0), textcolor=color.new(color.white, 0))

//--------------------------
// S & R
if pivot_high and vf[right] and disp_snr
    _arrayLoad      (highBull,  nPiv,   false)
    _arrayLoad      (pivotHigh, nPiv,   box.new( n[right]-5,       HH, n+20, HL, 
                                                 xloc           =   xloc.bar_index,
                                                 border_color   =   bearBorder,   
                                                 bgcolor        =   bearBgCol))

if pivot_low and vf[right] and disp_snr
    _arrayLoad      (lowsBull,  nPiv,   true)
    _arrayLoad      (pivotLows, nPiv,   box.new( n[right]-5,       LH, n+20, LL,    
                                                 xloc           =   xloc.bar_index,
                                                 border_color   =   bullBorder, 
                                                 bgcolor        =   bullBgCol))

_align(pivotHigh, pivotHigh)
_align(pivotHigh, pivotLows)
_align(pivotLows, pivotLows)
_align(pivotLows, pivotHigh)

_extend(pivotHigh)
_extend(pivotLows)

//-------------------------------------------------
// Alert
//-------------------------------------------------


alert1  = ta.crossunder(close, line1)
alert2  = ta.crossunder(close, safeline)
alert3  = ta.crossunder(close, stopline)
alert4  = ta.crossover(close, line1)
alert5  = ta.crossover(close, safeline)
alert6  = ta.crossover(close, stopline)

if safeline>stopline and alert_cross
    if alert1
        alert("Cross Below ShortLine", alert.freq_once_per_bar)
    if alert2
        alert("Cross Below SafeLine", alert.freq_once_per_bar)
    if alert3
        alert("Cross Below StopLine", alert.freq_once_per_bar)

    if alert4
        alert("Cross Above ShortLine", alert.freq_once_per_bar)
    if alert5
        alert("Cross Above SafeLine", alert.freq_once_per_bar)
    if alert6
        alert("Cross Above StopLine", alert.freq_once_per_bar)

if alert_signal
    if showsignal and disp_sts and start_signal
        alert("Start Signal", alert.freq_once_per_bar_close)
    if (showsignal or midend) and disp_sts and end_signal
        alert("End Signal", alert.freq_once_per_bar_close)
//----------------------------------
//----------------------------------
// ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼
// Info Panel
// ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
group3="Panel"
txt_sz1 = "Large",          txt_sz2  = "Normal",         txt_sz3  = "Small"

disp_ta         = input.bool(true,          group=group3, title = "Display Shariah Panel")
ta_size         = input.string(txt_sz2,     group=group3, title = "  Size:",    options=[txt_sz1, txt_sz2, txt_sz3, "Mobile"])

//----------------------------------
// Info Panel Variables
//----------------------------------
var ta_text_size    = ta_size == txt_sz1 ? size.large : ta_size == txt_sz2 ? size.normal : ta_size == txt_sz3 ? size.small : size.tiny
var t_position      = position.bottom_left
var dark=true
var head_col    = dark ? color.white : color.white
var head_bgc    = dark ? color.black : color.black
var text_col    = dark ? color.white : color.black


//----------------------------------
// Functions
//----------------------------------
fill_ta(_table, _row, _label, _value, _clrtyp) =>
    t_size      = ta_text_size
    header      = _value=="Header" ? true : false
    
    col_text    = header ? head_col : dark? color.gray : color.gray//text_col
    col_bg      = header ? head_bgc : #00000000
    _ValueText  = header ? "" : _value == "gap" ? "" : _value
    
    table.cell(_table, 0, _row, _label, bgcolor = col_bg, text_color = col_text,
      text_size = t_size, text_halign = header ? text.align_left : text.align_left)
    
    table.cell(_table, 1, _row, _ValueText, bgcolor = col_bg, text_color = header?head_col:col_text, 
      text_size = t_size, text_halign = text.align_right)

//----------------------------------
// Generate Table
//----------------------------------
var TA_table = table.new(position = position.bottom_right,
                          columns = 3, 
                          rows = 5, 
                          bgcolor = #00000000, 
                          frame_color = #000000, 
                          frame_width = 0, 
                          border_color = text_col,
                          border_width = 0)


// =====================================================================================================================
// TA Data
// =====================================================================================================================
ticker  = syminfo.type=='stock'?syminfo.tickerid:'NASDAQ:AAPL'
tos     = syminfo.type=='stock'?request.financial(ticker, 'TOTAL_SHARES_OUTSTANDING', "FQ", barmerge.gaps_off, ignore_invalid_symbol =true):-1.0

//Prep panel Data

string  mcap            = str.tostring(tos*close, format.volume) 
var     shariah         = shariah.status() ? "Compliant" : "N/A"

var myx = syminfo.prefix=='MYX' or syminfo.prefix=='MYX_DLY'

irow=-1
if barstate.islast and disp_ta
    if myx
        irow+=1, fill_ta(TA_table, irow, "❄️ Shariah Status",    shariah, 0)
    
    if tos>0 and syminfo.type=='stock'
        irow+=1, fill_ta(TA_table, irow, "🏦 Market Cap",       mcap, 0)

    // irow+=1, fill_ta(TA_table, irow, "📈 MA20>MA50",            trend20, 0)
    // irow+=1, fill_ta(TA_table, irow, "📈 MA50>MA200",           trend50, 0)
    // irow+=1, fill_ta(TA_table, irow, "📊 Relative Volume",  rvol, 0)
    
// bgcol=dailytrend==1?color.new(color.blue, 85):na
// bgcolor(bgcol)


//----------------------------------
// END
//----------------------------------

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fareidzulkifli

//@version=4
study(title="Directional Strength Panel", shorttitle="Directional Strength Panel", overlay = true) 

// ---------------------------
// Parameters
// ---------------------------
grp1         = "Table Settings",    grp2    = "Symbol List",     grp3 = "MA Settings"
var lbl_list = array.new_string(),  mom_val = array.new_float()
tips         = "Write the name for label in the second box"
tips2        = "Applicable only for ALMA"
tips3        = "Check to display MA on chart"

in_theme    = input("Dark",             title = "Chart Theme",                      group=grp1, options=["Light", "Dark"])
in_size     = input("Small",            title = "Table Size",                       group=grp1, options=["Small", "Large"])
// -------
ma_typ      = input("ALMA",             title="MA Type",      type=input.string,    group=grp3, options = ["ALMA","SMA","EMA","WMA","RMA","VWMA", "Hull", "SuperSmoother"])
ma_len      = input(20,                 title="MA Length",    type=input.integer,   group=grp3)
offset      = input(0.6,                title="  Offset",     type=input.float,     group=grp3, tooltip=tips2)
sigma       = input(6,                  title="  Sigma",      type=input.float,     group=grp3, tooltip=tips2)
disp        = input(true,               title="Display MA",   type=input.bool,      group=grp3, tooltip=tips3)
// -------
ticker_1    = input('BINANCE:BTCUSDT',  title="Ticker 1",     type=input.symbol,    group=grp2, inline="Ticker 1")                      
ticker_2    = input('BINANCE:ETHUSDT',  title="Ticker 2",     type=input.symbol,    group=grp2, inline="Ticker 2")
ticker_3    = input('BINANCE:BNBUSDT',  title="Ticker 3",     type=input.symbol,    group=grp2, inline="Ticker 3")
ticker_4    = input('BINANCE:XRPUSDT',  title="Ticker 4",     type=input.symbol,    group=grp2, inline="Ticker 4")
ticker_5    = input('BINANCE:ADAUSDT',  title="Ticker 5",     type=input.symbol,    group=grp2, inline="Ticker 5")
ticker_6    = input('BINANCE:DOGEUSDT', title="Ticker 6",     type=input.symbol,    group=grp2, inline="Ticker 6")

if(barstate.isfirst)                                                                                                                        //Index
	array.push(lbl_list, input("BTC",       title="",             type=input.string,    group=grp2, inline="Ticker 1", tooltip=tips))       //0
	array.push(lbl_list, input("ETH",       title="",             type=input.string,    group=grp2, inline="Ticker 2", tooltip=tips))       //1
	array.push(lbl_list, input("BNB",       title="",             type=input.string,    group=grp2, inline="Ticker 3", tooltip=tips))       //2
	array.push(lbl_list, input("XRP",       title="",             type=input.string,    group=grp2, inline="Ticker 4", tooltip=tips))       //3
	array.push(lbl_list, input("ADA",       title="",             type=input.string,    group=grp2, inline="Ticker 5", tooltip=tips))       //4
	array.push(lbl_list, input("DOGE",      title="",             type=input.string,    group=grp2, inline="Ticker 6", tooltip=tips))       //5
// ---------------------------
// Variables
// ---------------------------
var t_position  = position.bottom_right
var col_text    = in_theme  == "Dark" ? color.white : color.black

// -------
var PTable  = table.new(position = t_position, columns = 7, rows = 65)
var dash    = "■", var lim = "-------------"
var row_max = in_size == "Small" ? 20 : 40      // Number of 'dash'
var row_mul = 100/row_max

// ---------------------------
// Functions
// ---------------------------
//Supersmoother 2-pole
f_ss(_src, _length) =>
    s_a1    = exp(-sqrt(2) * math.pi / _length)
    s_b1    = 2 * s_a1 * cos(sqrt(2) * math.pi / _length)
    s_c3    = -pow(s_a1, 2)
    s_c2    = s_b1
    s_c1    = 1 - s_c2 - s_c3
    ss      = 0.0
    ss     := s_c1 * _src + s_c2 * nz(ss[1], _src[1]) + s_c3 * nz(ss[2], _src[2])

// Multiple Moving Average
get_MA(typ, len, _ofs, _sig) =>
    float maVal = na
    if (typ == "EMA")
        maVal := ema(close, len)
    if (typ == "SMA")
        maVal := sma(close, len)
    if (typ == "WMA")
        maVal := wma(close, len)
    if (typ == "RMA")
        maVal := rma(close, len)
    if (typ == "VWMA")
        maVal := vwma(close, len)
    if (typ == "Hull")
        maVal := hma(close, len)
    if (typ == "ALMA")
        maVal := alma(close, len, _ofs, _sig)
    if (typ == "SuperSmoother")
        maVal := f_ss(close, len)
    maVal

// Function to retrieve value for drawing
get_data(_sym, _typ, _len, _ofs, _sig)=>
    security(_sym, timeframe.period, rsi(get_MA(_typ, _len, _ofs, _sig), 14))    // Value should be between 0-100

// Function to update the color of each row
f_Fill(_table, column_i, _title, _val) =>
    for row_i=row_max to 1
        x1   = _val/row_mul, x2 = row_max - x1
        _col = na(_val) ? #00000000 : row_i == row_max ? #FF3333 : x2 > row_i-1 ? #00000000 : color.from_gradient(row_i*row_mul, 10, 100, #00CC00, #FF3333)
        table.cell_set_text_color(_table, column_i, row_i, _col)
        
    table.cell_set_text(_table, column_i, row_max+2, na(_val)? "n/a" : tostring(_val, "0.0"))

// ---------------------------
// Calculate
// ---------------------------
// push value for each ticker to array (same sequence with lbl_list)                Index
array.push(mom_val, get_data(ticker_1, ma_typ, ma_len, offset, sigma))              // 0
array.push(mom_val, get_data(ticker_2, ma_typ, ma_len, offset, sigma))              // 1
array.push(mom_val, get_data(ticker_3, ma_typ, ma_len, offset, sigma))              // 2
array.push(mom_val, get_data(ticker_4, ma_typ, ma_len, offset, sigma))              // 3
array.push(mom_val, get_data(ticker_5, ma_typ, ma_len, offset, sigma))              // 4
array.push(mom_val, get_data(ticker_6, ma_typ, ma_len, offset, sigma))              // 5

// ---------------------------
// Fill Table
// ---------------------------
if(barstate.isfirst)
    // Update first column with 25/50/75/100 levels
    for idx=0 to 3
        table.cell(PTable, 0, (idx*(row_max/4))+1, tostring(100-(25*idx)) + " -", height = 1, text_color = color.new(col_text, 30), text_size = size.tiny, text_halign = text.align_right)
    
    //fill the whole thing 1 time, each subsequent update will only update the color
    for col_i=1 to 6
        _lbl = array.get(lbl_list, col_i-1)
        table.cell(PTable, col_i, 0, lim, height=1.2, width = 2.5, text_color = col_text, text_size = size.tiny, text_halign = text.align_center, text_valign=text.align_center)
        for row_i=row_max to 1
            bg_col = row_i == ((2*(row_max/4))+1) ? color.new(col_text, 95) : #00000000
            table.cell(PTable, col_i, row_i, dash, height = 1.2, width = 0,   text_color = #00000000, text_size = size.normal, text_halign = text.align_center, bgcolor=bg_col)
        table.cell(PTable, col_i, row_max+1, lim,  height=1,     width = 2.5, text_color = col_text,  text_size = size.tiny,   text_halign = text.align_center, text_valign=text.align_center)
        table.cell(PTable, col_i, row_max+2, "",                 width = 0,   text_color = col_text,  text_size = size.small,  text_halign = text.align_center)
        table.cell(PTable, col_i, row_max+3, lim,  height=0.5,   width = 2.5, text_color = col_text,  text_size = size.tiny,   text_halign = text.align_center)
        table.cell(PTable, col_i, row_max+4, _lbl,               width = 2.5, text_color = col_text,  text_size = size.tiny,   text_halign = text.align_center)

if barstate.islast
    //Fill color based on calculated value
    for i=1 to 6
        f_Fill(PTable, i, array.get(lbl_list, i-1),   array.get(mom_val, i-1))

//Plot MA Line
plot(disp ? get_MA(ma_typ, ma_len, offset, sigma) : na, title="Moving Average")

// plot(array.size(lbl_list), title="Lbl_list Size")
// plot(array.size(mom_val), title="mom_val Size")

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// REUSING THIS CODE: You are welcome to reuse this code without permission, including in closed-source publications, as long as proper credits are given :)
// Author: ©fareidzulkifli

// Disclaimer:
// Past performance is not an indicator of future results.
// My opinions are my own and do not constitute financial advice in any way whatsoever. 
// Nothing published by me constitutes an investment/trading recommendation, nor should any data or Content published by me be relied upon for any investment/trading activities.
// I strongly recommends that you perform your own independent research and/or speak with a qualified investment professional before making any financial decisions.

// Any ideas to further improve this indicator are welcome :)

//@version=4
study("Financial Highlights", overlay=false, format=format.volume, precision=2)

//--------------------------------------------
// Parameter
//--------------------------------------------
per1     = "Quarter", per2 = "Annual"
typ1     = "Revenue & PAT", typ2 = "Net Profit Margin", typ3 = "Gross Profit Margin", typ4 = "EPS", typ5 = "Dividend"
loc1     = "Period Ended", loc2 = "Published Date"

per      = input(per1, title="Reporting Period", options=[per1, per2])
type     = input(typ1, title="Report Type", options=[typ1, typ2, typ3, typ4, typ5])
xloc     = input(loc2, title="Plot QR Earnings On: ", options=[loc1, loc2])

txtSet   = input(false, "═════════ Text ════════")
s_txt    = input(true, title="Use Small Text")
lbl_col  = input(color.orange, 'Text Label Color', type=input.color)

lineSet  = input(false, "═════════ Line Chart ════════")
line_col = input(color.orange, 'Line Chart Color', type=input.color)

barSet   = input(false, "═════════ Bar Chart ════════")
rev_col  = input(#ffcf03, 'Revenue Bar Color', type=input.color)
pt1_col  = input(#009900, 'Positive PAT Bar Color', type=input.color)
pt2_col  = input(#ff0000, 'Negative PAT Bar Color', type=input.color)
div_col  = input(#004c99, 'Dividend Bar Color', type=input.color)

//--------------------------------------------
// Variables
//--------------------------------------------

float   line_chart      = na
float   v_rev           = na
float   v_profit        = na
string  s_rev           = na
string  s_profit        = na
string  rev_txt         = na
float   p_nta           = na
string  s_nta           = na
float   p_eps           = na
string  s_eps           = na
float   p_margin        = na
string  s_p_margin      = na
float   gp_margin       = na
string  s_gp_margin     = na
float   p_div           = na
string  s_div           = na
color   profitcolor     = na

var period              = per == per2 or type==typ5 ? "FY" : "FQ"
var earning_ticker      = "ESD_FACTSET:" + syminfo.prefix + ";" + syminfo.ticker + ";EARNINGS"
var bar_width           = timeframe.isweekly ? 15 : timeframe.ismonthly ? 10 : 20

//--------------------------------------------
// Functions
//--------------------------------------------

get_date()=>
    security(earning_ticker, "D", time, lookahead=true) //earning report date

get_fin(_id)=>
    financial(syminfo.tickerid, _id, period, barmerge.gaps_off)

plot_bar(_val, _color)=>
    var line body = na, var line top = na, var line bottom = na
    body    := line.new(x1 = bar_index,  y1 = 0, x2 = bar_index, y2 = _val, color = _color, width = bar_width)

plot_label(_val, _txt, _align)=>
    label txt_lbl = label.new(x = bar_index, y = _val, 
                                  text      = "", 
                                  textalign = _align=="left" ? text.align_left : text.align_center, 
                                  textcolor = lbl_col,
                                  color     = #00000000, 
                                  style     = _val>0 and type!=typ1 and type!=typ5 ? label.style_label_up : label.style_label_down, 
                                  size      = s_txt ? size.small : size.normal)
    label.set_y(txt_lbl, _val)
    label.set_text(txt_lbl, _txt)


//--------------------------------------------
// Main Calculations
//--------------------------------------------
rev     = financial(syminfo.tickerid, "TOTAL_REVENUE", period, barmerge.gaps_on)//

int report_date = na
if(barstate.isconfirmed)
    report_date := get_date()

var _per = type==typ5 ? per2 : per
if((((xloc==loc1 and _per==per1) or _per==per2) and rev) or (_per == per1 and xloc==loc2 and report_date==time))
    if(type==typ1) //Revenue & Profit After Tax
        v_rev           := get_fin("TOTAL_REVENUE")
        v_profit        := get_fin("NET_INCOME")
        s_rev           := tostring(v_rev/1000000, "#,###,###.#")
        s_profit        := tostring(v_profit/1000000, "#,###,###.#")
        rev_txt         := "Rev: "+s_rev+" M \nPAT: "+s_profit+" M"
        profitcolor     := v_profit>0 ? pt1_col : pt2_col
        
        if(v_rev>=v_profit)
            plot_bar(v_rev, rev_col)
            plot_bar(v_profit, profitcolor)
        else
            plot_bar(v_profit, profitcolor)
            plot_bar(v_rev, rev_col)
        plot_label(max(v_rev, v_profit), rev_txt, "left")
    
    else if(type==typ2) //Net Profit Margin
        p_margin    := get_fin("NET_INCOME")/get_fin("TOTAL_REVENUE") * 100
        s_p_margin  := tostring(p_margin, "#.00")+" %"
        line_chart  := p_margin
        plot_label(p_margin, s_p_margin, "center")
        
    else if(type==typ3) //Gross Profit Margin
        gp_margin   := get_fin("GROSS_PROFIT")/get_fin("TOTAL_REVENUE") *100
        s_gp_margin := tostring(gp_margin, "#.00")+" %"
        line_chart  := gp_margin
        plot_label(gp_margin, s_gp_margin, "center")
        
    else if(type==typ4) //Earnings Per Share (EPS)
        p_eps       := get_fin("EARNINGS_PER_SHARE")
        p_eps       := (p_eps ? p_eps : get_fin("NET_INCOME")/get_fin("BASIC_SHARES_OUTSTANDING")) *100 //exception handling
        s_eps       := tostring(p_eps, "0.00#")
        line_chart  := p_eps
        plot_label(p_eps, s_eps, "center")

    else if(type==typ5) //Dividend
        p_div       := get_fin("DPS_COMMON_STOCK_PRIM_ISSUE")
        s_div       := tostring(p_div, "0.00#")
        plot_bar(p_div, div_col)
        plot_label(p_div, s_div, "left")

//--------------------------------------------
// Drawings
//--------------------------------------------

hline(0, linestyle=hline.style_dotted)
plot(line_chart,  title="Value", color=line_col, transp=0, style=plot.style_circles, linewidth=3, join=true)

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// REUSING THIS CODE: You are welcome to reuse this code without permission, including in closed-source publications, as long as proper credits are given :)
// Author: ©fareidzulkifli

// Disclaimer:
// Past performance is not an indicator of future results.
// My opinions are my own and do not constitute financial advice in any way whatsoever. 
// Nothing published by me constitutes an investment/trading recommendation, nor should any data or Content published by me be relied upon for any investment/trading activities.
// I strongly recommends that you perform your own independent research and/or speak with a qualified investment professional before making any financial decisions.

// Any ideas to further improve this indicator are welcome :)

//@version=4
study("Sector Sigma", overlay=false, max_bars_back=1000)

//************************************************************************************************************
// Parameter
//************************************************************************************************************
custom_tf   = input('D',                     title="Timeframe for Screening", type=input.resolution, options=["D","W"])
indiSet     = input(false,                  "═════════ SigmaSpike Parameter ════════")
length      = input(20,                     title="Lookback Period",minval=1)
treshold    = input(2.,                     title="Sigma Threshold",minval=0.2)
offset      = input(0,                      title="Period Offset",   minval=0, maxval=1)
disp_ret    = input(true,                   title="Show Last [x] Period Return (%)")
ret_len     = input(20,                     title="[x] Period",minval=1)

AddSet      = input(false,                  "═════════ Additional Setting ════════")
txtclr      = input("Custom",               title = "Text Color", options=["Custom","White","Black"])
lblsize     = input(35,                     title = "Distance Between Label", minval=1, maxval=100)

screenList  = input(false,                  "═════════ Index for Screening ════════")
index_01    = input('MYX:FBMKLCI',            title = "Benchmark index",  type=input.symbol)
index_02    = input('MYX:TECHNOLOGY',         title = "Index 01",  type=input.symbol)
index_03    = input('MYX:ENERGY',             title = "Index 02",  type=input.symbol)
index_04    = input('MYX:PLANTATION',         title = "Index 03",  type=input.symbol)
index_05    = input('MYX:PROPERTIES',         title = "Index 04",  type=input.symbol)
index_06    = input('MYX:CONSUMER',           title = "Index 05",  type=input.symbol)
index_07    = input('MYX:FINANCE',            title = "Index 06",  type=input.symbol)
index_08    = input('MYX:CONSTRUCTN',         title = "Index 07",  type=input.symbol)
index_09    = input('MYX:IND-PROD',           title = "Index 08",  type=input.symbol)
index_10    = input('MYX:HEALTH',             title = "Index 09",  type=input.symbol)
index_11    = input('MYX:TRANSPORTATION',     title = "Index 10",  type=input.symbol)
index_12    = input('MYX:TELECOMMUNICATIONS', title = "Index 11",  type=input.symbol)
index_13    = input('MYX:UTILITIES',          title = "Index 12",  type=input.symbol)

//************************************************************************************************************
// Indicator and Function
//************************************************************************************************************
// -- Constant
var brl        = "\n-----------------------\n"

// -- Function
get_sigma(_len)=>
    float sigma   = na
    x_ret   = ((close-close[ret_len]) / close[ret_len])*100
    return  = (close-close[1]) / close[1]
    sd      = stdev(return, _len)
    sigma   := return / sd[1]
    [sigma[offset], return[offset]*100, x_ret[offset]]

//************************************************************************************************************
// Screener Logic
//************************************************************************************************************
// set asset status {

[sigma_01, ret_01, x_ret_01] = security(index_01, custom_tf, get_sigma(length))
[sigma_02, ret_02, x_ret_02] = security(index_02, custom_tf, get_sigma(length))
[sigma_03, ret_03, x_ret_03] = security(index_03, custom_tf, get_sigma(length))
[sigma_04, ret_04, x_ret_04] = security(index_04, custom_tf, get_sigma(length))
[sigma_05, ret_05, x_ret_05] = security(index_05, custom_tf, get_sigma(length))
[sigma_06, ret_06, x_ret_06] = security(index_06, custom_tf, get_sigma(length))
[sigma_07, ret_07, x_ret_07] = security(index_07, custom_tf, get_sigma(length))
[sigma_08, ret_08, x_ret_08] = security(index_08, custom_tf, get_sigma(length))
[sigma_09, ret_09, x_ret_09] = security(index_09, custom_tf, get_sigma(length))
[sigma_10, ret_10, x_ret_10] = security(index_10, custom_tf, get_sigma(length))
[sigma_11, ret_11, x_ret_11] = security(index_11, custom_tf, get_sigma(length))
[sigma_12, ret_12, x_ret_12] = security(index_12, custom_tf, get_sigma(length))
[sigma_13, ret_13, x_ret_13] = security(index_13, custom_tf, get_sigma(length))

//} end


significant_gain    = ""
weak_gain           = ""
significant_loss    = ""
weak_loss           = ""
var screen_per      = 
  custom_tf=="D" and offset==0 ? "Today" : custom_tf=="D" and offset==1 ? "Yesterday" :
  custom_tf=="W" and offset==0 ? "This Week" : "Last Week"

var txt_ret1         = "\nReturn " + screen_per + ": " 
var txt_ret2         = "Return " + tostring(ret_len) + (custom_tf=="D" ? " Days: ": " Weeks: ")

var txt_title       = "Scan For: " + screen_per + "\nSigma Spike Threshold: " + tostring(treshold) + "\n\nBenchmark:\n" 

benchmark  = txt_title
  + index_01 
  + "\n\nSigma: " + tostring(sigma_01,"0.00") 
  + txt_ret1 + tostring(ret_01,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_01,"0.00") + "%" 
  
//--------------
// Prep Label Text
//--------------
if(barstate.islast)
    
    significant_gain  := sigma_02 > treshold ? significant_gain + index_02 + "\nSigma: " + tostring(sigma_02,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_02,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_02,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_03 > treshold ? significant_gain + index_03 + "\nSigma: " + tostring(sigma_03,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_03,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_03,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_04 > treshold ? significant_gain + index_04 + "\nSigma: " + tostring(sigma_04,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_04,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_04,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_05 > treshold ? significant_gain + index_05 + "\nSigma: " + tostring(sigma_05,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_05,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_05,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_06 > treshold ? significant_gain + index_06 + "\nSigma: " + tostring(sigma_06,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_06,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_06,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_07 > treshold ? significant_gain + index_07 + "\nSigma: " + tostring(sigma_07,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_07,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_07,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_08 > treshold ? significant_gain + index_08 + "\nSigma: " + tostring(sigma_08,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_08,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_08,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_09 > treshold ? significant_gain + index_09 + "\nSigma: " + tostring(sigma_09,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_09,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_09,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_10 > treshold ? significant_gain + index_10 + "\nSigma: " + tostring(sigma_10,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_10,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_10,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_11 > treshold ? significant_gain + index_11 + "\nSigma: " + tostring(sigma_11,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_11,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_11,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_12 > treshold ? significant_gain + index_12 + "\nSigma: " + tostring(sigma_12,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_12,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_12,"0.00") + "%\n\n" : "\n\n") : significant_gain
    significant_gain  := sigma_13 > treshold ? significant_gain + index_13 + "\nSigma: " + tostring(sigma_13,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_13,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_13,"0.00") + "%\n\n" : "\n\n") : significant_gain

    weak_gain  := sigma_02 >= 0 and sigma_02 <= treshold ? weak_gain + index_02 + "\nSigma: " + tostring(sigma_02,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_02,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_02,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_03 >= 0 and sigma_03 <= treshold ? weak_gain + index_03 + "\nSigma: " + tostring(sigma_03,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_03,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_03,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_04 >= 0 and sigma_04 <= treshold ? weak_gain + index_04 + "\nSigma: " + tostring(sigma_04,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_04,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_04,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_05 >= 0 and sigma_05 <= treshold ? weak_gain + index_05 + "\nSigma: " + tostring(sigma_05,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_05,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_05,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_06 >= 0 and sigma_06 <= treshold ? weak_gain + index_06 + "\nSigma: " + tostring(sigma_06,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_06,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_06,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_07 >= 0 and sigma_07 <= treshold ? weak_gain + index_07 + "\nSigma: " + tostring(sigma_07,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_07,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_07,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_08 >= 0 and sigma_08 <= treshold ? weak_gain + index_08 + "\nSigma: " + tostring(sigma_08,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_08,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_08,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_09 >= 0 and sigma_09 <= treshold ? weak_gain + index_09 + "\nSigma: " + tostring(sigma_09,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_09,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_09,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_10 >= 0 and sigma_10 <= treshold ? weak_gain + index_10 + "\nSigma: " + tostring(sigma_10,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_10,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_10,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_11 >= 0 and sigma_11 <= treshold ? weak_gain + index_11 + "\nSigma: " + tostring(sigma_11,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_11,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_11,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_12 >= 0 and sigma_12 <= treshold ? weak_gain + index_12 + "\nSigma: " + tostring(sigma_12,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_12,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_12,"0.00") + "%\n\n" : "\n\n") : weak_gain
    weak_gain  := sigma_13 >= 0 and sigma_13 <= treshold ? weak_gain + index_13 + "\nSigma: " + tostring(sigma_13,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_13,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_13,"0.00") + "%\n\n" : "\n\n") : weak_gain

    significant_loss  := sigma_02 < -1*treshold ? significant_loss + index_02 + "\nSigma: " + tostring(sigma_02,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_02,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_02,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_03 < -1*treshold ? significant_loss + index_03 + "\nSigma: " + tostring(sigma_03,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_03,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_03,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_04 < -1*treshold ? significant_loss + index_04 + "\nSigma: " + tostring(sigma_04,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_04,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_04,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_05 < -1*treshold ? significant_loss + index_05 + "\nSigma: " + tostring(sigma_05,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_05,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_05,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_06 < -1*treshold ? significant_loss + index_06 + "\nSigma: " + tostring(sigma_06,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_06,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_06,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_07 < -1*treshold ? significant_loss + index_07 + "\nSigma: " + tostring(sigma_07,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_07,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_07,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_08 < -1*treshold ? significant_loss + index_08 + "\nSigma: " + tostring(sigma_08,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_08,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_08,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_09 < -1*treshold ? significant_loss + index_09 + "\nSigma: " + tostring(sigma_09,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_09,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_09,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_10 < -1*treshold ? significant_loss + index_10 + "\nSigma: " + tostring(sigma_10,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_10,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_10,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_11 < -1*treshold ? significant_loss + index_11 + "\nSigma: " + tostring(sigma_11,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_11,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_11,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_12 < -1*treshold ? significant_loss + index_12 + "\nSigma: " + tostring(sigma_12,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_12,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_12,"0.00") + "%\n\n" : "\n\n") : significant_loss
    significant_loss  := sigma_13 < -1*treshold ? significant_loss + index_13 + "\nSigma: " + tostring(sigma_13,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_13,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_13,"0.00") + "%\n\n" : "\n\n") : significant_loss

    weak_loss  := sigma_02 < 0 and sigma_02 >= -1*treshold ? weak_loss + index_02 + "\nSigma: " + tostring(sigma_02,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_02,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_02,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_03 < 0 and sigma_03 >= -1*treshold ? weak_loss + index_03 + "\nSigma: " + tostring(sigma_03,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_03,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_03,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_04 < 0 and sigma_04 >= -1*treshold ? weak_loss + index_04 + "\nSigma: " + tostring(sigma_04,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_04,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_04,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_05 < 0 and sigma_05 >= -1*treshold ? weak_loss + index_05 + "\nSigma: " + tostring(sigma_05,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_05,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_05,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_06 < 0 and sigma_06 >= -1*treshold ? weak_loss + index_06 + "\nSigma: " + tostring(sigma_06,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_06,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_06,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_07 < 0 and sigma_07 >= -1*treshold ? weak_loss + index_07 + "\nSigma: " + tostring(sigma_07,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_07,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_07,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_08 < 0 and sigma_08 >= -1*treshold ? weak_loss + index_08 + "\nSigma: " + tostring(sigma_08,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_08,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_08,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_09 < 0 and sigma_09 >= -1*treshold ? weak_loss + index_09 + "\nSigma: " + tostring(sigma_09,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_09,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_09,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_10 < 0 and sigma_10 >= -1*treshold ? weak_loss + index_10 + "\nSigma: " + tostring(sigma_10,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_10,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_10,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_11 < 0 and sigma_11 >= -1*treshold ? weak_loss + index_11 + "\nSigma: " + tostring(sigma_11,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_11,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_11,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_12 < 0 and sigma_12 >= -1*treshold ? weak_loss + index_12 + "\nSigma: " + tostring(sigma_12,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_12,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_12,"0.00") + "%\n\n" : "\n\n") : weak_loss
    weak_loss  := sigma_13 < 0 and sigma_13 >= -1*treshold ? weak_loss + index_13 + "\nSigma: " + tostring(sigma_13,"0.00") + (disp_ret ? txt_ret1 + tostring(ret_13,"0.00") + "%\n" + txt_ret2 + tostring(x_ret_13,"0.00") + "%\n\n" : "\n\n") : weak_loss

//--------------
// Prep Label Value
//--------------
SigWin      = "Sector with Significant Gain"    + brl
WeakWin     = "Sector with Average Gain"        + brl
SigLoss     = "Sector with Significant Loss"    + brl
WeakLoss    = "Sector with Average Loss"        + brl

SigWin      := SigWin   + (significant_gain != ""   ? significant_gain  : "Not Available")
WeakWin     := WeakWin  + (weak_gain != ""          ? weak_gain         : "Not Available")
SigLoss     := SigLoss  + (significant_loss != ""   ? significant_loss  : "Not Available")
WeakLoss    := WeakLoss + (weak_loss != ""          ? weak_loss         : "Not Available")

//--------------
// Draw Label
//--------------
// color setting
var lblclr   = #00000000
var sigG_col = txtclr == "Custom" ? #009900   : txtclr == "White" ? color.white : color.black
var weaG_col = txtclr == "Custom" ? #999900   : txtclr == "White" ? color.white : color.black
var weaL_col = txtclr == "Custom" ? #CC6600   : txtclr == "White" ? color.white : color.black
var sigL_col = txtclr == "Custom" ? color.red : txtclr == "White" ? color.white : color.black

// Thanks to LucF for label function
f_lineLabel(_text, _barsBack, _txtclr) =>
    var label _lbl = na
    if barstate.islast
        if na(_lbl)
            _lbl := label.new(bar_index[_barsBack], 100, xloc = xloc.bar_index, style = label.style_label_up, text = _text, textalign = text.align_left, color = lblclr, textcolor = _txtclr, size = size.normal)
            int(na)
        else
            label.set_x(_lbl, bar_index[_barsBack])
            label.set_text(_lbl, _text)
            int(na)

f_lineLabel(SigWin,   5+lblsize*1, sigG_col) 
f_lineLabel(WeakWin,  5+lblsize*2, weaG_col)
f_lineLabel(WeakLoss, 5+lblsize*3, weaL_col)
f_lineLabel(SigLoss,  5+lblsize*4, sigL_col)

label lbl_0  = label.new(bar_index, 100, xloc=xloc.bar_index,
  text      = benchmark,
  color     = lblclr, 
  style     = label.style_label_up, 
  textcolor = txtclr == "Custom" ? (sigma_01 > 0 ? #009900 : color.red) : txtclr == "White" ? color.white : color.black,
  size      = size.normal,
  textalign = text.align_left)
label.set_x(lbl_0, bar_index[0])
label.delete(lbl_0[1])

hline(100, color=#00000000), hline(10, color=#00000000)

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// REUSING THIS CODE: You are welcome to reuse this code without permission, including in closed-source publications, as long as proper credits are given :)
// Author: ©fareidzulkifli

// Description : 
// Mean Reversion Channel objective, based on Mean Reversion theory (everything has a tendency to revert back to its mean), is to help visualizing: 
//     Inner Channel -> Dynamic Support and Resistance 
//     Outer Channel -> Overbought/Oversold Zone which may signal consolidation phase or potential reversal due to unsustainable move

// The concept of this indicator oriiginally derived from Keltner Channel (The Keltner Channel was first introduced by Chester Keltner in the 1960s. The original formula used simple moving averages (SMA) and the high-low price range to calculate the bands. In the 1980s, a new formula was introduced that used ATR.)
// Instead if using SMA/EMA, this indicator used SuperSmoother MA as it's mean with longer lookback period (default to 200) to get more stable channel line. i also added second level so the indicator will have inner and outer channel
// Details of each filtering type used for mean calculation can be read in Ehlers Technical Papers: "Swiss Army Knife Indicator" and/or his book "Cybernetics Analysis for Stock and Futures"

// Disclaimer:
// Past performance is not an indicator of future results.
// My opinions are my own and do not constitute financial advice in any way whatsoever. 
// Nothing published by me constitutes an investment/trading recommendation, nor should any data or Content published by me be relied upon for any investment/trading activities.
// I strongly recommends that you perform your own independent research and/or speak with a qualified investment professional before making any financial decisions.

// Any ideas to further improve this indicator are welcome :)

//@version=4
study("Mean Reversion Channel - MRI Variant", shorttitle="MRC", overlay=true, format=format.inherit)

//************************************************************************************************************
// Parameter
//************************************************************************************************************

indiSet     = input(false,              "═════════ MRC Parameter ════════")
source      = input(hlc3,               title="Price Source", type=input.source)
type        = input("SuperSmoother",    title="Filter Type", options=["SuperSmoother", "Ehlers EMA", "Gaussian", "Butterworth", "BandStop", "SMA", "EMA", "RMA"])
length      = input(200,                title="Lookback Period",minval=1)
innermult   = input(1.0,                title="Inner Channel Size Multiplier", minval = 0.1)
outermult   = input(2.415,              title="Outer Channel Size Multiplier", minval = 0.1)

ChartSet    = input(false,              "═════════ Chart Setting ════════")
drawchannel = input(true,               title="Draw Channel")
displayzone = input(true,               title="Draw Zone (With Channel)")
zonetransp  = input(60,                 title="Zone Transparency", minval=0, maxval=100)
displayline = input(true,               title="Display Line Extension")

MTFSet      = input(false,              "═════════ MTF Setting ════════")
enable_mtf  = input(true,               title="Enable Multiple TimeFrame Analysis")
mtf_disp_typ= input("On Hover",         title="MTF Display Type", options=["Always Display", "On Hover"])
mtf_typ     = input("Auto",             title="Multiple TimeFrame Type", options=["Auto", "Custom"])
mtf_lvl1    = input("D",                title="Custom MTF Level 1", type=input.resolution)
mtf_lvl2    = input("W",                title="Custom MTF Level 2", type=input.resolution)

//************************************************************************************************************
// Functions Start {
//************************************************************************************************************
var pi          = 2 * asin(1)
var mult        = pi * innermult
var mult2       = pi * outermult
var gradsize    = 0.5
var gradtransp  = zonetransp

//-----------------------
// Ehler SwissArmyKnife Function
//-----------------------
SAK_smoothing(_type, _src, _length) =>
    c0          = 1.0 
    c1          = 0.0 
    b0          = 1.0 
    b1          = 0.0 
    b2          = 0.0 
    a1          = 0.0 
    a2          = 0.0 
    alpha       = 0.0 
    beta        = 0.0 
    gamma       = 0.0 
    cycle       = 2 * pi / _length
    
    if _type == "Ehlers EMA"
        alpha   := (cos(cycle) + sin(cycle) - 1) / cos(cycle)
        b0      := alpha
        a1      := 1 - alpha
    if _type == "Gaussian"
        beta    := 2.415 * (1 - cos(cycle))
        alpha   := -beta + sqrt((beta * beta) + (2 * beta))
        c0      := alpha * alpha
        a1      := 2 * (1 - alpha)
        a2      := -(1 - alpha) * (1 - alpha)
    if _type == "Butterworth"
        beta    := 2.415 * (1 - cos(cycle))
        alpha   := -beta + sqrt((beta * beta) + (2 * beta))
        c0      := alpha * alpha / 4
        b1      := 2
        b2      := 1
        a1      := 2 * (1 - alpha)
        a2      := -(1 - alpha) * (1 - alpha)
    if _type == "BandStop"
        beta    := cos(cycle)
        gamma   := 1 / cos(cycle*2*0.1) // delta default to 0.1. Acceptable delta -- 0.05<d<0.5
        alpha   := gamma - sqrt((gamma * gamma) - 1)
        c0      := (1 + alpha) / 2
        b1      := -2 * beta
        b2      := 1
        a1      := beta * (1 + alpha)
        a2      := -alpha
    if _type == "SMA"
        c1      := 1 / _length
        b0      := 1 / _length
        a1      := 1
    if _type == "EMA"
        alpha   := 2/(_length+1)
        b0      := alpha
        a1      := 1 - alpha
    if _type == "RMA"
        alpha   := 1 / _length
        b0      := alpha
        a1      := 1 - alpha

    _Input       = _src
    _Output      = 0.0
    _Output     := (c0 * ((b0 * _Input) + (b1 * nz(_Input[1])) + (b2 * nz(_Input[2])))) + (a1 * nz(_Output[1])) + (a2 * nz(_Output[2])) - (c1 * nz(_Input[_length])) 

//-----------------------
// SuperSmoother Function
//-----------------------
supersmoother(_src, _length) =>
    s_a1    = exp(-sqrt(2) * pi / _length)
    s_b1    = 2 * s_a1 * cos(sqrt(2) * pi / _length)
    s_c3    = -pow(s_a1, 2)
    s_c2    = s_b1
    s_c1    = 1 - s_c2 - s_c3
    ss      = 0.0
    ss     := s_c1 * _src + s_c2 * nz(ss[1], _src[1]) + s_c3 * nz(ss[2], _src[2])

//-----------------------
// Auto TimeFrame Function
//-----------------------
// ————— Converts current chart resolution into a float minutes value.
f_resInMinutes() => 
    _resInMinutes = timeframe.multiplier * (
      timeframe.isseconds ? 1. / 60             :
      timeframe.isminutes ? 1.                  :
      timeframe.isdaily   ? 60. * 24            :
      timeframe.isweekly  ? 60. * 24 * 7        :
      timeframe.ismonthly ? 60. * 24 * 30.4375  : na)

get_tf(_lvl)=>
    y = f_resInMinutes()
    z = timeframe.period
    if(mtf_typ=="Auto")
        if y < 1
            z := _lvl == 1 ? "1"   : _lvl == 2 ? "5"  : z
        else if y <= 3
            z := _lvl == 1 ? "5"   : _lvl == 2 ? "15" : z
        else if y <= 10
            z := _lvl == 1 ? "15"  : _lvl == 2 ? "60" : z
        else if y <= 30
            z := _lvl == 1 ? "60"  : _lvl == 2 ? "240" : z
        else if y <= 120
            z := _lvl == 1 ? "240" : _lvl == 2 ? "D"  : z
        else if y <= 240
            z := _lvl == 1 ? "D"   : _lvl == 2 ? "W"  : z
        else if y <= 1440
            z := _lvl == 1 ? "W"   : _lvl == 2 ? "M"  : z
        else if y <= 10080
            z := _lvl == 1 ? "M"   : z
        else
            z := z
    else
        z := _lvl == 1 ? mtf_lvl1   : _lvl == 2 ? mtf_lvl2 : z

    z

//-----------------------
// Mean Reversion Channel Function
//-----------------------
get_mrc()=>
    v_condition   = 0
    v_meanline    = source
    v_meanrange   = supersmoother(tr, length)
    
    //-- Get Line value
    if(type == "SuperSmoother")
        v_meanline    := supersmoother(source, length)
        
    if(type != "SuperSmoother")
        v_meanline    := SAK_smoothing(type, source, length)
        
    v_upband1 = v_meanline+(v_meanrange*mult)
    v_loband1 = v_meanline-(v_meanrange*mult)
    v_upband2 = v_meanline+(v_meanrange*mult2)
    v_loband2 = v_meanline-(v_meanrange*mult2)
    
    //-- Check Condition
    if(close > v_meanline)
        v_upband2_1 = v_upband2  + (v_meanrange * gradsize * 4)
        v_upband2_9 = v_upband2  + (v_meanrange * gradsize * -4)
        if(high >= v_upband2_9 and high < v_upband2)
            v_condition   := 1
        else if(high >= v_upband2 and high < v_upband2_1)
            v_condition   := 2
        else if(high >= v_upband2_1)
            v_condition   := 3
        else if(close <= v_meanline+v_meanrange)
            v_condition   := 4
        else
            v_condition   := 5

    if(close < v_meanline)
        v_loband2_1 = v_loband2  - (v_meanrange * gradsize * 4)
        v_loband2_9 = v_loband2  - (v_meanrange * gradsize * -4)
        if(low <= v_loband2_9 and low > v_loband2)
            v_condition   := -1
        else if(low <= v_loband2 and low > v_loband2_1)
            v_condition   := -2
        else if(low <= v_loband2_1)
            v_condition   := -3
        else if(close >= v_meanline+v_meanrange)
            v_condition   := -4
        else
            v_condition   := -5
            
    [v_meanline, v_meanrange, v_upband1, v_loband1, v_upband2, v_loband2, v_condition]

//-----------------------
// MTF Analysis
//-----------------------

get_stat(_cond) =>
    ret = "Price at Mean Line\n"
    if (_cond == 1)
        ret := "Overbought (Weak)\n"
    else if (_cond == 2)
        ret := "Overbought\n"
    else if (_cond == 3)
        ret := "Overbought (Strong)\n"
    else if (_cond == 4)
        ret := "Price Near Mean\n"
    else if (_cond == 5)
        ret := "Price Above Mean\n"
    else if (_cond == -1)
        ret := "Oversold (Weak)\n"
    else if (_cond == -2)
        ret := "Oversold\n"
    else if (_cond == -3)
        ret := "Oversold (Strong)\n"
    else if (_cond == -4)
        ret := "Price Near Mean\n"
    else if (_cond == -5)
        ret := "Price Below Mean\n"
    ret

//-----------------------
// Chart Drawing Function
//-----------------------
format_price(x) =>
    y = tostring(x, "0.00000")
    if(x>10)
        y := tostring(x, "0.000")
    if(x>1000)
        y := tostring(x, "0.00")
    y

f_PriceLine(_ref, linecol) =>
    line.new(
      x1     = bar_index, x2     = bar_index - 1,
      y1     = _ref,      y2     = _ref,
      extend = extend.left,
      color  = linecol)

f_MTFLabel(_txt, _yloc) =>
    label.new(
      x         = time + round(change(time)*20),
      y         = _yloc, 
      xloc      = xloc.bar_time, 
      text      = mtf_disp_typ == "Always Display" ? _txt : "Check MTF",
      tooltip   = mtf_disp_typ == "Always Display" ? ""   : _txt,
      color     = color.black, 
      textcolor = color.white,
      size      = size.normal, 
      style     = mtf_disp_typ == "On Hover" and displayline ? label.style_label_lower_left : label.style_label_left,
      textalign = text.align_left)

//} Function End

//************************************************************************************************************
// Calculate Channel
//************************************************************************************************************
var tf_0 = timeframe.period
var tf_1 = get_tf(1)
var tf_2 = get_tf(2)

[meanline, meanrange, upband1, loband1, upband2, loband2, condition]                                    = get_mrc()
[mtf1_meanline, mtf1_meanrange, mtf1_upband1, mtf1_loband1, mtf1_upband2, mtf1_loband2, mtf1_condition] = security(syminfo.tickerid, tf_1, get_mrc())
[mtf2_meanline, mtf2_meanrange, mtf2_upband1, mtf2_loband1, mtf2_upband2, mtf2_loband2, mtf2_condition] = security(syminfo.tickerid, tf_2, get_mrc())

//************************************************************************************************************
// Drawing Start {
//************************************************************************************************************
float p_meanline  = drawchannel ? meanline   : na
float p_upband1   = drawchannel ? upband1    : na
float p_loband1   = drawchannel ? loband1    : na
float p_upband2   = drawchannel ? upband2    : na
float p_loband2   = drawchannel ? loband2    : na

z  = plot(p_meanline, color=#FFCD00,     style=plot.style_line,    title=" Mean", linewidth=2)
x1 = plot(p_upband1,  color=color.green, style=plot.style_circles, title=" R1", linewidth=1, transp=50)
x2 = plot(p_loband1,  color=color.green, style=plot.style_circles, title=" S1", linewidth=1, transp=50)
y1 = plot(p_upband2,  color=color.red,   style=plot.style_line,    title=" R2", linewidth=1, transp=50)
y2 = plot(p_loband2,  color=color.red,   style=plot.style_line,    title=" S2", linewidth=1, transp=50)

//-----------------------
// Draw zone
//-----------------------
//---
var color1 = #FF0000, var color2 = #FF4200, var color3 = #FF5D00, var color4 = #FF7400, var color5 = #FF9700, var color6 = #FFAE00, var color7 = #FFC500, var color8 = #FFCD00
//---
float upband2_1 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * 4)  : na, float loband2_1 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * 4)  : na
float upband2_2 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * 3)  : na, float loband2_2 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * 3)  : na
float upband2_3 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * 2)  : na, float loband2_3 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * 2)  : na
float upband2_4 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * 1)  : na, float loband2_4 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * 1)  : na
float upband2_5 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * 0)  : na, float loband2_5 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * 0)  : na
float upband2_6 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * -1) : na, float loband2_6 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * -1) : na
float upband2_7 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * -2) : na, float loband2_7 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * -2) : na
float upband2_8 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * -3) : na, float loband2_8 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * -3) : na
float upband2_9 = drawchannel and displayzone ? upband2 + (meanrange * gradsize * -4) : na, float loband2_9 = drawchannel and displayzone ? loband2 - (meanrange * gradsize * -4) : na

//---
plot_upband2_1 = plot(upband2_1, color=na, transp=100, display=display.none), plot_loband2_1 = plot(loband2_1, color=na, transp=100, display=display.none)
plot_upband2_2 = plot(upband2_2, color=na, transp=100, display=display.none), plot_loband2_2 = plot(loband2_2, color=na, transp=100, display=display.none)
plot_upband2_3 = plot(upband2_3, color=na, transp=100, display=display.none), plot_loband2_3 = plot(loband2_3, color=na, transp=100, display=display.none)
plot_upband2_4 = plot(upband2_4, color=na, transp=100, display=display.none), plot_loband2_4 = plot(loband2_4, color=na, transp=100, display=display.none)
plot_upband2_5 = plot(upband2_5, color=na, transp=100, display=display.none), plot_loband2_5 = plot(loband2_5, color=na, transp=100, display=display.none)
plot_upband2_6 = plot(upband2_6, color=na, transp=100, display=display.none), plot_loband2_6 = plot(loband2_6, color=na, transp=100, display=display.none)
plot_upband2_7 = plot(upband2_7, color=na, transp=100, display=display.none), plot_loband2_7 = plot(loband2_7, color=na, transp=100, display=display.none)
plot_upband2_8 = plot(upband2_8, color=na, transp=100, display=display.none), plot_loband2_8 = plot(loband2_8, color=na, transp=100, display=display.none)
plot_upband2_9 = plot(upband2_9, color=na, transp=100, display=display.none), plot_loband2_9 = plot(loband2_9, color=na, transp=100, display=display.none)

//---
fill(plot_upband2_1,plot_upband2_2, color=color1, transp=gradtransp), fill(plot_loband2_1,plot_loband2_2, color=color1, transp=gradtransp)
fill(plot_upband2_2,plot_upband2_3, color=color2, transp=gradtransp), fill(plot_loband2_2,plot_loband2_3, color=color2, transp=gradtransp)
fill(plot_upband2_3,plot_upband2_4, color=color3, transp=gradtransp), fill(plot_loband2_3,plot_loband2_4, color=color3, transp=gradtransp)
fill(plot_upband2_4,plot_upband2_5, color=color4, transp=gradtransp), fill(plot_loband2_4,plot_loband2_5, color=color4, transp=gradtransp)
fill(plot_upband2_5,plot_upband2_6, color=color5, transp=gradtransp), fill(plot_loband2_5,plot_loband2_6, color=color5, transp=gradtransp)
fill(plot_upband2_6,plot_upband2_7, color=color6, transp=gradtransp), fill(plot_loband2_6,plot_loband2_7, color=color6, transp=gradtransp)
fill(plot_upband2_7,plot_upband2_8, color=color7, transp=gradtransp), fill(plot_loband2_7,plot_loband2_8, color=color7, transp=gradtransp)
fill(plot_upband2_8,plot_upband2_9, color=color8, transp=gradtransp), fill(plot_loband2_8,plot_loband2_9, color=color8, transp=gradtransp)

//-----------------------
// Plot Extension
//-----------------------
if(displayline and enable_mtf and mtf_disp_typ == "Always Display")
    displayline := false
    
var line mean = na, line.delete(mean), mean := displayline ? f_PriceLine(meanline, #FFCD00)     : na
var line res1 = na, line.delete(res1), res1 := displayline ? f_PriceLine(upband1,  color.green) : na
var line sup1 = na, line.delete(sup1), sup1 := displayline ? f_PriceLine(loband1,  color.green) : na
var line res2 = na, line.delete(res2), res2 := displayline ? f_PriceLine(upband2,  color.red)   : na
var line sup2 = na, line.delete(sup2), sup2 := displayline ? f_PriceLine(loband2,  color.red)   : na

//--------------
// Prep MTF Label
//--------------
var brl         = "\n--------------------------------------"
dist_0          = "Distance from Mean: "+ tostring(((close-meanline)/close)*100, "#.##") + " %"
dist_1          = "Distance from Mean: "+ tostring(((close-mtf1_meanline)/close)*100, "#.##") + " %"
dist_2          = "Distance from Mean: "+ tostring(((close-mtf2_meanline)/close)*100, "#.##") + " %"

var title   = "Mean Reversion Channel\nMultiple TimeFrame Analysis" + brl
tf0 = 
      "\n\nTimeframe: "+ tf_0 + " (Current)\n\nStatus: " + get_stat(condition) + dist_0 + brl

tf1 = not timeframe.ismonthly ? 
      "\n\nTimeframe: "+ tf_1 + "\n\nStatus: " + get_stat(mtf1_condition) + dist_1 + brl : ""

tf2 = not timeframe.isweekly and not timeframe.ismonthly ? 
      "\n\nTimeframe: "+ tf_2 + "\n\nStatus: " + get_stat(mtf2_condition) + dist_2 + brl : ""

mtf_lbl = title+tf0+tf1+tf2
var label label_mtf = na, label.delete(label_mtf), label_mtf := enable_mtf ? f_MTFLabel(mtf_lbl, meanline) : na

//} Drawing End

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fareidzulkifli

//@version=4
study("Non-Rescaled RSI", overlay=false)

section1        = input(false,  "═════════ RSI ════════")
src             = input(close,  title="Price Source")
rsilen          = input(14,     title="Length", minval=1)
ob              = input(70,     title="Overbought Line", minval=1, maxval=100)
os              = input(30,     title="Overbought Line", minval=1, maxval=100)
section2        = input(false,  "═════════ Additional Setting ════════")
displaylbl      = input(true,   title="Display RSI Label")
cap             = input(20,     title="Ratio Cap", minval=2, maxval=30)
rsicol          = input("CSS3", title="RSI Color", options=["CSS1","CSS2","CSS3","CSS4"])

// ----------
// Function
// ----------
get_rs(val)=> res = (100/(100-val))-1 //--> rsi = 100 - (100 / (1 + up / down)) <==> up/down = (100/(100-rsi))-1

// ----------
// Calculate
// ----------
rsi  = rsi(src, rsilen)
up   = rma(max(change(src), 0), rsilen)
down = rma(-min(change(src), 0), rsilen)
rs   = up/down

prsi = 
  down == 0 ? cap         : 
  up   == 0 ? -cap        : 
  rs   == 1 ? 0.0         : 
  rs   >  1 ? min(rs,cap) : max(-1/rs,-cap) 

// ----------
// Gradient Color
// ----------
var css1=array.new_color(na), var css2=array.new_color(na), var css3=array.new_color(na), var css4=array.new_color(na)
if barstate.isfirst
    array.push(css1, #80000010), array.push(css1, #8000001f), array.push(css1, #8000002f), array.push(css1, #8000003f), array.push(css1, #8000004f), array.push(css1, #8000005f), array.push(css1, #8000006f), array.push(css1, #8000007f), array.push(css1, #8000008f), array.push(css1, #8000009f), array.push(css1, #800000af), array.push(css1, #800000cf), array.push(css1, #800000df), array.push(css1, #800000ef), array.push(css1, #800000ff), array.push(css1, #008000ff), array.push(css1, #008000ef), array.push(css1, #008000df), array.push(css1, #008000cf), array.push(css1, #008000bf), array.push(css1, #008000af), array.push(css1, #0080009f), array.push(css1, #0080008f), array.push(css1, #0080007f), array.push(css1, #0080006f), array.push(css1, #0080005f), array.push(css1, #0080004f), array.push(css1, #0080003f), array.push(css1, #0080002f), array.push(css1, #0080001f), array.push(css1, #00800010), 
    array.push(css2, #E50003), array.push(css2, #E30D00), array.push(css2, #E12100), array.push(css2, #DF3500), array.push(css2, #DD4800), array.push(css2, #DB5B00), array.push(css2, #D96E00), array.push(css2, #D78000), array.push(css2, #D59200), array.push(css2, #D3A400), array.push(css2, #D1B500), array.push(css2, #CFC600), array.push(css2, #C2CD00), array.push(css2, #AECB00), array.push(css2, #9AC900), array.push(css2, #87C700), array.push(css2, #74C500), array.push(css2, #61C300), array.push(css2, #4FC100), array.push(css2, #3DBF00), 
    array.push(css3, #E50000), array.push(css3, #D8020A), array.push(css3, #CC0414), array.push(css3, #C0071E), array.push(css3, #B40928), array.push(css3, #A80B32), array.push(css3, #9C0E3C), array.push(css3, #901046), array.push(css3, #841250), array.push(css3, #78155A), array.push(css3, #6C1764), array.push(css3, #601A6E), array.push(css3, #541C78), array.push(css3, #481E82), array.push(css3, #3C218C), array.push(css3, #302396), array.push(css3, #2425A0), array.push(css3, #1828AA), array.push(css3, #0C2AB4), array.push(css3, #002DBF), 
    array.push(css4, #002DBF), array.push(css4, #0D38C2), array.push(css4, #1A43C5), array.push(css4, #284EC9), array.push(css4, #3559CC), array.push(css4, #4364CF), array.push(css4, #506FD3), array.push(css4, #5D7AD6), array.push(css4, #6B85D9), array.push(css4, #7890DD), array.push(css4, #869BE0), array.push(css4, #93A6E4), array.push(css4, #A1B1E7), array.push(css4, #AEBCEA), array.push(css4, #BBC7EE), array.push(css4, #C9D2F1), array.push(css4, #D6DDF4), array.push(css4, #E4E8F8), array.push(css4, #F1F3FB), array.push(css4, #FFFFFF), 

clr = 
  rsicol=="CSS1" ? array.get(css1,round(rsi*0.29)) : 
  rsicol=="CSS2" ? array.get(css2,round(rsi*0.19)) : 
  rsicol=="CSS3" ? array.get(css3,round(rsi*0.19)) : 
  rsicol=="CSS4" ? array.get(css4,round(rsi*0.19)) : 
  na

// ----------
// Plot RS/OB/OS line
// ----------
hline(0)
var line line1 = na, line.delete(line1), line1 := line.new(x1 = bar_index, y1 = min(get_rs(ob),cap),     x2 = bar_index - 1, y2 = min(get_rs(ob),cap),     extend = extend.both, color = color.blue,  width = 1, style = line.style_dashed)
var line line2 = na, line.delete(line2), line2 := line.new(x1 = bar_index, y1 = max(-1/get_rs(os),-cap), x2 = bar_index - 1, y2 = max(-1/get_rs(os),-cap), extend = extend.both, color = color.blue,  width = 1, style = line.style_dashed)
var label lbl1 = na, label.delete(lbl1), lbl1  := displaylbl ? label.new(x=bar_index, y=prsi, xloc=xloc.bar_index, text ="RSI: "+tostring(rsi, "#.##")+"\nRelative\nStrength: "+tostring(prsi, "#.##"), color = #00000000, textcolor = clr, size = size.normal, style = label.style_label_left, textalign = text.align_left) : na
plot(prsi, title="RSI", style=plot.style_line, linewidth=2, color = clr)

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fareidzulkifli

//@version=4
study(title="[Pro] Dashboard", shorttitle="[Pro] Dashboard", overlay = true, max_bars_back=800) 

// ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼
// Parameters
// ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

col1    = "No",             col2     = "Yes",
txt_sz1 = "Large",          txt_sz2  = "Normal",         txt_sz3  = "Small"
_n      = "No",             _y       = "Yes"
line1   = "1",              line2    = "2",              line3    = "3",        line4    = "4"
typ1    = "Solid",          typ2     = "Dashed",         typ3     = "Dotted"
ext1    = "Don't Extend",   ext2     = "Extend Left"

grp0    = "Table Settings"
grp1    = "Chart Assistance"
grp2    = "Content Settings"
grp3    = "Styling"

help1   = "Highlight row if current price near key levels\nGreen if above level\nRed if below level"
help2   = "Based on Gann Square of 9"

in_theme    = input("Light",    title = "Theme",                            group=grp0, inline="pnl1", options=["Light", "Dark"])
in_color    = input(col1,       title = "Highlight",                        group=grp0, inline="pnl1", options=[col1, col2], tooltip=help1)
in_size     = input(txt_sz2,    title = "Size ",                            group=grp0, inline="pnl2", options=[txt_sz1, txt_sz2, txt_sz3])
in_loc      = input("Top",      title = "Position ",                        group=grp0, inline="pnl2", options=["Top", "Bottom"])
in_gap      = input(0,          title = "Gap ",                             group=grp0, inline="pnl3", minval = 0, maxval = 7, tooltip="Increase the gap between Dashboard and Right Panel")

disp_mark   = input(true,       title = "Display Swing High/Low",           group=grp1)

disp_vol    = input(true,       title = "Display Volume & Volatility",      group=grp2)
vol_typ     = input(_n,         title = "    Display as DNV",               group=grp2, options=[_y, _n], tooltip="Dollar Normalized Volume\nPrice * Volume")
vol_triv    = input(_n,         title = "    Display Volume & Average",     group=grp2, options=[_y, _n])
atr_triv    = input(_n,         title = "    Display ATR & Volatility",     group=grp2, options=[_y, _n])
vol_len     = input(20,         title = "    Avg Volume Length",            group=grp2)
atr_len     = input(14,         title = "    ATR Length",                   group=grp2)

disp_ta    = input(true,        title = "Display Trend Analysis",           group=grp2)
disp_risk  = input(_y,          title = "    Short-term Risk",              inline  = "risk", group=grp2, options=[_y, _n])
disp_ocl   = input(_y,          title = "    Trend Estimator",              inline  = "ocl",  group=grp2, options=[_y, _n])
disp_ocl_l = input(_n,          title = "      Draw Channel (L)",           group=grp2, options=[_y, _n], tooltip="Longterm Regression Channel\nWARNING: Channel repaint on each new bar.\nChannel used for determining Trend Direction\nDO NOT use as S/R levels")
disp_ocl_m = input(_n,          title = "      Draw Channel (M)",           group=grp2, options=[_y, _n], tooltip="Midterm Regression Channel\nWARNING: Channel repaint on each new bar.\nChannel used for determining Trend Direction\nDO NOT use as S/R levels")
disp_ocl_s = input(_n,          title = "      Draw Channel (S)",           group=grp2, options=[_y, _n], tooltip="Shortterm Regression Channel\nWARNING: Channel repaint on each new bar.\nChannel used for determining Trend Direction\nDO NOT use as S/R levels")
disp_tplus = input(_y,          title = "    T+        ",                   inline  = "T+", group=grp2, options=[_y, _n])

disp_trnd   = input(false,      title = "Display MA Distance",              group=grp2)
reverse_dist= input(_n,         title="    Reverse Distance Calculation",   options = [_y, _n],     group=grp2, tooltip="If Reverse is Yes, Calculation will be based on Price instead of MA")
MAtype      = input("%",        title="    Display Type    ",               options = ["%", "ATR"], group=grp2)

MA1type     = input("MA",       title="    MA 1",                           options = ["MA","EMA","WMA","RMA","VWMA", "Super Smoother"], inline=line1, group=grp2)
MA1len      = input(20,         title="",                                   inline  = line1, group=grp2) 
disp_ma1    = input(false,      title="",                                   inline  = line1, group=grp2)
MA2type     = input("MA",       title="    MA 2",                           options = ["MA","EMA","WMA","RMA","VWMA", "Super Smoother"], inline=line2, group=grp2)
MA2len      = input(50,         title="",                                   inline  = line2, group=grp2)
disp_ma2    = input(false,      title="",                                   inline  = line2, group=grp2)
MA3type     = input("MA",       title="    MA 3",                           options = ["MA","EMA","WMA","RMA","VWMA", "Super Smoother"], inline=line3, group=grp2)
MA3len      = input(200,        title="",                                   inline  = line3, group=grp2)
disp_ma3    = input(false,      title="",                                   inline  = line3, group=grp2)

MA4type     = input("MA",       title="    MA 4",                           options = ["MA","EMA","WMA","RMA","VWMA", "Super Smoother"], inline=line4, group=grp2)
MA4len      = input(150,        title="",                                   inline  = line4, group=grp2)
disp_ma4    = input(false,      title="",                                   inline  = line4, group=grp2)
show_ma4    = input(_n,         title="    *Show MA 4 in Panel",            group = grp2, options=[_y, _n])

disp_key    = input(false,      title = "Display Key Levels",               group=grp2)
disp_52w    = input(_y,         title = "    Show 52 Weeks",                inline  = "52w", group=grp2, options=[_y, _n])
disp_52wl   = input(false,      title = "",                                 inline  = "52w", group=grp2)
disp_gan    = input(_y,         title = "    Show Gann  ",                  inline  = "gan", group=grp2, options=[_y, _n])
disp_ganl   = input(false,      title = "",                                 inline  = "gan", group=grp2)

disp_cl     = input(false,      title = "Display CutLoss Levels",           group=grp2)
var allow_short = _n
in_pctcl    = input(10,         title = "    CL in %",                      group=grp2, minval=1., maxval=99.9)
in_atrcl    = input(2.,         title = "    CL in ATR Multiplier",         group=grp2, minval=0.2, maxval=10)
disp_cal    = input(_y,         title = "  Show Lot Calculator?",           group=grp2, options = [_y, _n])
in_caltype  = input("%",        title = "    Risk Based on: ",              group=grp2, options = ["%", "ATR"])
in_calamt   = input(1000.,      title = "    Risk Per Trade (RM):",         group=grp2, minval=50.)
in_calres   = input("Lot",      title = "    Show As:",                     group=grp2, options = ["Lot", "Unit"])
in_callot   = input(100,        title = "    Unit per Lot:",                group=grp2, minval=1)

ma1_pcol    = input(color.new(color.green, 0),  title="MA 1 Color        ",         group=grp3)
ma2_pcol    = input(color.new(color.blue, 0),   title="MA 2 Color        ",         group=grp3)
ma3_pcol    = input(color.new(color.red, 0),    title="MA 3 Color        ",         group=grp3)
ma4_pcol    = input(color.new(color.orange, 0), title="MA 4 Color        ",         group=grp3)

w52_sty     = input(typ1,                       title="52 Week Line        ",        inline = "52w style",  group=grp3, options=[typ1, typ2, typ3])
w52_col     = input(color.new(color.orange, 0), title="",                   inline = "52w style",  group=grp3)

gann_no     = input(3,                          title="Gann Line No",       inline  = "gannsty", group=grp3, minval=1, maxval=10)
gann_sty    = input(ext1,                       title="",                   inline  = "gannsty", group=grp3, options=[ext1, ext2])
gann_col    = input(color.new(color.aqua, 0),   title="",                   inline  = "gannsty", group=grp3)

// ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼
// Variables
// ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

//------------------------------
var t_demo      = in_loc    == "Top"    ? position.bottom_right    : position.top_right
var proversion  = true
var isdemo      = false
if barstate.isfirst and proversion==false
    if syminfo.type == "stock" and timeframe.period=='240'
        isdemo  := true
    else if timeframe.period == "30"
        isdemo  := true
    else
        isdemo  := false
    
    proversion:=isdemo

//------------------------------

var dark        = in_theme  == "Dark"   ? true                  : false
var text_size   = in_size   == txt_sz1  ? size.normal           : in_size == txt_sz2 ? size.small : size.tiny
var t_position  = in_loc    == "Top"    ? position.top_right    : position.bottom_right

var cardinal    = line.style_solid
var ordinal     = line.style_dotted
var gann_ext    = gann_sty == ext1 ? extend.none : extend.left
var w52_lsty    = w52_sty  == typ1 ? line.style_solid : w52_sty  == typ2 ? line.style_dashed : line.style_dotted

var transp      = in_color==col2 ? 80 : 100
var red         = #FF0000
var green       = #006600
if(barstate.isfirst and dark)
    red     := #FF3333
    green   := #00CC00

var head_col    = dark ? color.white : color.white
var head_bgc    = dark ? color.black : color.black
var text_col    = dark ? color.white : color.black

var disp_key2   = disp_52w==_y or disp_gan==_y

var ma1_txt     = MA1type +" "+ tostring(MA1len)
var ma2_txt     = MA2type +" "+ tostring(MA2len)
var ma3_txt     = MA3type +" "+ tostring(MA3len)
var ma4_txt     = MA4type +" "+ tostring(MA4len)

var arrow_up    = " ▲"
var arrow_dn    = " ▼"

var line_list   = array.new_line()
var lbl_list    = array.new_label()

//Swing Marked Price
var markedprice = array.new_label()

var marked_base  = 9
var marked_len  = 9
var float  cp   = 0.0   //current pivot price
var string cs   = ""    //current swing type
var float  lh   = 0.0   // last high
var float  ll   = 0.0   // last low

bool sh_ = na
bool sl_ = na

// ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼
// Functions
// ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

get_hi(len)=>
    x = highest(high, len)

get_lo(len)=>
    x = lowest(low, len)
    
get_52w_hi()=>
    security(syminfo.tickerid, "W", get_hi(52))

get_52w_lo()=>
    security(syminfo.tickerid, "W", get_lo(52))

f_norm(_val, _min, _max)=>
    (_val-_min) / (_max-_min)

//-----------------------
// SuperSmoother Function
//-----------------------
supersmoother(_src, _length) =>
    s_a1    = exp(-sqrt(2) * math.pi / _length)
    s_b1    = 2 * s_a1 * cos(sqrt(2) * math.pi / _length)
    s_c3    = -pow(s_a1, 2)
    s_c2    = s_b1
    s_c1    = 1 - s_c2 - s_c3
    ss      = 0.0
    ss     := s_c1 * _src + s_c2 * nz(ss[1], _src[1]) + s_c3 * nz(ss[2], _src[2])

get_MA(typ, len) =>
    float maVal = na
    if (typ == "EMA")
        maVal := ema(close, len)
    else if (typ == "MA")
        maVal := sma(close, len)
    else if (typ == "WMA")
        maVal := wma(close, len)
    else if (typ == "RMA")
        maVal := rma(close, len)
    else if (typ == "VWMA")
        maVal := vwma(close, len)
    else if(typ  == "Super Smoother")
        maVal := supersmoother(close, len)
    maVal

get_dist(_val, _typ, _atr)=>
    float dist = na
    if(_typ == "%")
        dist    := (close-_val) / (reverse_dist==_y ? close : _val)
    if(_typ == "ATR")
        dist    := abs((close-_val)) / _atr
    dist    

check_col(_val, _typ)=>
    float atr    = atr(14)
    int   res    = 0 //0-None 1-Green(Above) 2-Red(Below)
    bool  above  = false
    bool  below  = false
    
    if(in_color==col2)
        if(_typ=="Tick")
            // above   := close >  _val and close <= _val+(syminfo.mintick * 2)
            // below   := close <= _val and close >= _val-(syminfo.mintick * 2)
            above   := close >  _val and close <= _val+(atr*0.5)
            below   := close <= _val and close >= _val-(atr*0.5)

        if(_typ=="ATR")
            above   := close >  _val and close <= _val+(atr)
            below   := close <= _val and close >= _val-(atr)
        if(_typ=="52w")
            above   := _val >= 0.8
            below   := _val <= 0.2
            
        res := above ? 1 : below ? 2 : 0
    res

f_line(_val, _ext, _col, _style)=>
    line l = line.new(x1  = max(bar_index-70, 0), x2 = bar_index+10, xloc=xloc.bar_index, y1 = _val, y2 = _val, 
              style  = _style, 
              extend = _ext, 
              color  = _col)

f_label(_txt, _yloc, _col) =>
    label l2 = label.new(
                  x         = bar_index+10, xloc = xloc.bar_index, y = _yloc, 
                  text      = _txt,
                  color     = #00000000, 
                  textcolor = _col,
                  size      = text_size, 
                  style     = label.style_label_left,
                  textalign = text.align_left)

get_channel(src, _len)=>
    intercept=0., endy=0., dev=0., slope=0.

    mid         = sum(src, _len) / _len
    slope       := linreg(src, _len, 0) - linreg(src, _len, 1)
        
    if(disp_ocl==_y and barstate.islast)

        intercept   := mid - slope * floor(_len / 2) + ((1 - (_len % 2)) / 2) * slope
        endy        := intercept  + slope * (_len - 1)
        
        for x = 0 to _len - 1
            dev := dev + pow(src[x] - (slope * (_len - x) + intercept), 2)
        
        dev         := sqrt(dev/_len)
        
    [intercept, endy, dev, slope]


isbetween(n,min,max)=>
    bool return = n>=min and n<=max ? true : na

f_degree(src, len, ref_len)=>
    mid     = sum(src, len) / len
    slope   = linreg(src, len, 0) - linreg(src, len, 1)
    y1      = mid - slope * floor(len / 2) + ((1 - (len % 2)) / 2) * slope
    y2      = y1  + slope * (len - 1)
    h       = highest(high, ref_len)
    l       = lowest(low, ref_len)
    
    dx1     = f_norm(0, 0, ref_len)
    dx2     = f_norm(len, 0, ref_len)
    dy1     = f_norm(y1, l, h)
    dy2     = f_norm(y2, l, h)
    degree  = todegrees(atan((dy2 - dy1)/(dx2-dx1)))
    degree

f_label_markedprice(_y, _type, _atrmult, _chg)=>
    sgn     = _type == "H" ? 1 : -1
    pct_chg = _chg ? ("("+(_chg>=0?"+":"")+tostring(_chg, format.percent)+")") : ""
    price   = tostring(_y, format.mintick)
    
    label.new(
      x         = bar_index-marked_len, 
      y         = _y + (_atrmult*sgn), 
      text      = price +"\n"+ pct_chg,
      xloc      = xloc.bar_index, 
      yloc      = yloc.price, 
      color     = color.new(color.gray, 100), 
      style     = _type=="H" ? label.style_label_down : label.style_label_up, 
      textcolor = dark ? color.white : color.black,
      size      = size.small)

// ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼
// Prepare Data
// ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

//-----------------------------------------
// Volume & Volatility
//-----------------------------------------
_volume         = vol_typ==_y ? volume*close : volume
_voltxt         = vol_typ==_y ? "DNV"        : "Volume"
float rel_vol   = na
float bts_vol   = na
float atr       = atr(atr_len)
float a_atr     = rma(atr,7)
float avg_vol   = sma(_volume[1],vol_len)
float vprice    = na

ud_len   = timeframe.isweekly ? min(bar_index, 10) : min(bar_index, 50)
upvol    = sum(close>=open ? nz(_volume) : 0, max(ud_len,1))
dnvol    = sum(close<open  ? nz(_volume) : 0, max(ud_len,1))

if(volume)
    rel_vol := _volume/avg_vol
    vprice  := avg_vol
    bts_vol := upvol/dnvol

atr_p       = " (" + tostring(atr/close[1], "0.00%") + ")"
volatility  = atr > a_atr ? "Increasing" : "Decreasing"

//-----------------------------------------
// MA Distance
//-----------------------------------------

MA1     = get_MA(MA1type, MA1len)
MA2     = get_MA(MA2type, MA2len)
MA3     = get_MA(MA3type, MA3len)
MA4     = get_MA(MA4type, MA4len)

string ma1_dir = na
string ma2_dir = na
string ma3_dir = na
string ma4_dir = na

ma1_dir := close > MA1 ? arrow_up : close < MA1 ? arrow_dn : ma1_dir[1]
ma2_dir := close > MA2 ? arrow_up : close < MA2 ? arrow_dn : ma2_dir[1]
ma3_dir := close > MA3 ? arrow_up : close < MA3 ? arrow_dn : ma3_dir[1]
ma4_dir := close > MA4 ? arrow_up : close < MA4 ? arrow_dn : ma4_dir[1]

ma1dist = get_dist(MA1, MAtype, atr)
ma2dist = get_dist(MA2, MAtype, atr)
ma3dist = get_dist(MA3, MAtype, atr)
ma4dist = get_dist(MA4, MAtype, atr)

string dist1_text = na
string dist2_text = na
string dist3_text = na
string dist4_text = na

if(MAtype == "%")
    dist1_text  := tostring(ma1dist, "0.##%") + ma1_dir
    dist2_text  := tostring(ma2dist, "0.##%") + ma2_dir
    dist3_text  := tostring(ma3dist, "0.##%") + ma3_dir
    dist4_text  := tostring(ma4dist, "0.##%") + ma4_dir
if(MAtype == "ATR")
    dist1_text  := tostring(ma1dist, format.mintick) + " ATR" + ma1_dir
    dist2_text  := tostring(ma2dist, format.mintick) + " ATR" + ma2_dir
    dist3_text  := tostring(ma3dist, format.mintick) + " ATR" + ma3_dir
    dist4_text  := tostring(ma4dist, format.mintick) + " ATR" + ma4_dir

//-----------------------------------------
// Key Level
//-----------------------------------------

// .............
// 52 Week
// .............

float hi52      = get_52w_hi()
float hi52pct   = (hi52-close) / close

float lo52      = get_52w_lo()
float lo52pct   = (close-lo52) / close

float pct52     = (close-lo52) / (hi52-lo52) 

// .............
// Gann
// .............

denomenator=0.0
if barstate.islast
    if close >= 10000
        denomenator :=0.01
    else if close >= 1000
        denomenator :=0.1
    else if close >= 100
        denomenator :=1
    else if close >=10
        denomenator :=10
    else if close >=0.05
        denomenator :=100
    else 
        denomenator :=1000
        
mult    = denomenator //close<100 ? 100 : 1
src     = close*mult

var table_size      = 1200
var gann_table      = array.new_float()

int r_loc = na, int s_loc = na

// Generate Gann Table 

//--Initial value
val         = 1
increment   = 1
diag_check  = 3

if(barstate.isfirst)
    array.push(gann_table, 1)
    for cnt = 0 to table_size-1
        val := val+increment
        array.push(gann_table, val)
        if(val==pow(diag_check,2))
            increment   += 1
            diag_check  += 2

string set_gann = na
set_gann := close > close[1] ? "R" : close < close[1] ? "S" : set_gann[1]

// Gann Calculation
if barstate.islast
    int   idx = array.indexof(gann_table, src)
    float tmp = 0
    
    // if src==gann
    if(idx!=-1)
        if(set_gann=="R")
            r_loc := idx
            s_loc := idx-1 < 0 ? na : idx-1
        if(set_gann=="S")
            r_loc := idx+1
            s_loc := idx
    else 
        for cnt = 0 to (array.size(gann_table)-1)
            
            tmp := array.get(gann_table, cnt)
            if(tmp>src and not r_loc)
                r_loc := cnt
                s_loc := cnt-1

r_list  = array.new_float()
s_list  = array.new_float()

r_txt   = array.new_string()
s_txt   = array.new_string()

var totalline = gann_no
for i=0 to totalline-1
    float r_val = r_loc + i < 0 or r_loc + i > table_size-1 ? na : round_to_mintick(array.get(gann_table, r_loc + i)/mult)
    float s_val = s_loc - i < 0 or s_loc - i > table_size-1 ? na : round_to_mintick(array.get(gann_table, s_loc - i)/mult)

    if(r_val)
        array.push(r_list, r_val)
        array.push(r_txt, "R"+tostring(i+1, "# ("))
    if(s_val)
        array.push(s_list, s_val)
        array.push(s_txt, "S"+tostring(i+1, "# ("))

float   gann_r2     = r_loc + 1 < 0 or r_loc + 1 > table_size-1 ? na : round_to_mintick(array.get(gann_table, r_loc + 1)/mult)
float   gann_r1     = r_loc + 0 < 0 or r_loc + 0 > table_size-1 ? na : round_to_mintick(array.get(gann_table, r_loc + 0)/mult)
float   gann_s1     = s_loc - 0 < 0 or s_loc - 0 > table_size-1 ? na : round_to_mintick(array.get(gann_table, s_loc - 0)/mult)
float   gann_s2     = s_loc - 1 < 0 or s_loc - 1 > table_size-1 ? na : round_to_mintick(array.get(gann_table, s_loc - 1)/mult)

string r2_dist      = na(gann_r2) ? na : " (" + tostring(((gann_r2 - close)/close)*100, format.percent) + ")"
string r1_dist      = na(gann_r1) ? na : " (" + tostring(((gann_r1 - close)/close)*100, format.percent) + ")"
string s1_dist      = na(gann_s1) ? na : " (" + tostring(((gann_s1 - close)/close)*100, format.percent) + ")"
string s2_dist      = na(gann_s2) ? na : " (" + tostring(((gann_s2 - close)/close)*100, format.percent) + ")"

string r2_typ       = ((r_loc + 1)%2) == 1 ? " (c)" : na
string r1_typ       = ((r_loc + 0)%2) == 1 ? " (c)" : na
string s1_typ       = ((s_loc - 0)%2) == 1 ? " (c)" : na
string s2_typ       = ((s_loc - 1)%2) == 1 ? " (c)" : na

//-----------------------------------------
// StopLoss Level
//-----------------------------------------

float atr_cl    = max(round_to_mintick(close - (atr*in_atrcl)), syminfo.mintick)
float risk      = 1-(in_pctcl/100)
float pct_cl    = max(round_to_mintick(close*risk), syminfo.mintick)

float   sell_price  = in_caltype=="%" ? pct_cl : atr_cl
float   price_diff  = close - sell_price
int     cal_unit    = floor(in_calamt/price_diff)

int     buy_unit    = in_calres == "Lot" ? floor(cal_unit/(in_callot)) : cal_unit
float   cal_cost    = floor(cal_unit/(in_callot))*100 * close

var cal_txt = "Suggested "+in_calres+"\nBased on "+ (in_caltype=="%" ? (tostring(in_pctcl, "0.#")+"% Stop") : (tostring(in_atrcl, "#.#")+" ATR Stop"))

//------------------------------------------------------------------------------
// Risk Envelope
//------------------------------------------------------------------------------
float risk_res = na, float risk_sup = na, string risk_txt = "S"

var p_hi                = array.new_float()
var p_lo                = array.new_float()
var risk_array_size     = 12
var risk_treshold       = 2.

risk_basis  = supersmoother(close, 40)
risk_h      = (high-risk_basis) / atr
risk_l      = (low-risk_basis) / atr

pvthi_ = pivothigh(risk_h, 10, 10), pvthi = pvthi_ >  risk_treshold ? pvthi_ : na
pvtlo_ = pivotlow(risk_l, 10, 10),  pvtlo = pvtlo_ < -risk_treshold ? pvtlo_ : na

// keep each peak in array
if(barstate.isconfirmed)
    if(pvthi>0)
        if(array.size(p_hi) >= risk_array_size)
            array.shift(p_hi)       // remove oldest
        array.push(p_hi, pvthi)     // insert new
    
    if(pvtlo<0)
        if(array.size(p_lo) >= risk_array_size)
            array.shift(p_lo)       // remove oldest
        array.push(p_lo, pvtlo)     // insert new

var risk_lim = 0.7

if (barstate.islast)
    
    // Get the range based on average of historical peak
    risk_res := risk_basis+(max(array.avg(p_hi), 2.0)*atr)
    risk_sup := risk_basis+(min(array.avg(p_lo), -2.0)*atr)
    
    if(close > risk_basis)
        if(f_norm(close, risk_basis, risk_res) > 1.0) 
            risk_txt := "Over\nExtended ▲"
        else if(f_norm(close, risk_basis, risk_res) > risk_lim) 
            risk_txt := "Extended ▲\n(Slightly)"
        else 
            risk_txt := "Within Range"    
    else if(close < risk_basis) 
        if(f_norm(close, risk_sup, risk_basis) < -1.)
            risk_txt := "Over\nExtended ▼"
        else if(f_norm(close, risk_sup, risk_basis) < 1.-risk_lim)
            risk_txt := "Extended ▼\n(Slightly)"
        else
            risk_txt := "Within Range"
    else
        risk_txt := "Within Range"

//------------------------------------------------------------------------------
// Optimized Linear Regression Channel
//------------------------------------------------------------------------------

var olr_devlen      = 2.

var olr_shortlen    = 50
var olr_midlen      = 120
var olr_longlen     = 200

string  trend       = "na"
var     hi_tres     = 10.
var     lo_tres     = -10.
stoch               = stoch(close, high, low, 14)

[olr_y1_,   olr_y2_,    olr_dev,    olr_slope]   = get_channel(close, olr_longlen)
[mid_y1_,   mid_y2_,    mid_dev,    mid_slope]   = get_channel(close, olr_midlen)
[short_y1_, short_y2_,  short_dev,  short_slope] = get_channel(close, olr_shortlen)

short   = f_degree(close, olr_shortlen, olr_longlen)
mid     = f_degree(close, olr_midlen,   olr_longlen)
long    = f_degree(close, olr_longlen,  olr_longlen)

if(barstate.islast)
    if(isbetween(long, lo_tres, hi_tres))
        if(isbetween(mid, lo_tres, hi_tres))
            trend := "Sideway"
        else if(mid>hi_tres and short>10)
            trend := "Sideway\n(Bullish)"
        else if (close > olr_y2_ + (olr_dev * olr_devlen))
            trend := "Sideway\n(Bullish)"
        else if(mid<lo_tres and short < -10)
            trend := "Sideway\n(Bearish)"
        else if (close < olr_y2_ - (olr_dev * olr_devlen))
            trend := "Sideway\n(Bearish)"
        else
            trend := "Sideway"
//----------------------------------------------------------------------------------------------------------------------
    //Long above 20 degree
    else if(long>=hi_tres)
        if(long>=20)
            if(mid>=long)
                if (short<0)
                    trend := "Uptrend"
                else if(short<-15)
                    trend := "Uptrend\n(Pullback)"
                else
                    trend := "Strong Uptrend"
            if(mid<long)
                if (short<0)
                    trend := "Uptrend"
                else if(short<-15)
                    trend := "Uptrend\n(Pullback)"
                else
                    trend := "Uptrend"
//---------------------------------------------------------------
    //Long Between treshold and 20 degree
        else if(mid>=0)
            if(mid>=long)
                if (short>=mid)
                    trend := "Uptrend"
                else if(short>0)
                    trend := "Uptrend"
                else if(short<-15)
                    trend := "Uptrend\n(Pullback)"
                else
                    trend := "Weak Uptrend"
            else if(mid<=long)
                if (short>=mid)
                    trend := "Uptrend"
                else if(short>0)
                    trend := "Weak Uptrend"
                else if(short<-10)
                    trend := "Weak Uptrend\n(Pullback)"
                else
                    trend := "Weak Uptrend"
//---------------------------------------------------------------
        else if(mid<0)
            if(isbetween(short, -10., 10.))
                trend := "Weak Uptrend"
            if(short<=10)
                trend := "Weak Uptrend\n(Potential Reversal)"
            else if(short>=10)
                trend := "Weak Uptrend\n(Continuation)"
//----------------------------------------------------------------------------------------------------------------------
    //Short below -20 degree
    else if(long<=lo_tres)
        if(long<=-20)
            if(mid<=long)
                if (short>0)
                    trend := "Downtrend"
                else if(short>15)
                    trend := "Downtrend\n(Recovery)"
                else
                    trend := "Strong Downtrend"
            if(mid>long)
                if (short>0)
                    trend := "Downtrend"
                else if(short>15)
                    trend := "Downtrend\n(Recovery)"
                else
                    trend := "Downtrend"
//---------------------------------------------------------------
    //Short between treshold and -20 degree
        else if(mid<=0)
            if(mid<=long)
                if (short<=mid)
                    trend := "Downtrend"
                else if(short<0)
                    trend := "Downtrend"
                else if(short>10)
                    trend := "Downtrend\n(Recovery)"
                else
                    trend := "Weak Downtrend"
            else if(mid>=long)
                if (short<=mid)
                    trend := "Downtrend"
                else if(short<0)
                    trend := "Weak Downtrend"
                else if(short>0)
                    trend := "Weak Downtrend\n(Recovery)"
        else if(mid>0)
            if(isbetween(short, -10., 10.))
                trend := "Weak Downtrend"
            else if(short>=10)
                trend := "Weak Downtrend\n(Potential Reversal)"
            else if(short<=10)
                trend := "Weak Downtrend\n(Continuation)"
//--------------------------------------------------------------------------------------------
    else
        trend:="Insufficient Data"

olr_strength    = trend

//------------------------------------------------------------------------------
// Swing point (Marked Price)
//------------------------------------------------------------------------------

ph_ = pivothigh(high, marked_base, marked_len)
pl_ = pivotlow(low, marked_base, marked_len)

if ph_ and (cs=="L" or (cs=="H" and ph_ > cp) or cs=="")
    cp  := ph_
    cs  := "H"
    sh_ := true
    lh  := ph_

if pl_ and (cs=="H" or (cs=="L" and pl_ < cp) or cs=="")
    cp  := pl_
    cs  := "L"
    sl_ := true
    ll  := pl_


//------------------------------------------------------------------------------
// T+
//------------------------------------------------------------------------------

res20       = highest(high[1], 20)
var tplus   = 0
var tvol    = 0.
avg_tvol    = sma(volume, 20)

if high > res20 and volume > avg_tvol
    tplus   := 0
    tvol    := volume
    
else if high == res20 and volume > avg_tvol
    if volume >= tvol
        tplus := 0
    else
        tplus += 1
else
    tplus+=1

tplus_txt = tplus>30?"N/A":("T"+tostring(min(tplus, 30)))

// ▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼
// Prepare Dashboard
// ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

var PTable  = table.new(position = t_position, 
                          columns = 3+in_gap, 
                          rows = 45, 
                          bgcolor = #00000000, 
                          frame_color = #000000, 
                          frame_width = 0, 
                          border_color = #000000,
                          border_width = 0)

// fill table
// =====================================================================================================================
f_Fill(_table, _row, _label, _value, _clrtyp) =>
    t_size      = text_size
    header      = _value=="Header" ? true : false
    
    col_text    = header ? head_col : _clrtyp == 0 ? text_col   : _clrtyp == 1 ? green                      : red
    col_bg      = header ? head_bgc : _clrtyp == 0 ? #00000000  : _clrtyp == 1 ? color.new(green, transp)   : color.new(red, transp)
    _ValueText  = header ? "" : _value == "gap" ? "" : _value
    
    table.cell(_table, 0, _row, _label, bgcolor = col_bg, text_color = col_text,
      text_size = text_size, text_halign = header ? text.align_left : text.align_left)
    
    table.cell(_table, 1, _row, _ValueText == "" ? "" : ":", bgcolor = col_bg, text_color = header?head_col:col_text, 
      text_size = text_size, text_halign = text.align_center) 
      
    table.cell(_table, 2, _row, _ValueText, bgcolor = col_bg, text_color = header?head_col:col_text, 
      text_size = text_size, text_halign = text.align_right)
    
    if(in_gap>0)
        for k=1 to in_gap
            table.cell(_table, 2+k, _row, "-", bgcolor = #00000000, text_color = #00000000, 
              text_size = size.tiny, text_halign = text.align_center) 

    
// =====================================================================================================================

// Set Col

ma1_col     = check_col(MA1, "ATR")
ma2_col     = check_col(MA2, "ATR")
ma3_col     = check_col(MA3, "ATR")
ma4_col     = check_col(MA4, "ATR")

gannr1_col  = check_col(gann_r1, "Tick")
gannr2_col  = check_col(gann_r2, "Tick")
ganns1_col  = check_col(gann_s1, "Tick")
ganns2_col  = check_col(gann_s2, "Tick")

hi52w_col   = check_col(pct52, "52w")
lo52w_col   = check_col(pct52, "52w")

hi52w_col   := pct52 > 0.5 ? hi52w_col : 0
lo52w_col   := pct52 < 0.5 ? lo52w_col : 0
sc52w_col   = check_col(pct52, "52w")

// Fill table
i = -1
if barstate.islast and proversion==true

    if(disp_vol)
        if(avg_vol or (atr and atr_triv==_y))
            i += 1, f_Fill(PTable, i,     "Volume & Volatility",    "Header",                               0)
            if(_volume and vol_triv==_y)
                i += 1, f_Fill(PTable, i, _voltxt,                  tostring(_volume, format.volume),      0)

            if(avg_vol)
                if(vol_triv==_y)
                    i += 1, f_Fill(PTable, i, "Avg "+_voltxt,            tostring(vprice, format.volume),      0)
                i += 1, f_Fill(PTable, i, "Relative "+_voltxt,       tostring(rel_vol, "0.00"),            0)
                i += 1, f_Fill(PTable, i, "Buy to Sell Ratio",       tostring(bts_vol, "0.00"),            0)
            if(atr and atr_triv==_y)
                i += 1, f_Fill(PTable, i, "ATR",                     tostring(atr, format.mintick)+atr_p,    0)
                i += 1, f_Fill(PTable, i, "Volatility",              volatility,                             0)
            i += 1, f_Fill(PTable, i, "",                            "gap",                                  0)

    if(disp_ta and ((disp_risk == _y and bar_index>40) or (disp_ocl == _y and bar_index>120)or (disp_tplus == _y and volume and bar_index>=20)))
        i += 1, f_Fill(PTable, i, "Trend Analysis",                 "Header",       0)
        
        if(disp_risk == _y and bar_index>40)
            i += 1, f_Fill(PTable, i, "Shortterm Risk\n(MA 20)",    risk_txt,       0)
        if(disp_ocl == _y and bar_index>120)
            i += 1, f_Fill(PTable, i, "Trend Estimator",            olr_strength,   0)
        if(disp_tplus == _y and volume and bar_index>=20)
            i += 1, f_Fill(PTable, i, "T+",                         tplus_txt,      0)
        
        i += 1, f_Fill(PTable, i, "",                               "gap",          0)

    if(disp_trnd)
        if((MAtype=="ATR" and atr) or MAtype=="%")
            if(MA1 or MA2 or MA3 or (MA4 and show_ma4==_y))
                i += 1, f_Fill(PTable, i, "MA (Distance)",         "Header",             0)
                if(MA1)    
                    i += 1, f_Fill(PTable, i, ma1_txt,              dist1_text,          ma1_col)
                if(MA2)
                    i += 1, f_Fill(PTable, i, ma2_txt,              dist2_text,          ma2_col)
                if(MA3)
                    i += 1, f_Fill(PTable, i, ma3_txt,              dist3_text,          ma3_col)
                if(MA4 and show_ma4==_y)
                    i += 1, f_Fill(PTable, i, ma4_txt,              dist4_text,          ma4_col)
                
                i += 1, f_Fill(PTable, i, "",                       "gap",               0)
    
    if(disp_key and disp_key2)
        i += 1, f_Fill(PTable, i,     "Key Levels",                 "Header",                                                               0)
        if(hi52 and disp_52w==_y)
            i += 1, f_Fill(PTable, i, "52week High",                tostring(hi52, format.mintick) + " (" + tostring(hi52pct, "0.00%")+")",  hi52w_col)
            i += 1, f_Fill(PTable, i, "52week Low",                 tostring(lo52, format.mintick) + " (" + tostring(lo52pct, "0.00%")+")",  lo52w_col)
            i += 1, f_Fill(PTable, i, "52week Range(%)",            tostring(pct52*100, "#.##"),                                                sc52w_col)
            i += 1, f_Fill(PTable, i, "",                           "gap",                                                                  0)
        
        if(disp_gan==_y)
            i += 1, f_Fill(PTable, i, "Gann R2"+r2_typ,             tostring(gann_r2, format.mintick)+r2_dist,          gannr2_col)
            i += 1, f_Fill(PTable, i, "Gann R1"+r1_typ,             tostring(gann_r1, format.mintick)+r1_dist,          gannr1_col)
            i += 1, f_Fill(PTable, i, "Gann S1"+s1_typ,             tostring(gann_s1, format.mintick)+s1_dist,          ganns1_col)
            i += 1, f_Fill(PTable, i, "Gann S2"+s2_typ,             tostring(gann_s2, format.mintick)+s2_dist,          ganns2_col)
            i += 1, f_Fill(PTable, i, "",                           "gap",                                      0)

    if(disp_cl)
        i += 1, f_Fill(PTable, i, "StopLoss Levels",                                        "Header",                                   0)
        i += 1, f_Fill(PTable, i, tostring(in_pctcl, "0.#")+"% Stop",                       tostring(pct_cl, format.mintick),           0)
        if(atr)
            i += 1, f_Fill(PTable, i, tostring(in_atrcl, "0.#")+" ATR Stop",                tostring(atr_cl, format.mintick),           0)
        if(disp_cal==_y)
            i += 1, f_Fill(PTable, i, "",                                                   "gap",                                      0)
            i += 1, f_Fill(PTable, i, cal_txt,                                              tostring(buy_unit, "#,###")+" "+in_calres,  0)
            i += 1, f_Fill(PTable, i, "Cost",                                               syminfo.currency+tostring(cal_cost, " #,###,##0.00"), 0)

//--------------------------------
plot(disp_ma1 ? MA1 : na, title="MA 1", color=ma1_pcol)
plot(disp_ma2 ? MA2 : na, title="MA 2", color=ma2_pcol)
plot(disp_ma3 ? MA3 : na, title="MA 3", color=ma3_pcol)
plot(disp_ma4 ? MA4 : na, title="MA 4", color=ma4_pcol)


if atr and disp_mark  and proversion==true
    if sh_
        _pv          = high[marked_len]
        changes     = (_pv - ll) / ll * 100
        array.push(markedprice, f_label_markedprice(_pv, "H", atr*0.5, changes))
    
    if sl_
        _pv          = low[marked_len]
        changes     = (_pv - lh) / lh * 100
        array.push(markedprice, f_label_markedprice(_pv, "L", atr*0.5, changes))


var reglines = array.new_line()

if(barstate.islast  and proversion==true)

    if(array.size(line_list) > 0)
        for z = 0 to array.size(line_list)-1
            oldline = array.shift(line_list)
            line.delete(oldline)
    
    if(array.size(lbl_list) > 0)
        for z = 0 to array.size(lbl_list)-1
            oldlbl = array.shift(lbl_list)
            label.delete(oldlbl)
    
    if(disp_52wl)
        array.push(line_list, f_line(hi52, extend.both, w52_col, w52_lsty))
        array.push(line_list, f_line(lo52, extend.both, w52_col, w52_lsty))
    
    if(disp_ganl)
        if(array.size(r_list)>0)
            for k=0 to (array.size(r_list)-1)
                rline_typ   = (r_loc+k)%2==1 ? cardinal : ordinal
                gann_r      = array.get(r_list, k)
                array.push(line_list, f_line(gann_r, gann_ext, gann_col, rline_typ))
                array.push(lbl_list,  f_label(array.get(r_txt, k)+tostring(gann_r, format.mintick)+")", gann_r, gann_col))
                
        if(array.size(s_list)>0)
            for k=0 to (array.size(s_list)-1)
                sline_typ   = (s_loc-k)%2==1 ? cardinal : ordinal
                gann_s      = array.get(s_list, k)
                array.push(line_list, f_line(gann_s, gann_ext, gann_col, sline_typ))
                array.push(lbl_list,  f_label(array.get(s_txt, k)+tostring(gann_s, format.mintick)+")", gann_s, gann_col))
    
    if(disp_ocl_l==_y or disp_ocl_m==_y or disp_ocl_s==_y)
        if array.size(reglines) > 0
            for j=0 to array.size(reglines)-1
                o_ln = array.pop(reglines)
                line.delete(o_ln)
        
        for x = 0 to 2
            olr_linestyle = x % 2 == 1 ? line.style_solid : line.style_dotted
            
            if (disp_ocl_l==_y)
                array.push(reglines,
                          line.new(x1 = bar_index - (olr_longlen - 1), 
                                   y1 = olr_y1_ + olr_dev * olr_devlen * (x - 1), 
                                   x2 = bar_index, 
                                   y2 = olr_y2_ + olr_dev * olr_devlen * (x - 1),
                                   color = color.from_gradient(long, -80, 80, #FF3333, #00CC00), 
                                   style = olr_linestyle,
                                   width = x % 2 == 1 ? 2 : 1,
                                   extend = extend.none))
            if (disp_ocl_m==_y)
                array.push(reglines,
                          line.new(x1 = bar_index - (olr_midlen - 1), 
                                   y1 = mid_y1_ + mid_dev * olr_devlen * (x - 1), 
                                   x2 = bar_index, 
                                   y2 = mid_y2_ + mid_dev * olr_devlen * (x - 1),
                                   color = color.from_gradient(mid, -80, 80, #FF3333, #00CC00),
                                   style = olr_linestyle,
                                   width = x % 2 == 1 ? 2 : 1,
                                   extend = extend.none))
            if (disp_ocl_s==_y)
                array.push(reglines,
                          line.new(x1 = bar_index - (olr_shortlen - 1), 
                                   y1 = short_y1_ + short_dev * olr_devlen * (x - 1), 
                                   x2 = bar_index, 
                                   y2 = short_y2_ + short_dev * olr_devlen * (x - 1),
                                   color = color.from_gradient(short, -80, 80, #FF3333, #00CC00),
                                   style = olr_linestyle,
                                   width = x % 2 == 1 ? 2 : 1,
                                   extend = extend.none))


var DemoTable  = table.new(position = t_demo, 
                          columns = 1, 
                          rows = 1, 
                          bgcolor = #00000000, 
                          frame_color = #000000, 
                          frame_width = 0, 
                          border_color = #000000,
                          border_width = 0)

if(barstate.islast and proversion==false)
    table.cell(DemoTable, 0, 0, "Demo Version only available for\nStocks: 4-Hour Chart\nOthers: 30Minutes Chart", text_color=color.red, text_size=size.large, text_halign=text.align_left)

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fareidzulkifli

// Description : This SwissArmyKnife - MultiPurposeIndicator allows user to modify the Directional index based on one of filtering tools proposed by John F.Ehlers . 
// Details of each filtering type can be read in Ehlers Technical Papers: "Swiss Army Knife Indicator" and/or his book "Cybernetics Analysis for Stock and Futures"

// Disclaimer:
// These study scripts was built only to test/visualize an idea to see its viability and if it can be used to optimize existing strategy.
// This is experimental indicator. Any ideas to further improve this indicator are welcome :)


//@version=4
study("SAK-MPI: Smooth DX", overlay=false)

//************************************************************************************************************//
// Parameter
//************************************************************************************************************//

length      = input(title="Length", type=input.integer, defval=50, minval=1)
type        = input(title="Filter Type", defval="SuperSmoother", options=["SuperSmoother", "Ehlers EMA", "Gaussian", "Butterworth", "High Pass", "2 Pole High Pass", "BandPass", "BandStop", "SMA", "EMA", "RMA"])

//************************************************************************************************************//
// Funtion
//************************************************************************************************************//

//********************************************//
// Ehler SwissArmyKnife Funtion
//********************************************//
SAK_smoothing(_type, _src, _length) =>
    c0          = 1.0 
    c1          = 0.0 
    b0          = 1.0 
    b1          = 0.0 
    b2          = 0.0 
    a1          = 0.0 
    a2          = 0.0 
    alpha       = 0.0 
    beta        = 0.0 
    gamma       = 0.0 
    pi          = 2 * asin(1)
    cycle       = 2 * pi / _length
    
    if _type == "Ehlers EMA"
        alpha   := (cos(cycle) + sin(cycle) - 1) / cos(cycle)
        b0      := alpha
        a1      := 1 - alpha
    if _type == "Gaussian"
        beta    := 2.415 * (1 - cos(cycle))
        alpha   := -beta + sqrt((beta * beta) + (2 * beta))
        c0      := alpha * alpha
        a1      := 2 * (1 - alpha)
        a2      := -(1 - alpha) * (1 - alpha)
    if _type == "Butterworth"
        beta    := 2.415 * (1 - cos(cycle))
        alpha   := -beta + sqrt((beta * beta) + (2 * beta))
        c0      := alpha * alpha / 4
        b1      := 2
        b2      := 1
        a1      := 2 * (1 - alpha)
        a2      := -(1 - alpha) * (1 - alpha)
    if type == "High Pass"
        alpha   := (cos(cycle) + sin(cycle) - 1) / cos(cycle)
        c0      := 1 - alpha / 2
        b1      := -1
        a1      := 1 - alpha
    if type == "2 Pole High Pass"
        beta    := 2.415 * (1 - cos(cycle))
        alpha   := -beta + sqrt((beta * beta) + (2 * beta))
        c0      := (1 - alpha / 2) * (1 - alpha / 2)
        b1      := -2
        b2      := 1
        a1      := 2 * (1 - alpha)
        a2      := -(1 - alpha) * (1 - alpha)
    if type == "BandPass"
        beta    := cos(cycle)
        gamma   := 1 / cos(cycle*2*0.1) // delta default to 0.1. Acceptable delta -- 0.05<d<0.5
        alpha   := gamma - sqrt((gamma * gamma) - 1)
        c0      := (1 - alpha) / 2
        b2      := -1
        a1      := beta * (1 + alpha)
        a2      := -alpha
    if _type == "BandStop"
        beta    := cos(cycle)
        gamma   := 1 / cos(cycle*2*0.1) // delta default to 0.1. Acceptable delta -- 0.05<d<0.5
        alpha   := gamma - sqrt((gamma * gamma) - 1)
        c0      := (1 + alpha) / 2
        b1      := -2 * beta
        b2      := 1
        a1      := beta * (1 + alpha)
        a2      := -alpha
    if _type == "SMA"
        c1      := 1 / _length
        b0      := 1 / _length
        a1      := 1
    if _type == "EMA"
        alpha   := 2/(_length+1)
        b0      := alpha
        a1      := 1 - alpha
    if _type == "RMA"
        alpha   := 1 / _length
        b0      := alpha
        a1      := 1 - alpha   
    _Input        = _src
    _Output       = 0.0
    _Output      := (c0 * ((b0 * _Input) + (b1 * nz(_Input[1])) + (b2 * nz(_Input[2])))) + (a1 * nz(_Output[1])) + (a2 * nz(_Output[2])) - (c1 * nz(_Input[_length])) 

//********************************************//
// SuperSmoother Funtion
//********************************************//

supersmoother(_src, _length) =>
    pi      = 2 * asin(1)
    s_a1    = exp(-sqrt(2) * pi / _length)
    s_b1    = 2 * s_a1 * cos(sqrt(2) * pi / _length)
    s_c3    = -pow(s_a1, 2)
    s_c2    = s_b1
    s_c1    = 1 - s_c2 - s_c3
    ss      = 0.0
    ss     := s_c1 * _src + s_c2 * nz(ss[1], _src[1]) + s_c3 * nz(ss[2], _src[2])

    
//***************************************************************************************************************************************//
// DX Function
//***************************************************************************************************************************************//

DirectionUp             = high-high[1] > low[1]-low ? max(high-high[1], 0): 0
DirectionalDn           = low[1]-low > high-high[1] ? max(low[1]-low, 0): 0

DIPlus  = 0.0
DIMinus = 0.0

if(type != "SuperSmoother")
    DIPlus      := SAK_smoothing(type, DirectionUp, length)
    DIMinus     := SAK_smoothing(type, DirectionalDn, length)

if(type == "SuperSmoother")
    DIPlus      := supersmoother(DirectionUp, length)
    DIMinus     := supersmoother(DirectionalDn, length)


//************************************************************************************************************//
// Drawing
//************************************************************************************************************//
OutputColor   = DIPlus > DIMinus ? #3FE800 : DIPlus < DIMinus ? #FD0000 : color.blue

up = plot(DIPlus, color=#3FE800, title="DI+", linewidth=2)
dn = plot(DIMinus, color=#FD0000, title="DI-", linewidth=2)

fill(up, dn, color=OutputColor)

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fareidzulkifli

// Description : This Stochastic variant will auto-adjust stochastic period based on volatility measured by standard deviation. 
// The idea behind it are in highly volatile market, %K period will be reduced to account for recent price range, 
// while in low volatility market, %K period will be increased to account less of the recent price range.

// This idea is based on one of medium article written by Sofien Kaabar with slight modification on the adjusting logic implementation. Any ideas to further improve this indicator are welcome :)

// Disclaimer:
// I always felt Pinescript is a very fast to type language with excellent visualization capabilities, so I've been using it as code-testing platform prior to actual coding in other platform.
// Having said that, these study scripts was built only to test/visualize an idea to see its viability and if it can be used to optimize existing strategy.
// While some of it are useful and most are useless, none of it should be use as main decision maker.

//@version=4
study("SDev Adjusted Stochastic", overlay = false, precision=2)

length  = input(14, title="SDev Period")
Dsmooth = input(3, title="D")
Ksmooth = input(3, title="Smooth")
src     = input(close, title="Source", type=input.source)

//************************************************************************************************************//
// Standard Deviation (Normalized)
//************************************************************************************************************//
ema     = ema(src,length)
sdev    = stdev(ema,length)
hsd     = highest(sdev,length)
lsd     = lowest(sdev,length)
n_sdev  = (sdev-lsd) / (hsd-lsd) *100


//************************************************************************************************************//
// Define Lookback Period 
//************************************************************************************************************//

get_period(x) => int val = round(100+3-x)

//************************************************************************************************************//
// Stochastic 
//************************************************************************************************************//

stochlength = get_period(n_sdev)==0 ? 3 : get_period(n_sdev)

hh          = highest(high,stochlength)
ll          = lowest(low,stochlength)
k           = sma(((src-ll) /(hh-ll) * 100),Ksmooth)
d           = sma(k,Dsmooth)

//************************************************************************************************************//
// Drawing 
//************************************************************************************************************//


plot(k, color=#0094FF, title="%K")
plot(d, color=#FF6A00, title="%D")
h0 = hline(80, "Upper Band", color=#606060)
h1 = hline(20, "Lower Band", color=#606060)
fill(h0, h1, color=#9915FF, transp=80, title="Background")

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// @fareidzulkifli
// @version=4

study("Volatility Adjusted Grid [Gann]", shorttitle = "Volatility Adjusted Grid", overlay = true, precision=4)

//-----------------------
// Parameter
//-----------------------
source      = close
group       = "Style"
typ1        = "Solid",          typ2   = "Dashed",  typ3 = "Dotted"
ext1        = "Left",           ext2   = "None"
alert1      = "Once per Bar",   alert2 = "Once per Bar Close"

maxline     = input(15,                         title = "No. of S&R Lines",     minval=1,  maxval=20,            tooltip = "No. of each S & R\n20 means 20 Resistance and 20 Support")
atr_size    = input(1.5,                        title = "Range Size",           minval=.1, maxval=10., step=0.1, tooltip = "Smaller Number indicates tighter range\nMin Val=0.1\nMax Val = 10.0")
disp_rguide = input(true,                       title = "Range Guide",                                           tooltip = "Display Range Size guide to find next bigger/smaller range at bottom left of the chart")
in_ext      = input(ext1,                       title = "Line Extension",       group = group, options=[ext1, ext2])
c_style     = input(typ1,                       title = "Cardinal Cross Style", group = group, options=[typ1, typ2, typ3])
o_style     = input(typ3,                       title = "Ordinal Cross Style",  group = group, options=[typ1, typ2, typ3])
g_col       = input(color.new(#606060, 35),     title = "Line Color",           group = group)
alert_typ   = input(alert2,                     title = "Alert Frequency",      group = "Alert", options=[alert1, alert2])

//-----------------------
var cardinal    = c_style == typ1 ? line.style_solid : c_style == typ2 ? line.style_dashed : line.style_dotted
var ordinal     = o_style == typ1 ? line.style_solid : o_style == typ2 ? line.style_dashed : line.style_dotted
var ext_type    = in_ext  == ext1 ? extend.left      : extend.none

//-----------------------
// Generate Gann Square of 9 Sequence
//-----------------------
var table_size  = 1200
var gann_table  = array.new_float()
var val         = 1 
var increment   = 1
var diag_check  = 3

if(barstate.isfirst)
    array.push(gann_table, 1)
    
    for cnt = 0 to table_size-1
        val := val+increment
        array.push(gann_table, val)
        
        if(val==pow(diag_check,2))
            increment   += 1
            diag_check  += 2

//-----------------------
// Funtions
//-----------------------
get_mult(_val, adj)=>
    float initial   = 0.00001
    float res       = initial
    float check     = na
    
    int   cnt_run   = 0
    for i = 0 to 12
        check := adj * (initial * pow(10., i))
        cnt_run := cnt_run+1
        if(_val < check)
            res := 100.0/(initial * pow(10., i))
            break
    
    [res, cnt_run]

get_idx(_src)=>
    int   idx = array.indexof(gann_table, _src)
    float tmp = 0
    int   res = na, int r_idx = na, int s_idx = na
    
    // if src==gann
    if(idx!=-1)
        r_idx := idx+1
    
    // if src != gann
    if(idx==-1)
        for cnt = 0 to (array.size(gann_table)-1)

            tmp := array.get(gann_table, cnt)
            if(tmp>_src and not r_idx)
                r_idx := cnt
            if(r_idx)
                break

    res := r_idx
    
f_line(_yloc, _idx)=>
    line.new(
          x1     = bar_index-50,    x2 = bar_index+10, xloc=xloc.bar_index, 
          y1     = _yloc,           y2 = _yloc, 
          style  = _idx%2==1 ? cardinal : ordinal, 
          extend = ext_type, 
          color  = g_col)

f_label(_txt, _yloc) =>
    label.new(
          x         = bar_index+10, xloc = xloc.bar_index, 
          y         = _yloc, 
          text      = _txt,
          color     = #00000000, 
          textcolor = g_col,
          size      = size.normal, 
          style     = label.style_label_left,
          textalign = text.align_left)
          
//-----------------------
// Main Calculation
//-----------------------
varip int   r_loc       = na                // Keep index of SnR levels array
varip int   s_loc       = na
varip float r1          = na                // Temporary placeholder to check the range size
varip float s1          = na    
varip       r_list      = array.new_float() // Array to keep SnR level intrabar //workaround as varip cant be use with line array
varip       s_list      = array.new_float()
var         g_line      = array.new_line()  // Array for drawing SnR Lines
var         g_lbl       = array.new_label() // Array for drawing SnR Price Labels
varip float curr_size   = na
varip float prev_size   = na
varip int   run_num     = 0                 // Keep track no of execution of main calculation since it may go up to 1000+ iterations per run
varip int   count_run   = 0                 // Keep track no of execution of main calculation since it may go up to 1000+ iterations per run

//-----------------------
float   atr         = sma(tr, 30)
int     lookback    = max(min(bar_index, 20), 1)
float   range       = na
float   range2      = (highest(high, lookback) - lowest(low, lookback)) // Alternative when atr not available
float   mult        = na
float   src         = na
float   min_range   = atr[1] * atr_size

//-----------------------
if(barstate.isnew)          // reset on newbar
    run_num   := 0
    count_run   := 0
    r_loc       := na, r1 := na
    s_loc       := na, s1 := na
    curr_size   := na
    prev_size   := na
    array.clear(r_list)
    array.clear(s_list)

if(barstate.islast and run_num == 0)
    run_num += 1
    
    for i = 0.0 to 4.5 by 0.5   //10 iterations max
        for j = 1 to 10         //10 iterations max
            range       := atr * (j*3)
            [_mul,_run] = get_mult(nz(range, range2), (5-i)) //12 iterations max
            mult        := _mul
            src         := floor(source*mult)

            r_loc       := get_idx(src)
            s_loc       := r_loc-1
            r1          := round_to_mintick(array.get(gann_table, r_loc)/mult)
            s1          := round_to_mintick(array.get(gann_table, s_loc)/mult)
            count_run   := count_run + 1 //+ _run
            curr_size   := r1-s1
            
            if(curr_size >= min_range)  //break loop if found 
                break
        
            prev_size := curr_size
                
        if(curr_size >= min_range)      //break loop if found 
            break
    
    for i=0 to maxline-1
        float r_val = r_loc + i < 0 or r_loc + i > table_size-1 ? na : round_to_mintick(array.get(gann_table, r_loc + i)/mult)
        float s_val = s_loc - i < 0 or s_loc - i > table_size-1 ? na : round_to_mintick(array.get(gann_table, s_loc - i)/mult)

        if(r_val)
            array.push(r_list, r_val)

        if(s_val)
            array.push(s_list, s_val)
    
//-----------------------
// S/R Drawing
//-----------------------
float   _temp  = na
int     r_size  = array.size(r_list)
int     s_size  = array.size(s_list)

if(barstate.islast)
    if(array.size(g_line) > 0)
        for z = 0 to array.size(g_line)-1
            oldline = array.shift(g_line)
            line.delete(oldline)
    
    if(array.size(g_lbl) > 0)
        for z = 0 to array.size(g_lbl)-1
            oldlbl = array.shift(g_lbl)
            label.delete(oldlbl)
            
    if(r_size>0)
        for i=0 to r_size-1
            _temp := array.get(r_list, i)
            array.push(g_line, f_line(_temp, r_loc+i))
            array.push(g_lbl,  f_label("("+tostring(_temp, format.mintick)+")", _temp))

    if(s_size>0)
        for i=0 to s_size-1
            _temp := array.get(s_list, i)
            array.push(g_line, f_line(_temp, s_loc-i))
            array.push(g_lbl,  f_label("("+tostring(_temp, format.mintick)+")", _temp))

//-----------------------
// Alert
//-----------------------

alertup = (crossover(close, r1)  or (close[1] < close  and close==r1))
alertdn = (crossunder(close, s1) or (close[1] > close  and close==s1))

string alerttxt = na

if(alertup)
    alerttxt :="Cross Above "+ tostring(r1, format.mintick)
if(alertdn)
    alerttxt :="Cross Below "   + tostring(s1, format.mintick)

var alert_freq = alert_typ==alert1 ? alert.freq_once_per_bar : alert.freq_once_per_bar_close    

if(alertup or alertdn)
    alert(alerttxt, alert_freq)

//-----------------------
// Table for Range Guideline
//-----------------------
var PTable  = table.new(position = position.bottom_left, columns = 2, rows = 2)
prv_range   = prev_size/atr[1] > 0.1 ? tostring(prev_size/atr[1], "0.00") : "Not Available"
nxt_range   = curr_size/atr[1] < 10 and count_run < 80 ? tostring(curr_size/atr[1], "0.00") : "Not Available"

if(barstate.islast and disp_rguide)
    table.cell(PTable, 0, 0, text="Previous Range: ",   text_color=g_col, text_halign=text.align_left, text_size=size.small)
    table.cell(PTable, 1, 0, text="< " + prv_range,    text_color=g_col, text_halign=text.align_left, text_size=size.small)
    table.cell(PTable, 0, 1, text="Next Range: ",       text_color=g_col, text_halign=text.align_left, text_size=size.small)
    table.cell(PTable, 1, 1, text="> " + nxt_range,     text_color=g_col, text_halign=text.align_left, text_size=size.small)