Scribd
Upload
868 views11 pages

Brahmos

Uploaded by

kunaifiaangkunaifi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
868 views11 pages

Brahmos

Uploaded by

kunaifiaangkunaifi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 11

//@version=5

indicator(title='Brahmos', shorttitle='Brahmos', overlay=false)


swa = input(false, title='AROON')
length = input.int(14, minval=1)
upper = 100 * (ta.highestbars(high, length + 1) + length) / length
lower = 100 * (ta.lowestbars(low, length + 1) + length) / length
midp = 0
oscillator = upper - lower
osc = plot(swa ? oscillator : na, color=color.new(color.red, 0))
mp = plot(swa ? midp : na)
top = plot(swa ? 85 : na)
bottom = plot(swa ? -85 : na)
co = oscillator >= 95 and oscillator[1] >= oscillator ? color.red : oscillator <= -
88 ? color.green : na
bgcolor(swa ? co : na, transp=70)
fill(osc, mp, transp=90)
fill(top, bottom, transp=90)
//rsi
swr = input(true, title='RSI')
src = close
len = input.int(50, minval=1, title='Length RSI')
srs = input.int(50, minval=1, title='Length sma RSI')
up = ta.rma(math.max(ta.change(src), 0), len)
down = ta.rma(-math.min(ta.change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - 100 / (1 + up / down)
mr = ta.sma(rsi, srs)
plot(swr ? rsi : na, title='RSI', color=color.new(color.purple, 0))
plot(swr ? mr : na, title='sma RSI', color=color.new(color.red, 0))
//macd
swm = input(false, title='MACD')
source = close
fastLength = input.int(12, minval=1)
slowLength = input.int(26, minval=1)
signalLength = input.int(9, minval=1)
fastMA = ta.ema(source, fastLength)
slowMA = ta.ema(source, slowLength)
macd = fastMA - slowMA
signal = ta.ema(macd, signalLength)
hist = macd - signal
plot(swm ? hist : na, color=color.new(color.red, 0), style=plot.style_histogram)
plot(swm ? macd : na, color=color.new(color.blue, 0))
plot(swm ? signal : na, color=color.new(color.orange, 0))
//stoc
sws = input(false, title='STOCHASTIC')
periodK = input.int(14, title='K', minval=1)
periodD = input.int(3, title='D', minval=1)
smoothK = input.int(3, title='Smooth', minval=1)
k = ta.sma(ta.stoch(close, high, low, periodK), smoothK)
d = ta.sma(k, periodD)
plot(sws ? k : na, title='%K', color=color.new(color.blue, 0))
plot(sws ? d : na, title='%D', color=color.new(color.orange, 0))
h0 = plot(sws or swr ? 80 : na)
h1 = plot(sws or swr ? 20 : na)
fill(h0, h1, color=color.new(color.purple, 75))
//ADX
swx = input(false, title='ADX DI')

lenx = input.int(14, minval=1, title='DI Length')


lensig = input.int(14, title='ADX Smoothing', minval=1, maxval=50)
th = input(title='threshold', defval=25)

upx = ta.change(high)
downx = -ta.change(low)
plusDM = na(upx) ? na : upx > downx and upx > 0 ? upx : 0
minusDM = na(downx) ? na : downx > upx and downx > 0 ? downx : 0
trur = ta.rma(ta.tr, lenx)
plus = fixnan(100 * ta.rma(plusDM, lenx) / trur)
minus = fixnan(100 * ta.rma(minusDM, lenx) / trur)
sum = plus + minus
adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), lensig)

plot(swx ? plus : na, color=color.new(color.blue, 0), title='+DI')


plot(swx ? minus : na, color=color.new(color.orange, 0), title='-DI')
plot(swx ? adx : na, color=color.new(color.red, 0), title='ADX')
plot(swx ? th : na, color=color.new(color.black, 0), title='th')
//Vijayalakshmi

len1 = input(10)
o = ta.ema(open, len1)
c = ta.ema(close, len1)
h = ta.ema(high, len1)
l = ta.ema(low, len1)

haclose = (o + h + l + c) / 4 // [smoothing]
var float haopen = (o + c) / 2
haopen := (haopen + haclose) / 2
hahigh = math.max(h, math.max(haopen, haclose))
halow = math.min(l, math.min(haopen, haclose))

