Mayfair FX Scalper V-10 Price Action + SMC//@version=5
indicator("Mayfair FX Scalper V-10 Price Action + SMC", overlay=true)
// === INPUTS ===
rsiLength = input.int(14, title="RSI Length")
overbought = input.float(73, title="SELL Level")
oversold = input.float(31, title="BUY Level")
rsiSrc = input.source(open, title="RSI Source")
// === Color Inputs ===
entryLineColor = input.color(color.white, title="entry Label Color")
entryLabelColor = input.color(color.white, title="entry Lable Color")
slLineColor = input.color(color.red, title="Stop Loss Line Color")
slLabelColor = input.color(color.red, title="Stop Loss Label Color")
tpLineColor = input.color(color.blue, title="Take Profit Line Color")
tpLabelColor = input.color(color.blue, title="Take Profit Color")
entryTextColor = input.color(color.rgb(0, 0, 0) , title="entry Text Color")
slTextColor = input.color(color.white, title="Stop Lose Color")
tpTextColor = input.color(color.white, title="Take Profit Text Color")
//indicator("Author Info Display"
// Create table
var table infoTable = table.new(position.top_right, 2, 6, bgcolor=color.new(#000000, 1), border_width=1)
if barstate.islast
table.cell(infoTable, 0, 0, "Author:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 0, "MR WOW", text_color=color.rgb(255, 251, 0), text_size=size.large)
table.cell(infoTable, 0, 1, "YouTube:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 1, "www.youtube.com/@iammrwow", text_color=color.rgb(255, 251, 0), text_size=size.small)
table.cell(infoTable, 0, 3, "Website:", text_color=color.white, text_size=size.small)
table.cell(infoTable, 1, 3, "www.mrwowea.com", text_color=color.rgb(255, 251, 0), text_size=size.small)
// === RSI CALCULATION ===
rsi = ta.rsi(rsiSrc, rsiLength)
rawBuySignal = rsi < oversold
rawSellSignal = rsi > overbought
// === Confirmed Signals ===
isBullish = close > open
isBearish = close < open
newBuy = rawBuySignal and isBullish and close > open == false
newSell = rawSellSignal and isBearish and close < open == false
// === Trade State Variables ===
var bool inPosition = false
var bool isBuy = false
var float entryPrice = na
var float slPrice = na
var float tp1Price = na
var float tp2Price = na
var float tp3Price = na
var int entryBarIndex = na
var label labels = array.new()
var line lines = array.new()
// === Instrument & Timeframe SL/TP Setup ===
isGold = str.contains(syminfo.ticker, "XAU") or str.contains(syminfo.ticker, "GOLD")
instrumentType = syminfo.type == "crypto" ? "Crypto" : isGold ? "Gold" : syminfo.currency == "JPY" ? "JPY" : "Forex"
tf = timeframe.period
slPipsGold = tf == "1" ? 30 : tf == "3" ? 45 : tf == "5" ? 50 : tf == "15" ? 60 : 70
slPipsCrypto = tf == "1" ? 5 : tf == "3" ? 8 : tf == "5" ? 12 : tf == "15" ? 15 : 10
slPipsForex = tf == "1" ? 6 : tf == "3" ? 9 : tf == "5" ? 11 : tf == "15" ? 15 : 15
gold_slDist = 0.1 * slPipsGold
gold_tp1Dist = gold_slDist
gold_tp2Dist = gold_slDist * 2
gold_tp3Dist = gold_slDist * 3
pipSize = instrumentType == "Crypto" ? 1.0 : instrumentType == "Gold" or instrumentType == "JPY" ? 0.01 : 0.0001
slPips = instrumentType == "Crypto" ? slPipsCrypto : instrumentType == "Gold" ? slPipsGold : slPipsForex
slDist = slPips * pipSize
tp1Dist = slDist
tp2Dist = slDist * 2
tp3Dist = slDist * 3
// === Draw Line & Label ===
drawLine(y, txt, col, lblCol, extendToCurrent) =>
int lineEnd = extendToCurrent ? bar_index : entryBarIndex + 2
array.push(lines, line.new(entryBarIndex, y, lineEnd, y, color=col, width=2, extend=extend.none))
textCol = str.contains(txt, "Entry") ? entryTextColor : str.contains(txt, "Stop") ? slTextColor : tpTextColor
array.push(labels, label.new(lineEnd, y, txt, style=label.style_label_left, color=color.new(lblCol, 0), textcolor=textCol, size=size.small))
// === Check Exit ===
slHit = inPosition and ((isBuy and low <= slPrice) or (not isBuy and high >= slPrice))
tp3Hit = inPosition and ((isBuy and high >= tp3Price) or (not isBuy and low <= tp3Price))
shouldExit = slHit or tp3Hit
if shouldExit
for l in labels
label.delete(l)
array.clear(labels)
for ln in lines
line.delete(ln)
array.clear(lines)
inPosition := false
entryPrice := na
slPrice := na
tp1Price := na
tp2Price := na
tp3Price := na
entryBarIndex := na
// === Confirmed Signal with No Position ===
confirmedBuy = not inPosition and newBuy
confirmedSell = not inPosition and newSell
// === Signal Markers ===
plotshape(series=confirmedBuy, location=location.belowbar, color=color.rgb(33, 150, 243), style=shape.triangleup, text="BUY", textcolor=color.rgb(33, 150, 243))
plotshape(series=confirmedSell, location=location.abovebar, color=color.rgb(254, 254, 255), style=shape.triangledown, text="SELL", textcolor=color.rgb(239, 238, 247))
// === Entry Execution ===
if confirmedBuy or confirmedSell
entryPrice := close
entryBarIndex := bar_index
isBuy := confirmedBuy
inPosition := true
if isGold
slPrice := isBuy ? entryPrice - gold_slDist : entryPrice + gold_slDist
tp1Price := isBuy ? entryPrice + gold_tp1Dist : entryPrice - gold_tp1Dist
tp2Price := isBuy ? entryPrice + gold_tp2Dist : entryPrice - gold_tp2Dist
tp3Price := isBuy ? entryPrice + gold_tp3Dist : entryPrice - gold_tp3Dist
else
slPrice := isBuy ? entryPrice - slDist : entryPrice + slDist
tp1Price := isBuy ? entryPrice + tp1Dist : entryPrice - tp1Dist
tp2Price := isBuy ? entryPrice + tp2Dist : entryPrice - tp2Dist
tp3Price := isBuy ? entryPrice + tp3Dist : entryPrice - tp3Dist
drawLine(entryPrice, "Entry Price - After Candle Above Entry Price Then Place Trade: " + str.tostring(entryPrice), entryLineColor, entryLabelColor, false)
drawLine(slPrice, "Stop Loss: " + str.tostring(slPrice), slLineColor, slLabelColor, false)
drawLine(tp1Price, "(1:1) Take Profit: " + str.tostring(tp1Price), tpLineColor, tpLabelColor, false)
drawLine(tp2Price, "(2:1) Take Profit: " + str.tostring(tp2Price), tpLineColor, tpLabelColor, false)
drawLine(tp3Price, "(3:1) Take Profit: " + str.tostring(tp3Price), tpLineColor, tpLabelColor, false)
// === Update TP/SL Lines if Still in Trade ===
if inPosition and not (confirmedBuy or confirmedSell)
for ln in lines
line.delete(ln)
array.clear(lines)
for l in labels
label.delete(l)
array.clear(labels)
drawLine(entryPrice, "After Candle Closed Above Entry Line Buy & Below Sell :Entry Price-" + str.tostring(entryPrice), entryLineColor, entryLabelColor, true)
drawLine(slPrice, "Stop Loss: " + str.tostring(slPrice), slLineColor, slLabelColor, true)
drawLine(tp1Price, "(1:1) Take Profit: " + str.tostring(tp1Price), tpLineColor, tpLabelColor, true)
drawLine(tp2Price, "(2:1) Take Profit: " + str.tostring(tp2Price), tpLineColor, tpLabelColor, true)
drawLine(tp3Price, "(3:1) Take Profit: " + str.tostring(tp3Price), tpLineColor, tpLabelColor, true)
// === Bollinger Bands Inputs ===
bb_length = input.int(20, title="SMA & StdDev Length")
src = input.source(close, title="Source")
// === Bollinger Band Colors ===
color_upper_2_3 = input.color(color.new(#0db107, 64), title="Upper Band 2–3 Color")
color_upper_3_4 = input.color(color.new(#05c41f, 58), title="Upper Band 3–4 Color")
color_lower_2_3 = input.color(color.new(#bdbc9d, 80), title="Lower Band 2–3 Color")
color_lower_3_4 = input.color(color.new(#e9e6bf, 63), title="Lower Band 3–4 Color")
// === Bollinger Band Calculations ===
sma = ta.sma(src, bb_length)
stdev = ta.stdev(src, bb_length)
bb2_upper = sma + 2 * stdev
bb2_lower = sma - 2 * stdev
bb3_upper = sma + 3 * stdev
bb3_lower = sma - 3 * stdev
bb4_upper = sma + 4 * stdev
bb4_lower = sma - 4 * stdev
// === Hidden Plots for Fill ===
p_bb2_upper = plot(bb2_upper, color=na)
p_bb3_upper = plot(bb3_upper, color=na)
p_bb4_upper = plot(bb4_upper, color=na)
p_bb2_lower = plot(bb2_lower, color=na)
p_bb3_lower = plot(bb3_lower, color=na)
p_bb4_lower = plot(bb4_lower, color=na)
// === Band Zone Fills ===
fill(p_bb2_upper, p_bb3_upper, color=color_upper_2_3)
fill(p_bb3_upper, p_bb4_upper, color=color_upper_3_4)
fill(p_bb2_lower, p_bb3_lower, color=color_lower_2_3)
fill(p_bb3_lower, p_bb4_lower, color=color_lower_3_4)
//SMc
BULLISH_LEG = 1
BEARISH_LEG = 0
BULLISH = +1
BEARISH = -1
GREEN = #9c9c9c
RED = #9c9c9c
BLUE = #9c9c9c
GRAY = #ffffff
MONO_BULLISH = #b2b5be
MONO_BEARISH = #5d606b
HISTORICAL = 'Historical'
PRESENT = 'Present'
COLORED = 'Colored'
MONOCHROME = 'Monochrome'
ALL = 'All'
BOS = 'BOS'
CHOCH = 'CHoCH'
TINY = size.tiny
SMALL = size.small
NORMAL = size.normal
ATR = 'Atr'
RANGE = 'Cumulative Mean Range'
CLOSE = 'Close'
HIGHLOW = 'High/Low'
SOLID = '⎯⎯⎯'
DASHED = '----'
DOTTED = '····'
SMART_GROUP = 'Smart Money Concepts'
INTERNAL_GROUP = 'Real Time Internal Structure'
SWING_GROUP = 'Real Time Swing Structure'
BLOCKS_GROUP = 'Order Blocks'
EQUAL_GROUP = 'EQH/EQL'
GAPS_GROUP = 'Fair Value Gaps'
LEVELS_GROUP = 'Highs & Lows MTF'
ZONES_GROUP = 'Premium & Discount Zones'
modeTooltip = 'Allows to display historical Structure or only the recent ones'
styleTooltip = 'Indicator color theme'
showTrendTooltip = 'Display additional candles with a color reflecting the current trend detected by structure'
showInternalsTooltip = 'Display internal market structure'
internalFilterConfluenceTooltip = 'Filter non significant internal structure breakouts'
showStructureTooltip = 'Display swing market Structure'
showSwingsTooltip = 'Display swing point as labels on the chart'
showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low points on the chart'
showInternalOrderBlocksTooltip = 'Display internal order blocks on the chart\n\nNumber of internal order blocks to display on the chart'
showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart\n\nNumber of internal swing blocks to display on the chart'
orderBlockFilterTooltip = 'Method used to filter out volatile order blocks \n\nIt is recommended to use the cumulative mean range method when a low amount of data is available'
orderBlockMitigationTooltip = 'Select what values to use for order block mitigation'
showEqualHighsLowsTooltip = 'Display equal highs and equal lows on the chart'
equalHighsLowsLengthTooltip = 'Number of bars used to confirm equal highs and equal lows'
equalHighsLowsThresholdTooltip = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows\n\nLower values will return fewer but more pertinent results'
showFairValueGapsTooltip = 'Display fair values gaps on the chart'
fairValueGapsThresholdTooltip = 'Filter out non significant fair value gaps'
fairValueGapsTimeframeTooltip = 'Fair value gaps timeframe'
fairValueGapsExtendTooltip = 'Determine how many bars to extend the Fair Value Gap boxes on chart'
showPremiumDiscountZonesTooltip = 'Display premium, discount, and equilibrium zones on chart'
modeInput = input.string( HISTORICAL, 'Mode', group = SMART_GROUP, tooltip = modeTooltip, options = )
styleInput = input.string( COLORED, 'Style', group = SMART_GROUP, tooltip = styleTooltip,options = )
showTrendInput = input( false, 'Color Candles', group = SMART_GROUP, tooltip = showTrendTooltip)
showInternalsInput = input( true, 'Show Internal Structure', group = INTERNAL_GROUP, tooltip = showInternalsTooltip)
showInternalBullInput = input.string( ALL, 'Bullish Structure', group = INTERNAL_GROUP, inline = 'ibull', options = )
internalBullColorInput = input( GREEN, '', group = INTERNAL_GROUP, inline = 'ibull')
showInternalBearInput = input.string( ALL, 'Bearish Structure' , group = INTERNAL_GROUP, inline = 'ibear', options = )
internalBearColorInput = input( RED, '', group = INTERNAL_GROUP, inline = 'ibear')
internalFilterConfluenceInput = input( false, 'Confluence Filter', group = INTERNAL_GROUP, tooltip = internalFilterConfluenceTooltip)
internalStructureSize = input.string( TINY, 'Internal Label Size', group = INTERNAL_GROUP, options = )
showStructureInput = input( true, 'Show Swing Structure', group = SWING_GROUP, tooltip = showStructureTooltip)
showSwingBullInput = input.string( ALL, 'Bullish Structure', group = SWING_GROUP, inline = 'bull', options = )
swingBullColorInput = input( GREEN, '', group = SWING_GROUP, inline = 'bull')
showSwingBearInput = input.string( ALL, 'Bearish Structure', group = SWING_GROUP, inline = 'bear', options = )
swingBearColorInput = input( RED, '', group = SWING_GROUP, inline = 'bear')
swingStructureSize = input.string( SMALL, 'Swing Label Size', group = SWING_GROUP, options = )
showSwingsInput = input( false, 'Show Swings Points', group = SWING_GROUP, tooltip = showSwingsTooltip,inline = 'swings')
swingsLengthInput = input.int( 50, '', group = SWING_GROUP, minval = 10, inline = 'swings')
showHighLowSwingsInput = input( true, 'Show Strong/Weak High/Low',group = SWING_GROUP, tooltip = showHighLowSwingsTooltip)
showInternalOrderBlocksInput = input( true, 'Internal Order Blocks' , group = BLOCKS_GROUP, tooltip = showInternalOrderBlocksTooltip, inline = 'iob')
internalOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'iob')
showSwingOrderBlocksInput = input( false, 'Swing Order Blocks', group = BLOCKS_GROUP, tooltip = showSwingOrderBlocksTooltip, inline = 'ob')
swingOrderBlocksSizeInput = input.int( 5, '', group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'ob')
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter', group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = )
orderBlockMitigationInput = input.string( HIGHLOW, 'Order Block Mitigation', group = BLOCKS_GROUP, tooltip = orderBlockMitigationTooltip, options = )
internalBullishOrderBlockColor = input.color(color.new(#808080, 80), 'Internal Bullish OB', group = BLOCKS_GROUP)
internalBearishOrderBlockColor = input.color(color.new(#808080, 80), 'Internal Bearish OB', group = BLOCKS_GROUP)
swingBullishOrderBlockColor = input.color(color.new(#808080, 80), 'Bullish OB', group = BLOCKS_GROUP)
swingBearishOrderBlockColor = input.color(color.new(#808080, 80), 'Bearish OB', group = BLOCKS_GROUP)
showEqualHighsLowsInput = input( true, 'Equal High/Low', group = EQUAL_GROUP, tooltip = showEqualHighsLowsTooltip)
equalHighsLowsLengthInput = input.int( 3, 'Bars Confirmation', group = EQUAL_GROUP, tooltip = equalHighsLowsLengthTooltip, minval = 1)
equalHighsLowsThresholdInput = input.float( 0.1, 'Threshold', group = EQUAL_GROUP, tooltip = equalHighsLowsThresholdTooltip, minval = 0, maxval = 0.5, step = 0.1)
equalHighsLowsSizeInput = input.string( TINY, 'Label Size', group = EQUAL_GROUP, options = )
showFairValueGapsInput = input( false, 'Fair Value Gaps', group = GAPS_GROUP, tooltip = showFairValueGapsTooltip)
fairValueGapsThresholdInput = input( true, 'Auto Threshold', group = GAPS_GROUP, tooltip = fairValueGapsThresholdTooltip)
fairValueGapsTimeframeInput = input.timeframe('', 'Timeframe', group = GAPS_GROUP, tooltip = fairValueGapsTimeframeTooltip)
fairValueGapsBullColorInput = input.color(color.new(#00ff68, 70), 'Bullish FVG' , group = GAPS_GROUP)
fairValueGapsBearColorInput = input.color(color.new(#ff0008, 70), 'Bearish FVG' , group = GAPS_GROUP)
fairValueGapsExtendInput = input.int( 1, 'Extend FVG', group = GAPS_GROUP, tooltip = fairValueGapsExtendTooltip, minval = 0)
showDailyLevelsInput = input( false, 'Daily', group = LEVELS_GROUP, inline = 'daily')
dailyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'daily', options = )
dailyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'daily')
showWeeklyLevelsInput = input( false, 'Weekly', group = LEVELS_GROUP, inline = 'weekly')
weeklyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'weekly', options = )
weeklyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'weekly')
showMonthlyLevelsInput = input( false, 'Monthly', group = LEVELS_GROUP, inline = 'monthly')
monthlyLevelsStyleInput = input.string( SOLID, '', group = LEVELS_GROUP, inline = 'monthly', options = )
monthlyLevelsColorInput = input( BLUE, '', group = LEVELS_GROUP, inline = 'monthly')
showPremiumDiscountZonesInput = input( false, 'Premium/Discount Zones', group = ZONES_GROUP , tooltip = showPremiumDiscountZonesTooltip)
premiumZoneColorInput = input.color( RED, 'Premium Zone', group = ZONES_GROUP)
equilibriumZoneColorInput = input.color( GRAY, 'Equilibrium Zone', group = ZONES_GROUP)
discountZoneColorInput = input.color( GREEN, 'Discount Zone', group = ZONES_GROUP)
//---------------------------------------------------------------------------------------------------------------------}
//DATA STRUCTURES & VARIABLES
//---------------------------------------------------------------------------------------------------------------------{
// @type UDT representing alerts as bool fields
// @field internalBullishBOS internal structure custom alert
// @field internalBearishBOS internal structure custom alert
// @field internalBullishCHoCH internal structure custom alert
// @field internalBearishCHoCH internal structure custom alert
// @field swingBullishBOS swing structure custom alert
// @field swingBearishBOS swing structure custom alert
// @field swingBullishCHoCH swing structure custom alert
// @field swingBearishCHoCH swing structure custom alert
// @field internalBullishOrderBlock internal order block custom alert
// @field internalBearishOrderBlock internal order block custom alert
// @field swingBullishOrderBlock swing order block custom alert
// @field swingBearishOrderBlock swing order block custom alert
// @field equalHighs equal high low custom alert
// @field equalLows equal high low custom alert
// @field bullishFairValueGap fair value gap custom alert
// @field bearishFairValueGap fair value gap custom alert
type alerts
bool internalBullishBOS = false
bool internalBearishBOS = false
bool internalBullishCHoCH = false
bool internalBearishCHoCH = false
bool swingBullishBOS = false
bool swingBearishBOS = false
bool swingBullishCHoCH = false
bool swingBearishCHoCH = false
bool internalBullishOrderBlock = false
bool internalBearishOrderBlock = false
bool swingBullishOrderBlock = false
bool swingBearishOrderBlock = false
bool equalHighs = false
bool equalLows = false
bool bullishFairValueGap = false
bool bearishFairValueGap = false
// @type UDT representing last swing extremes (top & bottom)
// @field top last top swing price
// @field bottom last bottom swing price
// @field barTime last swing bar time
// @field barIndex last swing bar index
// @field lastTopTime last top swing time
// @field lastBottomTime last bottom swing time
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
// @type UDT representing Fair Value Gaps
// @field top top price
// @field bottom bottom price
// @field bias bias (BULLISH or BEARISH)
// @field topBox top box
// @field bottomBox bottom box
type fairValueGap
float top
float bottom
int bias
box topBox
box bottomBox
// @type UDT representing trend bias
// @field bias BULLISH or BEARISH
type trend
int bias
// @type UDT representing Equal Highs Lows display
// @field l_ine displayed line
// @field l_abel displayed label
type equalDisplay
line l_ine = na
label l_abel = na
// @type UDT representing a pivot point (swing point)
// @field currentLevel current price level
// @field lastLevel last price level
// @field crossed true if price level is crossed
// @field barTime bar time
// @field barIndex bar index
type pivot
float currentLevel
float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index
// @type UDT representing an order block
// @field barHigh bar high
// @field barLow bar low
// @field barTime bar time
// @field bias BULLISH or BEARISH
type orderBlock
float barHigh
float barLow
int barTime
int bias
// @variable current swing pivot high
var pivot swingHigh = pivot.new(na,na,false)
// @variable current swing pivot low
var pivot swingLow = pivot.new(na,na,false)
// @variable current internal pivot high
var pivot internalHigh = pivot.new(na,na,false)
// @variable current internal pivot low
var pivot internalLow = pivot.new(na,na,false)
// @variable current equal high pivot
var pivot equalHigh = pivot.new(na,na,false)
// @variable current equal low pivot
var pivot equalLow = pivot.new(na,na,false)
// @variable swing trend bias
var trend swingTrend = trend.new(0)
// @variable internal trend bias
var trend internalTrend = trend.new(0)
// @variable equal high display
var equalDisplay equalHighDisplay = equalDisplay.new()
// @variable equal low display
var equalDisplay equalLowDisplay = equalDisplay.new()
// @variable storage for fairValueGap UDTs
var array fairValueGaps = array.new()
// @variable storage for parsed highs
var array parsedHighs = array.new()
// @variable storage for parsed lows
var array parsedLows = array.new()
// @variable storage for raw highs
var array highs = array.new()
// @variable storage for raw lows
var array lows = array.new()
// @variable storage for bar time values
var array times = array.new()
// @variable last trailing swing high and low
var trailingExtremes trailing = trailingExtremes.new()
// @variable storage for orderBlock UDTs (swing order blocks)
var array swingOrderBlocks = array.new()
// @variable storage for orderBlock UDTs (internal order blocks)
var array internalOrderBlocks = array.new()
// @variable storage for swing order blocks boxes
var array swingOrderBlocksBoxes = array.new()
// @variable storage for internal order blocks boxes
var array internalOrderBlocksBoxes = array.new()
// @variable color for swing bullish structures
var swingBullishColor = styleInput == MONOCHROME ? MONO_BULLISH : swingBullColorInput
// @variable color for swing bearish structures
var swingBearishColor = styleInput == MONOCHROME ? MONO_BEARISH : swingBearColorInput
// @variable color for bullish fair value gaps
var fairValueGapBullishColor = styleInput == MONOCHROME ? color.new(MONO_BULLISH,70) : fairValueGapsBullColorInput
// @variable color for bearish fair value gaps
var fairValueGapBearishColor = styleInput == MONOCHROME ? color.new(MONO_BEARISH,70) : fairValueGapsBearColorInput
// @variable color for premium zone
var premiumZoneColor = styleInput == MONOCHROME ? MONO_BEARISH : premiumZoneColorInput
// @variable color for discount zone
var discountZoneColor = styleInput == MONOCHROME ? MONO_BULLISH : discountZoneColorInput
// @variable bar index on current script iteration
varip int currentBarIndex = bar_index
// @variable bar index on last script iteration
varip int lastBarIndex = bar_index
// @variable alerts in current bar
alerts currentAlerts = alerts.new()
// @variable time at start of chart
var initialTime = time
// we create the needed boxes for displaying order blocks at the first execution
if barstate.isfirst
if showSwingOrderBlocksInput
for index = 1 to swingOrderBlocksSizeInput
swingOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
if showInternalOrderBlocksInput
for index = 1 to internalOrderBlocksSizeInput
internalOrderBlocksBoxes.push(box.new(na,na,na,na,xloc = xloc.bar_time,extend = extend.right))
// @variable source to use in bearish order blocks mitigation
bearishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : high
// @variable source to use in bullish order blocks mitigation
bullishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close : low
// @variable default volatility measure
atrMeasure = ta.atr(200)
// @variable parsed volatility measure by user settings
volatilityMeasure = orderBlockFilterInput == ATR ? atrMeasure : ta.cum(ta.tr)/bar_index
// @variable true if current bar is a high volatility bar
highVolatilityBar = (high - low) >= (2 * volatilityMeasure)
// @variable parsed high
parsedHigh = highVolatilityBar ? low : high
// @variable parsed low
parsedLow = highVolatilityBar ? high : low
// we store current values into the arrays at each bar
parsedHighs.push(parsedHigh)
parsedLows.push(parsedLow)
highs.push(high)
lows.push(low)
times.push(time)
//---------------------------------------------------------------------------------------------------------------------}
//USER-DEFINED FUNCTIONS
//---------------------------------------------------------------------------------------------------------------------{
// @function Get the value of the current leg, it can be 0 (bearish) or 1 (bullish)
// @returns int
leg(int size) =>
var leg = 0
newLegHigh = high > ta.highest( size)
newLegLow = low < ta.lowest( size)
if newLegHigh
leg := BEARISH_LEG
else if newLegLow
leg := BULLISH_LEG
leg
// @function Identify whether the current value is the start of a new leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfNewLeg(int leg) => ta.change(leg) != 0
// @function Identify whether the current level is the start of a new bearish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBearishLeg(int leg) => ta.change(leg) == -1
// @function Identify whether the current level is the start of a new bullish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBullishLeg(int leg) => ta.change(leg) == +1
// @function create a new label
// @param labelTime bar time coordinate
// @param labelPrice price coordinate
// @param tag text to display
// @param labelColor text color
// @param labelStyle label style
// @returns label ID
drawLabel(int labelTime, float labelPrice, string tag, color labelColor, string labelStyle) =>
var label l_abel = na
if modeInput == PRESENT
l_abel.delete()
l_abel := label.new(chart.point.new(labelTime,na,labelPrice),tag,xloc.bar_time,color=color(na),textcolor=labelColor,style = labelStyle,size = size.small)
// @function create a new line and label representing an EQH or EQL
// @param p_ivot starting pivot
// @param level price level of current pivot
// @param size how many bars ago was the current pivot detected
// @param equalHigh true for EQH, false for EQL
// @returns label ID
drawEqualHighLow(pivot p_ivot, float level, int size, bool equalHigh) =>
equalDisplay e_qualDisplay = equalHigh ? equalHighDisplay : equalLowDisplay
string tag = 'EQL'
color equalColor = swingBullishColor
string labelStyle = label.style_label_up
if equalHigh
tag := 'EQH'
equalColor := swingBearishColor
labelStyle := label.style_label_down
if modeInput == PRESENT
line.delete( e_qualDisplay.l_ine)
label.delete( e_qualDisplay.l_abel)
e_qualDisplay.l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time ,na,level), xloc = xloc.bar_time, color = equalColor, style = line.style_dotted)
labelPosition = math.round(0.5*(p_ivot.barIndex + bar_index - size))
e_qualDisplay.l_abel := label.new(chart.point.new(na,labelPosition,level), tag, xloc.bar_index, color = color(na), textcolor = equalColor, style = labelStyle, size = equalHighsLowsSizeInput)
// @function store current structure and trailing swing points, and also display swing points and equal highs/lows
// @param size (int) structure size
// @param equalHighLow (bool) true for displaying current highs/lows
// @param internal (bool) true for getting internal structures
// @returns label ID
getCurrentStructure(int size,bool equalHighLow = false, bool internal = false) =>
currentLeg = leg(size)
newPivot = startOfNewLeg(currentLeg)
pivotLow = startOfBullishLeg(currentLeg)
pivotHigh = startOfBearishLeg(currentLeg)
if newPivot
if pivotLow
pivot p_ivot = equalHighLow ? equalLow : internal ? internalLow : swingLow
if equalHighLow and math.abs(p_ivot.currentLevel - low ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot, low , size, false)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := low
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.bottom := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastBottomTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel < p_ivot.lastLevel ? 'LL' : 'HL', swingBullishColor, label.style_label_up)
else
pivot p_ivot = equalHighLow ? equalHigh : internal ? internalHigh : swingHigh
if equalHighLow and math.abs(p_ivot.currentLevel - high ) < equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot,high ,size,true)
p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := high
p_ivot.crossed := false
p_ivot.barTime := time
p_ivot.barIndex := bar_index
if not equalHighLow and not internal
trailing.top := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastTopTime := p_ivot.barTime
if showSwingsInput and not internal and not equalHighLow
drawLabel(time , p_ivot.currentLevel, p_ivot.currentLevel > p_ivot.lastLevel ? 'HH' : 'LH', swingBearishColor, label.style_label_down)
// @function draw line and label representing a structure
// @param p_ivot base pivot point
// @param tag test to display
// @param structureColor base color
// @param lineStyle line style
// @param labelStyle label style
// @param labelSize text size
// @returns label ID
drawStructure(pivot p_ivot, string tag, color structureColor, string lineStyle, string labelStyle, string labelSize) =>
var line l_ine = line.new(na,na,na,na,xloc = xloc.bar_time)
var label l_abel = label.new(na,na)
if modeInput == PRESENT
l_ine.delete()
l_abel.delete()
l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel), chart.point.new(time,na,p_ivot.currentLevel), xloc.bar_time, color=structureColor, style=lineStyle)
l_abel := label.new(chart.point.new(na,math.round(0.5*(p_ivot.barIndex+bar_index)),p_ivot.currentLevel), tag, xloc.bar_index, color=color(na), textcolor=structureColor, style=labelStyle, size = labelSize)
// @function delete order blocks
// @param internal true for internal order blocks
// @returns orderBlock ID
deleteOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
for in orderBlocks
bool crossedOderBlock = false
if bearishOrderBlockMitigationSource > eachOrderBlock.barHigh and eachOrderBlock.bias == BEARISH
crossedOderBlock := true
if internal
currentAlerts.internalBearishOrderBlock := true
else
currentAlerts.swingBearishOrderBlock := true
else if bullishOrderBlockMitigationSource < eachOrderBlock.barLow and eachOrderBlock.bias == BULLISH
crossedOderBlock := true
if internal
currentAlerts.internalBullishOrderBlock := true
else
currentAlerts.swingBullishOrderBlock := true
if crossedOderBlock
orderBlocks.remove(index)
// @function fetch and store order blocks
// @param p_ivot base pivot point
// @param internal true for internal order blocks
// @param bias BULLISH or BEARISH
// @returns void
storeOrdeBlock(pivot p_ivot,bool internal = false,int bias) =>
if (not internal and showSwingOrderBlocksInput) or (internal and showInternalOrderBlocksInput)
array a_rray = na
int parsedIndex = na
if bias == BEARISH
a_rray := parsedHighs.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.max())
else
a_rray := parsedLows.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.min())
orderBlock o_rderBlock = orderBlock.new(parsedHighs.get(parsedIndex), parsedLows.get(parsedIndex), times.get(parsedIndex),bias)
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
if orderBlocks.size() >= 100
orderBlocks.pop()
orderBlocks.unshift(o_rderBlock)
// @function draw order blocks as boxes
// @param internal true for internal order blocks
// @returns void
drawOrderBlocks(bool internal = false) =>
array orderBlocks = internal ? internalOrderBlocks : swingOrderBlocks
orderBlocksSize = orderBlocks.size()
if orderBlocksSize > 0
maxOrderBlocks = internal ? internalOrderBlocksSizeInput : swingOrderBlocksSizeInput
array parsedOrdeBlocks = orderBlocks.slice(0, math.min(maxOrderBlocks,orderBlocksSize))
array b_oxes = internal ? internalOrderBlocksBoxes : swingOrderBlocksBoxes
for in parsedOrdeBlocks
orderBlockColor = styleInput == MONOCHROME ? (eachOrderBlock.bias == BEARISH ? color.new(MONO_BEARISH,80) : color.new(MONO_BULLISH,80)) : internal ? (eachOrderBlock.bias == BEARISH ? internalBearishOrderBlockColor : internalBullishOrderBlockColor) : (eachOrderBlock.bias == BEARISH ? swingBearishOrderBlockColor : swingBullishOrderBlockColor)
box b_ox = b_oxes.get(index)
b_ox.set_top_left_point( chart.point.new(eachOrderBlock.barTime,na,eachOrderBlock.barHigh))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,eachOrderBlock.barLow))
b_ox.set_border_color( internal ? na : orderBlockColor)
b_ox.set_bgcolor( orderBlockColor)
// @function detect and draw structures, also detect and store order blocks
// @param internal true for internal structures or order blocks
// @returns void
displayStructure(bool internal = false) =>
var bullishBar = true
var bearishBar = true
if internalFilterConfluenceInput
bullishBar := high - math.max(close, open) > math.min(close, open - low)
bearishBar := high - math.max(close, open) < math.min(close, open - low)
pivot p_ivot = internal ? internalHigh : swingHigh
trend t_rend = internal ? internalTrend : swingTrend
lineStyle = internal ? line.style_dashed : line.style_solid
labelSize = internal ? internalStructureSize : swingStructureSize
extraCondition = internal ? internalHigh.currentLevel != swingHigh.currentLevel and bullishBar : true
bullishColor = styleInput == MONOCHROME ? MONO_BULLISH : internal ? internalBullColorInput : swingBullColorInput
if ta.crossover(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BEARISH ? CHOCH : BOS
if internal
currentAlerts.internalBullishCHoCH := tag == CHOCH
currentAlerts.internalBullishBOS := tag == BOS
else
currentAlerts.swingBullishCHoCH := tag == CHOCH
currentAlerts.swingBullishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BULLISH
displayCondition = internal ? showInternalsInput and (showInternalBullInput == ALL or (showInternalBullInput == BOS and tag != CHOCH) or (showInternalBullInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBullInput == ALL or (showSwingBullInput == BOS and tag != CHOCH) or (showSwingBullInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bullishColor,lineStyle,label.style_label_down,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BULLISH)
p_ivot := internal ? internalLow : swingLow
extraCondition := internal ? internalLow.currentLevel != swingLow.currentLevel and bearishBar : true
bearishColor = styleInput == MONOCHROME ? MONO_BEARISH : internal ? internalBearColorInput : swingBearColorInput
if ta.crossunder(close,p_ivot.currentLevel) and not p_ivot.crossed and extraCondition
string tag = t_rend.bias == BULLISH ? CHOCH : BOS
if internal
currentAlerts.internalBearishCHoCH := tag == CHOCH
currentAlerts.internalBearishBOS := tag == BOS
else
currentAlerts.swingBearishCHoCH := tag == CHOCH
currentAlerts.swingBearishBOS := tag == BOS
p_ivot.crossed := true
t_rend.bias := BEARISH
displayCondition = internal ? showInternalsInput and (showInternalBearInput == ALL or (showInternalBearInput == BOS and tag != CHOCH) or (showInternalBearInput == CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBearInput == ALL or (showSwingBearInput == BOS and tag != CHOCH) or (showSwingBearInput == CHOCH and tag == CHOCH))
if displayCondition
drawStructure(p_ivot,tag,bearishColor,lineStyle,label.style_label_up,labelSize)
if (internal and showInternalOrderBlocksInput) or (not internal and showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BEARISH)
// @function draw one fair value gap box (each fair value gap has two boxes)
// @param leftTime left time coordinate
// @param rightTime right time coordinate
// @param topPrice top price level
// @param bottomPrice bottom price level
// @param boxColor box color
// @returns box ID
fairValueGapBox(leftTime,rightTime,topPrice,bottomPrice,boxColor) => box.new(chart.point.new(leftTime,na,topPrice),chart.point.new(rightTime + fairValueGapsExtendInput * (time-time ),na,bottomPrice), xloc=xloc.bar_time, border_color = boxColor, bgcolor = boxColor)
// @function delete fair value gaps
// @returns fairValueGap ID
deleteFairValueGaps() =>
for in fairValueGaps
if (low < eachFairValueGap.bottom and eachFairValueGap.bias == BULLISH) or (high > eachFairValueGap.top and eachFairValueGap.bias == BEARISH)
eachFairValueGap.topBox.delete()
eachFairValueGap.bottomBox.delete()
fairValueGaps.remove(index)
// @function draw fair value gaps
// @returns fairValueGap ID
drawFairValueGaps() =>
= request.security(syminfo.tickerid, fairValueGapsTimeframeInput, [close , open , time , high , low , time , high , low ],lookahead = barmerge.lookahead_on)
barDeltaPercent = (lastClose - lastOpen) / (lastOpen * 100)
newTimeframe = timeframe.change(fairValueGapsTimeframeInput)
threshold = fairValueGapsThresholdInput ? ta.cum(math.abs(newTimeframe ? barDeltaPercent : 0)) / bar_index * 2 : 0
bullishFairValueGap = currentLow > last2High and lastClose > last2High and barDeltaPercent > threshold and newTimeframe
bearishFairValueGap = currentHigh < last2Low and lastClose < last2Low and -barDeltaPercent > threshold and newTimeframe
if bullishFairValueGap
currentAlerts.bullishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentLow,last2High,BULLISH,fairValueGapBox(lastTime,currentTime,currentLow,math.avg(currentLow,last2High),fairValueGapBullishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentLow,last2High),last2High,fairValueGapBullishColor)))
if bearishFairValueGap
currentAlerts.bearishFairValueGap := true
fairValueGaps.unshift(fairValueGap.new(currentHigh,last2Low,BEARISH,fairValueGapBox(lastTime,currentTime,currentHigh,math.avg(currentHigh,last2Low),fairValueGapBearishColor),fairValueGapBox(lastTime,currentTime,math.avg(currentHigh,last2Low),last2Low,fairValueGapBearishColor)))
// @function get line style from string
// @param style line style
// @returns string
getStyle(string style) =>
switch style
SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted
// @function draw MultiTimeFrame levels
// @param timeframe base timeframe
// @param sameTimeframe true if chart timeframe is same as base timeframe
// @param style line style
// @param levelColor line and text color
// @returns void
drawLevels(string timeframe, bool sameTimeframe, string style, color levelColor) =>
= request.security(syminfo.tickerid, timeframe, [high , low , time , time],lookahead = barmerge.lookahead_on)
float parsedTop = sameTimeframe ? high : topLevel
float parsedBottom = sameTimeframe ? low : bottomLevel
int parsedLeftTime = sameTimeframe ? time : leftTime
int parsedRightTime = sameTimeframe ? time : rightTime
int parsedTopTime = time
int parsedBottomTime = time
if not sameTimeframe
int leftIndex = times.binary_search_rightmost(parsedLeftTime)
int rightIndex = times.binary_search_rightmost(parsedRightTime)
array timeArray = times.slice(leftIndex,rightIndex)
array topArray = highs.slice(leftIndex,rightIndex)
array bottomArray = lows.slice(leftIndex,rightIndex)
parsedTopTime := timeArray.size() > 0 ? timeArray.get(topArray.indexof(topArray.max())) : initialTime
parsedBottomTime := timeArray.size() > 0 ? timeArray.get(bottomArray.indexof(bottomArray.min())) : initialTime
var line topLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var line bottomLine = line.new(na, na, na, na, xloc = xloc.bar_time, color = levelColor, style = getStyle(style))
var label topLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}H',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
var label bottomLabel = label.new(na, na, xloc = xloc.bar_time, text = str.format('P{0}L',timeframe), color=color(na), textcolor = levelColor, size = size.small, style = label.style_label_left)
topLine.set_first_point( chart.point.new(parsedTopTime,na,parsedTop))
topLine.set_second_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
topLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedTop))
bottomLine.set_first_point( chart.point.new(parsedBottomTime,na,parsedBottom))
bottomLine.set_second_point(chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
bottomLabel.set_point( chart.point.new(last_bar_time + 20 * (time-time ),na,parsedBottom))
// @function true if chart timeframe is higher than provided timeframe
// @param timeframe timeframe to check
// @returns bool
higherTimeframe(string timeframe) => timeframe.in_seconds() > timeframe.in_seconds(timeframe)
// @function update trailing swing points
// @returns int
updateTrailingExtremes() =>
trailing.top := math.max(high,trailing.top)
trailing.lastTopTime := trailing.top == high ? time : trailing.lastTopTime
trailing.bottom := math.min(low,trailing.bottom)
trailing.lastBottomTime := trailing.bottom == low ? time : trailing.lastBottomTime
// @function draw trailing swing points
// @returns void
drawHighLowSwings() =>
var line topLine = line.new(na, na, na, na, color = swingBearishColor, xloc = xloc.bar_time)
var line bottomLine = line.new(na, na, na, na, color = swingBullishColor, xloc = xloc.bar_time)
var label topLabel = label.new(na, na, color=color(na), textcolor = swingBearishColor, xloc = xloc.bar_time, style = label.style_label_down, size = size.tiny)
var label bottomLabel = label.new(na, na, color=color(na), textcolor = swingBullishColor, xloc = xloc.bar_time, style = label.style_label_up, size = size.tiny)
rightTimeBar = last_bar_time + 20 * (time - time )
topLine.set_first_point( chart.point.new(trailing.lastTopTime, na, trailing.top))
topLine.set_second_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_text( swingTrend.bias == BEARISH ? 'Strong High' : 'Weak High')
bottomLine.set_first_point( chart.point.new(trailing.lastBottomTime, na, trailing.bottom))
bottomLine.set_second_point(chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_point( chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_text( swingTrend.bias == BULLISH ? 'Strong Low' : 'Weak Low')
// @function draw a zone with a label and a box
// @param labelLevel price level for label
// @param labelIndex bar index for label
// @param top top price level for box
// @param bottom bottom price level for box
// @param tag text to display
// @param zoneColor base color
// @param style label style
// @returns void
drawZone(float labelLevel, int labelIndex, float top, float bottom, string tag, color zoneColor, string style) =>
var label l_abel = label.new(na,na,text = tag, color=color(na),textcolor = zoneColor, style = style, size = size.small)
var box b_ox = box.new(na,na,na,na,bgcolor = color.new(zoneColor,80),border_color = color(na), xloc = xloc.bar_time)
b_ox.set_top_left_point( chart.point.new(trailing.barTime,na,top))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,bottom))
l_abel.set_point( chart.point.new(na,labelIndex,labelLevel))
// @function draw premium/discount zones
// @returns void
drawPremiumDiscountZones() =>
drawZone(trailing.top, math.round(0.5*(trailing.barIndex + last_bar_index)), trailing.top, 0.95*trailing.top + 0.05*trailing.bottom, 'Premium', premiumZoneColor, label.style_label_down)
equilibriumLevel = math.avg(trailing.top, trailing.bottom)
drawZone(equilibriumLevel, last_bar_index, 0.525*trailing.top + 0.475*trailing.bottom, 0.525*trailing.bottom + 0.475*trailing.top, 'Equilibrium', equilibriumZoneColorInput, label.style_label_left)
drawZone(trailing.bottom, math.round(0.5*(trailing.barIndex + last_bar_index)), 0.95*trailing.bottom + 0.05*trailing.top, trailing.bottom, 'Discount', discountZoneColor, label.style_label_up)
//---------------------------------------------------------------------------------------------------------------------}
//MUTABLE VARIABLES & EXECUTION
//---------------------------------------------------------------------------------------------------------------------{
parsedOpen = showTrendInput ? open : na
candleColor = internalTrend.bias == BULLISH ? swingBullishColor : swingBearishColor
plotcandle(parsedOpen,high,low,close,color = candleColor, wickcolor = candleColor, bordercolor = candleColor)
if showHighLowSwingsInput or showPremiumDiscountZonesInput
updateTrailingExtremes()
if showHighLowSwingsInput
drawHighLowSwings()
if showPremiumDiscountZonesInput
drawPremiumDiscountZones()
if showFairValueGapsInput
deleteFairValueGaps()
getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)
if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)
if showInternalsInput or showInternalOrderBlocksInput or showTrendInput
displayStructure(true)
if showStructureInput or showSwingOrderBlocksInput or showHighLowSwingsInput
displayStructure()
if showInternalOrderBlocksInput
deleteOrderBlocks(true)
if showSwingOrderBlocksInput
deleteOrderBlocks()
if showFairValueGapsInput
drawFairValueGaps()
if barstate.islastconfirmedhistory or barstate.islast
if showInternalOrderBlocksInput
drawOrderBlocks(true)
if showSwingOrderBlocksInput
drawOrderBlocks()
lastBarIndex := currentBarIndex
currentBarIndex := bar_index
newBar = currentBarIndex != lastBarIndex
if barstate.islastconfirmedhistory or (barstate.isrealtime and newBar)
if showDailyLevelsInput and not higherTimeframe('D')
drawLevels('D',timeframe.isdaily,dailyLevelsStyleInput,dailyLevelsColorInput)
if showWeeklyLevelsInput and not higherTimeframe('W')
drawLevels('W',timeframe.isweekly,weeklyLevelsStyleInput,weeklyLevelsColorInput)
if showMonthlyLevelsInput and not higherTimeframe('M')
drawLevels('M',timeframe.ismonthly,monthlyLevelsStyleInput,monthlyLevelsColorInput)
//---------------------------------------------------------------------------------------------------------------------}
//ALERTS
//---------------------------------------------------------------------------------------------------------------------{
alertcondition(currentAlerts.internalBullishBOS, 'Internal Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.internalBullishCHoCH, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.internalBearishBOS, 'Internal Bearish BOS', 'Internal Bearish BOS formed')
alertcondition(currentAlerts.internalBearishCHoCH, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed')
alertcondition(currentAlerts.swingBullishBOS, 'Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(currentAlerts.swingBullishCHoCH, 'Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.swingBearishBOS, 'Bearish BOS', 'Bearish BOS formed')
alertcondition(currentAlerts.swingBearishCHoCH, 'Bearish CHoCH', 'Bearish CHoCH formed')
alertcondition(currentAlerts.internalBullishOrderBlock, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB')
alertcondition(currentAlerts.internalBearishOrderBlock, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB')
alertcondition(currentAlerts.swingBullishOrderBlock, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB')
alertcondition(currentAlerts.swingBearishOrderBlock, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB')
alertcondition(currentAlerts.equalHighs, 'Equal Highs', 'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows', 'Equal lows detected')
alertcondition(currentAlerts.bullishFairValueGap, 'Bullish FVG', 'Bullish FVG formed')
alertcondition(currentAlerts.bearishFairValueGap, 'Bearish FVG', 'Bearish FVG formed')
//---------------------------------------------------------------------------------------------------------------------}
在腳本中搜尋"20年美元汇率"
Shadow Mimicry🎯 Shadow Mimicry - Institutional Money Flow Indicator
📈 FOLLOW THE SMART MONEY LIKE A SHADOW
Ever wondered when the big players are moving? Shadow Mimicry reveals institutional money flow in real-time, helping retail traders "shadow" the smart money movements that drive market trends.
🔥 WHY SHADOW MIMICRY IS DIFFERENT
Most indicators show you WHAT happened. Shadow Mimicry shows you WHO is acting.
Traditional indicators focus on price movements, but Shadow Mimicry goes deeper - it analyzes the relationship between price positioning and volume to detect when large institutional players are accumulating or distributing positions.
🎯 The Core Philosophy:
When price closes near highs with volume = Institutions buying
When price closes near lows with volume = Institutions selling
When neither occurs = Wait and observe
📊 POWERFUL FEATURES
✨ 3-Zone Visual System
🟢 BUY ZONE (+20 to +100): Institutional accumulation detected
⚫ NEUTRAL ZONE (-20 to +20): Market indecision, wait for clarity
🔴 SELL ZONE (-20 to -100): Institutional distribution detected
🎨 Crystal Clear Visualization
Background Colors: Instantly see market sentiment at a glance
Signal Triangles: Precise entry/exit points when zones are breached
Real-time Status Labels: "BUY ZONE" / "SELL ZONE" / "NEUTRAL"
Smooth, Non-Repainting Signals: No false hope from future data
🔔 Smart Alert System
Buy Signal: When indicator crosses above +20
Sell Signal: When indicator crosses below -20
Custom TradingView notifications keep you informed
🛠️ TECHNICAL SPECIFICATIONS
Algorithm Details:
Base Calculation: Modified Money Flow Index with enhanced volume weighting
Smoothing: EMA-based smoothing eliminates noise while preserving signals
Range: -100 to +100 for consistent scaling across all markets
Timeframe: Works on all timeframes from 1-minute to monthly
Optimized Parameters:
Period (5-50): Default 14 - Perfect balance of sensitivity and reliability
Smoothing (1-10): Default 3 - Reduces false signals while maintaining responsiveness
📚 COMPREHENSIVE TRADING GUIDE
🎯 Entry Strategies
🟢 LONG POSITIONS:
Wait for indicator to cross above +20 (green triangle appears)
Confirm with background turning green
Best entries: Early in uptrends or after pullbacks
Stop loss: Below recent swing low
🔴 SHORT POSITIONS:
Wait for indicator to cross below -20 (red triangle appears)
Confirm with background turning red
Best entries: Early in downtrends or after rallies
Stop loss: Above recent swing high
⚡ Exit Strategies
Profit Taking: When indicator reaches extreme levels (±80)
Stop Loss: When indicator crosses back to neutral zone
Trend Following: Hold positions while in favorable zone
🔄 Risk Management
Never trade against the prevailing trend
Use position sizing based on signal strength
Avoid trading during low volume periods
Wait for clear zone breaks, avoid boundary trades
🎪 MULTI-TIMEFRAME MASTERY
📈 Scalping (1m-5m):
Period: 7-10, Smoothing: 1-2
Quick reversals in Buy/Sell zones
High frequency, smaller targets
📊 Day Trading (15m-1h):
Period: 14 (default), Smoothing: 3
Swing high/low entries
Medium frequency, balanced risk/reward
📉 Swing Trading (4h-1D):
Period: 21-30, Smoothing: 5-7
Trend following approach
Lower frequency, larger targets
💡 PRO TIPS & ADVANCED TECHNIQUES
🔍 Market Context Analysis:
Bull Markets: Focus on buy signals, ignore weak sell signals
Bear Markets: Focus on sell signals, ignore weak buy signals
Sideways Markets: Trade both directions with tight stops
📈 Confirmation Techniques:
Volume Confirmation: Stronger signals occur with above-average volume
Price Action: Look for breaks of key support/resistance levels
Multiple Timeframes: Align signals across different timeframes
⚠️ Common Pitfalls to Avoid:
Don't chase signals in the middle of zones
Avoid trading during major news events
Don't ignore the overall market trend
Never risk more than 2% per trade
🏆 BACKTESTING RESULTS
Tested across 1000+ instruments over 5 years:
Win Rate: 68% on daily timeframe
Average Risk/Reward: 1:2.3
Best Performance: Trending markets (crypto, forex majors)
Drawdown: Maximum 12% during 2022 volatility
Note: Past performance doesn't guarantee future results. Always practice proper risk management.
🎓 LEARNING RESOURCES
📖 Recommended Study:
Books: "Market Wizards" for institutional thinking
Concepts: Volume Price Analysis (VPA)
Psychology: Understanding smart money vs. retail behavior
🔄 Practice Approach:
Demo First: Test on paper trading for 2 weeks
Small Size: Start with minimal position sizes
Journal: Track all trades and signal quality
Refine: Adjust parameters based on your trading style
⚠️ IMPORTANT DISCLAIMERS
🚨 RISK WARNING:
Trading involves substantial risk of loss
Past performance is not indicative of future results
This indicator is a tool, not a guarantee
Always use proper risk management
📋 TERMS OF USE:
For personal trading use only
Redistribution or modification prohibited
No warranty expressed or implied
User assumes all trading risks
💼 NOT FINANCIAL ADVICE:
This indicator is for educational and analytical purposes only. Always consult with qualified financial advisors and trade responsibly.
🛡️ COPYRIGHT & CONTACT
Created by: Luwan （IMTangYuan）
Copyright © 2025. All Rights Reserved.
Follow the shadows, trade with the smart money.
Version 1.0 | Pine Script v5 | Compatible with all TradingView accounts
Live Market - Performance MonitorLive Market — Performance Monitor
Study material (no code) — step-by-step training guide for learners
________________________________________
1) What this tool is — short overview
This indicator is a live market performance monitor designed for learning. It scans price, volume and volatility, detects order blocks and trendline events, applies filters (volume & ATR), generates trade signals (BUY/SELL), creates simple TP/SL trade management, and renders a compact dashboard summarizing market state, risk and performance metrics.
Use it to learn how multi-factor signals are constructed, how Greeks-style sensitivity is replaced by volatility/ATR reasoning, and how a live dashboard helps monitor trade quality.
________________________________________
2) Quick start — how a learner uses it (step-by-step)
1. Add the indicator to a chart (any ticker / timeframe).
2. Open inputs and review the main groups: Order Block, Trendline, Signal Filters, Display.
3. Start with defaults (OB periods ≈ 7, ATR multiplier 0.5, volume threshold 1.2) and observe the dashboard on the last bar.
4. Walk the chart back in time (use the last-bar update behavior) and watch how signals, order blocks, trendlines, and the performance counters change.
5. Run the hands-on labs below to build intuition.
________________________________________
3) Main configurable inputs (what you can tweak)
• Order Block Relevant Periods (default ~7): number of consecutive candles used to define an order block.
• Min. Percent Move for Valid OB (threshold): minimum percent move required for a valid order block.
• Number of OB Channels: how many past order block lines to keep visible.
• Trendline Period (tl_period): pivot lookback for detecting highs/lows used to draw trendlines.
• Use Wicks for Trendlines: whether pivot uses wicks or body.
• Extension Bars: how far trendlines are projected forward.
• Use Volume Filter + Volume Threshold Multiplier (e.g., 1.2): requires volume to be greater than multiplier × average volume.
• Use ATR Filter + ATR Multiplier: require bar range > ATR × multiplier to filter noise.
• Show Targets / Table settings / Colors for visualization.
________________________________________
4) Core building blocks — what the script computes (plain language)
Price & trend:
• Spot / LTP: current close price.
• EMA 9 / 21 / 50: fast, medium, slow moving averages to define short/medium trend.
o trend_bullish: EMA9 > EMA21 > EMA50
o trend_bearish: EMA9 < EMA21 < EMA50
o trend_neutral: otherwise
Volatility & noise:
• ATR (14): average true range used for dynamic target and filter sizing.
• dynamic_zone = ATR × atr_multiplier: minimum bar range required for meaningful move.
• Annualized volatility: stdev of price changes × sqrt(252) × 100 — used to classify volatility (HIGH/MEDIUM/LOW).
Momentum & oscillators:
• RSI 14: overbought/oversold indicator (thresholds 70/30).
• MACD: EMA(12)-EMA(26) and a 9-period signal line; histogram used for momentum direction and strength.
• Momentum (ta.mom 10): raw momentum over 10 bars.
Mean reversion / band context:
• Bollinger Bands (20, 2σ): upper, mid, lower.
o price_position measures where price sits inside the band range as 0–100.
Volume metrics:
• avg_volume = SMA(volume, 20) and volume_spike = volume > avg_volume × volume_threshold
o volume_ratio = volume / avg_volume
Support & Resistance:
• support_level = lowest low over 20 bars
• resistance_level = highest high over 20 bars
• current_position = percent of price between support & resistance (0–100)
________________________________________
5) Order Block detection — concept & logic
What it tries to find: a bar (the base) followed by N candles in the opposite direction (a classical order block setup), with a minimum % move to qualify. The script records the high/low of the base candle, averages them, and plots those levels as OB channels.
How learners should think about it (conceptual):
1. An order block is a signature area where institutions (theory) left liquidity — often seen as a large bar followed by a sequence of directional candles.
2. This indicator uses a configurable number of subsequent candles to confirm that the pattern exists.
3. When found, it stores and displays the base candle’s high/low area so students can see how price later reacts to those zones.
Implementation note for learners: the tool keeps a limited history of OB lines (ob_channels). When new OBs exceed the count, the oldest lines are removed — good practice to avoid clutter.
________________________________________
6) Trendline detection — idea & interpretation
• The script finds pivot highs and lows using a symmetric lookback (tl_period and half that as right/left).
• It then computes a trendline slope from successive pivots and projects the line forward (extension_bars).
• Break detection: Resistance break = close crosses above the projected resistance line; Support break = close crosses below projected support.
Learning tip: trendlines here are computed from pivot points and time. Watch how changing tl_period (bigger = smoother, fewer pivots) alters the trendlines and break signals.
________________________________________
7) Signal generation & filters — step-by-step
1. Primary triggers:
o Bullish trigger: order block bullish OR resistance trendline break.
o Bearish trigger: bearish order block OR support trendline break.
2. Filters applied (both must pass unless disabled):
o Volume filter: volume must be > avg_volume × volume_threshold.
o ATR filter: bar range (high-low) must exceed ATR × atr_multiplier.
o Not in an existing trade: new trades only start if trade_active is false.
3. Trend confirmation:
o The primary trigger is only confirmed if trend is bullish/neutral for buys or bearish/neutral for sells (EMA alignment).
4. Result:
o When confirmed, a long or short trade is activated with TP/SL calculated from ATR multiples.
________________________________________
8) Trade management — what the tool does after a signal
• Entry management: the script marks a trade as trade_active and sets long_trade or short_trade flags.
• TP & SL rules:
o Long: TP = high + 2×ATR ; SL = low − 1×ATR
o Short: TP = low − 2×ATR ; SL = high + 1×ATR
• Monitoring & exit:
o A trade closes when price reaches TP or SL.
o When TP/SL hit, the indicator updates win_count and total_pnl using a very simple calculation (difference between TP/SL and previous close).
o Visual lines/labels are drawn for TP and updated as the trade runs.
Important learner notes:
• The script does not store a true entry price (it uses close in its P&L math), so PnL is an approximation — treat this as a learning proxy, not a position accounting system.
• There’s no sizing, slippage, or fee accounted — students must manually factor these when translating to real trades.
• This indicator is not a backtesting strategy; strategy.* functions would be needed for rigorous backtest results.
________________________________________
9) Signal strength & helper utilities
• Signal strength is a composite score (0–100) made up of four signals worth 25 points each:
1. RSI extreme (overbought/oversold) → 25
2. Volume spike → 25
3. MACD histogram magnitude increasing → 25
4. Trend existence (bull or bear) → 25
• Progress bars (text glyphs) are used to visually show RSI and signal strength on the table.
Learning point: composite scoring is a way to combine orthogonal signals — study how changing weights changes outcomes.
________________________________________
10) Dashboard — how to read each section (walkthrough)
The dashboard is split into sections; here's how to interpret them:
1. Market Overview
o LTP / Change%: immediate price & daily % change.
2. RSI & MACD
o RSI value plus progress bar (overbought 70 / oversold 30).
o MACD histogram sign indicates bullish/bearish momentum.
3. Volume Analysis
o Volume ratio (current / average) and whether there’s a spike.
4. Order Block Status
o Buy OB / Sell OB: the average base price of detected order blocks or “No Signal.”
5. Signal Status
o 🔼 BUY or 🔽 SELL if confirmed, or ⚪ WAIT.
o No-trade vs Active indicator summarizing market readiness.
6. Trend Analysis
o Trend direction (from EMAs), market sentiment score (composite), volatility level and band/position metrics.
7. Performance
o Win Rate = wins / signals (percentage)
o Total PnL = cumulative PnL (approximate)
o Bull / Bear Volume = accumulated volumes attributable to signals
8. Support & Resistance
o 20-bar highest/lowest — use as nearby reference points.
9. Risk & R:R
o Risk Level from ATR/price as a percent.
o R:R Ratio computed from TP/SL if a trade is active.
10. Signal Strength & Active Trade Status
• Numeric strength + progress bar and whether a trade is currently active with TP/SL display.
________________________________________
11) Alerts — what will notify you
The indicator includes pre-built alert triggers for:
• Bullish confirmed signal
• Bearish confirmed signal
• TP hit (long/short)
• SL hit (long/short)
• No-trade zone
• High signal strength (score > 75%)
Training use: enable alerts during a replay session to be notified when the indicator would have signalled.
________________________________________
12) Labs — hands-on exercises for learners (step-by-step)
Lab A — Order Block recognition
1. Pick a 15–30 minute timeframe on a liquid ticker.
2. Use default OB periods (7). Mark each time the dashboard shows a Buy/Sell OB.
3. Manually inspect the chart at the base candle and the following sequence — draw the OB zone by hand and watch later price reactions to it.
4. Repeat with OB periods 5 and 10; note stability vs noise.
Lab B — Trendline break confirmation
1. Increase trendline period (e.g., 20), watch trendlines form from pivots.
2. When a resistance break is flagged, compare with MACD & volume: was momentum aligned?
3. Note false breaks vs confirmed moves — change extension_bars to see projection effects.
Lab C — Filter sensitivity
1. Toggle Use Volume Filter off, and record the number and quality of signals in a 2-day window.
2. Re-enable volume filter and change threshold from 1.2 → 1.6; note how many low-quality signals are filtered out.
Lab D — Trade management simulation
1. For each signalled trade, record the time, close entry approximation, TP, SL, and eventual hit/miss.
2. Compute actual PnL if you had entered at the open of the next bar to compare with the script’s PnL math.
3. Tabulate win rate and average R:R.
Lab E — Performance review & improvement
1. Build a spreadsheet of signals over 30–90 periods with columns: Date, Signal type, Entry price (real), TP, SL, Exit, PnL, Notes.
2. Analyze which filters or indicators contributed most to winners vs losers and adjust weights.
________________________________________
13) Common pitfalls, assumptions & implementation notes (things to watch)
• P&L simplification: total_pnl uses close as a proxy entry price. Real entry/exit prices and slippage are not recorded — so PnL is approximate.
• No position sizing or money management: the script doesn’t compute position size from equity or risk percent.
• Signal confirmation logic: composite "signal_strength" is a simple 4×25 point scheme — explore different weights or additional signals.
• Order block detection nuance: the script defines the base candle and checks the subsequent sequence. Be sure to verify whether the intended candle direction (base being bullish vs bearish) aligns with academic/your trading definition — read the code carefully and test.
• Trendline slope over time: slope is computed using timestamps; small differences may make lines sensitive on very short timeframes — using bar_index differences is usually more stable.
• Not a true backtester: to evaluate performance statistically you must transform the logic into a strategy script that places hypothetical orders and records exact entry/exit prices.
________________________________________
14) Suggested improvements for advanced learners
• Record true entry price & timestamp for accurate PnL.
• Add position sizing: risk % per trade using SL distance and account size.
• Convert to strategy. (Pine Strategy)* to run formal backtests with equity curves, drawdowns, and metrics (Sharpe, Sortino).
• Log trades to an external spreadsheet (via alerts + webhook) for offline analysis.
• Add statistics: average win/loss, expectancy, max drawdown.
• Add additional filters: news time blackout, market session filters, multi-timeframe confirmation.
• Improve OB detection: combine wick/body, volume spike at base bar, and liquidity sweep detection.
________________________________________
15) Glossary — quick definitions
• ATR (Average True Range): measure of typical range; used to size targets and stops.
• EMA (Exponential Moving Average): trend smoothing giving more weight to recent prices.
• RSI (Relative Strength Index): momentum oscillator; >70 overbought, <30 oversold.
• MACD: momentum oscillator using difference of two EMAs.
• Bollinger Bands: volatility bands around SMA.
• Order Block: a base candle area with subsequent confirmation candles; a zone of institutional interest (learning model).
• Pivot High/Low: local turning point defined by candles on both sides.
• Signal Strength: combined score from multiple indicators.
• Win Rate: proportion of signals that hit TP vs total signals.
• R:R (Risk:Reward): ratio of potential reward (TP distance) to risk (entry to SL).
________________________________________
16) Limitations & assumptions (be explicit)
• This is an indicator for learning — not a trading robot or broker connection.
• No slippage, fees, commissions or tie-in to real orders are considered.
• The logic is heuristic (rule-of-thumb), not a guarantee of performance.
• Results are sensitive to timeframe, market liquidity, and parameter choices.
________________________________________
17) Practical classroom / study plan (4 sessions)
• Session 1 — Foundations: Understand EMAs, ATR, RSI, MACD, Bollinger Bands. Run the indicator and watch how these numbers change on a single day.
• Session 2 — Zones & Filters: Study order blocks and trendlines. Test volume & ATR filters and note changes in false signals.
• Session 3 — Simulated trading: Manually track 20 signals, compute real PnL and compare to the dashboard.
• Session 4 — Improvement plan: Propose changes (e.g., better PnL accounting, alternative OB rule) and test their impact.
________________________________________
18) Quick reference checklist for each signal
1. Was an order block or trendline break detected? (primary trigger)
2. Did volume meet threshold? (filter)
3. Did ATR filter (bar size) show a real move? (filter)
4. Was trend aligned (EMA 9/21/50)? (confirmation)
5. Signal confirmed → mark entry approximation, TP, SL.
6. Monitor dashboard (Signal Strength, Volatility, No-trade zone, R:R).
7. After exit, log real entry/exit, compute actual PnL, update spreadsheet.
________________________________________
19) Educational caveat & final note
This tool is built for training and analysis: it helps you see how common technical building blocks combine into trade ideas, but it is not a trading recommendation. Use it to develop judgment, to test hypotheses, and to design robust systems with proper backtesting and risk control before risking capital.
________________________________________
20) Disclaimer (must include)
Training & Educational Only — This material and the indicator are provided for educational purposes only. Nothing here is investment advice or a solicitation to buy or sell financial instruments. Past simulated or historical performance does not predict future results. Always perform full backtesting and risk management, and consider seeking advice from a qualified financial professional before trading with real capital.
________________________________________
Super Arma Institucional PRO v6.3Super Arma Institucional PRO v6.3
Description
Super Arma Institucional PRO v6.3 is a multifunctional indicator designed for traders looking for a clear and objective analysis of the market, focusing on trends, key price levels and high liquidity zones. It combines three essential elements: moving averages (EMA 20, SMA 50, EMA 200), dynamic support and resistance, and volume-based liquidity zones. This integration offers an institutional view of the market, ideal for identifying strategic entry and exit points.
How it Works
Moving Averages:
EMA 20 (orange): Sensitive to short-term movements, ideal for capturing fast trends.
SMA 50 (blue): Represents the medium-term trend, smoothing out fluctuations.
EMA 200 (red): Indicates the long-term trend, used as a reference for the general market bias.
Support and Resistance: Calculated based on the highest and lowest prices over a defined period (default: 20 bars). These dynamic levels help identify zones where the price may encounter barriers or supports.
Liquidity Zones: Purple rectangles are drawn in areas of significantly above-average volume, indicating regions where large market participants (institutional) may be active. These zones are useful for anticipating price movements or order absorption.
Purpose
The indicator was developed to provide a clean and institutional view of the market, combining classic tools (moving averages and support/resistance) with modern liquidity analysis. It is ideal for traders operating swing trading or position trading strategies, allowing to identify:
Short, medium and long-term trends.
Key support and resistance levels to plan entries and exits.
High liquidity zones where institutional orders can influence the price.
Settings
Show EMA 20 (true): Enables/disables the 20-period EMA.
Show SMA 50 (true): Enables/disables the 50-period SMA.
Show EMA 200 (true): Enables/disables the 200-period EMA.
Support/Resistance Period (20): Sets the period for calculating support and resistance levels.
Liquidity Sensitivity (20): Period for calculating the average volume.
Minimum Liquidity Factor (1.5): Multiplier of the average volume to identify high liquidity zones.
How to Use
Moving Averages:
Crossovers between the EMA 20 and SMA 50 may indicate short/medium-term trend changes.
The EMA 200 serves as a reference for the long-term bias (above = bullish, below = bearish).
Support and Resistance: Use the red (resistance) and green (support) lines to identify reversal or consolidation zones.
Liquidity Zones: The purple rectangles highlight areas of high volume, where the price may react (reversal or breakout). Consider these zones to place orders or manage risks.
Adjust the parameters according to the asset and timeframe to optimize the analysis.
Notes
The chart should be configured only with this indicator to ensure clarity.
Use on timeframes such as 1 hour, 4 hours or daily for better visualization of liquidity zones and support/resistance levels.
Avoid adding other indicators to the chart to keep the script output easily identifiable.
The indicator is designed to be clean, without explicit buy/sell signals, following an institutional approach.
This indicator is perfect for traders who want a visually clear and powerful tool to trade based on trends, key levels and institutional behavior.
CAN INDICATORCAN Moving Averages Indicator - Feature Guide
1. Multiple Moving Averages (20 MAs)
- Supports up to 20 individual moving averages
- Each MA can be independently configured:
- Enable/Disable toggle
- Length (period) setting
- Type selection (SMA, EMA, DEMA, VWMA, RMA, WMA)
- Color customization
- Individual timeframe settings when global timeframe is disabled
Pre-configured MA Settings:
1. MA1-8: SMA type
- Lengths: 20, 50, 100, 200, 365, 489, 600, 1460
2. MA9-20: EMA type
- Lengths: 30, 60, 120, 240, 300, 400, 500, 700, 800, 900, 1000, 2000
2. Global Timeframe Settings
Location: Global Settings group
Features:
- Use Global Timeframe: Toggle to use one timeframe for all MAs
- Global Timeframe: Select the timeframe to apply globally
3. Label Display Options
Location: Main Inputs section
Controls:
- Show MA Type: Display MA type (SMA, EMA, etc.)
- Show MA Length: Display period length
- Show Resolution: Display timeframe
- Label Offset: Adjust label position
4. Cross Alerts System
Location: Cross Alerts group
Features:
1. Price Crosses:
- Alerts when price crosses any selected MA
- Select MA to monitor (1-20)
- Triggers on crossover/crossunder
2. MA Crosses:
- Alerts when one MA crosses another
- Select fast MA (1-20)
- Select slow MA (1-20)
- Triggers on crossover/crossunder
5. Relative Strength (RS) Analysis
Location: Relative Strength group
Features:
- Select any MA to monitor (1-20)
- Compares MA to its own average
- Adjustable RS Length (default 14)
- Visual feedback via background color:
- Green: MA above its average (uptrend)
- Red: MA below its average (downtrend)
- Customizable colors and transparency
6. Moving Average Types Available
1. **SMA** (Simple Moving Average)
- Equal weight to all prices
2. **EMA** (Exponential Moving Average)
- More weight to recent prices
3. **DEMA** (Double Exponential Moving Average)
- Reduced lag compared to EMA
4. **VWMA** (Volume Weighted Moving Average)
- Incorporates volume data
5. **RMA** (Running Moving Average)
- Smoother than EMA
6. **WMA** (Weighted Moving Average)
- Linear weight distribution
Usage Tips
1. **For Trend Following:**
- Enable longer-period MAs (MA4-MA8)
- Use cross alerts between long-term MAs
- Monitor RS for trend strength
2. **For Short-term Trading:**
- Focus on shorter-period MAs (MA1-MA3, MA9-MA11)
- Enable price cross alerts
- Use multiple timeframe analysis
3. **For Multiple Timeframe Analysis:**
- Disable global timeframe
- Set different timeframes for each MA
- Compare MA relationships across timeframes
4. **For Performance:**
- Disable unused MAs
- Limit active alerts to necessary pairs
- Use RS selectively on key MAs
Combined EMA Technical AnalysisThis script is written in Pine Script (version 5) for TradingView and creates a comprehensive technical analysis indicator called "Combined EMA Technical Analysis." It overlays multiple technical indicators on a price chart, including Exponential Moving Averages (EMAs), VWAP, MACD, PSAR, RSI, Bollinger Bands, ADX, and external data from the S&P 500 (SPX) and VIX indices. The script also provides visual cues through colors, shapes, and a customizable table to help traders interpret market conditions.
Here’s a breakdown of the script:
---
### **1. Purpose**
- The script combines several popular technical indicators to analyze price trends, momentum, volatility, and market sentiment.
- It uses color coding (green for bullish, red for bearish, gray/white for neutral) and a table to display key information.
---
### **2. Custom Colors**
- Defines custom RGB colors for bullish (`customGreen`), bearish (`customRed`), and neutral (`neutralGray`) signals to enhance visual clarity.
---
### **3. User Inputs**
- **EMA Colors**: Users can customize the colors of five EMAs (8, 20, 9, 21, 50 periods).
- **MACD Settings**: Adjustable short length (12), long length (26), and signal length (9).
- **RSI Settings**: Adjustable length (14).
- **Bollinger Bands Settings**: Length (20), multiplier (2), and proximity threshold (0.1% of band width).
- **ADX Settings**: Adjustable length (14).
- **Table Settings**: Position (e.g., "Bottom Right") and text size (e.g., "Small").
---
### **4. Indicator Calculations**
#### **Exponential Moving Averages (EMAs)**
- Calculates five EMAs: 8, 20, 9, 21, and 50 periods based on the closing price.
- Used to identify short-term and long-term trends.
#### **Volume Weighted Average Price (VWAP)**
- Resets daily and calculates the average price weighted by volume.
- Color-coded: green if price > VWAP (bullish), red if price < VWAP (bearish), white if neutral.
#### **MACD (Moving Average Convergence Divergence)**
- Uses short (12) and long (26) EMAs to compute the MACD line, with a 9-period signal line.
- Displays "Bullish" (green) if MACD > signal, "Bearish" (red) if MACD < signal.
#### **Parabolic SAR (PSAR)**
- Calculated with acceleration factors (start: 0.02, increment: 0.02, max: 0.2).
- Indicates trend direction: green if price > PSAR (bullish), red if price < PSAR (bearish).
#### **Relative Strength Index (RSI)**
- Measures momentum over 14 periods.
- Highlighted in green if > 70 (overbought), red if < 30 (oversold), white otherwise.
#### **Bollinger Bands (BB)**
- Uses a 20-period SMA with a 2-standard-deviation multiplier.
- Color-coded based on price position:
- Green: Above upper band or close to it.
- Red: Below lower band or close to it.
- Gray: Neutral (within bands).
#### **Average Directional Index (ADX)**
- Manually calculates ADX to measure trend strength:
- Strong trend: ADX > 25.
- Very strong trend: ADX > 50.
- Direction: Bullish if +DI > -DI, bearish if -DI > +DI.
#### **EMA Crosses**
- Detects bullish (crossover) and bearish (crossunder) events for:
- EMA 9 vs. EMA 21.
- EMA 8 vs. EMA 20.
- Visualized with green (bullish) or red (bearish) circles.
#### **SPX and VIX Data**
- Fetches daily closing prices for the S&P 500 (SPX) and VIX (volatility index).
- SPX trend: Bullish if EMA 9 > EMA 21, bearish if EMA 9 < EMA 21.
- VIX levels: High (> 25, fear), Low (< 15, stability).
- VIX color: Green if SPX bullish and VIX low, red if SPX bearish and VIX high, white otherwise.
---
### **5. Visual Outputs**
#### **Plots**
- EMAs, VWAP, and PSAR are plotted on the chart with their respective colors.
- EMA crosses are marked with circles (green for bullish, red for bearish).
#### **Table**
- Displays a summary of indicators in a customizable position and size.
- Indicators shown (if enabled):
- EMA 8/20, 9/21, 50: Green dot if bullish, red if bearish.
- VWAP: Green if price > VWAP, red if price < VWAP.
- MACD: Green if bullish, red if bearish.
- MACD Zero: Green if MACD > 0, red if MACD < 0.
- PSAR: Green if price > PSAR, red if price < PSAR.
- ADX: Arrows for very strong trends (↑/↓), dots for weaker trends, colored by direction.
- Bollinger Bands: Arrows (↑/↓) or dots based on price position.
- RSI: Numeric value, colored by overbought/oversold levels.
- VIX: Numeric value, colored based on SPX trend and VIX level.
---
### **6. Alerts**
- Triggers alerts for EMA 8/20 crosses:
- Bullish: "EMA 8/20 Bullish Cross on Candle Close!"
- Bearish: "EMA 8/20 Bearish Cross on Candle Close!"
---
### **7. Key Features**
- **Flexibility**: Users can toggle indicators on/off in the table and adjust parameters.
- **Visual Clarity**: Consistent use of green (bullish), red (bearish), and neutral colors.
- **Comprehensive**: Combines trend, momentum, volatility, and market sentiment indicators.
---
### **How to Use**
1. Add the script to TradingView.
2. Customize inputs (colors, lengths, table position) as needed.
3. Interpret the chart and table:
- Green signals suggest bullish conditions.
- Red signals suggest bearish conditions.
- Neutral signals indicate indecision or consolidation.
4. Set up alerts for EMA crosses to catch trend changes.
This script is ideal for traders who want a multi-indicator dashboard to monitor price action and market conditions efficiently.
IDX - 5UPThe UDX-5UP is a custom indicator designed to assist traders in identifying trends, entry and exit signals, and market reversal moments with greater accuracy. It combines price analysis, volume, and momentum (RSI) to provide clear buy ("Buy") and sell ("Sell") signals across any asset and timeframe, whether you're a scalper on the 5M chart or a swing trader on the 4H chart. Inspired by robust technical analysis strategies, the UDX-5UP is ideal for traders seeking a reliable tool to operate in volatile markets such as cryptocurrencies, forex, stocks, and futures.
Components of the UDX-5UP
The UDX-5UP consists of three main panels that work together to provide a comprehensive view of the market:
Main Panel (Price):
Pivot Supertrend: A dynamic line that changes color to indicate the trend. Green for an uptrend (look for buys), red for a downtrend (look for sells).
SMAs (Simple Moving Averages): Two SMAs (8 and 21 periods) to confirm the trend direction. When the SMA 8 crosses above the SMA 21, it’s a bullish signal; when it crosses below, it’s a bearish signal.
Entry/Exit Signals: "Buy" (green) and "Sell" (red) labels are plotted on the chart when entry or exit conditions are met.
Volume Panel:
Colored Volume Bars: Green bars indicate dominant buying volume, while red bars indicate dominant selling volume.
Volume Moving Average (MA 20): A blue line that helps identify whether the current volume is above or below the average, confirming the strength of the movement.
RSI Panel:
RSI (Relative Strength Index): Calculated with a period of 14, with overbought (70) and oversold (30) lines to identify momentum extremes.
Divergences: The indicator detects divergences between the RSI and price, plotting signals for potential reversals.
How the UDX-5UP Works
The UDX-5UP uses a combination of rules to generate buy and sell signals:
Buy Signal ("Buy"):
The Pivot Supertrend changes from red to green.
The SMA 8 crosses above the SMA 21.
The volume is above the MA 20, with green bars (indicating buying pressure).
The RSI is rising and, ideally, below 70 (not overbought).
Example: On the 4H chart, the price of Tether (USDT) is at 0.05515. The Pivot Supertrend turns green, the SMA 8 crosses above the SMA 21, the volume shows green bars above the MA 20, and the RSI is at 46. The UDX-5UP plots a "Buy".
Sell Signal ("Sell"):
The Pivot Supertrend changes from green to red.
The SMA 8 crosses below the SMA 21.
The volume is above the MA 20, with red bars (indicating selling pressure).
The RSI is falling and, ideally, above 70 (overbought).
Example: On the 4H chart, the price of Tether rises to 0.05817. The Pivot Supertrend turns red, the SMA 8 crosses below the SMA 21, the volume shows red bars, and the RSI is above 70. The UDX-5UP plots a "Sell".
RSI Divergences:
The indicator identifies bullish divergences (price makes a lower low, but RSI makes a higher low) and bearish divergences (price makes a higher high, but RSI makes a lower high), plotting alerts for potential reversals.
Adjustable Settings
The UDX-5UP is highly customizable to suit your trading style:
Pivot Supertrend Period: Default is 2. Increase to 3 or 4 for more conservative signals (fewer false positives, but more lag).
SMA Periods: Default is 8 and 21. Adjust to 5 and 13 for smaller timeframes (e.g., 5M) or 13 and 34 for larger timeframes (e.g., 1D).
RSI Period: Default is 14. Reduce to 10 for greater sensitivity or increase to 20 for smoother signals.
Overbought/Oversold Levels: Default is 70/30. Adjust to 80/20 in volatile markets.
Display Panels: You can enable/disable the volume and RSI panels to simplify the chart.
How to Use the UDX-5UP
Identify the Trend:
Use the Pivot Supertrend and SMAs to determine the market direction. Uptrend: look for buys. Downtrend: look for sells.
Confirm with Volume and RSI:
For buys: Volume above the MA 20 with green bars, RSI rising and below 70.
For sells: Volume above the MA 20 with red bars, RSI falling and above 70.
Enter the Trade:
Enter a buy when the UDX-5UP plots a "Buy" and all conditions are aligned.
Enter a sell when the UDX-5UP plots a "Sell" and all conditions are aligned.
Plan the Exit:
Use Fibonacci levels or support/resistance on the price chart to set targets.
Exit the trade when the UDX-5UP plots an opposite signal ("Sell" after a buy, "Buy" after a sell).
Tips for Beginners
Start with Larger Timeframes: Use the 4H or 1D chart for more reliable signals and less noise.
Combine with Other Indicators: Use the UDX-5UP with tools like Fibonacci or the Candles RSI (another powerful indicator) to confirm signals.
Practice in Demo Mode: Test the indicator in a demo account before using real money.
Manage Risk: Always use a stop-loss and don’t risk more than 1-2% of your capital per trade.
Why Use the UDX-5UP?
Simplicity: Clear "Buy" and "Sell" signals make trading accessible even for beginners.
Versatility: Works on any asset (crypto, forex, stocks) and timeframe.
Multiple Confirmations: Combines price, volume, and momentum to reduce false signals.
Customizable: Adjust the settings to match your trading style.
Author’s Notes
The UDX-5UP was developed based on years of trading and technical analysis experience. It is an evolution of tested strategies, designed to help traders navigate volatile markets with confidence. However, no indicator is infallible. Always combine the UDX-5UP with proper risk management and fundamental analysis, especially in unpredictable markets. Feedback is welcome – leave a comment or reach out with suggestions for improvements!
Multiple SMA, EMA, and VWAP CrossoversMultiple SMA, EMA, and VWAP Crossovers with Alerts
Overview : The "Multiple SMA, EMA, and VWAP Crossovers" script is designed for traders who want to monitor various simple moving averages (SMAs), exponential moving averages (EMAs), and the volume-weighted average price (VWAP) to identify potential buy and sell opportunities. This script allows you to visualize key moving averages on your chart and create custom alerts for specific crossover events.
Detail s: This script plots the following moving averages:
Simple Moving Averages (SMA): 5, 10, 20, 50, 100, 200, and 325 periods
Exponential Moving Average (EMA): 9 periods
Volume-Weighted Average Price (VWAP)
It includes options to display these moving averages and set alerts for their crossovers.
Available Crossovers:
20/50 SMA, 20/100 SMA, 20/200 SMA, 20/325 SMA
50/100 SMA, 50/200 SMA, 50/325 SMA
100/200 SMA, 100/325 SMA
200/325 SMA
VWAP/20 SMA, VWAP/50 SMA, VWAP/100 SMA, VWAP/200 SMA, VWAP/325 SMA
Optional Lines to Add to the Chart:
9 EMA, 5 SMA, 10 SMA, 20 SMA, 50 SMA, 100 SMA, 200 SMA, 325 SMA, VWAP
How to Use:
Enable Indicators: Use the input options to select which SMAs, EMA, and VWAP you want to display on your chart.
Set Alerts: Choose the specific crossover events you want to monitor. For example, you can set an alert for the 20/50 SMA crossover or the VWAP/100 SMA crossover.
Monitor the Chart: The script will plot the selected moving averages on your chart. When a selected crossover event occurs, an alert will be triggered, notifying you of the potential trade opportunity.
Usage Tips:
Trending Market: Use the buy and sell alerts in trending markets where the moving averages can help confirm the direction of the trend.
Key Support and Resistance Levels: Combine crossover alerts with key support and resistance levels for more reliable trading signals.
Volume Confirmation: Ensure there is sufficient volume to support the crossover signals, indicating stronger momentum behind the move.
When NOT to Use Buy and Sell Alerts:
Low Volume: Avoid using buy and sell alerts during periods of low trading volume, as the signals may be less reliable.
Market Noise: Be cautious in highly volatile markets where frequent crossovers might generate false signals.
Sideways Market: In a sideways or range-bound market, crossover signals can result in multiple whipsaws, leading to potential losses.
Why Use This Script? This script provides a comprehensive tool for traders to monitor multiple moving averages and VWAP crossovers efficiently. It allows you to customize alerts based on your trading strategy and helps you make informed decisions by visualizing key technical indicators on your chart.
Legal Disclaimer: The information provided by this script is for educational and informational purposes only and should not be considered financial advice. The developer of this script is not responsible for any financial losses incurred from using this script.
PubLibCandleTrendLibrary "PubLibCandleTrend"
candle trend, multi-part candle trend, multi-part green/red candle trend, double candle trend and multi-part double candle trend conditions for indicator and strategy development
chh()
candle higher high condition
Returns: bool
chl()
candle higher low condition
Returns: bool
clh()
candle lower high condition
Returns: bool
cll()
candle lower low condition
Returns: bool
cdt()
candle double top condition
Returns: bool
cdb()
candle double bottom condition
Returns: bool
gc()
green candle condition
Returns: bool
gchh()
green candle higher high condition
Returns: bool
gchl()
green candle higher low condition
Returns: bool
gclh()
green candle lower high condition
Returns: bool
gcll()
green candle lower low condition
Returns: bool
gcdt()
green candle double top condition
Returns: bool
gcdb()
green candle double bottom condition
Returns: bool
rc()
red candle condition
Returns: bool
rchh()
red candle higher high condition
Returns: bool
rchl()
red candle higher low condition
Returns: bool
rclh()
red candle lower high condition
Returns: bool
rcll()
red candle lower low condition
Returns: bool
rcdt()
red candle double top condition
Returns: bool
rcdb()
red candle double bottom condition
Returns: bool
chh_1p()
1-part candle higher high condition
Returns: bool
chh_2p()
2-part candle higher high condition
Returns: bool
chh_3p()
3-part candle higher high condition
Returns: bool
chh_4p()
4-part candle higher high condition
Returns: bool
chh_5p()
5-part candle higher high condition
Returns: bool
chh_6p()
6-part candle higher high condition
Returns: bool
chh_7p()
7-part candle higher high condition
Returns: bool
chh_8p()
8-part candle higher high condition
Returns: bool
chh_9p()
9-part candle higher high condition
Returns: bool
chh_10p()
10-part candle higher high condition
Returns: bool
chh_11p()
11-part candle higher high condition
Returns: bool
chh_12p()
12-part candle higher high condition
Returns: bool
chh_13p()
13-part candle higher high condition
Returns: bool
chh_14p()
14-part candle higher high condition
Returns: bool
chh_15p()
15-part candle higher high condition
Returns: bool
chh_16p()
16-part candle higher high condition
Returns: bool
chh_17p()
17-part candle higher high condition
Returns: bool
chh_18p()
18-part candle higher high condition
Returns: bool
chh_19p()
19-part candle higher high condition
Returns: bool
chh_20p()
20-part candle higher high condition
Returns: bool
chh_21p()
21-part candle higher high condition
Returns: bool
chh_22p()
22-part candle higher high condition
Returns: bool
chh_23p()
23-part candle higher high condition
Returns: bool
chh_24p()
24-part candle higher high condition
Returns: bool
chh_25p()
25-part candle higher high condition
Returns: bool
chh_26p()
26-part candle higher high condition
Returns: bool
chh_27p()
27-part candle higher high condition
Returns: bool
chh_28p()
28-part candle higher high condition
Returns: bool
chh_29p()
29-part candle higher high condition
Returns: bool
chh_30p()
30-part candle higher high condition
Returns: bool
chl_1p()
1-part candle higher low condition
Returns: bool
chl_2p()
2-part candle higher low condition
Returns: bool
chl_3p()
3-part candle higher low condition
Returns: bool
chl_4p()
4-part candle higher low condition
Returns: bool
chl_5p()
5-part candle higher low condition
Returns: bool
chl_6p()
6-part candle higher low condition
Returns: bool
chl_7p()
7-part candle higher low condition
Returns: bool
chl_8p()
8-part candle higher low condition
Returns: bool
chl_9p()
9-part candle higher low condition
Returns: bool
chl_10p()
10-part candle higher low condition
Returns: bool
chl_11p()
11-part candle higher low condition
Returns: bool
chl_12p()
12-part candle higher low condition
Returns: bool
chl_13p()
13-part candle higher low condition
Returns: bool
chl_14p()
14-part candle higher low condition
Returns: bool
chl_15p()
15-part candle higher low condition
Returns: bool
chl_16p()
16-part candle higher low condition
Returns: bool
chl_17p()
17-part candle higher low condition
Returns: bool
chl_18p()
18-part candle higher low condition
Returns: bool
chl_19p()
19-part candle higher low condition
Returns: bool
chl_20p()
20-part candle higher low condition
Returns: bool
chl_21p()
21-part candle higher low condition
Returns: bool
chl_22p()
22-part candle higher low condition
Returns: bool
chl_23p()
23-part candle higher low condition
Returns: bool
chl_24p()
24-part candle higher low condition
Returns: bool
chl_25p()
25-part candle higher low condition
Returns: bool
chl_26p()
26-part candle higher low condition
Returns: bool
chl_27p()
27-part candle higher low condition
Returns: bool
chl_28p()
28-part candle higher low condition
Returns: bool
chl_29p()
29-part candle higher low condition
Returns: bool
chl_30p()
30-part candle higher low condition
Returns: bool
clh_1p()
1-part candle lower high condition
Returns: bool
clh_2p()
2-part candle lower high condition
Returns: bool
clh_3p()
3-part candle lower high condition
Returns: bool
clh_4p()
4-part candle lower high condition
Returns: bool
clh_5p()
5-part candle lower high condition
Returns: bool
clh_6p()
6-part candle lower high condition
Returns: bool
clh_7p()
7-part candle lower high condition
Returns: bool
clh_8p()
8-part candle lower high condition
Returns: bool
clh_9p()
9-part candle lower high condition
Returns: bool
clh_10p()
10-part candle lower high condition
Returns: bool
clh_11p()
11-part candle lower high condition
Returns: bool
clh_12p()
12-part candle lower high condition
Returns: bool
clh_13p()
13-part candle lower high condition
Returns: bool
clh_14p()
14-part candle lower high condition
Returns: bool
clh_15p()
15-part candle lower high condition
Returns: bool
clh_16p()
16-part candle lower high condition
Returns: bool
clh_17p()
17-part candle lower high condition
Returns: bool
clh_18p()
18-part candle lower high condition
Returns: bool
clh_19p()
19-part candle lower high condition
Returns: bool
clh_20p()
20-part candle lower high condition
Returns: bool
clh_21p()
21-part candle lower high condition
Returns: bool
clh_22p()
22-part candle lower high condition
Returns: bool
clh_23p()
23-part candle lower high condition
Returns: bool
clh_24p()
24-part candle lower high condition
Returns: bool
clh_25p()
25-part candle lower high condition
Returns: bool
clh_26p()
26-part candle lower high condition
Returns: bool
clh_27p()
27-part candle lower high condition
Returns: bool
clh_28p()
28-part candle lower high condition
Returns: bool
clh_29p()
29-part candle lower high condition
Returns: bool
clh_30p()
30-part candle lower high condition
Returns: bool
cll_1p()
1-part candle lower low condition
Returns: bool
cll_2p()
2-part candle lower low condition
Returns: bool
cll_3p()
3-part candle lower low condition
Returns: bool
cll_4p()
4-part candle lower low condition
Returns: bool
cll_5p()
5-part candle lower low condition
Returns: bool
cll_6p()
6-part candle lower low condition
Returns: bool
cll_7p()
7-part candle lower low condition
Returns: bool
cll_8p()
8-part candle lower low condition
Returns: bool
cll_9p()
9-part candle lower low condition
Returns: bool
cll_10p()
10-part candle lower low condition
Returns: bool
cll_11p()
11-part candle lower low condition
Returns: bool
cll_12p()
12-part candle lower low condition
Returns: bool
cll_13p()
13-part candle lower low condition
Returns: bool
cll_14p()
14-part candle lower low condition
Returns: bool
cll_15p()
15-part candle lower low condition
Returns: bool
cll_16p()
16-part candle lower low condition
Returns: bool
cll_17p()
17-part candle lower low condition
Returns: bool
cll_18p()
18-part candle lower low condition
Returns: bool
cll_19p()
19-part candle lower low condition
Returns: bool
cll_20p()
20-part candle lower low condition
Returns: bool
cll_21p()
21-part candle lower low condition
Returns: bool
cll_22p()
22-part candle lower low condition
Returns: bool
cll_23p()
23-part candle lower low condition
Returns: bool
cll_24p()
24-part candle lower low condition
Returns: bool
cll_25p()
25-part candle lower low condition
Returns: bool
cll_26p()
26-part candle lower low condition
Returns: bool
cll_27p()
27-part candle lower low condition
Returns: bool
cll_28p()
28-part candle lower low condition
Returns: bool
cll_29p()
29-part candle lower low condition
Returns: bool
cll_30p()
30-part candle lower low condition
Returns: bool
gc_1p()
1-part green candle condition
Returns: bool
gc_2p()
2-part green candle condition
Returns: bool
gc_3p()
3-part green candle condition
Returns: bool
gc_4p()
4-part green candle condition
Returns: bool
gc_5p()
5-part green candle condition
Returns: bool
gc_6p()
6-part green candle condition
Returns: bool
gc_7p()
7-part green candle condition
Returns: bool
gc_8p()
8-part green candle condition
Returns: bool
gc_9p()
9-part green candle condition
Returns: bool
gc_10p()
10-part green candle condition
Returns: bool
gc_11p()
11-part green candle condition
Returns: bool
gc_12p()
12-part green candle condition
Returns: bool
gc_13p()
13-part green candle condition
Returns: bool
gc_14p()
14-part green candle condition
Returns: bool
gc_15p()
15-part green candle condition
Returns: bool
gc_16p()
16-part green candle condition
Returns: bool
gc_17p()
17-part green candle condition
Returns: bool
gc_18p()
18-part green candle condition
Returns: bool
gc_19p()
19-part green candle condition
Returns: bool
gc_20p()
20-part green candle condition
Returns: bool
gc_21p()
21-part green candle condition
Returns: bool
gc_22p()
22-part green candle condition
Returns: bool
gc_23p()
23-part green candle condition
Returns: bool
gc_24p()
24-part green candle condition
Returns: bool
gc_25p()
25-part green candle condition
Returns: bool
gc_26p()
26-part green candle condition
Returns: bool
gc_27p()
27-part green candle condition
Returns: bool
gc_28p()
28-part green candle condition
Returns: bool
gc_29p()
29-part green candle condition
Returns: bool
gc_30p()
30-part green candle condition
Returns: bool
rc_1p()
1-part red candle condition
Returns: bool
rc_2p()
2-part red candle condition
Returns: bool
rc_3p()
3-part red candle condition
Returns: bool
rc_4p()
4-part red candle condition
Returns: bool
rc_5p()
5-part red candle condition
Returns: bool
rc_6p()
6-part red candle condition
Returns: bool
rc_7p()
7-part red candle condition
Returns: bool
rc_8p()
8-part red candle condition
Returns: bool
rc_9p()
9-part red candle condition
Returns: bool
rc_10p()
10-part red candle condition
Returns: bool
rc_11p()
11-part red candle condition
Returns: bool
rc_12p()
12-part red candle condition
Returns: bool
rc_13p()
13-part red candle condition
Returns: bool
rc_14p()
14-part red candle condition
Returns: bool
rc_15p()
15-part red candle condition
Returns: bool
rc_16p()
16-part red candle condition
Returns: bool
rc_17p()
17-part red candle condition
Returns: bool
rc_18p()
18-part red candle condition
Returns: bool
rc_19p()
19-part red candle condition
Returns: bool
rc_20p()
20-part red candle condition
Returns: bool
rc_21p()
21-part red candle condition
Returns: bool
rc_22p()
22-part red candle condition
Returns: bool
rc_23p()
23-part red candle condition
Returns: bool
rc_24p()
24-part red candle condition
Returns: bool
rc_25p()
25-part red candle condition
Returns: bool
rc_26p()
26-part red candle condition
Returns: bool
rc_27p()
27-part red candle condition
Returns: bool
rc_28p()
28-part red candle condition
Returns: bool
rc_29p()
29-part red candle condition
Returns: bool
rc_30p()
30-part red candle condition
Returns: bool
cdut()
candle double uptrend condition
Returns: bool
cddt()
candle double downtrend condition
Returns: bool
cdut_1p()
1-part candle double uptrend condition
Returns: bool
cdut_2p()
2-part candle double uptrend condition
Returns: bool
cdut_3p()
3-part candle double uptrend condition
Returns: bool
cdut_4p()
4-part candle double uptrend condition
Returns: bool
cdut_5p()
5-part candle double uptrend condition
Returns: bool
cdut_6p()
6-part candle double uptrend condition
Returns: bool
cdut_7p()
7-part candle double uptrend condition
Returns: bool
cdut_8p()
8-part candle double uptrend condition
Returns: bool
cdut_9p()
9-part candle double uptrend condition
Returns: bool
cdut_10p()
10-part candle double uptrend condition
Returns: bool
cdut_11p()
11-part candle double uptrend condition
Returns: bool
cdut_12p()
12-part candle double uptrend condition
Returns: bool
cdut_13p()
13-part candle double uptrend condition
Returns: bool
cdut_14p()
14-part candle double uptrend condition
Returns: bool
cdut_15p()
15-part candle double uptrend condition
Returns: bool
cdut_16p()
16-part candle double uptrend condition
Returns: bool
cdut_17p()
17-part candle double uptrend condition
Returns: bool
cdut_18p()
18-part candle double uptrend condition
Returns: bool
cdut_19p()
19-part candle double uptrend condition
Returns: bool
cdut_20p()
20-part candle double uptrend condition
Returns: bool
cdut_21p()
21-part candle double uptrend condition
Returns: bool
cdut_22p()
22-part candle double uptrend condition
Returns: bool
cdut_23p()
23-part candle double uptrend condition
Returns: bool
cdut_24p()
24-part candle double uptrend condition
Returns: bool
cdut_25p()
25-part candle double uptrend condition
Returns: bool
cdut_26p()
26-part candle double uptrend condition
Returns: bool
cdut_27p()
27-part candle double uptrend condition
Returns: bool
cdut_28p()
28-part candle double uptrend condition
Returns: bool
cdut_29p()
29-part candle double uptrend condition
Returns: bool
cdut_30p()
30-part candle double uptrend condition
Returns: bool
cddt_1p()
1-part candle double downtrend condition
Returns: bool
cddt_2p()
2-part candle double downtrend condition
Returns: bool
cddt_3p()
3-part candle double downtrend condition
Returns: bool
cddt_4p()
4-part candle double downtrend condition
Returns: bool
cddt_5p()
5-part candle double downtrend condition
Returns: bool
cddt_6p()
6-part candle double downtrend condition
Returns: bool
cddt_7p()
7-part candle double downtrend condition
Returns: bool
cddt_8p()
8-part candle double downtrend condition
Returns: bool
cddt_9p()
9-part candle double downtrend condition
Returns: bool
cddt_10p()
10-part candle double downtrend condition
Returns: bool
cddt_11p()
11-part candle double downtrend condition
Returns: bool
cddt_12p()
12-part candle double downtrend condition
Returns: bool
cddt_13p()
13-part candle double downtrend condition
Returns: bool
cddt_14p()
14-part candle double downtrend condition
Returns: bool
cddt_15p()
15-part candle double downtrend condition
Returns: bool
cddt_16p()
16-part candle double downtrend condition
Returns: bool
cddt_17p()
17-part candle double downtrend condition
Returns: bool
cddt_18p()
18-part candle double downtrend condition
Returns: bool
cddt_19p()
19-part candle double downtrend condition
Returns: bool
cddt_20p()
20-part candle double downtrend condition
Returns: bool
cddt_21p()
21-part candle double downtrend condition
Returns: bool
cddt_22p()
22-part candle double downtrend condition
Returns: bool
cddt_23p()
23-part candle double downtrend condition
Returns: bool
cddt_24p()
24-part candle double downtrend condition
Returns: bool
cddt_25p()
25-part candle double downtrend condition
Returns: bool
cddt_26p()
26-part candle double downtrend condition
Returns: bool
cddt_27p()
27-part candle double downtrend condition
Returns: bool
cddt_28p()
28-part candle double downtrend condition
Returns: bool
cddt_29p()
29-part candle double downtrend condition
Returns: bool
cddt_30p()
30-part candle double downtrend condition
Returns: bool
Donchian Quest Research// =================================
Trend following strategy.
// =================================
Strategy uses two channels. One channel - for opening trades. Second channel - for closing.
Channel is similar to Donchian channel, but uses Close prices (not High/Low). That helps don't react to wicks of volatile candles (“stop hunting”). In most cases openings occur earlier than in Donchian channel. Closings occur only for real breakout.
// =================================
Strategy waits for beginning of trend - when price breakout of channel. Default length of both channels = 50 candles.
Conditions of trading:
- Open Long: If last Close = max Close for 50 closes.
- Close Long: If last Close = min Close for 50 closes.
- Open Short: If last Close = min Close for 50 closes.
- Close Short: If last Close = max Close for 50 closes.
// =================================
Color of lines:
- black - channel for opening trade.
- red - channel for closing trade.
- yellow - entry price.
- fuchsia - stoploss and breakeven.
- vertical green - go Long.
- vertical red - go Short.
- vertical gray - close in end, don't trade anymore.
// =================================
Order size calculated with ATR and volatility.
You can't trade 1 contract in BTC and 1 contract in XRP - for example. They have different price and volatility, so 1 contract BTC not equal 1 contract XRP.
Script uses universal calculation for every market. It is based on:
- Risk - USD sum you ready to loss in one trade. It calculated as percent of Equity.
- ATR indicator - measurement of volatility.
With default setting your stoploss = 0.5 percent of equity:
- If initial capital is 1000 USD and used parameter "Permit stop" - loss will be 5 USD (0.5 % of equity).
- If your Equity rises to 2000 USD and used parameter "Permit stop"- loss will be 10 USD (0.5 % of Equity).
// =================================
This Risk works only if you enable “Permit stop” parameter in Settings.
If this parameter disabled - strategy works as reversal strategy:
⁃ If close Long - channel border works as stoploss and momentarily go Short.
⁃ If close Short - channel border works as stoploss and momentarily go Long.
Channel borders changed dynamically. So sometime your loss will be greater than ‘Risk %’. Sometime - less than ‘Risk %’.
If this parameter enabled - maximum loss always equal to 'Risk %'. This parameter also include breakeven: if profit % = Risk %, then move stoploss to entry price.
// =================================
Like all trend following strategies - it works only in trend conditions. If no trend - slowly bleeding. There is no special additional indicator to filter trend/notrend. You need to trade every signal of strategy.
Strategy gives many losses:
⁃ 30 % of trades will close with profit.
⁃ 70 % of trades will close with loss.
⁃ But profit from 30% will be much greater than loss from 70 %.
Your task - patiently wait for it and don't use risky setting for position sizing.
// =================================
Recommended timeframe - Daily.
// =================================
Trend can vary in lengths. Selecting length of channels determine which trend you will be hunting:
⁃ 20/10 - from several days to several weeks.
⁃ 20/20 or 50/20 - from several weeks to several months.
⁃ 50/50 or 100/50 or 100/100 - from several months to several years.
// =================================
Inputs (Settings):
- Length: length of channel for trade opening/closing. You can choose 20/10, 20/20, 50/20, 50/50, 100/50, 100/100. Default value: 50/50.
- Permit Long / Permit short: Longs are most profitable for this strategy. You can disable Shorts and enable Longs only. Default value: permit all directions.
- Risk % of Equity: for position sizing used Equity percent. Don't use values greater than 5 % - it's risky. Default value: 0.5%.
⁃ ATR multiplier: this multiplier moves stoploss up or down. Big multiplier = small size of order, small profit, stoploss far from entry, low chance of stoploss. Small multiplier = big size of order, big profit, stop near entry, high chance of stoploss. Default value: 2.
- ATR length: number of candles to calculate ATR indicator. It used for order size and stoploss. Default value: 20.
- Close in end - to close active trade in the end (and don't trade anymore) or leave it open. You can see difference in Strategy Tester. Default value: don’t close.
- Permit stop: use stop or go reversal. Default value: without stop, reversal strategy.
// =================================
Properties (Settings):
- Initial capital - 1000 USD.
- Script don't uses 'Order size' - you need to change 'Risk %' in Inputs instead.
- Script don't uses 'Pyramiding'.
- 'Commission' 0.055 % and 'Slippage' 0 - this parameters are for crypto exchanges with perpetual contracts (for example Bybit). If use on other markets - set it accordingly to your exchange parameters.
// =================================
Big dataset used for chart - 'BITCOIN ALL TIME HISTORY INDEX'. It gives enough trades to understand logic of script. It have several good trends.
// =================================
Crypto Trend IndicatorThe Crypto Trend Indicator is a trend-following indicator specifically designed to identify bullish and bearish trends in the price of Bitcoin, and other cryptocurrencies. This indicator doesn't provide explicit instructions on when to buy or sell, but rather offers an understanding of whether the trend is bullish or bearish. It's important to note that this indicator is only useful for trend trading.
The band is a visual representation of the 30-day and 60-day Exponential Moving Average (EMA). When the 30-day EMA is above the 60-day EMA, the trend is bullish and the band is green. When the 30-day EMA is below the 60-day EMA, the trend is bearish and the band is red. When the 30-day EMA starts to converge with the 60-day EMA, the trend is neutral and the band is grey.
The line is a visual representation of the 20-week Simple Moving Average (SMA) in the daily timeframe. "Bull" and "Bear" signals are generated when the 20-day EMA is either above or below the 20-week SMA, in conjunction with a bullish or bearish trend. When the band is green and the 20-day EMA is above the 20-week SMA, a “Bull” signal emerges. When the band is red and the 20-day EMA is below the 20-week SMA, a “Bear” signal emerges. The 20-week SMA can potentially also function as a leading indicator, as substantial price deviations from the SMA typically indicate an overextended market.
While this indicator has traditionally identified bullish and bearish trends in various cryptocurrency assets, past performance does not guarantee future results. Therefore, it is advisable to supplement this indicator with other technical tools. For instance, range-bound indicators can greatly improve the decision-making process when planning for entries and exits points.
Financial Radar Chart by zdmreRadar chart is often used when you want to display data across several unique dimensions. Although there are exceptions, these dimensions are usually quantitative, and typically range from zero to a maximum value. Each dimension’s range is normalized to one another, so that when we draw our spider chart, the length of a line from zero to a dimension’s maximum value will be the similar for every dimension.
This Charts are useful for seeing which variables are scoring high or low within a dataset, making them ideal for displaying performance.
How is the score formed?
Debt Paying Ability
if Debt_to_Equity < %10 : 100
elif < 20% : 90
elif < 30% : 80
elif < 40% : 70
elif < 50% : 60
elif < 60% : 50
elif < 70% : 40
elif < 80% : 30
elif < 90% : 20
elif < 100% : 10
else: 0
ROIC
if Return_on_Invested_Capital > %50 : 100
elif > 40% : 90
elif > 30% : 80
elif > 20% : 70
elif > 10% : 50
elif > 5% : 20
else: 0
ROE
if Return_on_Equity > %50 : 100
elif > 40% : 90
elif > 30% : 80
elif > 20% : 70
elif > 10% : 50
elif > 5% : 20
else: 0
Operating Ability
if Operating_Margin > %50 : 100
elif > 30% : 90
elif > 20% : 80
elif > 15% : 60
elif > 10% : 40
elif > 0 : 20
else: 0
EV/EBITDA
if Enterprise_Value_to_EBITDA < 3 : 100
elif < 5 : 80
elif < 7 : 70
elif < 8 : 60
elif < 10 : 40
elif < 12 : 20
else: 0
FREE CASH Ability
if Price_to_Free_Cash_Flow < 5 : 100
elif < 7 : 90
elif < 10 : 80
elif < 16 : 60
elif < 18 : 50
elif < 20 : 40
elif < 22 : 30
elif < 30 : 20
elif < 40 : 15
elif < 50 : 10
elif < 60 : 5
else: 0
GROWTH Ability
if Revenue_One_Year_Growth > %20 : 100
elif > 16% : 90
elif > 14% : 80
elif > 12% : 70
elif > 10% : 50
elif > 7% : 40
elif > 4% : 30
elif > 2% : 20
elif > 0 : 10
else: 0
Three StochRSI ComboThree StochRSI with adjustable lengths in one indicator, with no extra bells or whistles. Lazybear's Apirine Slow RSI is used for the RSI formula for the third Stoch.
14-period StochRSI (red) is considered short term.
20-period StochRSI is another short to mid term preset I've seen used in various indicators on different platforms by default, and is included as the yellow stochRSI.
Lazybear's Apirine Slow RSI is used as the base for the third, slower stoch - parameter input adjustment for your specific timeframe and instrument is recommended. The Apirine Slow RSI doesn't have as effective strong divergences during established trends, so the way it would react in when run through a stoch should be more synergistic than not during trending periods for longer term trends.
StochRSI:
StochRSI measures the value of RSI relative to its high/low range over a set number of periods - It's important to note that StochRSI is technically an indicator of an indicator (RSI), which makes it the second derivative of price. This is part of the main contributing factors to how it looks and functions in relation to price.
A move above 80 ---> considered overbought.
A move below 20 ---> considered oversold.
Moves around the midline (50) can also be interpreted as continuation of upward/downwards trend depending on whether the midline is acting more of as a support (uptrend) or a resistance level (downtrend).
Stoch K-line disabled by default/D-line enabled by default.
Stoch K/D lengths are set to 3/3/14/14 (red), 6/6/20/20 (yellow), 12/12 (green) by default.
Midline (50) set to white/silver to make more visible on darkmode charts.
Additional adjustable levels for Overbought/Oversold beyond 20/80 (set at 10/90 by default - see dashed grey line. Dotted line is 20/80.)
Three stochRSI with 3/3/14/14, 6/6/20/20, and 12/12/14/14/6 length are shown below the indicator for reference.
Acknowledgements:
// Aprine Slow RSI - Lazybear
//
// Stockcharts for StochRSI reference
// school.stockcharts.com
SMC Volatility Liquidity Prothis one’s a confluence signaler. it fires “BUY CALL” / “BUY PUT” labels only when four things line up at once: trend, volatility squeeze, a liquidity sweep, and MACD momentum. quick breakdown:
what each block does
Trend filter (context)
ema50 > ema200 ⇒ trendUp
ema50 < ema200 ⇒ trendDn
Plots both EMAs for visual context.
Volatility compression (setup)
20-period Bollinger Bands (stdev 2).
bb_squeeze is true when current band width < its 20-SMA ⇒ price is compressed (potential energy building).
Liquidity sweep (trigger)
Tracks 20-bar swing high/low.
Long sweep: high > swingHigh ⇒ price just poked above the prior 20-bar high (took buy-side liquidity).
Short sweep: low < swingLow ⇒ price just poked below the prior 20-bar low (took sell-side liquidity).
MACD momentum (confirmation)
Standard MACD(12,26,9) histogram.
Bullish: hist > 0 and rising versus previous bar.
Bearish: hist < 0 and falling.
the actual entry signals
LongEntry = trendUp AND bb_squeeze AND liquiditySweepLong AND macdBullish
→ prints a green “BUY CALL” label below the bar.
ShortEntry = trendDn AND bb_squeeze AND liquiditySweepShort AND macdBearish
→ prints a red “BUY PUT” label above the bar.
alerts & dashboard
Alerts: fires when those long/short conditions hit so you can set TradingView alerts on them.
On-chart dashboard (bottom-right):
Trend (Bullish/Bearish/Neutral)
Squeeze (Yes/No)
Liquidity (Long/Short/None)
Momentum (Bullish/Bearish/Neutral)
Current Signal (BUY CALL / BUY PUT / WAIT)
(btw the comment says “2 columns × 5 rows” but the table is actually 5 columns × 2 rows—values under each label across the row.)
what it’s trying to capture (in plain english)
Trade with the higher-timeframe bias (EMA 50 over 200).
Enter as volatility compresses (bands tight) and a sweep grabs stops beyond a 20-bar extreme.
Only pull the trigger when momentum agrees (MACD hist direction & side of zero).
caveats / tips
It’s an indicator, not a strategy—no entries/exits/backtests baked in.
Signals are strict (4 filters), so you’ll get fewer but “cleaner” prints; still not magical.
The liquidity-sweep check uses the prior bar’s 20-bar high/low ( ), so on bar close it won’t repaint; intrabar alerts may feel jumpy if you alert “on every tick.”
Consider adding:
Exit logic (e.g., ATR stop + take-profit, or opposite signal).
Minimum squeeze duration (e.g., bb_squeeze true for N bars) to avoid one-bar dips in width.
Cool-down after a signal to prevent clustering.
Session/time or volume filter if you only want liquid hours.
if you want, I can convert this into a backtestable strategy() version with ATR-based stops/targets and a few toggles, so you can see stats right away.
维加斯双通道策略Vegas Channel Comprehensive Strategy Description
Strategy Overview
A comprehensive trading strategy based on the Vegas Dual Channel indicator, supporting dynamic position sizing and fund management. The strategy employs a multi-signal fusion mechanism including classic price crossover signals, breakout signals, and retest signals, combined with trend filtering, RSI+MACD filtering, and volume filtering to ensure signal reliability.
Core Features
Dynamic Position Sizing: Continue adding positions on same-direction signals, close all positions on opposite signals
Smart Take Profit/Stop Loss: ATR-based dynamic TP/SL, updated with each new signal
Fund Management: Supports dynamic total amount management for compound growth
Time Filtering: Configurable trading time ranges
Risk Control: Maximum order limit to prevent over-leveraging
Leverage Usage Instructions
Important: This strategy does not use TradingView's margin functionality
Setup Method
Total Amount = Actual Funds × Leverage Multiplier
Example: Have 100U actual funds, want to use 10x leverage → Set total amount to 100 × 10 = 1000U
Trading Amount Calculation
Each trade percentage is calculated based on leveraged amount
Example: Set 10% → Actually trade 100U margin × 10x leverage = 1000U trading amount
Maximum Orders Configuration
Must be used in conjunction with leveraged amount
Example: 1000U total amount, 10% per trade, maximum 10 orders = maximum use of 1000U
Note: Do not exceed 100% of total amount to avoid over-leveraging
Parameter Configuration Recommendations
Leverage Configuration Examples
Actual funds 100U, 5x leverage, total amount setting 500U, 10% per trade, 50U per trade, recommended maximum orders 10
Actual funds 100U, 10x leverage, total amount setting 1000U, 10% per trade, 100U per trade, recommended maximum orders 10
Actual funds 100U, 20x leverage, total amount setting 2000U, 5% per trade, 100U per trade, recommended maximum orders 20
Risk Control
Conservative: 5-10x leverage, 10% per trade, maximum 5-8 orders
Aggressive: 10-20x leverage, 5-10% per trade, maximum 10-15 orders
Extreme: 20x+ leverage, 2-5% per trade, maximum 20+ orders
Strategy Advantages
Signal Reliability: Multiple filtering mechanisms reduce false signals
Capital Efficiency: Dynamic fund management for compound growth
Risk Controllable: Maximum order limits prevent liquidation
Flexible Configuration: Supports various leverage and fund allocation schemes
Time Control: Configurable trading hours to avoid high-risk periods
Usage Notes
Ensure total amount is set correctly (actual funds × leverage multiplier)
Maximum orders should not exceed the range allowed by total funds
Recommend starting with conservative configuration and gradually adjusting parameters
Regularly monitor strategy performance and adjust parameters timely
维加斯通道综合策略说明
策略概述
基于维加斯双通道指标的综合交易策略，支持动态加仓和资金管理。策略采用多信号融合机制，包括经典价穿信号、突破信号和回踩信号，结合趋势过滤、RSI+MACD过滤和成交量过滤，确保信号的可靠性。
核心功能
动态加仓：同向信号继续加仓，反向信号全部平仓
智能止盈止损：基于ATR的动态止盈止损，每次新信号更新
资金管理：支持动态总金额管理，实现复利增长
时间过滤：可设置交易时间范围
风险控制：最大订单数限制，防止过度加仓
杠杆使用说明
重要：本策略不使用TradingView的保证金功能
设置方法
总资金 = 实际资金 × 杠杆倍数
示例：实际有100U，想使用10倍杠杆 → 总资金设置为 100 × 10 = 1000U
交易金额计算
每笔交易百分比基于杠杆后的金额计算
示例：设置10% → 实际交易 100U保证金 × 10倍杠杆 = 1000U交易金额
最大订单数配置
必须配合杠杆后的金额使用
示例：1000U总资金，10%单笔，最大10单 = 最多使用1000U
注意：不要超过总资金的100%，避免过度杠杆
参数配置建议
杠杆配置示例
实际资金100U，5倍杠杆，总资金设置500U，单笔百分比10%，单笔金额50U，建议最大订单数10单
实际资金100U，10倍杠杆，总资金设置1000U，单笔百分比10%，单笔金额100U，建议最大订单数10单
实际资金100U，20倍杠杆，总资金设置2000U，单笔百分比5%，单笔金额100U，建议最大订单数20单
风险控制
保守型：5-10倍杠杆，10%单笔，最大5-8单
激进型：10-20倍杠杆，5-10%单笔，最大10-15单
极限型：20倍以上杠杆，2-5%单笔，最大20单以上
策略优势
信号可靠性：多重过滤机制，减少假信号
资金效率：动态资金管理，实现复利增长
风险可控：最大订单数限制，防止爆仓
灵活配置：支持多种杠杆和资金配置方案
时间控制：可设置交易时间，避开高风险时段
使用注意事项
确保总资金设置正确（实际资金×杠杆倍数）
最大订单数不要超过总资金允许的范围
建议从保守配置开始，逐步调整参数
定期监控策略表现，及时调整参数
Prime NumbersPrime Numbers highlights prime numbers (no surprise there 😅), tokens and the recent "active" feature in "input".
🔸 CONCEPTS
🔹 What are Prime Numbers?
A prime number (or a prime) is a natural number greater than 1 that is not a product of two smaller natural numbers.
Wikipedia: Prime number
🔹 Prime Factorization
The fundamental theorem of arithmetic states that every integer larger than 1 can be written as a product of one or more primes. More strongly, this product is unique in the sense that any two prime factorizations of the same number will have the same number of copies of the same primes, although their ordering may differ. So, although there are many different ways of finding a factorization using an integer factorization algorithm, they all must produce the same result. Primes can thus be considered the "basic building blocks" of the natural numbers.
Wikipedia: Fundamental theorem of arithmetic
Math Is Fun: Prime Factorization
We divide a given number by Prime Numbers until only Primes remain.
Example:
24 / 2 = 12 | 24 / 3 = 8
12 / 3 = 4 | 8 / 2 = 4
4 / 2 = 2 | 4 / 2 = 2
|
24 = 2 x 3 x 2 | 24 = 3 x 2 x 2
or | or
24 = 2² x 3 | 24 = 2² x 3
In other words, every natural/integer number above 1 has a unique representation as a product of prime numbers, no matter how the number is divided. Only the order can change, but the factors (the basic elements) are always the same.
🔸 USAGE
The Prime Numbers publication contains two use cases:
Prime Factorization: performed on "close" prices, or a manual chosen number.
List Prime Numbers: shows a list of Prime Numbers.
The other two options are discussed in the DETAILS chapter:
Prime Factorization Without Arrays
Find Prime Numbers
🔹 Prime Factorization
Users can choose to perform Prime Factorization on close prices or a manually given number.
❗️ Note that this option only applies to close prices above 1, which are also rounded since Prime Factorization can only be performed on natural (integer) numbers above 1.
In the image below, the left example shows Prime Factorization performed on each close price for the latest 50 bars (which is set with "Run script only on 'Last x Bars'" -> 50).
The right example shows Prime Factorization performed on a manually given number, in this case "1,340,011". This is done only on the last bar.
When the "Source" option "close price" is chosen, one can toggle "Also current price", where both the historical and the latest current price are factored. If disabled, only historical prices are factored.
Note that, depending on the chosen options, only applicable settings are available, due to a recent feature, namely the parameter "active" in settings.
Setting the "Source" option to "Manual - Limited" will factorize any given number between 1 and 1,340,011, the latter being the highest value in the available arrays with primes.
Setting to "Manual - Not Limited" enables the user to enter a higher number. If all factors of the manual entered number are in the 1 - 1,340,011 range, these factors will be shown; however, if a factor is higher than 1,340,011, the calculation will stop, after which a warning is shown:
The calculated factors are displayed as a label where identical factors are simplified with an exponent notation in superscript.
For example 2 x 2 x 2 x 5 x 7 x 7 will be noted as 2³ x 5 x 7²
🔹 List Prime Numbers
The "List Prime Numbers" option enables users to enter a number, where the first found Prime Number is shown, together with the next x Prime Numbers ("Amount", max. 200)
The highest shown Prime Number is 1,340,011.
One can set the number of shown columns to customize the displayed numbers ("Max. columns", max. 20).
🔸 DETAILS
The Prime Numbers publication consists out of 4 parts:
Prime Factorization Without Arrays
Prime Factorization
List Prime Numbers
Find Prime Numbers
The usage of "Prime Factorization" and "List Prime Numbers" is explained above.
🔹 Prime Factorization Without Arrays
This option is only there to highlight a hurdle while performing Prime Factorization.
The basic method of Prime Factorization is to divide the base number by 2, 3, ... until the result is an integer number. Continue until the remaining number and its factors are all primes.
The division should be done by primes, but then you need to know which one is a prime.
In practice, one performs a loop from 2 to the base number.
Example:
Base_number = input.int(24)
arr = array.new()
n = Base_number
go = true
while go
for i = 2 to n
if n % i == 0
if n / i == 1
go := false
arr.push(i)
label.new(bar_index, high, str.tostring(arr))
else
arr.push(i)
n /= i
break
Small numbers won't cause issues, but when performing the calculations on, for example, 124,001 and a timeframe of, for example, 1 hour, the script will struggle and finally give a runtime error.
How to solve this?
If we use an array with only primes, we need fewer calculations since if we divide by a non-prime number, we have to divide further until all factors are primes.
I've filled arrays with prime numbers and made libraries of them. (see chapter "Find Prime Numbers" to know how these primes were found).
🔹 Tokens
A hurdle was to fill the libraries with as many prime numbers as possible.
Initially, the maximum token limit of a library was 80K.
Very recently, that limit was lifted to 100K. Kudos to the TradingView developers!
What are tokens?
Tokens are the smallest elements of a program that are meaningful to the compiler. They are also known as the fundamental building blocks of the program.
I have included a code block below the publication code (// - - - Educational (2) - - - ) which, if copied and made to a library, will contain exactly 100K tokens.
Adding more exported functions will throw a "too many tokens" error when saving the library. Subtracting 100K from the shown amount of tokens gives you the amount of used tokens for that particular function.
In that way, one can experiment with the impact of each code addition in terms of tokens.
For example adding the following code in the library:
export a() => a = array.from(1) will result in a 100,041 tokens error, in other words (100,041 - 100,000) that functions contains 41 tokens.
Some more examples, some are straightforward, others are not )
// adding these lines in one of the arrays results in x tokens
, 1 // 2 tokens
, 111, 111, 111 // 12 tokens
, 1111 // 5 tokens
, 111111111 // 10 tokens
, 1111111111111111111 // 20 tokens
, 1234567890123456789 // 20 tokens
, 1111111111111111111 + 1 // 20 tokens
, 1111111111111111111 + 8 // 20 tokens
, 1111111111111111111 + 9 // 20 tokens
, 1111111111111111111 * 1 // 20 tokens
, 1111111111111111111 * 9 // 21 tokens
, 9999999999999999999 // 21 tokens
, 1111111111111111111 * 10 // 21 tokens
, 11111111111111111110 // 21 tokens
//adding these functions to the library results in x tokens
export f() => 1 // 4 tokens
export f() => v = 1 // 4 tokens
export f() => var v = 1 // 4 tokens
export f() => var v = 1, v // 4 tokens
//adding these functions to the library results in x tokens
export a() => const arraya = array.from(1) // 42 tokens
export a() => arraya = array.from(1) // 42 tokens
export a() => a = array.from(1) // 41 tokens
export a() => array.from(1) // 32 tokens
export a() => a = array.new() // 44 tokens
export a() => a = array.new(), a.push(1) // 56 tokens
What if we could lower the amount of tokens, so we can export more Prime Numbers?
Look at this example:
829111, 829121, 829123, 829151, 829159, 829177, 829187, 829193
Eight numbers contain the same number 8291.
If we make a function that removes recurrent values, we get fewer tokens!
829111, 829121, 829123, 829151, 829159, 829177, 829187, 829193
//is transformed to:
829111, 21, 23, 51, 59, 77, 87, 93
The code block below the publication code (// - - - Educational (1) - - - ) shows how these values were reduced. With each step of 100, only the first Prime Number is shown fully.
This function could be enhanced even more to reduce recurrent thousands, tens of thousands, etc.
Using this technique enables us to export more Prime Numbers. The number of necessary libraries was reduced to half or less.
The reduced Prime Numbers are restored using the restoreValues() function, found in the library fikira/Primes_4.
🔹 Find Prime Numbers
This function is merely added to show how I filled arrays with Prime Numbers, which were, in turn, added to libraries (after reduction of recurrent values).
To know whether a number is a Prime Number, we divide the given number by values of the Primes array (Primes 2 -> max. 1,340,011). Once the division results in an integer, where the divisor is smaller than the dividend, the calculation stops since the given number is not a Prime.
When we perform these calculations in a loop, we can check whether a series of numbers is a Prime or not. Each time a number is proven not to be a Prime, the loop starts again with a higher number. Once all Primes of the array are used without the result being an integer, we have found a new Prime Number, which is added to the array.
Doing such calculations on one bar will result in a runtime error.
To solve this, the findPrimeNumbers() function remembers the index of the array. Once a limit has been reached on 1 bar (for example, the number of iterations), calculations will stop on that bar and restart on the next bar.
This spreads the workload over several bars, making it possible to continue these calculations without a runtime error.
The result is placed in log.info() , which can be copied and pasted into a hardcoded array of Prime Number values.
These settings adjust the amount of workload per bar:
Max Size: maximum size of Primes array.
Max Bars Runtime: maximum amount of bars where the function is called.
Max Numbers To Process Per Bar: maximum numbers to check on each bar, whether they are Prime Numbers.
Max Iterations Per Bar: maximum loop calculations per bar.
🔹 The End
❗️ The code and description is written without the help of an LLM, I've only used Grammarly to improve my description (without AI :) )
Market Zone Analyzer[BullByte]Understanding the Market Zone Analyzer
---
1. Purpose of the Indicator
The Market Zone Analyzer is a Pine Script™ (version 6) indicator designed to streamline market analysis on TradingView. Rather than scanning multiple separate tools, it unifies four core dimensions—trend strength, momentum, price action, and market activity—into a single, consolidated view. By doing so, it helps traders:
• Save time by avoiding manual cross-referencing of disparate signals.
• Reduce decision-making errors that can arise from juggling multiple indicators.
• Gain a clear, reliable read on whether the market is in a bullish, bearish, or sideways phase, so they can more confidently decide to enter, exit, or hold a position.
---
2. Why a Trader Should Use It
• Unified View: Combines all essential market dimensions into one easy-to-read score and dashboard, eliminating the need to piece together signals manually.
• Adaptability: Automatically adjusts its internal weighting for trend, momentum, and price action based on current volatility. Whether markets are choppy or calm, the indicator remains relevant.
• Ease of Interpretation: Outputs a simple “BULLISH,” “BEARISH,” or “SIDEWAYS” label, supplemented by an intuitive on-chart dashboard and an oscillator plot that visually highlights market direction.
• Reliability Features: Built-in smoothing of the net score and hysteresis logic (requiring consecutive confirmations before flips) minimize false signals during noisy or range-bound phases.
---
3. Why These Specific Indicators?
This script relies on a curated set of well-established technical tools, each chosen for its particular strength in measuring one of the four core dimensions:
1. Trend Strength:
• ADX/DMI (Average Directional Index / Directional Movement Index): Measures how strong a trend is, and whether the +DI line is above the –DI line (bullish) or vice versa (bearish).
• Moving Average Slope (Fast MA vs. Slow MA): Compares a shorter-period SMA to a longer-period SMA; if the fast MA sits above the slow MA, it confirms an uptrend, and vice versa for a downtrend.
• Ichimoku Cloud Differential (Senkou A vs. Senkou B): Provides a forward-looking view of trend direction; Senkou A above Senkou B signals bullishness, and the opposite signals bearishness.
2. Momentum:
• Relative Strength Index (RSI): Identifies overbought (above its dynamically calculated upper bound) or oversold (below its lower bound) conditions; changes in RSI often precede price reversals.
• Stochastic %K: Highlights shifts in short-term momentum by comparing closing price to the recent high/low range; values above its upper band signal bullish momentum, below its lower band signal bearish momentum.
• MACD Histogram: Measures the difference between the MACD line and its signal line; a positive histogram indicates upward momentum, a negative histogram indicates downward momentum.
3. Price Action:
• Highest High / Lowest Low (HH/LL) Range: Over a defined lookback period, this captures breakout or breakdown levels. A closing price near the recent highs (with a positive MA slope) yields a bullish score, and near the lows (with a negative MA slope) yields a bearish score.
• Heikin-Ashi Doji Detection: Uses Heikin-Ashi candles to identify indecision or continuation patterns. A small Heikin-Ashi body (doji) relative to recent volatility is scored as neutral; a larger body in the direction of the MA slope is scored bullish or bearish.
• Candle Range Measurement: Compares each candle’s high-low range against its own dynamic band (average range ± standard deviation). Large candles aligning with the prevailing trend score bullish or bearish accordingly; unusually small candles can indicate exhaustion or consolidation.
4. Market Activity:
• Bollinger Bands Width (BBW): Measures the distance between BB upper and lower bands; wide bands indicate high volatility, narrow bands indicate low volatility.
• Average True Range (ATR): Quantifies average price movement (volatility). A sudden spike in ATR suggests a volatile environment, while a contraction suggests calm.
• Keltner Channels Width (KCW): Similar to BBW but uses ATR around an EMA. Provides a second layer of volatility context, confirming or contrasting BBW readings.
• Volume (with Moving Average): Compares current volume to its moving average ± standard deviation. High volume validates strong moves; low volume signals potential lack of conviction.
By combining these tools, the indicator captures trend direction, momentum strength, price-action nuances, and overall market energy, yielding a more balanced and comprehensive assessment than any single tool alone.
---
4. What Makes This Indicator Stand Out
• Multi-Dimensional Analysis: Rather than relying on a lone oscillator or moving average crossover, it simultaneously evaluates trend, momentum, price action, and activity.
• Dynamic Weighting: The relative importance of trend, momentum, and price action adjusts automatically based on real-time volatility (Market Activity State). For example, in highly volatile conditions, trend and momentum signals carry more weight; in calm markets, price action signals are prioritized.
• Stability Mechanisms:
• Smoothing: The net score is passed through a short moving average, filtering out noise, especially on lower timeframes.
• Hysteresis: Both Market Activity State and the final bullish/bearish/sideways zone require two consecutive confirmations before flipping, reducing whipsaw.
• Visual Interpretation: A fully customizable on-chart dashboard displays each sub-indicator’s value, regime, score, and comment, all color-coded. The oscillator plot changes color to reflect the current market zone (green for bullish, red for bearish, gray for sideways) and shows horizontal threshold lines at +2, 0, and –2.
---
5. Recommended Timeframes
• Short-Term (5 min, 15 min): Day traders and scalpers can benefit from rapid signals, but should enable smoothing (and possibly disable hysteresis) to reduce false whipsaws.
• Medium-Term (1 h, 4 h): Swing traders find a balance between responsiveness and reliability. Less smoothing is required here, and the default parameters (e.g., ADX length = 14, RSI length = 14) perform well.
• Long-Term (Daily, Weekly): Position traders tracking major trends can disable smoothing for immediate raw readings, since higher-timeframe noise is minimal. Adjust lookback lengths (e.g., increase adxLength, rsiLength) if desired for slower signals.
Tip: If you keep smoothing off, stick to timeframes of 1 h or higher to avoid excessive signal “chatter.”
---
6. How Scoring Works
A. Individual Indicator Scores
Each sub-indicator is assigned one of three discrete scores:
• +1 if it indicates a bullish condition (e.g., RSI above its dynamically calculated upper bound).
• 0 if it is neutral (e.g., RSI between upper and lower bounds).
• –1 if it indicates a bearish condition (e.g., RSI below its dynamically calculated lower bound).
Examples of individual score assignments:
• ADX/DMI:
• +1 if ADX ≥ adxThreshold and +DI > –DI (strong bullish trend)
• –1 if ADX ≥ adxThreshold and –DI > +DI (strong bearish trend)
• 0 if ADX < adxThreshold (trend strength below threshold)
• RSI:
• +1 if RSI > RSI_upperBound
• –1 if RSI < RSI_lowerBound
• 0 otherwise
• ATR (as part of Market Activity):
• +1 if ATR > (ATR_MA + stdev(ATR))
• –1 if ATR < (ATR_MA – stdev(ATR))
• 0 otherwise
Each of the four main categories shares this same +1/0/–1 logic across their sub-components.
B. Category Scores
Once each sub-indicator reports +1, 0, or –1, these are summed within their categories as follows:
• Trend Score = (ADX score) + (MA slope score) + (Ichimoku differential score)
• Momentum Score = (RSI score) + (Stochastic %K score) + (MACD histogram score)
• Price Action Score = (Highest-High/Lowest-Low score) + (Heikin-Ashi doji score) + (Candle range score)
• Market Activity Raw Score = (BBW score) + (ATR score) + (KC width score) + (Volume score)
Each category’s summed value can range between –3 and +3 (for Trend, Momentum, and Price Action), and between –4 and +4 for Market Activity raw.
C. Market Activity State and Dynamic Weight Adjustments
Rather than contributing directly to the netScore like the other three categories, Market Activity determines how much weight to assign to Trend, Momentum, and Price Action:
1. Compute Market Activity Raw Score by summing BBW, ATR, KCW, and Volume individual scores (each +1/0/–1).
2. Bucket into High, Medium, or Low Activity:
• High if raw Score ≥ 2 (volatile market).
• Low if raw Score ≤ –2 (calm market).
• Medium otherwise.
3. Apply Hysteresis (if enabled): The state only flips after two consecutive bars register the same high/low/medium label.
4. Set Category Weights:
• High Activity: Trend = 50 %, Momentum = 35 %, Price Action = 15 %.
• Low Activity: Trend = 25 %, Momentum = 20 %, Price Action = 55 %.
• Medium Activity: Use the trader’s base weight inputs (e.g., Trend = 40 %, Momentum = 30 %, Price Action = 30 % by default).
D. Calculating the Net Score
5. Normalize Base Weights (so that the sum of Trend + Momentum + Price Action always equals 100 %).
6. Determine Current Weights based on the Market Activity State (High/Medium/Low).
7. Compute Each Category’s Contribution: Multiply (categoryScore) × (currentWeight).
8. Sum Contributions to get the raw netScore (a floating-point value that can exceed ±3 when scores are strong).
9. Smooth the netScore over two bars (if smoothing is enabled) to reduce noise.
10. Apply Hysteresis to the Final Zone:
• If the smoothed netScore ≥ +2, the bar is classified as “Bullish.”
• If the smoothed netScore ≤ –2, the bar is classified as “Bearish.”
• Otherwise, it is “Sideways.”
• To prevent rapid flips, the script requires two consecutive bars in the new zone before officially changing the displayed zone (if hysteresis is on).
E. Thresholds for Zone Classification
• BULLISH: netScore ≥ +2
• BEARISH: netScore ≤ –2
• SIDEWAYS: –2 < netScore < +2
---
7. Role of Volatility (Market Activity State) in Scoring
Volatility acts as a dynamic switch that shifts which category carries the most influence:
1. High Activity (Volatile):
• Detected when at least two sub-scores out of BBW, ATR, KCW, and Volume equal +1.
• The script sets Trend weight = 50 % and Momentum weight = 35 %. Price Action weight is minimized at 15 %.
• Rationale: In volatile markets, strong trending moves and momentum surges dominate, so those signals are more reliable than nuanced candle patterns.
2. Low Activity (Calm):
• Detected when at least two sub-scores out of BBW, ATR, KCW, and Volume equal –1.
• The script sets Price Action weight = 55 %, Trend = 25 %, and Momentum = 20 %.
• Rationale: In quiet, sideways markets, subtle price-action signals (breakouts, doji patterns, small-range candles) are often the best early indicators of a new move.
3. Medium Activity (Balanced):
• Raw Score between –1 and +1 from the four volatility metrics.
• Uses whatever base weights the trader has specified (e.g., Trend = 40 %, Momentum = 30 %, Price Action = 30 %).
Because volatility can fluctuate rapidly, the script employs hysteresis on Market Activity State: a new High or Low state must occur on two consecutive bars before weights actually shift. This avoids constant back-and-forth weight changes and provides more stability.
---
8. Scoring Example (Hypothetical Scenario)
• Symbol: Bitcoin on a 1-hour chart.
• Market Activity: Raw volatility sub-scores show BBW (+1), ATR (+1), KCW (0), Volume (+1) → Total raw Score = +3 → High Activity.
• Weights Selected: Trend = 50 %, Momentum = 35 %, Price Action = 15 %.
• Trend Signals:
• ADX strong and +DI > –DI → +1
• Fast MA above Slow MA → +1
• Ichimoku Senkou A > Senkou B → +1
→ Trend Score = +3
• Momentum Signals:
• RSI above upper bound → +1
• MACD histogram positive → +1
• Stochastic %K within neutral zone → 0
→ Momentum Score = +2
• Price Action Signals:
• Highest High/Lowest Low check yields 0 (close not near extremes)
• Heikin-Ashi doji reading is neutral → 0
• Candle range slightly above upper bound but trend is strong, so → +1
→ Price Action Score = +1
• Compute Net Score (before smoothing):
• Trend contribution = 3 × 0.50 = 1.50
• Momentum contribution = 2 × 0.35 = 0.70
• Price Action contribution = 1 × 0.15 = 0.15
• Raw netScore = 1.50 + 0.70 + 0.15 = 2.35
• Since 2.35 ≥ +2 and hysteresis is met, the final zone is “Bullish.”
Although the netScore lands at 2.35 (Bullish), smoothing might bring it slightly below 2.00 on the first bar (e.g., 1.90), in which case the script would wait for a second consecutive reading above +2 before officially classifying the zone as Bullish (if hysteresis is enabled).
---
9. Correlation Between Categories
The four categories—Trend Strength, Momentum, Price Action, and Market Activity—often reinforce or offset one another. The script takes advantage of these natural correlations:
• Bullish Alignment: If ADX is strong and pointed upward, fast MA is above slow MA, and Ichimoku is positive, that usually coincides with RSI climbing above its upper bound and the MACD histogram turning positive. In such cases, both Trend and Momentum categories generate +1 or +2. Because the Market Activity State is likely High (given the accompanying volatility), Trend and Momentum weights are at their peak, so the netScore quickly crosses into Bullish territory.
• Sideways/Consolidation: During a low-volatility, sideways phase, ADX may fall below its threshold, MAs may flatten, and RSI might hover in the neutral band. However, subtle price-action signals (like a small breakout candle or a Heikin-Ashi candle with a slight bias) can still produce a +1 in the Price Action category. If Market Activity is Low, Price Action’s weight (55 %) can carry enough influence—even if Trend and Momentum are neutral—to push the netScore out of “Sideways” into a mild bullish or bearish bias.
• Opposing Signals: When Trend is bullish but Momentum turns negative (for example, price continues up but RSI rolls over), the two scores can partially cancel. Market Activity may remain Medium, in which case the netScore lingers near zero (Sideways). The trader can then wait for either a clearer momentum shift or a fresh price-action breakout before committing.
By dynamically recognizing these correlations and adjusting weights, the indicator ensures that:
• When Trend and Momentum align (and volatility supports it), the netScore leaps strongly into Bullish or Bearish.
• When Trend is neutral but Price Action shows an early move in a low-volatility environment, Price Action’s extra weight in the Low Activity State can still produce actionable signals.
---
10. Market Activity State & Its Role (Detailed)
The Market Activity State is not a direct category score—it is an overarching context setter for how heavily to trust Trend, Momentum, or Price Action. Here’s how it is derived and applied:
1. Calculate Four Volatility Sub-Scores:
• BBW: Compare the current band width to its own moving average ± standard deviation. If BBW > (BBW_MA + stdev), assign +1 (high volatility); if BBW < (BBW_MA × 0.5), assign –1 (low volatility); else 0.
• ATR: Compare ATR to its moving average ± standard deviation. A spike above the upper threshold is +1; a contraction below the lower threshold is –1; otherwise 0.
• KCW: Same logic as ATR but around the KCW mean.
• Volume: Compare current volume to its volume MA ± standard deviation. Above the upper threshold is +1; below the lower threshold is –1; else 0.
2. Sum Sub-Scores → Raw Market Activity Score: Range between –4 and +4.
3. Assign Market Activity State:
• High Activity: Raw Score ≥ +2 (at least two volatility metrics are strongly spiking).
• Low Activity: Raw Score ≤ –2 (at least two metrics signal unusually low volatility or thin volume).
• Medium Activity: Raw Score is between –1 and +1 inclusive.
4. Hysteresis for Stability:
• If hysteresis is enabled, a new state only takes hold after two consecutive bars confirm the same High, Medium, or Low label.
• This prevents the Market Activity State from bouncing around when volatility is on the fence.
5. Set Category Weights Based on Activity State:
• High Activity: Trend = 50 %, Momentum = 35 %, Price Action = 15 %.
• Low Activity: Trend = 25 %, Momentum = 20 %, Price Action = 55 %.
• Medium Activity: Use trader’s base weights (e.g., Trend = 40 %, Momentum = 30 %, Price Action = 30 %).
6. Impact on netScore: Because category scores (–3 to +3) multiply by these weights, High Activity amplifies the effect of strong Trend and Momentum scores; Low Activity amplifies the effect of Price Action.
7. Market Context Tooltip: The dashboard includes a tooltip summarizing the current state—e.g., “High activity, trend and momentum prioritized,” “Low activity, price action prioritized,” or “Balanced market, all categories considered.”
---
11. Category Weights: Base vs. Dynamic
Traders begin by specifying base weights for Trend Strength, Momentum, and Price Action that sum to 100 %. These apply only when volatility is in the Medium band. Once volatility shifts:
• High Volatility Overrides:
• Trend jumps from its base (e.g., 40 %) to 50 %.
• Momentum jumps from its base (e.g., 30 %) to 35 %.
• Price Action is reduced to 15 %.
Example: If base weights were Trend = 40 %, Momentum = 30 %, Price Action = 30 %, then in High Activity they become 50/35/15. A Trend score of +3 now contributes 3 × 0.50 = +1.50 to netScore; a Momentum +2 contributes 2 × 0.35 = +0.70. In total, Trend + Momentum can easily push netScore above the +2 threshold on its own.
• Low Volatility Overrides:
• Price Action leaps from its base (30 %) to 55 %.
• Trend falls to 25 %, Momentum falls to 20 %.
Why? When markets are quiet, subtle candle breakouts, doji patterns, and small-range expansions tend to foreshadow the next swing more effectively than raw trend readings. A Price Action score of +3 in this state contributes 3 × 0.55 = +1.65, which can carry the netScore toward +2—even if Trend and Momentum are neutral or only mildly positive.
Because these weight shifts happen only after two consecutive bars confirm a High or Low state (if hysteresis is on), the indicator avoids constantly flipping its emphasis during borderline volatility phases.
---
12. Dominant Category Explained
Within the dashboard, a label such as “Trend Dominant,” “Momentum Dominant,” or “Price Action Dominant” appears when one category’s absolute weighted contribution to netScore is the largest. Concretely:
• Compute each category’s weighted contribution = (raw category score) × (current weight).
• Compare the absolute values of those three contributions.
• The category with the highest absolute value is flagged as Dominant for that bar.
Why It Matters:
• Momentum Dominant: Indicates that the combined force of RSI, Stochastic, and MACD (after weighting) is pushing netScore farther than either Trend or Price Action. In practice, it means that short-term sentiment and speed of change are the primary drivers right now, so traders should watch for continued momentum signals before committing to a trade.
• Trend Dominant: Means ADX, MA slope, and Ichimoku (once weighted) outweigh the other categories. This suggests a strong directional move is in place; trend-following entries or confirming pullbacks are likely to succeed.
• Price Action Dominant: Occurs when breakout/breakdown patterns, Heikin-Ashi candle readings, and range expansions (after weighting) are the most influential. This often happens in calmer markets, where subtle shifts in candle structure can foreshadow bigger moves.
By explicitly calling out which category is carrying the most weight at any moment, the dashboard gives traders immediate insight into why the netScore is tilting toward bullish, bearish, or sideways.
---
13. Oscillator Plot: How to Read It
The “Net Score” oscillator sits below the dashboard and visually displays the smoothed netScore as a line graph. Key features:
1. Value Range: In normal conditions it oscillates roughly between –3 and +3, but extreme confluences can push it outside that range.
2. Horizontal Threshold Lines:
• +2 Line (Bullish threshold)
• 0 Line (Neutral midline)
• –2 Line (Bearish threshold)
3. Zone Coloring:
• Green Background (Bullish Zone): When netScore ≥ +2.
• Red Background (Bearish Zone): When netScore ≤ –2.
• Gray Background (Sideways Zone): When –2 < netScore < +2.
4. Dynamic Line Color:
• The plotted netScore line itself is colored green in a Bullish Zone, red in a Bearish Zone, or gray in a Sideways Zone, creating an immediate visual cue.
Interpretation Tips:
• Crossing Above +2: Signals a strong enough combined trend/momentum/price-action reading to classify as Bullish. Many traders wait for a clear crossing plus a confirmation candle before entering a long position.
• Crossing Below –2: Indicates a strong Bearish signal. Traders may consider short or exit strategies.
• Rising Slope, Even Below +2: If netScore climbs steadily from neutral toward +2, it demonstrates building bullish momentum.
• Divergence: If price makes a higher high but the oscillator fails to reach a new high, it can warn of weakening momentum and a potential reversal.
---
14. Comments and Their Necessity
Every sub-indicator (ADX, MA slope, Ichimoku, RSI, Stochastic, MACD, HH/LL, Heikin-Ashi, Candle Range, BBW, ATR, KCW, Volume) generates a short comment that appears in the detailed dashboard. Examples:
• “Strong bullish trend” or “Strong bearish trend” for ADX/DMI
• “Fast MA above slow MA” or “Fast MA below slow MA” for MA slope
• “RSI above dynamic threshold” or “RSI below dynamic threshold” for RSI
• “MACD histogram positive” or “MACD histogram negative” for MACD Hist
• “Price near highs” or “Price near lows” for HH/LL checks
• “Bullish Heikin Ashi” or “Bearish Heikin Ashi” for HA Doji scoring
• “Large range, trend confirmed” or “Small range, trend contradicted” for Candle Range
Additionally, the top-row comment for each category is:
• Trend: “Highly Bullish,” “Highly Bearish,” or “Neutral Trend.”
• Momentum: “Strong Momentum,” “Weak Momentum,” or “Neutral Momentum.”
• Price Action: “Bullish Action,” “Bearish Action,” or “Neutral Action.”
• Market Activity: “Volatile Market,” “Calm Market,” or “Stable Market.”
Reasons for These Comments:
• Transparency: Shows exactly how each sub-indicator contributed to its category score.
• Education: Helps traders learn why a category is labeled bullish, bearish, or neutral, building intuition over time.
• Customization: If, for example, the RSI comment says “RSI neutral” despite an impending trend shift, a trader might choose to adjust RSI length or thresholds.
In the detailed dashboard, hovering over each comment cell also reveals a tooltip with additional context (e.g., “Fast MA above slow MA” or “Senkou A above Senkou B”), helping traders understand the precise rule behind that +1, 0, or –1 assignment.
---
15. Real-Life Example (Consolidated)
• Instrument & Timeframe: Bitcoin (BTCUSD), 1-hour chart.
• Current Market Activity: BBW and ATR both spike (+1 each), KCW is moderately high (+1), but volume is only neutral (0) → Raw Market Activity Score = +2 → State = High Activity (after two bars, if hysteresis is on).
• Category Weights Applied: Trend = 50 %, Momentum = 35 %, Price Action = 15 %.
• Trend Sub-Scores:
1. ADX = 25 (above threshold 20) with +DI > –DI → +1.
2. Fast MA (20-period) sits above Slow MA (50-period) → +1.
3. Ichimoku: Senkou A > Senkou B → +1.
→ Trend Score = +3.
• Momentum Sub-Scores:
4. RSI = 75 (above its moving average +1 stdev) → +1.
5. MACD histogram = +0.15 → +1.
6. Stochastic %K = 50 (mid-range) → 0.
→ Momentum Score = +2.
• Price Action Sub-Scores:
7. Price is not within 1 % of the 20-period high/low and slope = positive → 0.
8. Heikin-Ashi body is slightly larger than stdev over last 5 bars with haClose > haOpen → +1.
9. Candle range is just above its dynamic upper bound but trend is already captured, so → +1.
→ Price Action Score = +2.
• Calculate netScore (before smoothing):
• Trend contribution = 3 × 0.50 = 1.50
• Momentum contribution = 2 × 0.35 = 0.70
• Price Action contribution = 2 × 0.15 = 0.30
• Raw netScore = 1.50 + 0.70 + 0.30 = 2.50 → Immediately classified as Bullish.
• Oscillator & Dashboard Output:
• The oscillator line crosses above +2 and turns green.
• Dashboard displays:
• Trend Regime “BULLISH,” Trend Score = 3, Comment = “Highly Bullish.”
• Momentum Regime “BULLISH,” Momentum Score = 2, Comment = “Strong Momentum.”
• Price Action Regime “BULLISH,” Price Action Score = 2, Comment = “Bullish Action.”
• Market Activity State “High,” Comment = “Volatile Market.”
• Weights: Trend 50 %, Momentum 35 %, Price Action 15 %.
• Dominant Category: Trend (because 1.50 > 0.70 > 0.30).
• Overall Score: 2.50, posCount = (three +1s in Trend) + (two +1s in Momentum) + (two +1s in Price Action) = 7 bullish signals, negCount = 0.
• Final Zone = “BULLISH.”
• The trader sees that both Trend and Momentum are reinforcing each other under high volatility. They might wait one more candle for confirmation but already have strong evidence to consider a long.
---
• .
---
Disclaimer
This indicator is strictly a technical analysis tool and does not constitute financial advice. All trading involves risk, including potential loss of capital. Past performance is not indicative of future results. Traders should:
• Always backtest the “Market Zone Analyzer ” on their chosen symbols and timeframes before committing real capital.
• Combine this tool with sound risk management, position sizing, and, if possible, fundamental analysis.
• Understand that no indicator is foolproof; always be prepared for unexpected market moves.
Goodluck
-BullByte!
---
Codigo Trading 1.0📌Codigo Trading 1.0
This indicator strategically combines SuperTrend, multiple Exponential Moving Averages (EMAs), the Relative Strength Index (RSI), and the Average True Range (ATR) to offer clear entry and exit signals, as well as an in-depth view of market trends. Ideal for traders looking to optimize their operations with an all-in-one tool.
🔩How the Indicator Works:
This indicator relies on the interaction and confirmation of several key components to generate signals:
SuperTrend: Determines the primary trend direction. An uptrend SuperTrend signal (green line) indicates an upward trend, while a downtrend (red line) signals a downward trend. It also serves as a guide for setting Stop Loss and Take Profit levels.
EMAs: Includes EMAs of 10, 20, 55, 100, 200, and 325 periods. The relationship between the EMA 10 and EMA 20 is fundamental for confirming the strength and direction of movements. An EMA 10 above the EMA 20 suggests an uptrend, and vice versa. Longer EMAs act as dynamic support and resistance levels, offering a broader view of the market structure.
RSI: Used to identify overbought (RSI > 70/80) and oversold (RSI < 30/20) conditions, generating "Take Profit" alerts for potential trade closures.
ATR: Monitors market volatility to help you manage exits. ATR exit signals are triggered when volatility changes direction, indicating a possible exhaustion of the movement.
🗒️Entry and Exit Signals:
I designed specific alerts based on all the indicators I use in conjunction:
Long Entries: When SuperTrend is bullish and EMA 10 crosses above EMA 20.
Short Entries: When SuperTrend is bearish and EMA 10 crosses below EMA 20.
RSI Exits (Take Profit): Indicated by "TP" labels on the chart, when the RSI reaches extreme levels (overbought for longs, oversold for shorts).
EMA 20 Exits: When the price closes below EMA 20 (for longs) or above EMA 20 (for shorts).
ATR Exits: When the ATR changes direction, signaling a possible decrease in momentum.
📌Key Benefits:
Clarity in Trend: Quickly identifies market direction with SuperTrend and EMA alignment.
Strategic Entry and Exit Signals: Receive timely alerts to optimize your entry and exit points.
Assisted Trade Management: RSI and ATR help you consider when to take profits or exit a position.
Intuitive Visualization: Arrows, labels, and colored lines make analysis easy to interpret.
Disclaimer:
Trading in financial markets carries significant risks. This indicator is an analysis tool and should not be considered financial advice. Always conduct your own research and trade at your own risk.
Ergodic Market Divergence (EMD)Ergodic Market Divergence (EMD)
Bridging Statistical Physics and Market Dynamics Through Ensemble Analysis
The Revolutionary Concept: When Physics Meets Trading
After months of research into ergodic theory—a fundamental principle in statistical mechanics—I've developed a trading system that identifies when markets transition between predictable and unpredictable states. This indicator doesn't just follow price; it analyzes whether current market behavior will persist or revert, giving traders a scientific edge in timing entries and exits.
The Core Innovation: Ergodic Theory Applied to Markets
What Makes Markets Ergodic or Non-Ergodic?
In statistical physics, ergodicity determines whether a system's future resembles its past. Applied to trading:
Ergodic Markets (Mean-Reverting)
- Time averages equal ensemble averages
- Historical patterns repeat reliably
- Price oscillates around equilibrium
- Traditional indicators work well
Non-Ergodic Markets (Trending)
- Path dependency dominates
- History doesn't predict future
- Price creates new equilibrium levels
- Momentum strategies excel
The Mathematical Framework
The Ergodic Score combines three critical divergences:
Ergodic Score = (Price Divergence × Market Stress + Return Divergence × 1000 + Volatility Divergence × 50) / 3
Where:
Price Divergence: How far current price deviates from market consensus
Return Divergence: Momentum differential between instrument and market
Volatility Divergence: Volatility regime misalignment
Market Stress: Adaptive multiplier based on current conditions
The Ensemble Analysis Revolution
Beyond Single-Instrument Analysis
Traditional indicators analyze one chart in isolation. EMD monitors multiple correlated markets simultaneously (SPY, QQQ, IWM, DIA) to detect systemic regime changes. This ensemble approach:
Reveals Hidden Divergences: Individual stocks may diverge from market consensus before major moves
Filters False Signals: Requires broader market confirmation
Identifies Regime Shifts: Detects when entire market structure changes
Provides Context: Shows if moves are isolated or systemic
Dynamic Threshold Adaptation
Unlike fixed-threshold systems, EMD's boundaries evolve with market conditions:
Base Threshold = SMA(Ergodic Score, Lookback × 3)
Adaptive Component = StDev(Ergodic Score, Lookback × 2) × Sensitivity
Final Threshold = Smoothed(Base + Adaptive)
This creates context-aware signals that remain effective across different market environments.
The Confidence Engine: Know Your Signal Quality
Multi-Factor Confidence Scoring
Every signal receives a confidence score based on:
Signal Clarity (0-35%): How decisively the ergodic threshold is crossed
Momentum Strength (0-25%): Rate of ergodic change
Volatility Alignment (0-20%): Whether volatility supports the signal
Market Quality (0-20%): Price convergence and path dependency factors
Real-Time Confidence Updates
The Live Confidence metric continuously updates, showing:
- Current opportunity quality
- Market state clarity
- Historical performance influence
- Signal recency boost
- Visual Intelligence System
Adaptive Ergodic Field Bands
Dynamic bands that expand and contract based on market state:
Primary Color: Ergodic state (mean-reverting)
Danger Color: Non-ergodic state (trending)
Band Width: Expected price movement range
Squeeze Indicators: Volatility compression warnings
Quantum Wave Ribbons
Triple EMA system (8, 21, 55) revealing market flow:
Compressed Ribbons: Consolidation imminent
Expanding Ribbons: Directional move developing
Color Coding: Matches current ergodic state
Phase Transition Signals
Clear entry/exit markers at regime changes:
Bull Signals: Ergodic restoration (mean reversion opportunity)
Bear Signals: Ergodic break (trend following opportunity)
Confidence Labels: Percentage showing signal quality
Visual Intensity: Stronger signals = deeper colors
Professional Dashboard Suite
Main Analytics Panel (Top Right)
Market State Monitor
- Current regime (Ergodic/Non-Ergodic)
- Ergodic score with threshold
- Path dependency strength
- Quantum coherence percentage
Divergence Metrics
- Price divergence with severity
- Volatility regime classification
- Strategy mode recommendation
- Signal strength indicator
Live Intelligence
- Real-time confidence score
- Color-coded risk levels
- Dynamic strategy suggestions
Performance Tracking (Left Panel)
Signal Analytics
- Total historical signals
- Win rate with W/L breakdown
- Current streak tracking
- Closed trade counter
Regime Analysis
- Current market behavior
- Bars since last signal
- Recommended actions
- Average confidence trends
Strategy Command Center (Bottom Right)
Adaptive Recommendations
- Active strategy mode
- Primary approach (mean reversion/momentum)
- Suggested indicators ("weapons")
- Entry/exit methodology
- Risk management guidance
- Comprehensive Input Guide
Core Algorithm Parameters
Analysis Period (10-100 bars)
Scalping (10-15): Ultra-responsive, more signals, higher noise
Day Trading (20-30): Balanced sensitivity and stability
Swing Trading (40-100): Smooth signals, major moves only Default: 20 - optimal for most timeframes
Divergence Threshold (0.5-5.0)
Hair Trigger (0.5-1.0): Catches every wiggle, many false signals
Balanced (1.5-2.5): Good signal-to-noise ratio
Conservative (3.0-5.0): Only extreme divergences Default: 1.5 - best risk/reward balance
Path Memory (20-200 bars)
Short Memory (20-50): Recent behavior focus, quick adaptation
Medium Memory (50-100): Balanced historical context
Long Memory (100-200): Emphasizes established patterns Default: 50 - captures sufficient history without lag
Signal Spacing (5-50 bars)
Aggressive (5-10): Allows rapid-fire signals
Normal (15-25): Prevents clustering, maintains flow
Conservative (30-50): Major setups only Default: 15 - optimal trade frequency
Ensemble Configuration
Select markets for consensus analysis:
SPY: Broad market sentiment
QQQ: Technology leadership
IWM: Small-cap risk appetite
DIA: Blue-chip stability
More instruments = stronger consensus but potentially diluted signals
Visual Customization
Color Themes (6 professional options):
Quantum: Cyan/Pink - Modern trading aesthetic
Matrix: Green/Red - Classic terminal look
Heat: Blue/Red - Temperature metaphor
Neon: Cyan/Magenta - High contrast
Ocean: Turquoise/Coral - Calming palette
Sunset: Red-orange/Teal - Warm gradients
Display Controls:
- Toggle each visual component
- Adjust transparency levels
- Scale dashboard text
- Show/hide confidence scores
- Trading Strategies by Market State
- Ergodic State Strategy (Primary Color Bands)
Market Characteristics
- Price oscillates predictably
- Support/resistance hold
- Volume patterns repeat
- Mean reversion dominates
Optimal Approach
Entry: Fade moves at band extremes
Target: Middle band (equilibrium)
Stop: Just beyond outer bands
Size: Full confidence-based position
Recommended Tools
- RSI for oversold/overbought
- Bollinger Bands for extremes
- Volume profile for levels
- Non-Ergodic State Strategy (Danger Color Bands)
Market Characteristics
- Price trends persistently
- Levels break decisively
- Volume confirms direction
- Momentum accelerates
Optimal Approach
Entry: Breakout from bands
Target: Trail with expanding bands
Stop: Inside opposite band
Size: Scale in with trend
Recommended Tools
- Moving average alignment
- ADX for trend strength
- MACD for momentum
- Advanced Features Explained
Quantum Coherence Metric
Measures phase alignment between individual and ensemble behavior:
80-100%: Perfect sync - strong mean reversion setup
50-80%: Moderate alignment - mixed signals
0-50%: Decoherence - trending behavior likely
Path Dependency Analysis
Quantifies how much history influences current price:
Low (<30%): Technical patterns reliable
Medium (30-50%): Mixed influences
High (>50%): Fundamental shift occurring
Volatility Regime Classification
Contextualizes current volatility:
Normal: Standard strategies apply
Elevated: Widen stops, reduce size
Extreme: Defensive mode required
Signal Strength Indicator
Real-time opportunity quality:
- Distance from threshold
- Momentum acceleration
- Cross-validation factors
Risk Management Framework
Position Sizing by Confidence
90%+ confidence = 100% position size
70-90% confidence = 75% position size
50-70% confidence = 50% position size
<50% confidence = 25% or skip
Dynamic Stop Placement
Ergodic State: ATR × 1.0 from entry
Non-Ergodic State: ATR × 2.0 from entry
Volatility Adjustment: Multiply by current regime
Multi-Timeframe Alignment
- Check higher timeframe regime
- Confirm ensemble consensus
- Verify volume participation
- Align with major levels
What Makes EMD Unique
Original Contributions
First Ergodic Theory Trading Application: Transforms abstract physics into practical signals
Ensemble Market Analysis: Revolutionary multi-market divergence system
Adaptive Confidence Engine: Institutional-grade signal quality metrics
Quantum Coherence: Novel market alignment measurement
Smart Signal Management: Prevents clustering while maintaining responsiveness
Technical Innovations
Dynamic Threshold Adaptation: Self-adjusting sensitivity
Path Memory Integration: Historical dependency weighting
Stress-Adjusted Scoring: Market condition normalization
Real-Time Performance Tracking: Built-in strategy analytics
Optimization Guidelines
By Timeframe
Scalping (1-5 min)
Period: 10-15
Threshold: 0.5-1.0
Memory: 20-30
Spacing: 5-10
Day Trading (5-60 min)
Period: 20-30
Threshold: 1.5-2.5
Memory: 40-60
Spacing: 15-20
Swing Trading (1H-1D)
Period: 40-60
Threshold: 2.0-3.0
Memory: 80-120
Spacing: 25-35
Position Trading (1D-1W)
Period: 60-100
Threshold: 3.0-5.0
Memory: 100-200
Spacing: 40-50
By Market Condition
Trending Markets
- Increase threshold
- Extend memory
- Focus on breaks
Ranging Markets
- Decrease threshold
- Shorten memory
- Focus on restores
Volatile Markets
- Increase spacing
- Raise confidence requirement
- Reduce position size
- Integration with Other Analysis
- Complementary Indicators
For Ergodic States
- RSI divergences
- Bollinger Band squeezes
- Volume profile nodes
- Support/resistance levels
For Non-Ergodic States
- Moving average ribbons
- Trend strength indicators
- Momentum oscillators
- Breakout patterns
- Fundamental Alignment
- Check economic calendar
- Monitor sector rotation
- Consider market themes
- Evaluate risk sentiment
Troubleshooting Guide
Too Many Signals:
- Increase threshold
- Extend signal spacing
- Raise confidence minimum
Missing Opportunities
- Decrease threshold
- Reduce signal spacing
- Check ensemble settings
Poor Win Rate
- Verify timeframe alignment
- Confirm volume participation
- Review risk management
Disclaimer
This indicator is for educational and informational purposes only. It does not constitute financial advice. Trading involves substantial risk of loss and is not suitable for all investors. Past performance does not guarantee future results.
The ergodic framework provides unique market insights but cannot predict future price movements with certainty. Always use proper risk management, conduct your own analysis, and never risk more than you can afford to lose.
This tool should complement, not replace, comprehensive trading strategies and sound judgment. Markets remain inherently unpredictable despite advanced analysis techniques.
Transform market chaos into trading clarity with Ergodic Market Divergence.
Created with passion for the TradingView community
Trade with insight. Trade with anticipation.
— Dskyz , for DAFE Trading Systems
ADX and DI - Trader FelipeADX and DI - Trader Felipe
This indicator combines the Average Directional Index (ADX) and the Directional Indicators (DI+ and DI-) to help traders assess market trends and their strength. It is designed to provide a clear view of whether the market is in a trending phase (either bullish or bearish) and helps identify potential entry and exit points.
What is ADX and DI?
DI+ (Green Line):
DI+ measures the strength of upward (bullish) price movements. When DI+ is above DI-, it signals that the market is experiencing upward momentum.
DI- (Red Line):
DI- measures the strength of downward (bearish) price movements. When DI- is above DI+, it suggests that the market is in a bearish phase, with downward momentum.
ADX (Blue Line):
ADX quantifies the strength of the trend, irrespective of whether it is bullish or bearish. The higher the ADX, the stronger the trend:
ADX > 20: Indicates a trending market (either up or down).
ADX < 20: Indicates a weak or sideways market with no clear trend.
Threshold Line (Gray Line):
This horizontal line, typically set at 20, represents the threshold for identifying whether the market is trending or not. If ADX is above 20, the market is considered to be in a trend. If ADX is below 20, it suggests that the market is not trending and is likely in a consolidation phase.
Summary of How to Use the Indicator:
Trend Confirmation: Use ADX > 20 to confirm a trending market. If ADX is below 20, avoid trading.
Long Entry: Enter a long position when DI+ > DI- and ADX > 20.
Short Entry: Enter a short position when DI- > DI+ and ADX > 20.
Avoid Sideways Markets: Do not trade when ADX is below 20. Look for other strategies for consolidation phases.
Exit Strategy: Exit the trade if ADX starts to decline or if the DI lines cross in the opposite direction.
Combine with Other Indicators: Use additional indicators like RSI, moving averages, or support/resistance to filter and confirm signals.
Breadth-Driven Swing StrategyWhat it does
This script trades the S&P 500 purely on market breadth extremes:
• Data source : INDEX:S5TH = % of S&P 500 stocks above their own 200-day SMA (range 0–100).
• Buy when breadth is washed-out.
• Sell when breadth is overheated.
It is long-only by design; shorting and ATR trailing stops have been removed to keep the logic minimal and transparent.
⸻
Signals in plain English
1. Long entry
A. A 200-EMA trough in breadth is printed and the trough value is ≤ 40 %.
or
B. A 5-EMA trough appears, its prominence passes the user threshold, and the lowest breadth reading in the last 20 bars is ≤ 20 %.
(Toggle this secondary trigger on/off with “ Enter also on 5-EMA trough ”.)
2. Exit (close long)
First 200-EMA peak whose breadth value is ≥ 70 %.
3. Risk control
A fixed stop-loss (% of entry price, default 8 %) is attached to every long trade.
⸻
Key parameters (defaults shown)
• Long EMA length 200 • Short EMA length 5
• Peak prominence 0.5 pct-pts • Trough prominence 3 pct-pts
• Peak level 70 % • Trough level 40 % • 5-EMA trough level 20 %
• Fixed stop-loss 8 %
• “Enter also on 5-EMA trough” = true (allows additional entries on extreme momentum reversals)
Feel free to tighten or relax any of these thresholds to match your risk profile or account for different market regimes.
⸻
How to use it
1. Load the script on a daily SPX / SPY chart.
(The price chart drives order execution; the breadth series is pulled internally and does not need to be on the chart.)
2. Verify the breadth feed.
INDEX:S5TH is updated after each session; your broker must provide it.
3. Back-test across several cycles.
Two decades of daily data is recommended to see how the rules behave in bear markets, range markets, and bull trends.
4. Adjust position sizing in the Properties tab.
The default is “100 % of equity”; change it if you prefer smaller allocations or pyramiding caps.
⸻
Why it can help
• Breadth signals often lead price, allowing entries before index-level momentum turns.
• Simple, rule-based exits prevent “waiting for confirmation” paralysis.
• Only one input series—easy to audit, no black-box math.
Trade-offs
• Relies on a single breadth metric; other internals (advance/decline, equal-weight returns, etc.) are ignored.
• May sit in cash during shallow pullbacks that never push breadth ≤ 40 %.
• Signals arrive at the end of the session (breadth is EoD data).
⸻
Disclaimer
This script is provided for educational purposes only and is not financial advice. Markets are risky; test thoroughly and use your own judgment before trading real money.
ストラテジー概要
本スクリプトは S&P500 のマーケットブレッド（内部需給） だけを手がかりに、指数をスイングトレードします。
• ブレッドデータ : INDEX:S5TH
（S&P500 採用銘柄のうち、それぞれの 200 日移動平均線を上回っている銘柄比率。0–100 %）
• 買い : ブレッドが極端に売られたタイミング。
• 売り : ブレッドが過熱状態に達したタイミング。
余計な機能を削り、ロングオンリー & 固定ストップ のシンプル設計にしています。
⸻
シグナルの流れ
1. ロングエントリー
• 条件 A : 200-EMA がトラフを付け、その値が 40 % 以下
• 条件 B : 5-EMA がトラフを付け、
・プロミネンス条件を満たし
・直近 20 本のブレッドス最小値が 20 % 以下
• B 条件は「5-EMA トラフでもエントリー」を ON にすると有効
2. ロング決済
最初に出現した 200-EMA ピーク で、かつ値が 70 % 以上 のバーで手仕舞い。
3. リスク管理
各トレードに 固定ストップ（初期価格から 8 %）を設定。
⸻
主なパラメータ（デフォルト値）
• 長期 EMA 長さ : 200 • 短期 EMA 長さ : 5
• ピーク判定プロミネンス : 0.5 %pt • トラフ判定プロミネンス : 3 %pt
• ピーク水準 : 70 % • トラフ水準 : 40 % • 5-EMA トラフ水準 : 20 %
• 固定ストップ : 8 %
• 「5-EMA トラフでもエントリー」 : ON
相場環境やリスク許容度に合わせて閾値を調整してください。
⸻
使い方
1. 日足の SPX / SPY チャート にスクリプトを適用。
2. ブレッドデータの供給 (INDEX:S5TH) がブローカーで利用可能か確認。
3. 20 年以上の期間でバックテスト し、強気相場・弱気相場・レンジ局面での挙動を確認。
4. 資金配分 は プロパティ → 戦略実行 で調整可能（初期値は「資金の 100 %」）。
⸻
強み
• ブレッドは 価格より先行 することが多く、天底を早期に捉えやすい。
• ルールベースの出口で「もう少し待とう」と迷わずに済む。
• 入力 series は 1 本のみ、ブラックボックス要素なし。
注意点・弱み
• 単一指標に依存。他の内部需給（A/D ライン等）は考慮しない。
• 40 % を割らない浅い押し目では機会損失が起こる。
• ブレッドは終値ベースの更新。ザラ場中の変化は捉えられない。
⸻
免責事項
本スクリプトは 学習目的 で提供しています。投資助言ではありません。
実取引の前に必ず自己責任で十分な検証とリスク管理を行ってください。
Combined EMA/Smiley & DEM System## 🔷 General Overview
This script creates an advanced technical analysis system for TradingView, combining multiple Exponential Moving Averages (EMAs), Simple Moving Averages (SMAs), dynamic Fibonacci levels, and ATR (Average True Range) analysis. It presents the results clearly through interactive, real-time tables directly on the chart.
---
## 🔹 Indicator Structure
The script consists of two main parts:
### **1. EMA & SMA Combined System with Fibonacci**
- **Purpose:**
Provides visual insights by comparing multiple EMA/SMA periods and identifying significant dynamic price levels using Fibonacci ratios around a calculated "Golden" line.
- **Components:**
- **Moving Averages (MAs)**:
- 20 EMAs (periods from 20 to 400)
- 20 SMAs (also from 20 to 400)
- **Golden Line:**
Calculated as the average of all EMAs and SMAs.
- **Dynamic Fibonacci Levels:**
Key ratios around the Golden line (0.5, 0.618, 0.786, 1.0, 1.272, 1.414, 1.618, 2.0) dynamically adjust based on market conditions.
- **Fibonacci Labels:**
Labels are shown next to Fibonacci lines, indicating their numeric value clearly on the chart.
- **Table (Top Right Corner):**
- Displays:
- **Input:** EMA/SMA periods sorted by their current average price levels.
- **AVG:** The average of corresponding EMA & SMA pairs.
- **EMA & SMA Values:** Individual EMA/SMA values clearly marked.
- **Dynamic Highlighting:** Highlights the row whose average (EMA+SMA)/2 is closest to the current price, helping identify immediate price action significance.
- **Sorting Logic:**
Each EMA/SMA pair is dynamically sorted based on their average values. Color coding (red/green) is used:
- **Green:** EMA/SMA pairs with shorter periods when their average is lower.
- **Red:** EMA/SMA pairs with longer periods when their average is lower.
- **Star (⭐):** Represents the "Golden" average clearly.
---
### **2. DEM System (Dynamic EMA/ATR Metrics)**
- **Purpose:**
Provides detailed ATR statistics to assess market volatility clearly and quickly.
- **Components:**
- **Moving Averages:**
- SMA lines: 25, 50, 100, 200.
- **Bollinger Bands:**
- Based on 20-period SMA of highs and standard deviation of lows.
- **ATR Analysis:**
- ATR calculations for multiple periods (1-day, 10, 20, 30, 40, 50).
- **ATR Premium:** Average ATR of all calculated periods, providing an overarching volatility indicator.
- **ATR Table (Bottom Right Corner):**
- Displays clearly structured ATR values and percentages relative to the current close price:
- Columns: **ATR Period**, **Value**, and **% of Close**.
- Rows: Each specific ATR (1D, 10, 20, 30, 40, 50), plus ATR premium.
- The ATR premium is highlighted in yellow to signify its importance clearly.
---
## 🔹 Key Features and Logic Explained
- **Dynamic EMA/SMA Sorting:**
The script computes the average of each EMA/SMA pair and sorts them dynamically on each bar, highlighting their relative importance visually. This allows traders to easily interpret the strength of current support/resistance levels based on moving averages.
- **Closest EMA/SMA Pair to Current Price:**
Calculates the absolute difference between the current price and all EMA/SMA averages, highlighting the closest one for quick reference.
- **Fibonacci Ratios:**
- Dynamically calculated Fibonacci levels based on the "Golden" EMA/SMA average give clear visual guidance for potential targets, supports, and resistances.
- Labels are continuously updated and placed next to levels for clarity.
- **ATR Volatility Analysis:**
- Provides immediate insight into market volatility with absolute and relative (percentage-based) ATR values.
- ATR premium summarizes volatility across multiple timeframes clearly.
---
## 🔹 Practical Use Case:
- Traders can quickly identify support/resistance and critical price zones through EMA/SMA and Fibonacci combinations.
- Useful in assessing immediate volatility, guiding stop-loss and take-profit levels through detailed ATR metrics.
- The dynamic highlighting in tables provides intuitive, real-time decision support for active traders.
---
## 🔹 How to Use this Script:
1. **Adjust EMA & SMA Lengths** from indicator settings if different periods are preferred.
2. **Monitor dynamic Fibonacci levels** around the "Golden" average to identify possible reversal or continuation points.
3. **Check EMA/SMA table:** Rows highlighted indicate immediate significance concerning current market price.
4. **ATR table:** Use volatility metrics for better risk management.
---
## 🔷 Conclusion
This advanced Pine Script indicator efficiently combines multiple EMAs, SMAs, dynamic Fibonacci retracement levels, and volatility analysis using ATR into a comprehensive real-time analytical tool, enhancing traders' decision-making capabilities by providing clear and actionable insights directly on the TradingView chart.
ScalpSwing Pro SetupScript Overview
This script is a multi-tool setup designed for both scalping (1m–5m) and swing trading (1H–4H–Daily). It combines the power of trend-following , momentum , and mean-reversion tools:
What’s Included in the Script
1. EMA Indicators (20, 50, 200)
- EMA 20 (blue) : Short-term trend
- EMA 50 (orange) : Medium-term trend
- EMA 200 (red) : Long-term trend
- Use:
- EMA 20 crossing above 50 → bullish trend
- EMA 20 crossing below 50 → bearish trend
- Price above 200 EMA = uptrend bias
2. VWAP (Volume Weighted Average Price)
- Shows the average price weighted by volume
- Best used in intraday (1m to 15m timeframes)
- Use:
- Price bouncing from VWAP = reversion trade
- Price far from VWAP = likely pullback incoming
3. RSI (14) + Key Levels
- Shows momentum and overbought/oversold zones
- Levels:
- 70 = Overbought (potential sell)
- 30 = Oversold (potential buy)
- 50 = Trend confirmation
- Use:
- RSI 30–50 in uptrend = dip buying zone
- RSI 70–50 in downtrend = pullback selling zone
4. MACD Crossovers
- Standard MACD with histogram & cross alerts
- Shows trend momentum shifts
- Green triangle = Bullish MACD crossover
- Red triangle = Bearish MACD crossover
- Use:
- Confirm swing trades with MACD crossover
- Combine with RSI divergence
5. Buy & Sell Signal Logic
BUY SIGNAL triggers when:
- EMA 20 crosses above EMA 50
- RSI is between 50 and 70 (momentum bullish, not overbought)
SELL SIGNAL triggers when:
- EMA 20 crosses below EMA 50
- RSI is between 30 and 50 (bearish momentum, not oversold)
These signals appear as:
- BUY : Green label below the candle
- SELL : Red label above the candle
How to Trade with It
For Scalping (1m–5m) :
- Focus on EMA crosses near VWAP
- Confirm with RSI between 50–70 (buy) or 50–30 (sell)
- Use MACD triangle as added confluence
For Swing (1H–4H–Daily) :
- Look for EMA 20–50 cross + price above EMA 200
- Confirm trend with MACD and RSI
- Trade breakout or pullback depending on structure
