Kripto Fema ind/ This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// © Femayakup
//@version=5
indicator(title = "Kripto Fema ind", shorttitle="Kripto Fema ind", overlay=true, format=format.price, precision=2,max_lines_count = 500, max_labels_count = 500, max_bars_back=500)
showEma200 = input(true, title="EMA 200")
showPmax = input(true, title="Pmax")
showLinreg = input(true, title="Linreg")
showMavilim = input(true, title="Mavilim")
showNadaray = input(true, title="Nadaraya Watson")
ma(source, length, type) =>
switch type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)
//Ema200
timeFrame = input.timeframe(defval = '240',title= 'EMA200 TimeFrame',group = 'EMA200 Settings')
len200 = input.int(200, minval=1, title="Length",group = 'EMA200 Settings')
src200 = input(close, title="Source",group = 'EMA200 Settings')
offset200 = input.int(title="Offset", defval=0, minval=-500, maxval=500,group = 'EMA200 Settings')
out200 = ta.ema(src200, len200)
higherTimeFrame = request.security(syminfo.tickerid,timeFrame,out200 ,barmerge.gaps_on,barmerge.lookahead_on)
ema200Plot = showEma200 ? higherTimeFrame : na
plot(ema200Plot, title="EMA200", offset=offset200)
//Linreq
group1 = "Linreg Settings"
lengthInput = input.int(100, title="Length", minval = 1, maxval = 5000,group = group1)
sourceInput = input.source(close, title="Source")
useUpperDevInput = input.bool(true, title="Upper Deviation", inline = "Upper Deviation", group = group1)
upperMultInput = input.float(2.0, title="", inline = "Upper Deviation", group = group1)
useLowerDevInput = input.bool(true, title="Lower Deviation", inline = "Lower Deviation", group = group1)
lowerMultInput = input.float(2.0, title="", inline = "Lower Deviation", group = group1)
group2 = "Linreg Display Settings"
showPearsonInput = input.bool(true, "Show Pearson's R", group = group2)
extendLeftInput = input.bool(false, "Extend Lines Left", group = group2)
extendRightInput = input.bool(true, "Extend Lines Right", group = group2)
extendStyle = switch
extendLeftInput and extendRightInput => extend.both
extendLeftInput => extend.left
extendRightInput => extend.right
=> extend.none
group3 = "Linreg Color Settings"
colorUpper = input.color(color.new(color.blue, 85), "Linreg Renk", inline = group3, group = group3)
colorLower = input.color(color.new(color.red, 85), "", inline = group3, group = group3)
calcSlope(source, length) =>
max_bars_back(source, 5000)
if not barstate.islast or length <= 1
else
sumX = 0.0
sumY = 0.0
sumXSqr = 0.0
sumXY = 0.0
for i = 0 to length - 1 by 1
val = source
per = i + 1.0
sumX += per
sumY += val
sumXSqr += per * per
sumXY += val * per
slope = (length * sumXY - sumX * sumY) / (length * sumXSqr - sumX * sumX)
average = sumY / length
intercept = average - slope * sumX / length + slope
= calcSlope(sourceInput, lengthInput)
startPrice = i + s * (lengthInput - 1)
endPrice = i
var line baseLine = na
if na(baseLine) and not na(startPrice) and showLinreg
baseLine := line.new(bar_index - lengthInput + 1, startPrice, bar_index, endPrice, width=1, extend=extendStyle, color=color.new(colorLower, 0))
else
line.set_xy1(baseLine, bar_index - lengthInput + 1, startPrice)
line.set_xy2(baseLine, bar_index, endPrice)
na
calcDev(source, length, slope, average, intercept) =>
upDev = 0.0
dnDev = 0.0
stdDevAcc = 0.0
dsxx = 0.0
dsyy = 0.0
dsxy = 0.0
periods = length - 1
daY = intercept + slope * periods / 2
val = intercept
for j = 0 to periods by 1
price = high - val
if price > upDev
upDev := price
price := val - low
if price > dnDev
dnDev := price
price := source
dxt = price - average
dyt = val - daY
price -= val
stdDevAcc += price * price
dsxx += dxt * dxt
dsyy += dyt * dyt
dsxy += dxt * dyt
val += slope
stdDev = math.sqrt(stdDevAcc / (periods == 0 ? 1 : periods))
pearsonR = dsxx == 0 or dsyy == 0 ? 0 : dsxy / math.sqrt(dsxx * dsyy)
= calcDev(sourceInput, lengthInput, s, a, i)
upperStartPrice = startPrice + (useUpperDevInput ? upperMultInput * stdDev : upDev)
upperEndPrice = endPrice + (useUpperDevInput ? upperMultInput * stdDev : upDev)
var line upper = na
lowerStartPrice = startPrice + (useLowerDevInput ? -lowerMultInput * stdDev : -dnDev)
lowerEndPrice = endPrice + (useLowerDevInput ? -lowerMultInput * stdDev : -dnDev)
var line lower = na
if na(upper) and not na(upperStartPrice) and showLinreg
upper := line.new(bar_index - lengthInput + 1, upperStartPrice, bar_index, upperEndPrice, width=1, extend=extendStyle, color=color.new(colorUpper, 0))
else
line.set_xy1(upper, bar_index - lengthInput + 1, upperStartPrice)
line.set_xy2(upper, bar_index, upperEndPrice)
na
if na(lower) and not na(lowerStartPrice) and showLinreg
lower := line.new(bar_index - lengthInput + 1, lowerStartPrice, bar_index, lowerEndPrice, width=1, extend=extendStyle, color=color.new(colorUpper, 0))
else
line.set_xy1(lower, bar_index - lengthInput + 1, lowerStartPrice)
line.set_xy2(lower, bar_index, lowerEndPrice)
na
showLinregPlotUpper = showLinreg ? upper : na
showLinregPlotLower = showLinreg ? lower : na
showLinregPlotBaseLine = showLinreg ? baseLine : na
linefill.new(showLinregPlotUpper, showLinregPlotBaseLine, color = colorUpper)
linefill.new(showLinregPlotBaseLine, showLinregPlotLower, color = colorLower)
// Pearson's R
var label r = na
label.delete(r )
if showPearsonInput and not na(pearsonR) and showLinreg
r := label.new(bar_index - lengthInput + 1, lowerStartPrice, str.tostring(pearsonR, "#.################"), color = color.new(color.white, 100), textcolor=color.new(colorUpper, 0), size=size.normal, style=label.style_label_up)
//Mavilim
group4 = "Mavilim Settings"
mavilimold = input(false, title="Show Previous Version of MavilimW?",group=group4)
fmal=input(3,"First Moving Average length",group = group4)
smal=input(5,"Second Moving Average length",group = group4)
tmal=fmal+smal
Fmal=smal+tmal
Ftmal=tmal+Fmal
Smal=Fmal+Ftmal
M1= ta.wma(close, fmal)
M2= ta.wma(M1, smal)
M3= ta.wma(M2, tmal)
M4= ta.wma(M3, Fmal)
M5= ta.wma(M4, Ftmal)
MAVW= ta.wma(M5, Smal)
col1= MAVW>MAVW
col3= MAVWpmaxsrc ? pmaxsrc-pmaxsrc : 0
vdd1=pmaxsrc
ma = 0.0
if mav == "SMA"
ma := ta.sma(pmaxsrc, length)
ma
if mav == "EMA"
ma := ta.ema(pmaxsrc, length)
ma
if mav == "WMA"
ma := ta.wma(pmaxsrc, length)
ma
if mav == "TMA"
ma := ta.sma(ta.sma(pmaxsrc, math.ceil(length / 2)), math.floor(length / 2) + 1)
ma
if mav == "VAR"
ma := VAR
ma
if mav == "WWMA"
ma := WWMA
ma
if mav == "ZLEMA"
ma := ZLEMA
ma
if mav == "TSF"
ma := TSF
ma
ma
MAvg=getMA(pmaxsrc, length)
longStop = Normalize ? MAvg - Multiplier*atr/close : MAvg - Multiplier*atr
longStopPrev = nz(longStop , longStop)
longStop := MAvg > longStopPrev ? math.max(longStop, longStopPrev) : longStop
shortStop = Normalize ? MAvg + Multiplier*atr/close : MAvg + Multiplier*atr
shortStopPrev = nz(shortStop , shortStop)
shortStop := MAvg < shortStopPrev ? math.min(shortStop, shortStopPrev) : shortStop
dir = 1
dir := nz(dir , dir)
dir := dir == -1 and MAvg > shortStopPrev ? 1 : dir == 1 and MAvg < longStopPrev ? -1 : dir
PMax = dir==1 ? longStop: shortStop
plot(showsupport ? MAvg : na, color=#fbff04, linewidth=2, title="EMA9")
pALL=plot(PMax, color=color.new(color.red, transp = 0), linewidth=2, title="PMax")
alertcondition(ta.cross(MAvg, PMax), title="Cross Alert", message="PMax - Moving Avg Crossing!")
alertcondition(ta.crossover(MAvg, PMax), title="Crossover Alarm", message="Moving Avg BUY SIGNAL!")
alertcondition(ta.crossunder(MAvg, PMax), title="Crossunder Alarm", message="Moving Avg SELL SIGNAL!")
alertcondition(ta.cross(pmaxsrc, PMax), title="Price Cross Alert", message="PMax - Price Crossing!")
alertcondition(ta.crossover(pmaxsrc, PMax), title="Price Crossover Alarm", message="PRICE OVER PMax - BUY SIGNAL!")
alertcondition(ta.crossunder(pmaxsrc, PMax), title="Price Crossunder Alarm", message="PRICE UNDER PMax - SELL SIGNAL!")
buySignalk = ta.crossover(MAvg, PMax)
plotshape(buySignalk and showsignalsk ? PMax*0.995 : na, title="Buy", text="Buy", location=location.absolute, style=shape.labelup, size=size.tiny, color=color.new(color.green, transp = 0), textcolor=color.white)
sellSignallk = ta.crossunder(MAvg, PMax)
plotshape(sellSignallk and showsignalsk ? PMax*1.005 : na, title="Sell", text="Sell", location=location.absolute, style=shape.labeldown, size=size.tiny, color=color.new(color.red, transp = 0), textcolor=color.white)
// buySignalc = ta.crossover(pmaxsrc, PMax)
// plotshape(buySignalc and showsignalsc ? PMax*0.995 : na, title="Buy", text="Buy", location=location.absolute, style=shape.labelup, size=size.tiny, color=#0F18BF, textcolor=color.white)
// sellSignallc = ta.crossunder(pmaxsrc, PMax)
// plotshape(sellSignallc and showsignalsc ? PMax*1.005 : na, title="Sell", text="Sell", location=location.absolute, style=shape.labeldown, size=size.tiny, color=#0F18BF, textcolor=color.white)
// mPlot = plot(ohlc4, title="", style=plot.style_circles, linewidth=0,display=display.none)
longFillColor = highlighting ? (MAvg>PMax ? color.new(color.green, transp = 90) : na) : na
shortFillColor = highlighting ? (MAvg math.exp(-(math.pow(x, 2)/(h * h * 2)))
//-----------------------------------------------------------------------------}
//Append lines
//-----------------------------------------------------------------------------{
n = bar_index
var ln = array.new_line(0)
if barstate.isfirst and repaint
for i = 0 to 499
array.push(ln,line.new(na,na,na,na))
//-----------------------------------------------------------------------------}
//End point method
//-----------------------------------------------------------------------------{
var coefs = array.new_float(0)
var den = 0.
if barstate.isfirst and not repaint
for i = 0 to 499
w = gauss(i, h)
coefs.push(w)
den := coefs.sum()
out = 0.
if not repaint
for i = 0 to 499
out += src * coefs.get(i)
out /= den
mae = ta.sma(math.abs(src - out), 499) * mult
upperN = out + mae
lowerN = out - mae
//-----------------------------------------------------------------------------}
//Compute and display NWE
//-----------------------------------------------------------------------------{
float y2 = na
float y1 = na
nwe = array.new(0)
if barstate.islast and repaint
sae = 0.
//Compute and set NWE point
for i = 0 to math.min(499,n - 1)
sum = 0.
sumw = 0.
//Compute weighted mean
for j = 0 to math.min(499,n - 1)
w = gauss(i - j, h)
sum += src * w
sumw += w
y2 := sum / sumw
sae += math.abs(src - y2)
nwe.push(y2)
sae := sae / math.min(499,n - 1) * mult
for i = 0 to math.min(499,n - 1)
if i%2 and showNadaray
line.new(n-i+1, y1 + sae, n-i, nwe.get(i) + sae, color = upCss)
line.new(n-i+1, y1 - sae, n-i, nwe.get(i) - sae, color = dnCss)
if src > nwe.get(i) + sae and src < nwe.get(i) + sae and showNadaray
label.new(n-i, src , '▼', color = color(na), style = label.style_label_down, textcolor = dnCss, textalign = text.align_center)
if src < nwe.get(i) - sae and src > nwe.get(i) - sae and showNadaray
label.new(n-i, src , '▲', color = color(na), style = label.style_label_up, textcolor = upCss, textalign = text.align_center)
y1 := nwe.get(i)
//-----------------------------------------------------------------------------}
//Dashboard
//-----------------------------------------------------------------------------{
var tb = table.new(position.top_right, 1, 1
, bgcolor = #1e222d
, border_color = #373a46
, border_width = 1
, frame_color = #373a46
, frame_width = 1)
if repaint
tb.cell(0, 0, 'Repainting Mode Enabled', text_color = color.white, text_size = size.small)
//-----------------------------------------------------------------------------}
//Plot
//-----------------------------------------------------------------------------}
// plot(repaint ? na : out + mae, 'Upper', upCss)
// plot(repaint ? na : out - mae, 'Lower', dnCss)
//Crossing Arrows
// plotshape(ta.crossunder(close, out - mae) ? low : na, "Crossunder", shape.labelup, location.absolute, color(na), 0 , text = '▲', textcolor = upCss, size = size.tiny)
// plotshape(ta.crossover(close, out + mae) ? high : na, "Crossover", shape.labeldown, location.absolute, color(na), 0 , text = '▼', textcolor = dnCss, size = size.tiny)
//-----------------------------------------------------------------------------}
//////////////////////////////////////////////////////////////////////////////////
enableD = input (true, "DIVERGANCE ON/OFF" , group="INDICATORS ON/OFF")
//DIVERGANCE
prd1 = input.int (defval=5 , title='PIVOT PERIOD' , minval=1, maxval=50 , group="DIVERGANCE")
source = input.string(defval='HIGH/LOW' , title='SOURCE FOR PIVOT POINTS' , options= , group="DIVERGANCE")
searchdiv = input.string(defval='REGULAR/HIDDEN', title='DIVERGANCE TYPE' , options= , group="DIVERGANCE")
showindis = input.string(defval='FULL' , title='SHOW INDICATORS NAME' , options= , group="DIVERGANCE")
showlimit = input.int(1 , title='MINIMUM NUMBER OF DIVERGANCES', minval=1, maxval=11 , group="DIVERGANCE")
maxpp = input.int (defval=20 , title='MAXIMUM PIVOT POINTS TO CHECK', minval=1, maxval=20 , group="DIVERGANCE")
maxbars = input.int (defval=200 , title='MAXIMUM BARS TO CHECK' , minval=30, maxval=200 , group="DIVERGANCE")
showlast = input (defval=false , title='SHOW ONLY LAST DIVERGANCE' , group="DIVERGANCE")
dontconfirm = input (defval=false , title="DON'T WAIT FOR CONFORMATION" , group="DIVERGANCE")
showlines = input (defval=false , title='SHOW DIVERGANCE LINES' , group="DIVERGANCE")
showpivot = input (defval=false , title='SHOW PIVOT POINTS' , group="DIVERGANCE")
calcmacd = input (defval=true , title='MACD' , group="DIVERGANCE")
calcmacda = input (defval=true , title='MACD HISTOGRAM' , group="DIVERGANCE")
calcrsi = input (defval=true , title='RSI' , group="DIVERGANCE")
calcstoc = input (defval=true , title='STOCHASTIC' , group="DIVERGANCE")
calccci = input (defval=true , title='CCI' , group="DIVERGANCE")
calcmom = input (defval=true , title='MOMENTUM' , group="DIVERGANCE")
calcobv = input (defval=true , title='OBV' , group="DIVERGANCE")
calcvwmacd = input (true , title='VWMACD' , group="DIVERGANCE")
calccmf = input (true , title='CHAIKIN MONEY FLOW' , group="DIVERGANCE")
calcmfi = input (true , title='MONEY FLOW INDEX' , group="DIVERGANCE")
calcext = input (false , title='CHECK EXTERNAL INDICATOR' , group="DIVERGANCE")
externalindi = input (defval=close , title='EXTERNAL INDICATOR' , group="DIVERGANCE")
pos_reg_div_col = input (defval=#ffffff , title='POSITIVE REGULAR DIVERGANCE' , group="DIVERGANCE")
neg_reg_div_col = input (defval=#00def6 , title='NEGATIVE REGULAR DIVERGANCE' , group="DIVERGANCE")
pos_hid_div_col = input (defval=#00ff0a , title='POSITIVE HIDDEN DIVERGANCE' , group="DIVERGANCE")
neg_hid_div_col = input (defval=#ff0015 , title='NEGATIVE HIDDEN DIVERGANCE' , group="DIVERGANCE")
reg_div_l_style_ = input.string(defval='SOLID' , title='REGULAR DIVERGANCE LINESTYLE' , options= , group="DIVERGANCE")
hid_div_l_style_ = input.string(defval='SOLID' , title='HIDDEN DIVERGANCE LINESTYLE' , options= , group="DIVERGANCE")
reg_div_l_width = input.int (defval=2 , title='REGULAR DIVERGANCE LINEWIDTH' , minval=1, maxval=5 , group="DIVERGANCE")
hid_div_l_width = input.int (defval=2 , title='HIDDEN DIVERGANCE LINEWIDTH' , minval=1, maxval=5 , group="DIVERGANCE")
showmas = input.bool (defval=false , title='SHOW MOVING AVERAGES (50 & 200)', inline='MA' , group="DIVERGANCE")
cma1col = input.color (defval=#ffffff , title='' , inline='MA' , group="DIVERGANCE")
cma2col = input.color (defval=#00def6 , title='' , inline='MA' , group="DIVERGANCE")
//PLOTS
plot(showmas ? ta.sma(close, 50) : na, color=showmas ? cma1col : na)
plot(showmas ? ta.sma(close, 200) : na, color=showmas ? cma2col : na)
var reg_div_l_style = reg_div_l_style_ == 'SOLID' ? line.style_solid : reg_div_l_style_ == 'DASHED' ? line.style_dashed : line.style_dotted
var hid_div_l_style = hid_div_l_style_ == 'SOLID' ? line.style_solid : hid_div_l_style_ == 'DASHED' ? line.style_dashed : line.style_dotted
rsi = ta.rsi(close, 14)
= ta.macd(close, 12, 26, 9)
moment = ta.mom(close, 10)
cci = ta.cci(close, 10)
Obv = ta.obv
stk = ta.sma(ta.stoch(close, high, low, 14), 3)
maFast = ta.vwma(close, 12)
maSlow = ta.vwma(close, 26)
vwmacd = maFast - maSlow
Cmfm = (close - low - (high - close)) / (high - low)
Cmfv = Cmfm * volume
cmf = ta.sma(Cmfv, 21) / ta.sma(volume, 21)
Mfi = ta.mfi(close, 14)
var indicators_name = array.new_string(11)
var div_colors = array.new_color(4)
if barstate.isfirst and enableD
array.set(indicators_name, 0, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 1, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 2, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 3, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 4, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 5, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 6, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 7, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 8, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 9, showindis == "DON'T SHOW" ? '' : '')
array.set(indicators_name, 10, showindis == "DON'T SHOW" ? '' : '')
array.set(div_colors, 0, pos_reg_div_col)
array.set(div_colors, 1, neg_reg_div_col)
array.set(div_colors, 2, pos_hid_div_col)
array.set(div_colors, 3, neg_hid_div_col)
float ph1 = ta.pivothigh(source == 'CLOSE' ? close : high, prd1, prd1)
float pl1 = ta.pivotlow(source == 'CLOSE' ? close : low, prd1, prd1)
plotshape(ph1 and showpivot, text='H', style=shape.labeldown, color=color.new(color.white, 100), textcolor=#00def6, location=location.abovebar, offset=-prd1)
plotshape(pl1 and showpivot, text='L', style=shape.labelup, color=color.new(color.white, 100), textcolor=#ffffff, location=location.belowbar, offset=-prd1)
var int maxarraysize = 20
var ph_positions = array.new_int(maxarraysize, 0)
var pl_positions = array.new_int(maxarraysize, 0)
var ph_vals = array.new_float(maxarraysize, 0.)
var pl_vals = array.new_float(maxarraysize, 0.)
if ph1
array.unshift(ph_positions, bar_index)
array.unshift(ph_vals, ph1)
if array.size(ph_positions) > maxarraysize
array.pop(ph_positions)
array.pop(ph_vals)
if pl1
array.unshift(pl_positions, bar_index)
array.unshift(pl_vals, pl1)
if array.size(pl_positions) > maxarraysize
array.pop(pl_positions)
array.pop(pl_vals)
positive_regular_positive_hidden_divergence(src, cond) =>
divlen = 0
prsc = source == 'CLOSE' ? close : low
if dontconfirm or src > src or close > close
startpoint = dontconfirm ? 0 : 1
for x = 0 to maxpp - 1 by 1
len = bar_index - array.get(pl_positions, x) + prd1
if array.get(pl_positions, x) == 0 or len > maxbars
break
if len > 5 and (cond == 1 and src > src and prsc < nz(array.get(pl_vals, x)) or cond == 2 and src < src and prsc > nz(array.get(pl_vals, x)))
slope1 = (src - src ) / (len - startpoint)
virtual_line1 = src - slope1
slope2 = (close - close ) / (len - startpoint)
virtual_line2 = close - slope2
arrived = true
for y = 1 + startpoint to len - 1 by 1
if src < virtual_line1 or nz(close ) < virtual_line2
arrived := false
break
virtual_line1 -= slope1
virtual_line2 -= slope2
virtual_line2
if arrived
divlen := len
break
divlen
negative_regular_negative_hidden_divergence(src, cond) =>
divlen = 0
prsc = source == 'CLOSE' ? close : high
if dontconfirm or src < src or close < close
startpoint = dontconfirm ? 0 : 1
for x = 0 to maxpp - 1 by 1
len = bar_index - array.get(ph_positions, x) + prd1
if array.get(ph_positions, x) == 0 or len > maxbars
break
if len > 5 and (cond == 1 and src < src and prsc > nz(array.get(ph_vals, x)) or cond == 2 and src > src and prsc < nz(array.get(ph_vals, x)))
slope1 = (src - src ) / (len - startpoint)
virtual_line1 = src - slope1
slope2 = (close - nz(close )) / (len - startpoint)
virtual_line2 = close - slope2
arrived = true
for y = 1 + startpoint to len - 1 by 1
if src > virtual_line1 or nz(close ) > virtual_line2
arrived := false
break
virtual_line1 -= slope1
virtual_line2 -= slope2
virtual_line2
if arrived
divlen := len
break
divlen
//CALCULATIONS
calculate_divs(cond, indicator_1) =>
divs = array.new_int(4, 0)
array.set(divs, 0, cond and (searchdiv == 'REGULAR' or searchdiv == 'REGULAR/HIDDEN') ? positive_regular_positive_hidden_divergence(indicator_1, 1) : 0)
array.set(divs, 1, cond and (searchdiv == 'REGULAR' or searchdiv == 'REGULAR/HIDDEN') ? negative_regular_negative_hidden_divergence(indicator_1, 1) : 0)
array.set(divs, 2, cond and (searchdiv == 'HIDDEN' or searchdiv == 'REGULAR/HIDDEN') ? positive_regular_positive_hidden_divergence(indicator_1, 2) : 0)
array.set(divs, 3, cond and (searchdiv == 'HIDDEN' or searchdiv == 'REGULAR/HIDDEN') ? negative_regular_negative_hidden_divergence(indicator_1, 2) : 0)
divs
var all_divergences = array.new_int(44)
array_set_divs(div_pointer, index) =>
for x = 0 to 3 by 1
array.set(all_divergences, index * 4 + x, array.get(div_pointer, x))
array_set_divs(calculate_divs(calcmacd , macd) , 0)
array_set_divs(calculate_divs(calcmacda , deltamacd) , 1)
array_set_divs(calculate_divs(calcrsi , rsi) , 2)
array_set_divs(calculate_divs(calcstoc , stk) , 3)
array_set_divs(calculate_divs(calccci , cci) , 4)
array_set_divs(calculate_divs(calcmom , moment) , 5)
array_set_divs(calculate_divs(calcobv , Obv) , 6)
array_set_divs(calculate_divs(calcvwmacd, vwmacd) , 7)
array_set_divs(calculate_divs(calccmf , cmf) , 8)
array_set_divs(calculate_divs(calcmfi , Mfi) , 9)
array_set_divs(calculate_divs(calcext , externalindi), 10)
total_div = 0
for x = 0 to array.size(all_divergences) - 1 by 1
total_div += math.round(math.sign(array.get(all_divergences, x)))
total_div
if total_div < showlimit
array.fill(all_divergences, 0)
var pos_div_lines = array.new_line(0)
var neg_div_lines = array.new_line(0)
var pos_div_labels = array.new_label(0)
var neg_div_labels = array.new_label(0)
delete_old_pos_div_lines() =>
if array.size(pos_div_lines) > 0
for j = 0 to array.size(pos_div_lines) - 1 by 1
line.delete(array.get(pos_div_lines, j))
array.clear(pos_div_lines)
delete_old_neg_div_lines() =>
if array.size(neg_div_lines) > 0
for j = 0 to array.size(neg_div_lines) - 1 by 1
line.delete(array.get(neg_div_lines, j))
array.clear(neg_div_lines)
delete_old_pos_div_labels() =>
if array.size(pos_div_labels) > 0
for j = 0 to array.size(pos_div_labels) - 1 by 1
label.delete(array.get(pos_div_labels, j))
array.clear(pos_div_labels)
delete_old_neg_div_labels() =>
if array.size(neg_div_labels) > 0
for j = 0 to array.size(neg_div_labels) - 1 by 1
label.delete(array.get(neg_div_labels, j))
array.clear(neg_div_labels)
delete_last_pos_div_lines_label(n) =>
if n > 0 and array.size(pos_div_lines) >= n
asz = array.size(pos_div_lines)
for j = 1 to n by 1
line.delete(array.get(pos_div_lines, asz - j))
array.pop(pos_div_lines)
if array.size(pos_div_labels) > 0
label.delete(array.get(pos_div_labels, array.size(pos_div_labels) - 1))
array.pop(pos_div_labels)
delete_last_neg_div_lines_label(n) =>
if n > 0 and array.size(neg_div_lines) >= n
asz = array.size(neg_div_lines)
for j = 1 to n by 1
line.delete(array.get(neg_div_lines, asz - j))
array.pop(neg_div_lines)
if array.size(neg_div_labels) > 0
label.delete(array.get(neg_div_labels, array.size(neg_div_labels) - 1))
array.pop(neg_div_labels)
pos_reg_div_detected = false
neg_reg_div_detected = false
pos_hid_div_detected = false
neg_hid_div_detected = false
var last_pos_div_lines = 0
var last_neg_div_lines = 0
var remove_last_pos_divs = false
var remove_last_neg_divs = false
if pl1
remove_last_pos_divs := false
last_pos_div_lines := 0
last_pos_div_lines
if ph1
remove_last_neg_divs := false
last_neg_div_lines := 0
last_neg_div_lines
divergence_text_top = ''
divergence_text_bottom = ''
distances = array.new_int(0)
dnumdiv_top = 0
dnumdiv_bottom = 0
top_label_col = color.white
bottom_label_col = color.white
old_pos_divs_can_be_removed = true
old_neg_divs_can_be_removed = true
startpoint = dontconfirm ? 0 : 1
for x = 0 to 10 by 1
div_type = -1
for y = 0 to 3 by 1
if array.get(all_divergences, x * 4 + y) > 0
div_type := y
if y % 2 == 1
dnumdiv_top += 1
top_label_col := array.get(div_colors, y)
top_label_col
if y % 2 == 0
dnumdiv_bottom += 1
bottom_label_col := array.get(div_colors, y)
bottom_label_col
if not array.includes(distances, array.get(all_divergences, x * 4 + y))
array.push(distances, array.get(all_divergences, x * 4 + y))
new_line = showlines ? line.new(x1=bar_index - array.get(all_divergences, x * 4 + y), y1=source == 'CLOSE' ? close : y % 2 == 0 ? low : high , x2=bar_index - startpoint, y2=source == 'CLOSE' ? close : y % 2 == 0 ? low : high , color=array.get(div_colors, y), style=y < 2 ? reg_div_l_style : hid_div_l_style, width=y < 2 ? reg_div_l_width : hid_div_l_width) : na
if y % 2 == 0
if old_pos_divs_can_be_removed
old_pos_divs_can_be_removed := false
if not showlast and remove_last_pos_divs
delete_last_pos_div_lines_label(last_pos_div_lines)
last_pos_div_lines := 0
last_pos_div_lines
if showlast
delete_old_pos_div_lines()
array.push(pos_div_lines, new_line)
last_pos_div_lines += 1
remove_last_pos_divs := true
remove_last_pos_divs
if y % 2 == 1
if old_neg_divs_can_be_removed
old_neg_divs_can_be_removed := false
if not showlast and remove_last_neg_divs
delete_last_neg_div_lines_label(last_neg_div_lines)
last_neg_div_lines := 0
last_neg_div_lines
if showlast
delete_old_neg_div_lines()
array.push(neg_div_lines, new_line)
last_neg_div_lines += 1
remove_last_neg_divs := true
remove_last_neg_divs
if y == 0
pos_reg_div_detected := true
pos_reg_div_detected
if y == 1
neg_reg_div_detected := true
neg_reg_div_detected
if y == 2
pos_hid_div_detected := true
pos_hid_div_detected
if y == 3
neg_hid_div_detected := true
neg_hid_div_detected
if div_type >= 0
divergence_text_top += (div_type % 2 == 1 ? showindis != "DON'T SHOW" ? array.get(indicators_name, x) + ' ' : '' : '')
divergence_text_bottom += (div_type % 2 == 0 ? showindis != "DON'T SHOW" ? array.get(indicators_name, x) + ' ' : '' : '')
divergence_text_bottom
if showindis != "DON'T SHOW"
if dnumdiv_top > 0
divergence_text_top += str.tostring(dnumdiv_top)
divergence_text_top
if dnumdiv_bottom > 0
divergence_text_bottom += str.tostring(dnumdiv_bottom)
divergence_text_bottom
if divergence_text_top != ''
if showlast
delete_old_neg_div_labels()
array.push(neg_div_labels, label.new(x=bar_index, y=math.max(high, high ), color=top_label_col, style=label.style_diamond, size = size.auto))
if divergence_text_bottom != ''
if showlast
delete_old_pos_div_labels()
array.push(pos_div_labels, label.new(x=bar_index, y=math.min(low, low ), color=bottom_label_col, style=label.style_diamond, size = size.auto))
// POSITION AND SIZE
PosTable = input.string(defval="Bottom Right", title="Position", options= , group="Table Location & Size", inline="1")
SizTable = input.string(defval="Auto", title="Size", options= , group="Table Location & Size", inline="1")
Pos1Table = PosTable == "Top Right" ? position.top_right : PosTable == "Middle Right" ? position.middle_right : PosTable == "Bottom Right" ? position.bottom_right : PosTable == "Top Center" ? position.top_center : PosTable == "Middle Center" ? position.middle_center : PosTable == "Bottom Center" ? position.bottom_center : PosTable == "Top Left" ? position.top_left : PosTable == "Middle Left" ? position.middle_left : position.bottom_left
Siz1Table = SizTable == "Auto" ? size.auto : SizTable == "Huge" ? size.huge : SizTable == "Large" ? size.large : SizTable == "Normal" ? size.normal : SizTable == "Small" ? size.small : size.tiny
tbl = table.new(Pos1Table, 21, 16, border_width = 1, border_color = color.gray, frame_color = color.gray, frame_width = 1)
// Kullanıcı tarafından belirlenecek yeşil ve kırmızı zaman dilimi sayısı
greenThreshold = input.int(5, minval=1, maxval=10, title="Yeşil Zaman Dilimi Sayısı", group="Alarm Ayarları")
redThreshold = input.int(5, minval=1, maxval=10, title="Kırmızı Zaman Dilimi Sayısı", group="Alarm Ayarları")
// TIMEFRAMES OPTIONS
box01 = input.bool(true, "TF ", inline = "01", group="Select Timeframe")
tf01 = input.timeframe("1", "", inline = "01", group="Select Timeframe")
box02 = input.bool(false, "TF ", inline = "02", group="Select Timeframe")
tf02 = input.timeframe("3", "", inline = "02", group="Select Timeframe")
box03 = input.bool(true, "TF ", inline = "03", group="Select Timeframe")
tf03 = input.timeframe("5", "", inline = "03", group="Select Timeframe")
box04 = input.bool(true, "TF ", inline = "04", group="Select Timeframe")
tf04 = input.timeframe("15", "", inline = "04", group="Select Timeframe")
box05 = input.bool(false, "TF ", inline = "05", group="Select Timeframe")
tf05 = input.timeframe("30", "", inline = "05", group="Select Timeframe")
box06 = input.bool(true, "TF ", inline = "01", group="Select Timeframe")
tf06 = input.timeframe("60", "", inline = "01", group="Select Timeframe")
box07 = input.bool(false, "TF ", inline = "02", group="Select Timeframe")
tf07 = input.timeframe("120", "", inline = "02", group="Select Timeframe")
box08 = input.bool(false, "TF ", inline = "03", group="Select Timeframe")
tf08 = input.timeframe("180", "", inline = "03", group="Select Timeframe")
box09 = input.bool(true, "TF ", inline = "04", group="Select Timeframe")
tf09 = input.timeframe("240", "", inline = "04", group="Select Timeframe")
box10 = input.bool(false, "TF ", inline = "05", group="Select Timeframe")
tf10 = input.timeframe("D", "", inline = "05", group="Select Timeframe")
// indicator('Tillson FEMA', overlay=true)
length1 = input(1, 'FEMA Length')
a1 = input(0.7, 'Volume Factor')
e1 = ta.ema((high + low + 2 * close) / 4, length1)
e2 = ta.ema(e1, length1)
e3 = ta.ema(e2, length1)
e4 = ta.ema(e3, length1)
e5 = ta.ema(e4, length1)
e6 = ta.ema(e5, length1)
c1 = -a1 * a1 * a1
c2 = 3 * a1 * a1 + 3 * a1 * a1 * a1
c3 = -6 * a1 * a1 - 3 * a1 - 3 * a1 * a1 * a1
c4 = 1 + 3 * a1 + a1 * a1 * a1 + 3 * a1 * a1
FEMA = c1 * e6 + c2 * e5 + c3 * e4 + c4 * e3
tablocol1 = FEMA > FEMA
tablocol3 = FEMA < FEMA
color_1 = col1 ? color.rgb(149, 219, 35): col3 ? color.rgb(238, 11, 11) : color.yellow
plot(FEMA, color=color_1, linewidth=3, title='FEMA')
tilson1 = FEMA
tilson1a =FEMA
// DEFINITION OF VALUES
symbol = ticker.modify(syminfo.tickerid, syminfo.session)
tfArr = array.new(na)
tilson1Arr = array.new(na)
tilson1aArr = array.new(na)
// DEFINITIONS OF RSI & CCI FUNCTIONS APPENDED IN THE TIMEFRAME OPTIONS
cciNcciFun(tf, flg) =>
= request.security(symbol, tf, )
if flg and (barstate.isrealtime ? true : timeframe.in_seconds(timeframe.period) <= timeframe.in_seconds(tf))
array.push(tfArr, na(tf) ? timeframe.period : tf)
array.push(tilson1Arr, tilson_)
array.push(tilson1aArr, tilson1a_)
cciNcciFun(tf01, box01), cciNcciFun(tf02, box02), cciNcciFun(tf03, box03), cciNcciFun(tf04, box04),
cciNcciFun(tf05, box05), cciNcciFun(tf06, box06), cciNcciFun(tf07, box07), cciNcciFun(tf08, box08),
cciNcciFun(tf09, box09), cciNcciFun(tf10, box10)
// TABLE AND CELLS CONFIG
// Post Timeframe in format
tfTxt(x)=>
out = x
if not str.contains(x, "S") and not str.contains(x, "M") and
not str.contains(x, "W") and not str.contains(x, "D")
if str.tonumber(x)%60 == 0
out := str.tostring(str.tonumber(x)/60)+"H"
else
out := x + "m"
out
if barstate.islast
table.clear(tbl, 0, 0, 20, 15)
// TITLES
table.cell(tbl, 0, 0, "⏱", text_color=color.white, text_size=Siz1Table, bgcolor=#000000)
table.cell(tbl, 1, 0, "FEMA("+str.tostring(length1)+")", text_color=#FFFFFF, text_size=Siz1Table, bgcolor=#000000)
j = 1
greenCounter = 0 // Yeşil zaman dilimlerini saymak için bir sayaç
redCounter = 0
if array.size(tilson1Arr) > 0
for i = 0 to array.size(tilson1Arr) - 1
if not na(array.get(tilson1Arr, i))
//config values in the cells
TF_VALUE = array.get(tfArr,i)
tilson1VALUE = array.get(tilson1Arr, i)
tilson1aVALUE = array.get(tilson1aArr, i)
SIGNAL1 = tilson1VALUE >= tilson1aVALUE ? "▲" : tilson1VALUE <= tilson1aVALUE ? "▼" : na
// Yeşil oklar ve arka planı ayarla
greenArrowColor1 = SIGNAL1 == "▲" ? color.rgb(0, 255, 0) : color.rgb(255, 0, 0)
greenBgColor1 = SIGNAL1 == "▲" ? color.rgb(25, 70, 22) : color.rgb(93, 22, 22)
allGreen = tilson1VALUE >= tilson1aVALUE
allRed = tilson1VALUE <= tilson1aVALUE
// Determine background color for time text
timeBgColor = allGreen ? #194616 : (allRed ? #5D1616 : #000000)
txtColor = allGreen ? #00FF00 : (allRed ? #FF4500 : color.white)
if allGreen
greenCounter := greenCounter + 1
redCounter := 0
else if allRed
redCounter := redCounter + 1
greenCounter := 0
else
redCounter := 0
greenCounter := 0
// Dinamik pair değerini oluşturma
pair = "USDT_" + syminfo.basecurrency + "USDT"
// Bot ID için kullanıcı girişi
bot_id = input.int(12387976, title="Bot ID", minval=0,group ='3Comas Message', inline = '1') // Varsayılan değeri 12387976 olan bir tamsayı girişi alır
// E-posta tokenı için kullanıcı girişi
email_token = input("cd4111d4-549a-4759-a082-e8f45c91fa47", title="Email Token",group ='3Comas Message', inline = '1')
// USER INPUT FOR DELAY
delay_seconds = input.int(0, title="Delay Seconds", minval=0, maxval=86400,group ='3Comas Message', inline = '1')
// Dinamik mesajın oluşturulması
message = '{ "message_type": "bot", "bot_id": ' + str.tostring(bot_id) + ', "email_token": "' + email_token + '", "delay_seconds": ' + str.tostring(delay_seconds) + ', "pair": "' + pair + '"}'
// Kullanıcının belirlediği yeşil veya kırmızı zaman dilimi sayısına ulaşıldığında alarmı tetikle
if greenCounter >= greenThreshold
alert(message, alert.freq_once_per_bar_close)
// if redCounter >= redThreshold
// alert(message, alert.freq_once_per_bar_close)
// Kullanıcının belirlediği yeşil veya kırmızı zaman dilimi sayısına ulaşıldığında alarmı tetikle
// if greenCounter >= greenThreshold
// alert("Yeşil zaman dilimi sayısı " + str.tostring(greenThreshold) + " adede ulaştı", alert.freq_once_per_bar_close)
// if redCounter >= redThreshold
// alert("Kırmızı zaman dilimi sayısı " + str.tostring(redThreshold) + " adede ulaştı", alert.freq_once_per_bar_close)
table.cell(tbl, 0, j, tfTxt(TF_VALUE), text_color=txtColor, text_halign=text.align_left, text_size=Siz1Table, bgcolor=timeBgColor)
table.cell(tbl, 1, j, str.tostring(tilson1VALUE, "#.#######")+SIGNAL1, text_color=greenArrowColor1, text_halign=text.align_right, text_size=Siz1Table, bgcolor=greenBgColor1)
j += 1
prd = input.int(defval=10, title='Pivot Period', minval=4, maxval=30, group='Setup')
ppsrc = input.string(defval='High/Low', title='Source', options= , group='Setup')
maxnumpp = input.int(defval=20, title=' Maximum Number of Pivot', minval=5, maxval=100, group='Setup')
ChannelW = input.int(defval=10, title='Maximum Channel Width %', minval=1, group='Setup')
maxnumsr = input.int(defval=5, title=' Maximum Number of S/R', minval=1, maxval=10, group='Setup')
min_strength = input.int(defval=2, title=' Minimum Strength', minval=1, maxval=10, group='Setup')
labelloc = input.int(defval=20, title='Label Location', group='Colors', tooltip='Positive numbers reference future bars, negative numbers reference histical bars')
linestyle = input.string(defval='Dashed', title='Line Style', options= , group='Colors')
linewidth = input.int(defval=2, title='Line Width', minval=1, maxval=4, group='Colors')
resistancecolor = input.color(defval=color.red, title='Resistance Color', group='Colors')
supportcolor = input.color(defval=color.lime, title='Support Color', group='Colors')
showpp = input(false, title='Show Point Points')
float src1 = ppsrc == 'High/Low' ? high : math.max(close, open)
float src2 = ppsrc == 'High/Low' ? low : math.min(close, open)
float ph = ta.pivothigh(src1, prd, prd)
float pl = ta.pivotlow(src2, prd, prd)
plotshape(ph and showpp, text='H', style=shape.labeldown, color=na, textcolor=color.new(color.red, 0), location=location.abovebar, offset=-prd)
plotshape(pl and showpp, text='L', style=shape.labelup, color=na, textcolor=color.new(color.lime, 0), location=location.belowbar, offset=-prd)
Lstyle = linestyle == 'Dashed' ? line.style_dashed : linestyle == 'Solid' ? line.style_solid : line.style_dotted
//calculate maximum S/R channel zone width
prdhighest = ta.highest(300)
prdlowest = ta.lowest(300)
cwidth = (prdhighest - prdlowest) * ChannelW / 100
var pivotvals = array.new_float(0)
if ph or pl
array.unshift(pivotvals, ph ? ph : pl)
if array.size(pivotvals) > maxnumpp // limit the array size
array.pop(pivotvals)
get_sr_vals(ind) =>
float lo = array.get(pivotvals, ind)
float hi = lo
int numpp = 0
for y = 0 to array.size(pivotvals) - 1 by 1
float cpp = array.get(pivotvals, y)
float wdth = cpp <= lo ? hi - cpp : cpp - lo
if wdth <= cwidth // fits the max channel width?
if cpp <= hi
lo := math.min(lo, cpp)
else
hi := math.max(hi, cpp)
numpp += 1
numpp
var sr_up_level = array.new_float(0)
var sr_dn_level = array.new_float(0)
sr_strength = array.new_float(0)
find_loc(strength) =>
ret = array.size(sr_strength)
for i = ret > 0 ? array.size(sr_strength) - 1 : na to 0 by 1
if strength <= array.get(sr_strength, i)
break
ret := i
ret
ret
check_sr(hi, lo, strength) =>
ret = true
for i = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
//included?
if array.get(sr_up_level, i) >= lo and array.get(sr_up_level, i) <= hi or array.get(sr_dn_level, i) >= lo and array.get(sr_dn_level, i) <= hi
if strength >= array.get(sr_strength, i)
array.remove(sr_strength, i)
array.remove(sr_up_level, i)
array.remove(sr_dn_level, i)
ret
else
ret := false
ret
break
ret
var sr_lines = array.new_line(11, na)
var sr_labels = array.new_label(11, na)
for x = 1 to 10 by 1
rate = 100 * (label.get_y(array.get(sr_labels, x)) - close) / close
label.set_text(array.get(sr_labels, x), text=str.tostring(label.get_y(array.get(sr_labels, x))) + '(' + str.tostring(rate, '#.##') + '%)')
label.set_x(array.get(sr_labels, x), x=bar_index + labelloc)
label.set_color(array.get(sr_labels, x), color=label.get_y(array.get(sr_labels, x)) >= close ? color.red : color.lime)
label.set_textcolor(array.get(sr_labels, x), textcolor=label.get_y(array.get(sr_labels, x)) >= close ? color.white : color.black)
label.set_style(array.get(sr_labels, x), style=label.get_y(array.get(sr_labels, x)) >= close ? label.style_label_down : label.style_label_up)
line.set_color(array.get(sr_lines, x), color=line.get_y1(array.get(sr_lines, x)) >= close ? resistancecolor : supportcolor)
if ph or pl
//because of new calculation, remove old S/R levels
array.clear(sr_up_level)
array.clear(sr_dn_level)
array.clear(sr_strength)
//find S/R zones
for x = 0 to array.size(pivotvals) - 1 by 1
= get_sr_vals(x)
if check_sr(hi, lo, strength)
loc = find_loc(strength)
// if strength is in first maxnumsr sr then insert it to the arrays
if loc < maxnumsr and strength >= min_strength
array.insert(sr_strength, loc, strength)
array.insert(sr_up_level, loc, hi)
array.insert(sr_dn_level, loc, lo)
// keep size of the arrays = 5
if array.size(sr_strength) > maxnumsr
array.pop(sr_strength)
array.pop(sr_up_level)
array.pop(sr_dn_level)
for x = 1 to 10 by 1
line.delete(array.get(sr_lines, x))
label.delete(array.get(sr_labels, x))
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
rate = 100 * (mid - close) / close
array.set(sr_labels, x + 1, label.new(x=bar_index + labelloc, y=mid, text=str.tostring(mid) + '(' + str.tostring(rate, '#.##') + '%)', color=mid >= close ? color.red : color.lime, textcolor=mid >= close ? color.white : color.black, style=mid >= close ? label.style_label_down : label.style_label_up))
array.set(sr_lines, x + 1, line.new(x1=bar_index, y1=mid, x2=bar_index - 1, y2=mid, extend=extend.both, color=mid >= close ? resistancecolor : supportcolor, style=Lstyle, width=linewidth))
f_crossed_over() =>
ret = false
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
if close <= mid and close > mid
ret := true
ret
ret
f_crossed_under() =>
ret = false
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
if close >= mid and close < mid
ret := true
ret
ret
alertcondition(f_crossed_over(), title='Resistance Broken', message='Resistance Broken')
alertcondition(f_crossed_under(), title='Support Broken', message='Support Broken')
Pita dan Kanal
Ummah X Squeeze (BB + KC)This script highlights the three phases of volatility:
🔴 Squeeze ON – Compression
BB contracts inside KC, signaling reduced volatility and energy building beneath the surface.
This is when smart traders begin watching closely — not trading impulsively — because the market is loading pressure.
🟢 Squeeze OFF – Expansion
BB pushes outside KC, confirming volatility expansion.
This is the moment when price leaves equilibrium and major directional moves often begin.
The squeeze firing can lead to:
Trend reversals
Breakouts
Momentum ignitions
Rapid volatility bursts
⚪ Neutral – No Squeeze
Normal volatility conditions with no actionable compression.
🔥 How Traders Use It
This tool is designed to enhance:
Breakout strategies
Trend-following systems
Scalping and intraday setups
Swing trading entries
Volatility-based confirmation
Identifying high-probability inflection zones
The squeeze does not tell you direction by itself — it tells you when a powerful move is about to start.
Direction is best confirmed using:
Market structure & breakout levels
Volume surges
EMA trend direction
RSI / MACD momentum shifts
🧠 Why This Version Is Special
This script is optimized for clarity and speed, with:
Clean BB + KC visualization
Color-coded squeeze states at the bottom of the chart
Works across all assets (stocks, crypto, futures, FX)
Works on all timeframes
Alerts built-in for both “Squeeze ON” and “Squeeze OFF”
📌 Ideal For
Momentum traders
Breakout traders
Options traders (pre-move volatility setups)
Crypto scalpers
Swing traders
Anyone who wants to anticipate volatility before it hits the chart
✨ Created for the Ummah X Trading System
This indicator is part of the Ummah X methodology — a structured trading approach built around:
Trend confirmation
Volume pressure
Market structure
Volatility compression & release
This BB+KC squeeze module is the foundation for identifying high-probability expansion phases.
Wick-RSI-CandleBody_SEZERthis strategy is ideal to recognize peaks for both long and short positions in 1h and 4h periods. for quick response and faster trade, please use 15m period but keep in mind targeting lower profits. otherwise you may lose your profit.
Directional Imbalance Index [BigBeluga]🔵 OVERVIEW
The Directional Imbalance Index is designed to track market strength by counting how often price sets new highs or lows over a defined lookback period. Every time a bar forms a new extreme, the indicator records a +1 count for either bullish (highs) or bearish (lows). These counts are aggregated into a rolling calculation, allowing traders to see which side dominates and how directional imbalance evolves.
🔵 CONCEPTS
Each new highest high → adds a bullish count (+1).
Each new lowest low → adds a bearish count (+1).
Counts are stored inside arrays over a user-defined Calculation Period .
for i = 0 to period-1
h = high
l = low
if h == upper
countUp.push(1)
if l == lower
countDn.push(1)
The balance between bullish and bearish counts highlights dominance and imbalance.
Normalized percentages help compare both sides (e.g., 65% bullish vs 35% bearish).
🔵 FEATURES
Counts new highs/lows over a chosen Highest/Lowest Length .
Aggregates values over a rolling Calculation Period .
Plots cumulative bullish vs bearish totals in the subchart.
Displays % share of bulls vs bears from total counts.
On-chart labels mark bars where a count was added.
Plots reference lines of the current upper (high) and lower (low) ranges.
Dynamic fill between bullish/bearish plots to visualize which side dominates.
🔵 HOW TO USE
Look for persistent bullish imbalance (bull % > bear %) as confirmation of upward momentum.
Look for persistent bearish imbalance (bear % > bull %) as confirmation of downward momentum.
Watch for shifts in % dominance — often early signs of trend reversal or weakening strength.
Use labels on the chart to visually confirm which bars contributed to directional bias.
Combine with trend or volume tools to confirm whether imbalance aligns with market direction.
🔵 CONCLUSION
The Directional Imbalance Index offers a systematic way to measure directional pressure. By counting how often price pushes into new territory, the indicator reveals whether bulls or bears are taking control. This makes it a valuable tool for detecting early signs of trend continuation or exhaustion, helping traders align with the side most likely to dominate.
【SY】AI量化指标📌 TradingView Strategy Description (English)
Strategy Overview
This strategy combines trend-following and momentum confirmation to identify high-probability entries in the direction of the prevailing market trend. The objective is not to trade every move, but to capture the strongest phases of price expansion while minimizing exposure during choppy periods.
How It Works
A trend filter determines whether the market is currently in a bullish or bearish environment
Trades are only taken in the direction of the trend — no counter-trend entries
A breakout / momentum signal triggers entry when conditions align
Risk management uses a combination of fixed take-profit, stop-loss and trailing stop
Positions are closed when price strength weakens or when exit criteria are triggered
Risk Management
Fixed stop-loss protects capital during adverse movement
Trailing stop locks in floating profits once the trade is in profit
No martingale, grid or averaging-down — each position is managed independently
Avoids overtrading during sideways markets by requiring trend confirmation
Markets & Timeframes
Suitable for: Crypto / Indices / Commodities / Forex
Recommended timeframes: 15m – 4H
Can be used for both backtesting and automated trading (Webhook / API compatible)
Disclaimer
This script is for educational and research purposes only and does not constitute financial advice. Past performance does not guarantee future results. Trading involves risk — manage leverage and position size responsibly.
If you'd like, I can also provide:
🔹 A short description for the TradingView title area
🔹 A marketing-style preview text to drive more script saves & followers
🔹 A customized version including key terms from your strategy (EMA / KDJ / Supertrend / ATR / RSI / volatility filter / etc.)
CPA2 PROCrypto Professional Analyzer (CPA) - Instructions
Purpose: CPA is a Multi-Factor Weighted System designed to confirm signals by analyzing three key areas simultaneously: Trend Alignment, Volume Support, and Momentum Strength.
Signal Types:
Strong Buy/Sell: Highest confidence signals, confirmed by all major factors.
Buy/Sell: Standard signals, confirmed by the majority of factors.
Key Features:
Risk Flags: Look for PUMP, DUMP, or FAKE (Fake Breakout) alerts to avoid potential traps.
Trend Health: Monitor the ribbon colors; they indicate the overall health and direction of the EMA trend alignment.
Risk Management: Use the plotted TP1 and TP2 levels (Take Profits) for planning your exits.
Pro-Tip: Adjust the 'Risk Level' setting in the indicator inputs to filter signals (e.g., set to 'Low' for stricter signal requirements).
V3 9-20 Smart EMA Cross + RSI + FVG Zones (Instant Signal)V3 9-20 Smart EMA Cross + RSI + FVG Zones (Instant Signal)
MTF Bollinger Bands (1-2-3 SD)MTF Bollinger Bands (1-2-3 SD)
Plots Bollinger Bands from any higher timeframe (e.g., Daily or Weekly) directly on your current chart (1m, 15m, 1h, etc.).
Features:
Shows 1σ (blue), 2σ (orange), and 3σ (red) bands with transparent fills
Fully customizable timeframe, length, and deviation multipliers
Option to show/hide each band pair independently
Smooth (no gaps) or stepped display
Perfectly matches the native Bollinger Bands when you switch to the selected higher timeframe
Great for keeping higher-timeframe structure and extreme levels in view while trading lower timeframes.
Trend or Reversal (NQ optimized)This indicator is a session-aware trade map for NQ futures that combines VWAP, an adaptive Opening Range Box (ORB), prior-day/weekly value areas, and CVD-based divergences into a single confluence engine. It scores trend and reversal setups separately on every bar, then selects one best signal per bar (long or short) so you’re never flooded with conflicting entries.
Key features
Adaptive ORB box (RTH only): First 5–15 minutes after 9:30 ET (length auto-adjusts with ADX). The box defines the opening auction; once it closes, those highs/lows are locked as ORB breakout levels for the rest of the session.
Dynamic bias: Bias flips between bullish, bearish, or neutral based on ORB breaks and how price + EMA9 behave around VWAP.
Value-area context: Uses yesterday’s and last week’s VAH/VAL (70% range model) to define “safer” long/short zones (above VAL for longs, below VAH for shorts).
Session CVD & divergence: Builds a running intraday Cumulative Volume Delta and flags bullish/bearish divergences at extremes.
Confluence scoring: Four internal scores—Trend Long, Trend Short, Reversal Long, Reversal Short—each built from multiple factors (bias, VWAP, ORB, value areas, divergence). The side with the stronger score that passes its threshold prints:
T-LONG / T-SHORT for trend continuation
R-L / R-S for mean-reversion (fade) setups
How to use
Treat T-signals as your primary entries in strong directional moves, aligned with VWAP and ORB/value-area structure.
Treat R-signals as tactical fade opportunities into extremes, preferably at prior VAH/VAL or ORB edges and supported by CVD divergence.
The indicator is not a standalone system—combine it with your own execution rules, risk management, and higher-timeframe context. Not Financial Advice
Renko 2-block entry, 1-block exit (signals EVERY block)Renko 2-block entry, 1-block exit (signals EVERY block)
Vector CPR Bands## Overview
The Vector CPR Bands indicator enhances the classic Central Pivot Range (CPR) by incorporating "vector" detection—identifying periods with above-average or climactic volume. It projects CPR ranges from these high-volume periods forward as visual bands, which act as persistent support/resistance zones until invalidated by price action. Ideal for spotting key levels in trending or ranging markets, especially on higher timeframes like weekly or monthly.
## Key Features
- **CPR Calculation**: Plots previous, developing (non-repainting), and repainting CPR with mid-pivot, TC (top central), and BC (bottom central) lines, plus fills.
- **Vector Detection**: Scans for high-volume bars in the anchor timeframe (default weekly). Flags "above-average" (≥1.5x avg) or "large" (≥2x avg or max climax).
- **Band Projection**: Creates bands from vector-qualified CPR periods. Extends them rightward until touched/revisited (configurable: invalidate on wick/close, delete or freeze/gray out).
- **Customization**:
- Timeframe: Set CPR anchor (e.g., 'W' for weekly, 'M' for monthly).
- Display: Toggle CPR types, pivot guides.
- Volume Thresholds: Adjust lookback and ratios.
- De-clutter: Limit max bands, pin to period start, always extend.
- **Alerts & Signals**: Built-in alerts for developing pivot crossing previous pivot (bullish/bearish).
## How to Use
1. Add to chart and set anchor timeframe (e.g., 'M' for monthly vCPR on BTC, as shown in example charts).
2. Watch bands as S/R: Virgin (untested) bands often provide strong bounces; mitigated ones fade.
3. Combine with volume/price action: Bullish bands suggest upside bias, especially if price holds above.
4. Example: On BTC weekly, vector bands from high-volume weeks highlight multi-month zones—breaks signal shifts.
1Hr Stock Breakout HunterThis is a script works for 15min or 1hr, it tells you a trend is breakingout
Pi Cycle BTC Top + Pre-Alert BandsPi Cycle BTC Top + Pre-Alert Bands is an advanced implementation of the classic Pi Cycle Top model, designed for Bitcoin cycle analysis on higher timeframes (especially 1D BTCUSD/BTCUSD·INDEX).
The original Pi Cycle Top uses two moving averages:
• 111-day SMA (short MA)
• 350-day SMA ×2 (long MA)
A Pi Top is signaled when the 111 SMA crosses above the 350×2 SMA. Historically, this has occurred near major BTC cycle highs.
This script extends that idea with a 3-step early-warning sequence:
• Pi Green – early compression: short/long MA ratio crosses upward into the green band (convergence from below is required).
• Pi Yellow – mid-cycle warning: only fires if a valid Green has already occurred in the same cycle.
• Pi Cycle Top – final top: the classic Pi Cycle cross, limited to one top signal per cycle. After a top, no new Yellow or Top signals can appear until a new Green event starts the next cycle.
Background shading shows the active phase (Green / Yellow / late-cycle zone), so you can see at a glance where BTC is within its Pi-based macro structure.
All logic is non-repainting: request.security() uses lookahead_off and no future data is accessed.
Typical use
This indicator is intended as a macro-cycle timing and risk-awareness tool, not a stand-alone entry system. Many traders use it to:
• Watch for Pi Green as the start of a potential late-cycle advance.
• Treat Pi Yellow as a rising-risk environment and tighten risk management.
• Use the Pi Cycle Top as a historical high-risk zone where large profit-taking or hedging may be considered.
Always combine this with your own analysis (trend, volume, on-chain, macro) before making decisions.
How to set alerts
Add the indicator to your chart (1D BTCUSD or BTCUSD·INDEX recommended).
Click Alerts → Condition → Pi Cycle BTC Top + Pre-Alert Bands.
Choose one of:
• Pi Cycle – Green Pre-Alert (early convergence)
• Pi Cycle – Yellow Pre-Alert (after Green only)
• Pi Cycle – TOP (Single per Cycle, after Green)
Use “Once per bar close” for higher-timeframe reliability.
Disclaimer
This tool is for educational and analytical purposes only. The Pi Cycle concept is based on historical behavior and does not guarantee future results. This is not financial advice; always do your own research and manage risk appropriately.
Enhanced ML-FRAMA with HTFCore Concept
FRAMA (Fractal Adaptive Moving Average) is an adaptive moving average that automatically adjusts its sensitivity based on market volatility using fractal geometry. This indicator enhances it with Machine Learning predictions and multi-timeframe analysis.
Key Components:
1. ML-Enhanced FRAMA
ML Enhancement: Uses machine learning to adjust FRAMA's sensitivity
Dynamic Adaptation: ML predictions modify the smoothing constant based on market conditions
2. Machine Learning System
Three ML Models Combined:
K-Nearest Neighbors (KNN): Finds similar historical patterns
Trend Model: Uses EMA crossovers for trend detection
Momentum Model: Combines RSI, ROC, and volume for momentum
Features Used:
RSI, MACD, ATR, Rate of Change
Volume ratio and momentum
VWAP deviation
Higher timeframe RSI
Daily EMA trend
3. Higher Timeframe Integration
HTF1: 1-hour timeframe
HTF2: 4-hour timeframe
Confluence Trading: Requires agreement across multiple timeframes
4. Visual Features
Support/Resistance Circles: Dynamic levels based on ATR volatility
Color Coding:
Green: Bullish signals
Red: Bearish signals
Purple/Orange: HTF indicators
Trend Detection: Colors change based on direction
Requirements for Bullish Signal:
Price crosses above ML-FRAMA
ML prediction > 60% bullish
High confidence (>30%)
Volume 20% above average
Both HTF timeframes bullish
Performance Tracking:
Adaptive Weights: Automatically adjusts model weights based on recent accuracy
Dynamic K: Adjusts KNN neighbors based on market volatility
Outlier Detection: Filters unusual bars from training data
Trading Philosophy:
Multi-Timeframe Confirmation
Avoids false signals by requiring HTF agreement
Reduces noise by focusing on higher probability setups
Volume Confirmation
Requires above-average volume for valid signals
Volume momentum adds conviction
Machine Learning Edge
Learns from historical patterns
Adapts to changing market conditions
Combines multiple analysis techniques
Use Cases:
Trend Following: ML-FRAMA as dynamic support/resistance
Breakout Trading: Price crosses with volume and HTF confirmation
Mean Reversion: Support/resistance circles as reversal zones
Swing Trading: HTF confluence for higher probability setups
Strengths:
Adaptive: Adjusts to market volatility
Multi-timeframe: Reduces false signals
Volume-confirmed: Adds conviction
ML-enhanced: Learns from market behavior
Visual: Clear support/resistance levels
Ideal For:
Swing traders looking for high-probability entries
Trend followers wanting adaptive moving averages
Technical analysts who value multi-timeframe confirmation
Traders who want machine learning without complexity
The indicator essentially creates a "smart" adaptive moving average that learns from the market and only provides signals when multiple timeframes and technical factors align.
Trend Drawing + OB Signal (MTF) [ASCII]Script Description: Advanced Multi-Timeframe Trend Lines & OB/OS Signal
Overview
This advanced Pine Script indicator is designed to identify and project key support and resistance levels using pivot-based trend lines across multiple timeframes. It combines this powerful trend analysis with a sophisticated Overbought/Oversold (OB/OS) detection system using CCI and Bollinger Bands, providing clear trading signals with integrated alert functionality.
Key Features
1. Multi-Timeframe Trend Lines
Automated Pivot Detection: Automatically identifies significant swing highs and lows based on user-defined left/right bar parameters
Smart Timeframe Adaptation: Uses different sensitivity settings for each timeframe (15min to 1Week) for optimal pivot detection
Dynamic Line Projection: Draws trend lines connecting the two most recent pivots and extends them forward
Flexible Source Selection: Choose between Close price, Wick extremes, or Auto mode (Auto uses Wick for higher timeframes, Close for lower timeframes)
2. Advanced OB/OS Detection System
Dual Indicator Confirmation: Combines CCI momentum and Bollinger Band position for reliable signals
Customizable Parameters: Adjustable CCI length, OB/OS thresholds, and Bollinger Band settings
Bar Confirmation Option: Optional wait-for-close confirmation to avoid false signals
Visual Markers: Clear triangle markers above/below bars for quick signal identification
3. Timeframe Support
Available Timeframes: 15min, 30min, 1h, 2h, 4h, 8h, 12h, 1D, 1W
Independent Settings: Custom left/right bar parameters for each timeframe
Automatic Adaptation: Script automatically applies the correct settings for your current chart timeframe
Input Parameters
Trend Lines Configuration
Left/Right Bars: Defines the pivot detection sensitivity for each timeframe
Line Length: Controls how far trend lines extend into the future
Line Source: Choose between Close, Wick, or Auto selection
Colors: Customizable support/resistance line colors
OB/OS Signal Settings
CCI Parameters: Length and OB/OS thresholds
Bollinger Bands: Length and multiplier for band width
Plot Options: Toggle OB markers and bar confirmation
Signal Logic
OB UP Signal (Short Bias)
Conditions: CCI ≥ OB threshold AND Close ≥ Upper Bollinger Band
Marker: Red triangle down above bar
Alert Direction: SHORT
OB DOWN Signal (Long Bias)
Conditions: CCI ≤ OS threshold AND Close ≤ Lower Bollinger Band
Marker: Green triangle up below bar
Alert Direction: LONG
Alert System
The script includes pre-formatted JSON alerts for external integration:
Structured data format with symbol, timeframe, direction, and signal type
Secret key for authentication (replace "MY_SECRET" with your actual key)
Compatible with webhook services and custom alert handlers
Usage Tips
Timeframe Selection: Use higher timeframes (4H-Daily) for major levels, lower timeframes for precise entries
Parameter Tuning: Adjust left/right bars based on market volatility - increase for smoother trends, decrease for more reactive lines
Confirmation: Combine trend line breaks with OB/OS signals for high-probability setups
Risk Management: Always use proper stop losses - trend lines indicate potential areas, not guaranteed reversals
Technical Notes
Built with Pine Script v6
Maximum 200 lines/labels to maintain performance
Works on all asset types (forex, stocks, crypto)
Optimized for real-time and historical analysis
This script provides institutional-grade trend analysis with retail-friendly signals, making complex multi-timeframe analysis accessible to traders of all experience levels.
This description covers all the technical aspects while being accessible for users.
KC-BB Squeeze Trend Trader█ OVERVIEW
The KC-BB Squeeze Trend Trader identifies volatility compression and expansion by detecting when Bollinger Bands contract inside Keltner Channels and then release with confirmed momentum. It highlights potential trend-starting breakouts by combining squeeze detection, directional momentum, trend bias, and optional volume filters.
During periods of low volatility, price consolidates and energy builds. When volatility expands again, strong directional moves often follow. This tool helps traders spot those opportunities early with clear visual cues and optional performance tracking.
█ KEY FEATURES
Squeeze detection using Bollinger Bands inside Keltner Channels
Automatic identification of volatility expansion after the squeeze ends
Optional filters for momentum, trend direction, volume, and signal cooldown
Dynamic color fills for squeeze, bullish expansion, bearish expansion, and neutral states
Dashboard showing squeeze duration, tightness, momentum, trend, and volume context
Optional win-rate analytics using ATR-based target and stop evaluation
Multi-timeframe confirmation for higher-quality breakouts
█ HOW IT WORKS
A squeeze occurs when both Bollinger Bands sit inside the Keltner Channels.
A breakout begins when the Bollinger Bands expand outside the KCs.
Long signals appear when squeeze release aligns with bullish momentum and trend strength.
Short signals appear when bearish momentum and trend conditions agree.
Volume and cooldown filters help reduce noise and avoid low-quality entries.
█ HOW TO USE
Wait for a squeeze period (yellow fill).
Monitor duration and tightness: longer/tighter squeezes often lead to stronger moves.
When a long or short signal appears, use the plotted ATR-based target and stop as reference levels.
Watch for contraction or exit hints when momentum fades or volatility narrows again.
Higher timeframes generally provide cleaner and more reliable signals.
█ TIMEFRAME GUIDANCE
Crypto: 4H or 1D; consider increasing KC multiplier for high volatility.
Forex: 1H–4H; longer squeeze duration can improve selectivity.
Stocks: 1D–1W; consider slightly higher BB multiplier on slow-moving markets.
█ SETTINGS SUMMARY
Adjustable Bollinger Band and Keltner Channel lengths and multipliers
Three momentum modes: Linear Regression, Price–SMA, or ROC
Trend and volume filters (optional)
Configurable minimum squeeze duration and signal cooldown
ATR-based target and stop multipliers
Optional historically tight squeeze filter (percentile-based)
█ ALERTS
Squeeze Detected
Squeeze Released
Long Entry
Short Entry
Exit Hint
Historically Tight Squeeze
█ NOTES
ATR-based win-rate calculations provide simplified performance estimates.
Past behavior does not guarantee future movement.
Use position sizing and risk management appropriate for the instrument and timeframe.
█ CREDITS
Inspired by the Bollinger Band and Keltner Channel squeeze concept popularized by John Carter’s TTM Squeeze, with added enhancements for squeeze strength, filtering, and real-time performance metrics.
Z-Score IndicatorA Z-Score measures how many standard deviations a value is from its mean.
In finance, it indicates how far the current price is from its historical average in statistical terms.
Practically speaking, the Z-Score quantifies price anomalies and serves as the statistical foundation behind mean-reversion strategies and dispersion analysis (pairs trading, Z-bands, etc.).
±1σ: normal movement.
±2σ: moderate overextension.
±3σ: statistically extreme event (≈ 0.3% probability under a normal distribution).
SuperMegaIndicator5000SuperMegaIndicator5000
key levels
ema
volume on price High Vol LowV and chop on price
London open close
vwap
orb
and maybe a couple other indicators
Semi-Martingala Sicura 1.20x PROIncrements or a maximum amount of 200. If the previous trade is profitable, the count is reset and the initial amount is resumed. Exit management uses fixed percentage stop loss and take profit, set relative to the entry price. In summary, this strategy aims to capitalize on trend and momentum signals, using a semi-martingale system to increase positions in case of losses, but with precise limits to contain risk. Note: This method aims to be "safer" than a classic martingale, respecting increment limits and a maximum amount.
Comment by saying what you think and what I could change.
Fibonacci Set-upThe indicator plots Fibonacci retracements based on recent lows and highs.
Additionally it calculates position size, max leverage, max drawdown and pricelevels.
SwiftTrend█ OVERVIEW
SwiftTrend is a trend-following indicator inspired by the classic SuperTrend, but built on a completely different calculation method — using the average candle body size and the body midpoint (bodyMid). It reacts very dynamically to changes in momentum strength. The indicator is clean, easy to read, and perfect for traders who want fast yet confirmed trend direction. By adjusting the settings, you can make signals extremely sensitive or, conversely, reduce their frequency to almost completely eliminate trend flips on minor price moves.
█ CONCEPT
The indicator was created to strike the perfect balance between signal speed and effective noise filtering.
Instead of using classic ATR and price extremes (high/low), SwiftTrend uses the average candle body size and the midpoint of the previous candle’s body as its core reference. The dynamic trend line (avgLine) is protected by a tolerance zone – the trend only changes after price closes beyond this zone. This approach delivers significantly faster reaction times than many traditional solutions while maintaining excellent resistance to false signals during ranging markets.
█ FEATURES
Data source:
- Average candle body size: SMA(|open – close|, period)
- Reference point: midpoint of the previous candle’s body (bodyMid )
Dynamic trend line (avgLine):
- Built using Band Multiplier
- The line is “attracted” toward price movement
Tolerance zone (margin):
- Tolerance = Tolerance Multiplier × avgBody
- Default: 2.5 (for both band and tolerance)
Trend change logic:
- Down → Up: close > avgLine + tolerance
- Up → Down: close < avgLine – tolerance
Visual signals:
- “Buy” label (green upward arrow) and “Sell” label (red downward arrow) only on confirmed trend change
- Optional soft gradient fill between trend line and price
- Optional bar coloring based on current trend
- Trend line with breaks at reversal points
Alerts:
- Buy alert – triggers only when the closing price crosses from below to above the marginLineBase
- Sell alert – triggers only when the closing price crosses from above to below the marginLineBase
█ HOW TO USE
Add to chart → paste the code in Pine Editor or search for “SwiftTrend”.
Main settings:
- Average Body Periods → default 100
- Band Multiplier → default 2.5
- Tolerance Multiplier → default 2.5 (key sensitivity parameter)
- Colors, fill, and bar coloring – fully customizable
Interpretation:
- Green line & shading = uptrend
- Red line & shading = downtrend
- Higher Tolerance Multiplier = fewer but higher-quality signals
- Tolerance Multiplier near 0 = ultra-fast signals (aggressive mode)
█ APPLICATIONS
Excellent for:
- Trend-following (enter with trend, exit on reversal)
- Breakout and momentum strategies
- Filtering consolidation and noise – thanks to the adjustable tolerance zone
Best combined with:
- Classic support/resistance levels
- Fibonacci retracements, Pivot Points, psychological round numbers
- Confirmation from oscillators (RSI, Stochastic, MACD)
- Volume or volume profile analysis
Style adaptation:
- Scalping / daytrading → lower Tolerance Multiplier (0.8–1.8) + shorter period
- Swing / position trading → higher values (2.5–5.0) + longer period
█ NOTES
- Works on all markets and timeframes
- Success depends on matching the Tolerance Multiplier to your strategy and the instrument’s volatility
- Higher multiplier & period values = fewer signals, significantly higher quality
- At Tolerance Multiplier = 0 the indicator becomes extremely responsive – perfect for aggressive momentum trading