len2 = input(10)
o2 = ta.ema(haopen, len2)
c2 = ta.ema(haclose, len2)
h2 = ta.ema(hahigh, len2)
l2 = ta.ema(halow, len2)

col = o2 > c2 ? color.red : color.lime


//plotcandle(o2, h2, l2, c2, title='heikin smoothed', color=col, force_overlay =
true)

//--------------------Trend colour
ema------------------------------------------------//
src0 = close
len0 = input.int(13, minval=1, title='EMA 1')
ema0 = ta.ema(src0, len0)
direction = ta.rising(ema0, 2) ? +1 : ta.falling(ema0, 2) ? -1 : 0
plot_color = direction > 0 ? color.lime : direction < 0 ? color.red : na
plot(ema0, title='EMA', linewidth=1, color=plot_color, force_overlay = true)
//--------------------Trend colour ema
2------------------------------------------------//
src02 = close
len02 = input.int(21, minval=1, title='EMA 2')
ema02 = ta.ema(src02, len02)
direction2 = ta.rising(ema02, 2) ? +1 : ta.falling(ema02, 2) ? -1 : 0
plot_color2 = direction2 > 0 ? color.lime : direction2 < 0 ? color.red : na
plot(ema02, title='EMA Signal 2', linewidth=1, color=plot_color2, force_overlay =
true)
//
//--Modified vyacheslav.shindin-------------------------------------------------//
Signal 1
//Configured ema signal output
fast = input.int(5, minval=1, title='Signal Generator')
slow = input.int(8, minval=1)
vh1 = ta.ema(ta.highest(math.avg(low, close), fast), 5)
vl1 = ta.ema(ta.lowest(math.avg(high, close), slow), 8)
//
e_ema1 = ta.ema(close, 1)
e_ema2 = ta.ema(e_ema1, 1)
e_ema3 = ta.ema(e_ema2, 1)
tema = 1 * (e_ema1 - e_ema2) + e_ema3
//
e_e1 = ta.ema(close, 8)
e_e2 = ta.ema(e_e1, 5)
dema = 2 * e_e1 - e_e2
signal1 = tema > dema ? math.max(vh1, vl1) : math.min(vh1, vl1)
is_call = tema > dema and signal1 > low and signal1 - signal1[1] > signal1[1] -
signal1[2]
is_put = tema < dema and signal1 < high and signal1[1] - signal1 > signal1[2] -
signal1[1]
plotshape(is_call and direction > 0 ? 1 : na, title='BUY ARROW',
color=color.new(color.aqua, 0), text='Buy', style=shape.labelup,
location=location.belowbar, force_overlay = true)
plotshape(is_put and direction < 0 ? -1 : na, title='SELL ARROW',
color=color.new(color.red, 0), text='Sell', style=shape.labeldown, force_overlay =
true)

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

//indicator(title='Om Namah Shivay+', shorttitle='Om Namah Shivay', overlay=false)


showpivot = input(defval=false, title='Show CPR')
showVWAP = input(title='Show VWAP', defval=false)
showEMA9 = input(title='Show EMA-9', defval=false)
showEMA20 = input(title='Show EMA-20', defval=false)
showEMA50 = input(title='Show EMA-50', defval=false)
showEMA100 = input(title='Show EMA-100', defval=false)
showEMA200 = input(title='Show EMA-200', defval=false)
SST = input(true, title='Buy Sell Arrow')

// Long and Short Strategy

[superTrend, dir] = ta.supertrend(3, 10)

// Continuous BUY SELL Signal CONDITIONS

Long = close > ta.ema(close, 21) and close > ta.ema(close, 9) and ta.rsi(close, 14)
> 55 and close > ta.vwap and dir == -1 and volume > ta.sma(volume, 300) and close >
open
Short = close < ta.ema(close, 21) and close < ta.ema(close, 9) and ta.rsi(close,
14) < 45 and close < ta.vwap and dir == 1 and volume > ta.sma(volume, 300) and
close < open

