Advance Trading Script

//@version=6
indicator(title="Advance Trading Script v6 © devgagan.in", shorttitle="ATMA v6", overlay=true)

// Filter function 
f_filt9x (_a, _s, _i) =>
    int _m2 = 0
    int _m3 = 0
    int _m4 = 0
    int _m5 = 0
    int _m6 = 0
    int _m7 = 0
    int _m8 = 0
    int _m9 = 0
    float _f = .0
    _x = (1 - _a)
    
    // Weights.
    if _i == 9
        _m2 := 36
        _m3 := 84
        _m4 := 126
        _m5 := 126
        _m6 := 84
        _m7 := 36
        _m8 := 9
        _m9 := 1
    else if _i == 8
        _m2 := 28
        _m3 := 56
        _m4 := 70
        _m5 := 56
        _m6 := 28
        _m7 := 8
        _m8 := 1
    else if _i == 7
        _m2 := 21
        _m3 := 35
        _m4 := 35
        _m5 := 21
        _m6 := 7
        _m7 := 1
    else if _i == 6
        _m2 := 15
        _m3 := 20
        _m4 := 15
        _m5 := 6
        _m6 := 1
        _m7 := 0
    else if _i == 5
        _m2 := 10
        _m3 := 10
        _m4 := 5
        _m5 := 1
        _m6 := 0
    else if _i == 4
        _m2 := 6
        _m3 := 4
        _m4 := 1
        _m5 := 0
    else if _i == 3
        _m2 := 3
        _m3 := 1
        _m4 := 0
    else if _i == 2
        _m2 := 1
        _m3 := 0
    else
        _m2 := 0

    // Filter
    _f := math.pow(_a, _i) * nz(_s) +
          _i * _x * nz(_f[1]) -
          (_i >= 2 ? _m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + 
          (_i >= 3 ? _m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - 
          (_i >= 4 ? _m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + 
          (_i >= 5 ? _m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - 
          (_i >= 6 ? _m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + 
          (_i >= 7 ? _m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - 
          (_i >= 8 ? _m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + 
          (_i == 9 ? _m9 * math.pow(_x, 9) * nz(_f[9]) : 0)

    _f

// 9 var declaration function
f_pole (_a, _s, _i) =>
    _f1 = f_filt9x(_a, _s, 1)
    _f2 = (_i >= 2 ? f_filt9x(_a, _s, 2) : 0)
    _f3 = (_i >= 3 ? f_filt9x(_a, _s, 3) : 0)
    _f4 = (_i >= 4 ? f_filt9x(_a, _s, 4) : 0)
    _f5 = (_i >= 5 ? f_filt9x(_a, _s, 5) : 0)
    _f6 = (_i >= 6 ? f_filt9x(_a, _s, 6) : 0)
    _f7 = (_i >= 2 ? f_filt9x(_a, _s, 7) : 0)
    _f8 = (_i >= 8 ? f_filt9x(_a, _s, 8) : 0)
    _f9 = (_i == 9 ? f_filt9x(_a, _s, 9) : 0)
    _fn = _i == 1 ? _f1 : _i == 2 ? _f2 : _i == 3 ? _f3 :
         _i == 4 ? _f4 : _i == 5 ? _f5 : _i == 6 ? _f6 :
         _i == 7 ? _f7 : _i == 8 ? _f8 : _i == 9 ? _f9 : na
    [_fn, _f1]

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
src = input.source(hlc3, title="Source")
N = input.int(4, title="Poles", minval=1, maxval=9)
per = input.int(144, title="Sampling Period", minval=2)
mult = input.float(1.414, title="Filtered True Range Multiplier", minval=0)
modeLag = input.bool(false, title="Reduced Lag Mode")
modeFast = input.bool(false, title="Fast Response Mode")

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Definitions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
beta  = (1 - math.cos(4 * math.asin(1) / per)) / (math.pow(1.414, 2 / N) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2 * beta)
lag = (per - 1) / (2 * N)

srcdata = modeLag ? src + (src - src[lag]) : src
trdata  = modeLag ? ta.tr(true) + (ta.tr(true) - ta.tr(true)[lag]) : ta.tr(true)

[filtn, filt1] = f_pole(alpha, srcdata, N)
[filtntr, filt1tr] = f_pole(alpha, trdata, N)

filt = modeFast ? (filtn + filt1) / 2 : filtn
filttr = modeFast ? (filtntr + filt1tr) / 2 : filtntr

hband = filt + filttr * mult
lband = filt - filttr * mult

color1   = #0aff68
color2   = #00752d
color3   = #ff0a5a
color4   = #990032
fcolor   = filt > filt[1] ? #0aff68 : filt < filt[1] ? #ff0a5a : #cccccc
barcolor = (src > src[1]) and (src > filt) and (src < hband) ? #0aff68 : (src > src[1]) and (src >= hband) ? #0aff1b : (src <= src[1]) and (src > filt) ? #00752d : 
           (src < src[1]) and (src < filt) and (src > lband) ? #ff0a5a : (src < src[1]) and (src <= lband) ? #ff0a11 : (src >= src[1]) and (src < filt) ? #990032 : #cccccc

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Outputs : Visit my github -- https://github.com/devgaganin
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
bg_label = label.new(x=bar_index, y=na, text="ATMA V6\n© devgaganin", color=color.new(color.white, 0), style=label.style_label_down, size=size.small, textcolor=color.black, 
                     xloc=xloc.bar_index, yloc=yloc.price)
label.set_xy(bg_label, bar_index, (high + low) / 2)

filtplot = plot(filt, title="Filter", color=fcolor, linewidth=3)
hbandplot = plot(hband, title="Filtered True Range High Band", color=fcolor)
lbandplot = plot(lband, title="Filtered True Range Low Band", color=fcolor)
fill(hbandplot, lbandplot, title="Channel Fill", color=color.new(fcolor, 80))

barcolor(barcolor)



source = close
fastFilter = f_filt9x(alpha, source, 1)
slowFilter = f_filt9x(alpha, source, 9)

buySignal = ta.crossover(fastFilter, slowFilter)
sellSignal = ta.crossunder(fastFilter, slowFilter)

plotshape(buySignal, style=shape.labelup, color=color.green, size=size.large, location=location.belowbar, text="BUY-Gagan", textcolor=color.white)
plotshape(sellSignal, style=shape.labeldown, color=color.red, size=size.large, location=location.abovebar, text="SELL-Gagan", textcolor=color.white)