plotshape(SST and Long ? Long : na, title='Long Strategy', style=shape.triangleup,


location=location.belowbar, color=color.new(#4ebb53, 0), size=size.small,
force_overlay = true)
plotshape(SST and Short ? Short : na, title='Short Strategy',
style=shape.triangledown, location=location.abovebar, color=color.new(#FF5252, 0),
size=size.small, force_overlay = true)

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
//////////////////////////////////////////////// EMA -
5/20/50/100/200 ///////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
//////////////////////////////
EMA9_Len = input.int(9, minval=1, title='EMA9_Length')
//EMA5_src = input(close, title="EMA9_Source")
//EMA5_offset = input(title="EMA9_Offset", type=input.integer, defval=0, minval=-
500, maxval=500)
EMA9_out = ta.ema(close, EMA9_Len)
plot(showEMA9 ? EMA9_out : na, title='EMA9', color=color.new(color.green, 0),
offset=0, linewidth=2, force_overlay = true)

EMA20_Len = input.int(20, minval=1, title='EMA20_Length')


//EMA20_src = input(close, title="EMA20_Source")
//EMA20_offset = input(title="EMA20_Offset", type=input.integer, defval=0,
minval=-500, maxval=500)
EMA20_out = ta.ema(close, EMA20_Len)
plot(showEMA20 ? EMA20_out : na, title='EMA20', color=color.new(color.red, 0),
offset=0, linewidth=2, force_overlay = true)

EMA50_Len = input.int(50, minval=1, title='EMA50_Length')


//EMA50_src = input(close, title="EMA50_Source")
//EMA50_offset = input(title="EMA50_Offset", type=input.integer, defval=0,
minval=-500, maxval=500)
EMA50_out = ta.ema(close, EMA50_Len)
plot(showEMA50 ? EMA50_out : na, title='EMA50', color=color.new(color.blue, 0),
offset=0, linewidth=2, force_overlay = true)

EMA100_Len = input.int(100, minval=1, title='EMA100_Length')


//EMA100_src = input(close, title="EMA100_Source")
//EMA100_offset = input(title="EMA100_Offset", type=input.integer, defval=0,
minval=-500, maxval=500)
EMA100_out = ta.ema(close, EMA100_Len)
plot(showEMA100 ? EMA100_out : na, title='EMA100', color=color.new(color.aqua, 0),
offset=0, force_overlay = true)

EMA200_Len = input.int(200, minval=1, title='EMA200_Length')


//EMA200_src = input(close, title="EMA200_Source")
//EMA200_offset = input(title="EMA200_Offset", type=input.integer, defval=0,
minval=-500, maxval=500)
EMA200_out = ta.ema(close, EMA200_Len)
plot(showEMA200 ? EMA200_out : na, title='EMA200', color=color.new(color.yellow,
0), offset=0, linewidth=2, force_overlay = true)

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
///////////////////////////////////////////////////
VWAP /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
//////////////////////////////
//vwaplength = input(title="VWAP Length", type=input.integer, defval=1)
//cvwap = ema(vwap,vwaplength)
cvwap1 = ta.vwap(hlc3)
plotvwap = plot(showVWAP ? cvwap1 : na, title='VWAP', color=color.new(color.black,
0), linewidth=2, force_overlay = true)
[dvwap, dupper, dlower] = ta.vwap(hlc3, timeframe.change('D'), 1)

plot(ta.valuewhen(timeframe.change('D'), dvwap[1], 0), color=color.black,


force_overlay = true)

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
///////////////////////////////////// CENTRAL PIVOT RANGE
(CPR) //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
//////////////////////////////
res = input.timeframe(title='Resolution', defval='D')
res1 = input.timeframe(title='Resolution', defval='W')
res2 = input.timeframe(title='Resolution', defval='M')
H = request.security(syminfo.tickerid, res, high[1], barmerge.gaps_off,
barmerge.lookahead_on)
L = request.security(syminfo.tickerid, res, low[1], barmerge.gaps_off,
barmerge.lookahead_on)
C = request.security(syminfo.tickerid, res, close[1], barmerge.gaps_off,
barmerge.lookahead_on)
WH = request.security(syminfo.tickerid, res1, high[1], barmerge.gaps_off,
barmerge.lookahead_on)
WL = request.security(syminfo.tickerid, res1, low[1], barmerge.gaps_off,
barmerge.lookahead_on)
WC = request.security(syminfo.tickerid, res1, close[1], barmerge.gaps_off,
barmerge.lookahead_on)
//MH = request.security(syminfo.tickerid, res2, high[1], barmerge.gaps_off,
barmerge.lookahead_on)
//ML = request.security(syminfo.tickerid, res2, low[1], barmerge.gaps_off,
barmerge.lookahead_on)
//MC = request.security(syminfo.tickerid, res2, close[1], barmerge.gaps_off,
barmerge.lookahead_on)
TTH = request.security(syminfo.tickerid, res, high, barmerge.gaps_off,
barmerge.lookahead_on)
TTL = request.security(syminfo.tickerid, res, low, barmerge.gaps_off,
barmerge.lookahead_on)
TTC = request.security(syminfo.tickerid, res, close, barmerge.gaps_off,
barmerge.lookahead_on)

PP = (H + L + C) / 3
TC = (H + L) / 2
BC = PP - TC + PP
R1 = PP * 2 - L
R2 = PP + H - L
R3 = H + 2 * (PP - L)
R4 = PP * 3 + H - 3 * L
S1 = PP * 2 - H
S2 = PP - (H - L)
S3 = L - 2 * (H - PP)
S4 = PP * 3 - (3 * H - L)
WPP = (WH + WL + WC) / 3
WTC = (WH + WL) / 2
WBC = WPP - WTC + WPP
TOPP = (TTH + TTL + TTC) / 3
TOTC = (TTH + TTL) / 2
TOBC = TOPP - TOTC + TOPP
TR1 = TOPP * 2 - TTL
TR2 = TOPP + TTH - TTL
TS1 = TOPP * 2 - TTH
TS2 = TOPP - (TTH - TTL)
plot(showpivot ? PP : na, title='PP', style=plot.style_stepline,
color=color.new(color.blue, 0), linewidth=2, force_overlay = true)
plot(showpivot ? TC : na, title='TC', style=plot.style_circles,
color=color.new(color.blue, 0), linewidth=1, force_overlay = true)
plot(showpivot ? BC : na, title='BC', style=plot.style_circles,
color=color.new(color.blue, 0), linewidth=1, force_overlay = true)

plot(showpivot ? WPP : na, title='WPP', style=plot.style_stepline,


color=color.new(color.black, 0), linewidth=2, force_overlay = true)
plot(showpivot ? WTC : na, title='WTC', style=plot.style_stepline,
color=color.new(color.black, 0), linewidth=2, force_overlay = true)
plot(showpivot ? WBC : na, title='WBC', style=plot.style_stepline,
color=color.new(color.black, 0), linewidth=2, force_overlay = true)

//plot(showpivot ? MPP : na, title='MPP', style=plot.style_stepline,


color=color.new(color.black, 0), linewidth=2, force_overlay = true)
//plot(showpivot ? MTC : na, title='MTC', style=plot.style_stepline,
color=color.new(color.black, 0), linewidth=2, force_overlay = true)
//plot(showpivot ? MBC : na, title='MBC', style=plot.style_stepline,
color=color.new(color.black, 0), linewidth=2, force_overlay = true)

plot(showpivot ? S1 : na, title='S1', style=plot.style_stepline,


color=color.new(color.green, 0), linewidth=1, force_overlay = true)
plot(showpivot ? S2 : na, title='S2', style=plot.style_stepline,
color=color.new(color.green, 0), linewidth=1, force_overlay = true)
plot(showpivot ? S3 : na, title='S3', style=plot.style_stepline,
color=color.new(color.green, 0), linewidth=1, force_overlay = true)
//plot(showpivot ? S4 : na, title='S4', style=plot.style_stepline,
color=color.new(color.green, 0), linewidth=1, force_overlay = true)

plot(showpivot ? R1 : na, title='R1', style=plot.style_stepline,


color=color.new(color.red, 0), linewidth=1, force_overlay = true)
plot(showpivot ? R2 : na, title='R2', style=plot.style_stepline,
color=color.new(color.red, 0), linewidth=1, force_overlay = true)
plot(showpivot ? R3 : na, title='R3', style=plot.style_stepline,
color=color.new(color.red, 0), linewidth=1, force_overlay = true)
//plot(showpivot ? R4 : na, title='R4', style=plot.style_stepline,
color=color.new(color.red, 0), linewidth=1, force_overlay = true)

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
/////////////////////////////////////////////////// PREVIOUS
DAY /////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
prevDayHigh = request.security(syminfo.tickerid, 'D', high[1],
lookahead=barmerge.lookahead_on)
prevDayLow = request.security(syminfo.tickerid, 'D', low[1],
lookahead=barmerge.lookahead_on)
plot(prevDayHigh, title='Prev Day High', style=plot.style_cross, linewidth=2,
color=color.new(color.black, 0), force_overlay = true)
plot(prevDayLow, title='Prev Day Low', style=plot.style_cross, linewidth=2,
color=color.new(color.red, 0), force_overlay = true)

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
///////////////////////////////////////////////// PREVIOUS
WEEKLY ///////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
prevWeekHigh = request.security(syminfo.tickerid, 'W', high[1],
lookahead=barmerge.lookahead_on)
prevWeekLow = request.security(syminfo.tickerid, 'W', low[1],
lookahead=barmerge.lookahead_on)
plot(showpivot and prevWeekHigh ? prevWeekHigh : na, title='Prev Week High',
style=plot.style_stepline, linewidth=2, color=color.new(color.red, 0),
force_overlay = true)
plot(showpivot and prevWeekLow ? prevWeekLow : na, title='Prev Week Low',
style=plot.style_stepline, linewidth=2, color=color.new(color.green, 0),
force_overlay = true)

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
///////////////////////////////////////////////// PREVIOUS
MONTH /////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////
//prevMonthHigh = request.security(syminfo.tickerid, 'M', high[1],
lookahead=barmerge.lookahead_on)
//prevMonthLow = request.security(syminfo.tickerid, 'M', low[1],
lookahead=barmerge.lookahead_on)
//plot(showpivot and prevMonthHigh ? prevMonthHigh : na, title='Prev Month High',
style=plot.style_stepline, linewidth=2, color=color.new(color.red, 0),
force_overlay = true)
//plot(showpivot and prevMonthLow ? prevMonthLow : na, title='Prev Month Low',
style=plot.style_stepline, linewidth=2, color=color.new(color.green, 0),
force_overlay = true)

//HAlftrend
amplitude = input(title='Amplitude', defval=4)
channelDeviation = input(title='Channel Deviation', defval=1)
showArrows = input(title='Show Arrows', defval=true)
showChannels = input(title='Show Channels', defval=false)

var int trend1 = 0


var int nextTrend = 0
var float maxLowPrice = nz(low[1], low)
var float minHighPrice = nz(high[1], high)

var float Up = 0.0


var float Down = 0.0
float atrHigh = 0.0
float atrLow = 0.0
float arrowUp = na
float arrowDown = na

atr2 = ta.atr(100) / 2
dev1 = channelDeviation * atr2

highPrice = high[math.abs(ta.highestbars(amplitude))]
lowPrice = low[math.abs(ta.lowestbars(amplitude))]
highma = ta.sma(high, amplitude)
lowma = ta.sma(low, amplitude)
if nextTrend == 1
maxLowPrice := math.max(lowPrice, maxLowPrice)

if highma < maxLowPrice and close < nz(low[1], low)


trend1 := 1
nextTrend := 0
minHighPrice := highPrice
minHighPrice
else
minHighPrice := math.min(highPrice, minHighPrice)

if lowma > minHighPrice and close > nz(high[1], high)


trend1 := 0
nextTrend := 1
maxLowPrice := lowPrice
maxLowPrice

if trend1 == 0
if not na(trend1[1]) and trend1[1] != 0
Up := na(Down[1]) ? Down : Down[1]
arrowUp := Up - atr2
arrowUp
else
Up := na(Up[1]) ? maxLowPrice : math.max(maxLowPrice, Up[1])
Up
atrHigh := Up + dev1
atrLow := Up - dev1
atrLow
else
if not na(trend1[1]) and trend1[1] != 1
Down := na(Up[1]) ? Up : Up[1]
arrowDown := Down + atr2
arrowDown
else
Down := na(Down[1]) ? minHighPrice : math.min(minHighPrice, Down[1])
Down
atrHigh := Down + dev1
atrLow := Down - dev1
atrLow

ht = trend1 == 0 ? Up : Down

var color buyColor = color.green


var color sellColor = color.red

htColor = trend1 == 0 ? buyColor : sellColor


htPlot = plot(ht, title='HalfTrend', linewidth=2, color=htColor, force_overlay =
true)

//atrHighPlot = plot(showChannels ? atrHigh : na, title="ATR High",


style=plot.style_circles, color=sellColor)
//atrLowPlot = plot(showChannels ? atrLow : na, title="ATR Low",
style=plot.style_circles, color=buyColor)

//fill(htPlot, atrHighPlot, title="ATR High Ribbon", color=sellColor)


//fill(htPlot, atrLowPlot, title="ATR Low Ribbon", color=buyColor)

buySignal = not na(arrowUp) and trend1 == 0 and trend1[1] == 1


sellSignal = not na(arrowDown) and trend1 == 1 and trend1[1] == 0
plotshape(showArrows and buySignal ? atrLow : na, title='BUY', text='BUY',
style=shape.labelup, color=color.new(color.green, 0),
textcolor=color.new(color.white, 0), location=location.absolute, size=size.small,
force_overlay = true)
plotshape(showArrows and sellSignal ? atrHigh : na, title='SELL', text='SELL',
color=color.new(color.red, 0), textcolor=color.new(color.white, 0),
style=shape.labeldown, location=location.absolute, size=size.small, force_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.
// Initial weight _m1 is a pole number and equal to _i
_m2 := _i == 9 ? 36 : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10
: _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
_m3 := _i == 9 ? 84 : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10
: _i == 4 ? 4 : _i == 3 ? 1 : 0
_m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5
: _i == 4 ? 1 : 0
_m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6 : _i == 5 ?
1 : 0
_m6 := _i == 9 ? 84 : _i == 8 ? 28 : _i == 7 ? 7 : _i == 6 ? 1 : 0
_m7 := _i == 9 ? 36 : _i == 8 ? 8 : _i == 7 ? 1 : 0
_m8 := _i == 9 ? 9 : _i == 8 ? 1 : 0
_m9 := _i == 9 ? 1 : 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 fun


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
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------

//Source
srcc = input(defval=hlc3, title='Source')

//Poles
int N = input.int(defval=2, title='Poles', minval=1, maxval=9)

//Period
int per = input.int(defval=100, title='Sampling Period', minval=2)

//True Range Multiplier


float mult = input.float(defval=0.414, title='Filtered True Range Multiplier',
minval=0)

//Lag Reduction
bool modeLag = input(defval=false, title='Reduced Lag Mode')
bool modeFast = input(defval=false, title='Fast Response Mode')

//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
//Definitions
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------

//Beta and Alpha Components


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
lag = (per - 1) / (2 * N)

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

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

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

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

// Colors
color1 = #0aff68
color2 = color.orange
color3 = #ff0a5a
color4 = #990032
fcolor = filt > filt[1] ? #0aff68 : filt < filt[1] ? #ff0a5a : #cccccc
barcolor = srcc > srcc[1] and srcc > filt and srcc < hband ? #0aff68 : srcc >
srcc[1] and srcc >= hband ? #0aff1b : srcc <= srcc[1] and srcc > filt ?
color.orange : srcc < srcc[1] and srcc < filt and srcc > lband ? #ff0a5a : srcc <
srcc[1] and srcc <= lband ? #ff0a11 : srcc >= srcc[1] and srcc < filt ? #990032 :
#cccccc

//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------
//Outputs
//---------------------------------------------------------------------------------
--------------------------------------------------------------------------------

//Filter Plot
filtplot = plot(filt, title='Filter', color=fcolor, linewidth=3, force_overlay =
true)

//Band Plots
hbandplot = plot(hband, title='Filtered True Range High Band', color=fcolor,
force_overlay = true)
lbandplot = plot(lband, title='Filtered True Range Low Band', color=fcolor,
force_overlay = true)

//Channel Fill
fill(hbandplot, lbandplot, title='Channel Fill', color=fcolor, transp=80)

//Bar Color
barcolor(barcolor)

You might also like