GusteriTBL
time based liq
am salvat o copie de la OGDubsky, pentru a putea lucra ulterior pe aceasta
指標和策略
LQC GUIDED PATH - CONFIRMATION🎯 LQC GUIDED PATH - CONFIRMATION
Never Trade in the Wrong Direction Again!
🚦 REVOLUTIONARY PSYCHOLOGICAL COLOR SYSTEM:
✅ 🟢 GREEN PATH = GO LONG (Confirmed bullish bias)
✅ 🔵 BLUE PATH = GO SHORT (Confirmed bearish bias)
✅ 🟡 YELLOW PATH = WEAK SIGNAL (Wait for confirmation)
✅ ⚪ GRAY PATH = NEUTRAL (No clear direction)
✅ 🔴 RED BACKGROUND = DANGER ZONE (Near key levels - STOP!)
🛡️ MULTI-LAYER CONFIRMATION SYSTEM:
✅ Trend Confirmation - Dynamic EMA alignment
✅ Momentum Confirmation - RSI + MACD validation
✅ Volume Confirmation - Above-average volume surge
✅ Price Action Confirmation - Strong candle closes
✅ Key Level Protection - Daily/Premarket/Yesterday levels
⚠️ PEAK PROFIT PROTECTION:
✅ Tracks Maximum Profit Achieved
✅ Warns When Peak is Reached: “BEYOND THIS = YOUR RISK”
✅ Prevents Giving Back Gains
✅ One-Time Warning System
✅ Customizable Threshold Settings
🔑 KEY LEVELS INCLUDED:
✅ Daily High/Low - Orange dashed lines
✅ Premarket High/Low - Blue dotted lines
✅ Yesterday High/Low - Gray solid lines
✅ Overnight High/Low - Purple lines
✅ Automatic Danger Zone Detection
📊 CUSTOMIZABLE DASHBOARD:
✅ 6 Position Options (Top/Bottom/Middle Left/Right)
✅ 4 Size Options (Tiny/Small/Normal/Large)
✅ Complete ON/OFF Control
✅ Real-Time Status Updates
✅ Confirmation Counter (X/3 CONFIRMED)
🎛️ ADAPTIVE SENSITIVITY
MACD DIVERGENCE MACD DIVERGENCE is a momentum oscillator that combines the power of multi-timeframe (MTF) MACD with a regular divergence engine (bullish/bearish) and bias-shift alerts, providing a professional, actionable read of the impulse–correction cycle. 📈🧭
Key Benefits ✅
Selectable MTF MACD: compute MACD from 1m…W or use the chart’s timeframe to align entries with the higher-timeframe bias.
Intelligent visual read: histogram and line colors adapt to reflect inertia and pace changes (acceleration/deceleration).
Robust regular divergences: detects bullish/bearish by comparing oscillator pivots vs. price extremes within configurable search ranges (helps avoid false positives from pivots too far apart or too close).
Ready-to-trade alerts:
Strong Buy: histogram crosses > 0 (bullish bias).
Strong Sell: histogram crosses < 0 (bearish bias). 🔔
Versatile by design: works on crypto, indices, forex, commodities; from intraday to swing.
Recommended Workflow ⚙️
Bias (MTF): choose the MACD timeframe to inherit context (e.g., trade 15m using a 1h MACD).
Trigger: prioritize zero-line crosses accompanied by regular divergences (confluence).
Management: apply your risk plan (position size, SL/TP) and use alerts to synchronize execution.
Core Parameters 🔧
MACD Timeframe (MTF): “same as chart” or manual selection (1, 5, 15, 30, 60, 240, D, W).
MACD Lengths: fast/slow/signal (defaults 12/26/9).
Divergences: enable bullish/bearish, set pivot left/right, and min/max search range to control sensitivity.
Best Practices 🛡️
Match pivot windows and range to the asset’s structure and volatility.
Don’t rely on a single condition; seek confluence (MTF + zero-cross + divergence).
Run backtests/forward tests and document results before scaling up.
Compatibility 🌐
Works on any asset and timeframe supported by TradingView; plotted in a separate panel (overlay=false) to keep the main chart clean.
Disclaimer ⚠️
This product is not financial advice and does not guarantee results. Performance depends on the asset, market conditions, chosen configuration, and the user’s risk management. Trade responsibly.
GC Checklist Signals (All TF, v6 • SR-safe • Clean blocks)GC (COMEX Gold) checklist strategy with a 3:1 reward-to-risk to your training bot. It enforces the following rules:
Heiken Ashi chart logic for color, wicks, and doji detection
100-EMA filter (only buys above / sells below)
Market structure: higher-low above EMA for buys; lower-high below EMA for sells (simple pivot check)
Clean pullback: at least 2 opposite-color candles; clean = no top wicks (buys) / no bottom wicks (sells)
Entry: on high-volume doji (body ≤ ~12% of range and volume ≥ last 1–3 candles), as soon as it closes
Stops: sell = above doji high; buy = below doji low
GC Checklist Signals (All Timeframes, v6)GC (COMEX Gold) checklist strategy with a 3:1 reward-to-risk to your training bot. It enforces your rules:
Heiken Ashi chart logic for color, wicks, and doji detection
100-EMA filter (only buys above / sells below)
Market structure: higher-low above EMA for buys; lower-high below EMA for sells (simple pivot check)
Clean pullback: at least 2 opposite-color candles; clean = no top wicks (buys) / no bottom wicks (sells)
Entry: on high-volume doji (body ≤ ~12% of range and volume ≥ last 1–3 candles), as soon as it closes
Stops: sell = above doji high; buy = below doji low
30s Opening Range with TargetsSimple 30 Second opening range with profit targets and adjustable fill transparency and profit targets
Volume SMA with Multiple Overlays in Separate PaneVolume plays a pivotal role in our trading. Stock market price movements are randam until and unless same is supported by volume. Voulme is the only leding indicator and can track instituitional activity.
This indicator analyses volume to indentify unsual volumes in the market. it draws there sma lines of last 1200 barrs as follows:
1. sma of 1200 bars represented by blue
2. sma of 1200 bars multiplied by 15, represented by red
3. sma of 1200 bars multiplied by 20, represented by black.
The clor codes and line width can be modified.
Chimera [theUltimator5]In myth, the chimera is an “impossible” hybrid—lion, goat, and serpent fused into one—striking to look at and formidable in presence. The word has come to mean a beautiful, improbable union of parts that shouldn’t work together, yet do.
Chimera is a dual-mode market context tool that blends a multi-input oscillator with classic ADX/DI trend strength, plus optional multi-timeframe “gap-line” tracking. Use it to visualize regime (trend vs. range), momentum swings around an adaptive midline, and higher timeframe (HTF) reference levels that auto-terminate on touch/cross.
Modes
1) Oscillator view
A smoothed composite of five common inputs—RSI, MACD (oscillator), Bollinger position, Stochastic, and an ATR/DI-weighted bias. Each is normalized to a comparable 0–100 style scale, averaged, and plotted as a candle-style oscillator (short vs. long smoothing, wickless for clarity). A dynamic midline with standard-deviation bands frames neutral → bearish/bullish zones. Colors ramp from neutral to your chosen Oversold/Overbought endpoints; consolidation can override to white.
Here is a description of the (5) signals used to calculate the sentiment oscillator:
RSI (14): Measures recent momentum by comparing average gains vs. losses. High = strength after advances; low = weakness after declines. (Z-score normalized to 0–100.)
MACD oscillator (12/26/9): Uses the difference between MACD and its signal (histogram) to gauge momentum shifts. Positive = bullish tilt; negative = bearish. (Z-score normalized.)
Bollinger Bands position (20, 2): Locates price within the bands (0–100 from lower → upper). Near upper suggests strength/expansion; near lower suggests weakness/contraction. (Then normalized.)
Stochastic (14, 3, 3): Shows where the close sits within the recent high-low range, smoothed via %D. Higher values = closes near highs; lower = near lows. (Scaled 0–100.)
ATR/DI composite (14): Volatility-weighted directional bias: (+DI − −DI) amplified by ATR as a % of price and its relative average. Positive = bullish pressure with volatility; negative = bearish. (Rank/scale normalized.)
All five are normalized and averaged into one composite, then smoothed (short/long) and compared to an adaptive midline with bands.
2) ADX view
Shows ADX, +DI, –DI with user-defined High Threshold. Transparency and color shift with regime. When ADX is strong, a directional “fire/ice” gradient fills the area between ADX and the high threshold, biased toward the dominant DI; when ADX is weak, a soft white fade highlights low-trend conditions.
HTF gap-line tracking (optional; both modes)
Detects “gap-like” reference levels after weak-trend consolidation flips into a sudden DI jump.
Anchors a line at the event bar’s open and auto-terminates upon first touch/cross (tick-size tolerance).
Auto-selects up to three higher timeframes suited to your chart resolution and prints non-overlapping lines with labels like 1H / 4H / 1D. Lower-priority duplicates are suppressed to reduce clutter.
Confirmation / repaint notes
Signals and lines finalize on bar close of the relevant timeframe.
HTF elements update only on the HTF bar close. During a forming bar they may appear transiently.
Line removal finalizes after the bar that produced the touch/cross closes.
Visual cues & effects
Oscillator candles: Open/High = long smoothing; Low/Close = short smoothing (no wicks).
Adaptive bands: Midline ± StdDev Multiplier × stdev of the blended series.
Consolidation tint: Optional white backdrop/candles when the consolidation condition is true (balance + low ADX).
Breakout VFX (optional): With strong DI/ADX and Bollinger breaks, renders a subtle “fire” flare above upper-band thrusts or “ice” shelf below lower-band thrusts.
Inputs (high-level)
Visual Style: Oscillator or ADX.
General (Oscillator): Lookback Period, Short/Long Smoothing, Standard Deviation Multiplier.
Color (Oscillator): Oversold/Overbought colors for gradient endpoints.
Plot (Oscillator): Show Candles, Show Slow MA Line, Show Individual Component (RSI/MACD/BB/Stoch/ATR).
Table (Oscillator): Show Information Table & position (compact dashboard of component values + status).
ADX / Gaps / VFX (both modes): ADX High Threshold, Highlight Backgrounds, Show Gap Labels, Visual Overlay Effects, and color choices for current-TF & HTF lines.
HTF selection: Automatic ladder (3 tiers) based on your chart timeframe.
Alerts (built-in)
Buy Signal – Primary: Oscillator exits oversold.
Sell Signal – Primary: Oscillator exits overbought.
Gap Fill Line Created (Any TF)
Gap Fill Line Terminated (Any TF)
ADX Crossed ABOVE/BELOW Low Threshold
ADX Crossed ABOVE/BELOW High Threshold
Consolidation Started
Alerts evaluate on the close of the relevant timeframe.
How to read it (quick guide)
Pick your lens: Oscillator for blended momentum around an adaptive midline; ADX for trend strength and DI skew.
Watch extremes & mean re-entries (Oscillator): Approaches to the top/bottom band show persistent momentum; returns toward the midline show normalization.
Check regime (ADX): Below Low = low-trend; above High = strong trend, with “fire/ice” bias toward +DI/–DI.
Track gap lines: Fresh labels mark new reference levels; lines auto-remove on first interaction. HTF lines add context but finalize only on HTF close.
The uniqueness from this indicator comes from multiple areas:
1. A unique multi-timeframe algorithm detects gap fill zones and plots them on the chart.
2. Visual effects for both visual modes were hand crafted to provide a visually stunning and intuitive interface.
3. The algorithm to determine sentiment uses a unique blend of weight and sensitivity adjustment to create a plot with elastic upper and lower bounds based off historical volatility and price action.
Market Order Risk CalculatorObviously the Long/Short Position tool does this, but when you are scalping, 10 - 15 seconds matters. What matters more than that is defined risk, you dont want your losses being scattered, 300 here 145 there, you want consistent risk to have consistent data.
What this does is when you are framing a trade, it provides a hands off tool that tells you exactly how many contracts to enter with, that way if you have bracket orders on, your stop will be exactly where you want it to be without going over your defined risk.
VPT-style Close-to-Close Indicator📈Cumulative momentum (close-to-close × rel. volume) | MA & Donchian optional | ⚡ Alerts
Key Features:
- Tracks cumulative price momentum using close-to-close changes weighted by relative volume.
- Optional smoothed line (SMA/EMA) to identify trend direction.
- Optional Donchian channels to detect potential breakouts and breakdowns.
- Includes alerts for:
- Moving average crosses (bullish/bearish)
- Local maxima/minima in cumulative momentum
- Donchian upper/lower channel breakouts
- Customizable inputs: smoothing length, channel lengths, scaling factor, and visibility toggles.
- Visual cues: line colors indicate momentum direction (green = up, red = down).
- Use Case: Quickly spot momentum shifts, trend direction, and breakout opportunities with clear alerts and visual cues.
Fractal FU//@version=5
indicator("Fractal FU", shorttitle="Fractal FU", overlay=true, max_labels_count=500)
// ===== Inputs
showBull = input.bool(true, "Show aligned bullish balls")
showBear = input.bool(true, "Show aligned bearish balls")
bullCol = input.color(color.blue, "Bull ball color")
bearCol = input.color(color.red, "Bear ball color")
ballSize = input.string("small", "Ball size", options= )
gateTo15 = input.bool(true, "Gate to 15m close (clean, fewer signals)")
showDebug = input.bool(false, "Show per-timeframe debug dots")
// ===== Helpers
// one-liner you asked for:
f_sig(res) => request.security(syminfo.tickerid, res, (high > high and low < low ) ? (close > open ? 1 : close < open ? -1 : 0) : 0, barmerge.gaps_off, barmerge.lookahead_off)
// Pull confirmed signals from each TF
sig1 = f_sig("1")
sig5 = f_sig("5")
sig10 = f_sig("10")
sig15 = f_sig("15")
// Alignment (all four agree)
bullAll = showBull and (sig1 == 1 and sig5 == 1 and sig10 == 1 and sig15 == 1)
bearAll = showBear and (sig1 == -1 and sig5 == -1 and sig10 == -1 and sig15 == -1)
// Emit control
emit15 = ta.change(time("15"))
emit = gateTo15 ? emit15 : barstate.isconfirmed // if not gated, show wherever alignment is true
// ===== Debug (tiny dots at bar to verify which TFs are firing)
plotshape(showDebug and sig1 == 1, title="1m bull", style=shape.circle, size=size.tiny, color=color.new(color.blue, 0), location=location.bottom)
plotshape(showDebug and sig5 == 1, title="5m bull", style=shape.circle, size=size.tiny, color=color.new(color.aqua, 0), location=location.bottom)
plotshape(showDebug and sig10 == 1, title="10m bull", style=shape.circle, size=size.tiny, color=color.new(color.teal, 0), location=location.bottom)
plotshape(showDebug and sig15 == 1, title="15m bull", style=shape.circle, size=size.tiny, color=color.new(color.navy, 0), location=location.bottom)
plotshape(showDebug and sig1 == -1, title="1m bear", style=shape.circle, size=size.tiny, color=color.new(color.red, 0), location=location.top)
plotshape(showDebug and sig5 == -1, title="5m bear", style=shape.circle, size=size.tiny, color=color.new(color.orange, 0), location=location.top)
plotshape(showDebug and sig10 == -1, title="10m bear", style=shape.circle, size=size.tiny, color=color.new(color.maroon, 0), location=location.top)
plotshape(showDebug and sig15 == -1, title="15m bear", style=shape.circle, size=size.tiny, color=color.new(color.purple, 0), location=location.top)
// ===== Markers (size must be const → gate each size)
off = gateTo15 ? -1 : 0 // when gated, place on the just-closed 15m bar
// ── Marker offset control stays the same ──
off2 = gateTo15 ? -1 : 0
// ── Bullish balls exactly at LOW ──
plot(bullAll and emit and ballSize == "tiny" ? low : na, title="Bullish tiny", style=plot.style_circles, color=bullCol, linewidth=1, offset=off2)
plot(bullAll and emit and ballSize == "small" ? low : na, title="Bullish small", style=plot.style_circles, color=bullCol, linewidth=2, offset=off2)
plot(bullAll and emit and ballSize == "normal" ? low : na, title="Bullish normal", style=plot.style_circles, color=bullCol, linewidth=3, offset=off2)
plot(bullAll and emit and ballSize == "large" ? low : na, title="Bullish large", style=plot.style_circles, color=bullCol, linewidth=4, offset=off2)
plot(bullAll and emit and ballSize == "huge" ? low : na, title="Bullish huge", style=plot.style_circles, color=bullCol, linewidth=5, offset=off2)
// ── Bearish balls exactly at HIGH ──
plot(bearAll and emit and ballSize == "tiny" ? high : na, title="Bearish tiny", style=plot.style_circles, color=bearCol, linewidth=1, offset=off2)
plot(bearAll and emit and ballSize == "small" ? high : na, title="Bearish small", style=plot.style_circles, color=bearCol, linewidth=2, offset=off2)
plot(bearAll and emit and ballSize == "normal" ? high : na, title="Bearish normal", style=plot.style_circles, color=bearCol, linewidth=3, offset=off2)
plot(bearAll and emit and ballSize == "large" ? high : na, title="Bearish large", style=plot.style_circles, color=bearCol, linewidth=4, offset=off2)
plot(bearAll and emit and ballSize == "huge" ? high : na, title="Bearish huge", style=plot.style_circles, color=bearCol, linewidth=5, offset=off2)
// Alerts
alertcondition(bullAll and emit, title="Aligned Bullish Outside (1/5/10/15)", message="Aligned bullish outside bar on 1/5/10/15m")
alertcondition(bearAll and emit, title="Aligned Bearish Outside (1/5/10/15)", message="Aligned bearish outside bar on 1/5/10/15m")
alertcondition((bullAll or bearAll) and emit, title="Aligned Any (1/5/10/15)", message="Aligned outside bar (bull or bear) on 1/5/10/15m")
さくらんぼーい//@version=6
indicator("さくらんぼーい", overlay=true, max_labels_count=500, max_lines_count=500)
//==================== Inputs ====================//
// ---- Anchor (shared) ----
grpA = "Anchor (shared)"
anchorMode = input.string("Time", "Anchor Mode", options= , group=grpA)
anchorTime = input.time(timestamp("2025-06-24T20:31:00"), "Anchor Time (exchange)", group=grpA)
anchorBarsAgo = input.int(100, "Anchor Bars Ago", minval=1, group=grpA)
anchorPriceMode = input.string("Close", "Anchor Price", options= , group=grpA)
anchorPriceManual = input.float(0.0, "Manual Anchor Price (0=auto)", step=0.0001, group=grpA)
// ---- Light-Cone ----
grpLC = "Light-Cone ATR"
atrLen = input.int(14, "ATR Length", minval=1, group=grpLC)
atrTF = input.timeframe("", "ATR Timeframe (blank=same)", group=grpLC)
projBars = input.int(60, "Projection Horizon (bars)", minval=1, group=grpLC)
coneMode = input.string("Diffusive √n", "Cone Growth Mode", options= , group=grpLC)
mult = input.float(1.0, "ATR Multiplier (σ-ish)", step=0.1, minval=0.0, group=grpLC)
wickMode = input.string("Close", "Height uses", options= , group=grpLC)
coneFillCol= input.color(color.new(color.teal, 90), "Cone Fill", group=grpLC)
coneLineCol= input.color(color.new(color.aqua, 40), "Cone Edge", group=grpLC)
// ---- Light-Cone guide lines ----
grpFan = "Light-Cone Guides (0.5c / 1.5c)"
showFan = input.bool(true, "Show 0.5c & 1.5c guide lines", group=grpFan)
fan05Color = input.color(color.new(color.aqua, 75), "0.5c line", group=grpFan)
fan15Color = input.color(color.new(color.aqua, 60), "1.5c line", group=grpFan)
fanWidth = input.int(1, "Guide line width", minval=1, maxval=3, group=grpFan)
// ---- √n Stripes ----
grpZ = "Convergence (√n stripes)"
stepBars = input.int(20, "Base Step (bars)", minval=1, group=grpZ)
maxOrderM = input.int(8, "Max Order M (m²)", minval=1, maxval=50, group=grpZ)
halfWindow = input.int(2, "Stripe Half-Width (bars)", minval=0, group=grpZ)
stripeColor = input.color(color.new(color.fuchsia, 86), "Stripe Color", group=grpZ)
showCenters = input.bool(false, "Draw Stripe Center Lines", group=grpZ)
// ---- Fractal ----
grpF = "Fractal (Pivot) Detector"
leftP = input.int(2, "Left bars (L)", minval=1, group=grpF)
rightP = input.int(2, "Right bars (R)", minval=1, group=grpF)
hitColHi = input.color(color.new(color.lime, 0), "Pivot High Mark", group=grpF)
hitColLo = input.color(color.new(color.red, 0), "Pivot Low Mark", group=grpF)
// ---- Display / Limits ----
grpO = "Display / Limits"
showHitTable = input.bool(true, "Show m² Hit Table", group=grpO)
limitScreen = input.bool(true, "Reduce drawing near screen", group=grpO)
screenPastBars = input.int(5000, "Screen past window (bars)", minval=100, group=grpO)
futureLimitBars= input.int(500, "FUTURE draw limit (TV max 500)", minval=0, maxval=500, group=grpO)
// ---- Bias Panel ----
grpB = "Bias Panel"
showBiasPanel = input.bool(true, "Show Bias Panel", group=grpB)
biasTf = input.timeframe("15", "HTF timeframe", group=grpB)
emaFast = input.int(20, "HTF EMA fast", minval=1, group=grpB)
emaSlow = input.int(50, "HTF EMA slow", minval=2, group=grpB)
zThresh = input.float(0.30, "Z threshold (±)", step=0.05, group=grpB)
railLookback = input.int(20, "Rail lookback bars", minval=5, group=grpB)
railPct = input.float(0.40, "Rail touch ratio (0–1)", minval=0.1, maxval=0.9, step=0.05, group=grpB)
// ---- Positions (NEW) ----
panelCorner = input.string("Top-Right", "Bias Panel Position",
options= , group=grpB)
hitsCorner = input.string("Top-Left", "Hits Table Position",
options= , group=grpO)
// ---- Helpers: table positions ----
f_pos(s) =>
p = position.top_left
if s == "Top-Right"
p := position.top_right
else if s == "Bottom-Left"
p := position.bottom_left
else if s == "Bottom-Right"
p := position.bottom_right
p
//==================== Anchor Resolve ====================//
var int anchorBar = na
var float anchorPrice = na
var label anchorLbl = na
// 初バー保護付きタイム検索
f_find_anchor_bar_by_time(_t) =>
ta.valuewhen(nz(time , time ) < _t and time >= _t, bar_index, 0)
if anchorMode == "Time"
anchorBar := f_find_anchor_bar_by_time(anchorTime)
else
// バッファ下限保護
anchorBar := math.max(0, bar_index - anchorBarsAgo)
// アンカー価格（安全取得）
f_price_at_anchor(_bar) =>
float _v = na
if anchorPriceMode == "Close"
_v := ta.valuewhen(bar_index == _bar, close, 0)
else if anchorPriceMode == "High"
_v := ta.valuewhen(bar_index == _bar, high, 0)
else if anchorPriceMode == "Low"
_v := ta.valuewhen(bar_index == _bar, low, 0)
else if anchorPriceMode == "Open"
_v := ta.valuewhen(bar_index == _bar, open, 0)
_v
float autoPrice = na
if not na(anchorBar) and anchorBar <= bar_index
autoPrice := f_price_at_anchor(anchorBar)
anchorPrice := (anchorPriceMode == "Manual" and anchorPriceManual != 0.0) ? anchorPriceManual : autoPrice
bool anchorOK = not na(anchorBar) and anchorBar >= 0 and anchorBar <= bar_index + futureLimitBars and not na(anchorPrice)
// ラベル
if anchorOK
if na(anchorLbl)
anchorLbl := label.new(anchorBar, anchorPrice, "Anchor", xloc=xloc.bar_index, yloc=yloc.price, style=label.style_label_down, textcolor=color.black, color=color.yellow, size=size.tiny)
else
label.set_x(anchorLbl, anchorBar), label.set_y(anchorLbl, anchorPrice)
//==================== Light-Cone (ATR-based) ====================//
float atrSame = ta.atr(atrLen)
float atrOther = request.security(syminfo.tickerid, atrTF, ta.atr(atrLen), gaps=barmerge.gaps_off, lookahead=barmerge.lookahead_off)
float baseATR = (na(atrTF) or atrTF == "") ? atrSame : atrOther
float c_main = mult * baseATR
int horizon = math.min(projBars, futureLimitBars)
var line upL = na
var line dnL = na
var line up05 = na
var line dn05 = na
var line up15 = na
var line dn15 = na
var linefill coneFill = na
f_growth(_n) =>
coneMode == "Linear n" ? _n : math.sqrt(_n)
if anchorOK
if not na(coneFill)
linefill.delete(coneFill)
if not na(upL)
line.delete(upL)
if not na(dnL)
line.delete(dnL)
if not na(up05)
line.delete(up05)
if not na(dn05)
line.delete(dn05)
if not na(up15)
line.delete(up15)
if not na(dn15)
line.delete(dn15)
int x1 = anchorBar + horizon
float dyPer= (wickMode == "Wick (High/Low)") ? c_main * 0.5 : c_main
float grow = f_growth(horizon)
float upY = anchorPrice + dyPer * grow
float dnY = anchorPrice - dyPer * grow
float upY05 = anchorPrice + (dyPer * 0.5) * grow
float dnY05 = anchorPrice - (dyPer * 0.5) * grow
float upY15 = anchorPrice + (dyPer * 1.5) * grow
float dnY15 = anchorPrice - (dyPer * 1.5) * grow
upL := line.new(anchorBar, anchorPrice, x1, upY, xloc=xloc.bar_index, extend=extend.none, color=coneLineCol, width=2)
dnL := line.new(anchorBar, anchorPrice, x1, dnY, xloc=xloc.bar_index, extend=extend.none, color=coneLineCol, width=2)
coneFill := linefill.new(upL, dnL, color=coneFillCol)
if showFan
up05 := line.new(anchorBar, anchorPrice, x1, upY05, xloc=xloc.bar_index, extend=extend.none, color=fan05Color, width=fanWidth)
dn05 := line.new(anchorBar, anchorPrice, x1, dnY05, xloc=xloc.bar_index, extend=extend.none, color=fan05Color, width=fanWidth)
up15 := line.new(anchorBar, anchorPrice, x1, upY15, xloc=xloc.bar_index, extend=extend.none, color=fan15Color, width=fanWidth)
dn15 := line.new(anchorBar, anchorPrice, x1, dnY15, xloc=xloc.bar_index, extend=extend.none, color=fan15Color, width=fanWidth)
//==================== √n Stripes ====================//
var array centers = array.new_int()
array.clear(centers)
if not na(anchorBar)
for m = 1 to maxOrderM
array.push(centers, anchorBar + stepBars * m * m)
f_in_any_stripe(_bi) =>
sz = array.size(centers)
if sz == 0
false
else
bool hit = false
for i = 0 to sz - 1
int c0 = array.get(centers, i)
if _bi >= c0 - halfWindow and _bi <= c0 + halfWindow
hit := true
hit
// どの m² ストライプか（なければ na）
f_stripe_index(_bi) =>
int mFound = na
if array.size(centers) > 0
for m = 1 to maxOrderM
int cCenter = array.get(centers, m - 1)
if _bi >= cCenter - halfWindow and _bi <= cCenter + halfWindow
mFound := m
mFound
bgcolor(f_in_any_stripe(bar_index) ? stripeColor : na)
if showCenters and array.size(centers) > 0
for i = 0 to array.size(centers) - 1
int c0 = array.get(centers, i)
bool withinFutureLimit = c0 <= bar_index + futureLimitBars
bool nearScreen = not limitScreen or (c0 >= bar_index - screenPastBars and c0 <= bar_index + futureLimitBars)
if withinFutureLimit and nearScreen
line.new(c0, high, c0, low, xloc=xloc.bar_index, extend=extend.both, color=color.new(color.white, 70), width=1)
//==================== Fractal Detection ====================//
isPH = not na(ta.pivothigh(high, leftP, rightP))
isPL = not na(ta.pivotlow (low , leftP, rightP))
int pivotCenter = bar_index - rightP
hitPH = isPH and f_in_any_stripe(pivotCenter)
hitPL = isPL and f_in_any_stripe(pivotCenter)
//==================== m² Hit Table (robust) ====================//
var table tbHits = na
var hitsHi = array.new_int()
var hitsLo = array.new_int()
f_sync_len_int(_arr, _n, _fill) =>
while array.size(_arr) < _n
array.push(_arr, _fill)
while array.size(_arr) > _n
array.pop(_arr)
_arr
f_safe_get_int(_arr, _idx) =>
(_idx >= 0 and _idx < array.size(_arr)) ? array.get(_arr, _idx) : 0
// 毎バー長さ同期
f_sync_len_int(hitsHi, maxOrderM, 0)
f_sync_len_int(hitsLo, maxOrderM, 0)
// 集計
if (hitPH or hitPL) and array.size(centers) > 0
int nC = array.size(centers)
int nM = math.min(maxOrderM, nC)
for m = 1 to nM
int c0 = array.get(centers, m - 1)
if pivotCenter >= c0 - halfWindow and pivotCenter <= c0 + halfWindow
if hitPH
array.set(hitsHi, m - 1, f_safe_get_int(hitsHi, m - 1) + 1)
if hitPL
array.set(hitsLo, m - 1, f_safe_get_int(hitsLo, m - 1) + 1)
// 表示
if showHitTable and barstate.islast
if na(tbHits)
tbHits := table.new(f_pos(hitsCorner), 3, maxOrderM + 1, border_width=1)
table.cell(tbHits, 0, 0, "m²", bgcolor=color.new(color.blue, 20), text_color=color.white)
table.cell(tbHits, 1, 0, "PH▲", bgcolor=color.new(color.green,10), text_color=color.white)
table.cell(tbHits, 2, 0, "PL▼", bgcolor=color.new(color.red, 10), text_color=color.white)
int rows = array.size(hitsHi)
int nRow = math.min(maxOrderM, rows)
for m = 1 to nRow
table.cell(tbHits, 0, m, str.tostring(m) + "²")
table.cell(tbHits, 1, m, str.tostring(f_safe_get_int(hitsHi, m - 1)))
table.cell(tbHits, 2, m, str.tostring(f_safe_get_int(hitsLo, m - 1)))
//==================== Bias Components ====================//
// 1) HTF trend
bool htfBull = request.security(syminfo.tickerid, biasTf, ta.ema(close, emaFast) > ta.ema(close, emaSlow), gaps=barmerge.gaps_off)
bool htfBear = request.security(syminfo.tickerid, biasTf, ta.ema(close, emaFast) < ta.ema(close, emaSlow), gaps=barmerge.gaps_off)
int scHTF = htfBull ? 1 : (htfBear ? -1 : 0)
string stHTF = htfBull ? "Bull" : (htfBear ? "Bear" : "—")
// 2) Cone Z
float z = 0.0
if anchorOK
int barsFromAnchor = math.max(1, bar_index - anchorBar)
float dyPerNow = (wickMode == "Wick (High/Low)") ? (mult * baseATR * 0.5) : (mult * baseATR)
float growNow = f_growth(math.min(barsFromAnchor, horizon))
float denom = dyPerNow * growNow
z := denom != 0 ? (close - anchorPrice) / denom : 0.0
int scZ = z > zThresh ? 1 : (z < -zThresh ? -1 : 0)
string stZ = anchorOK ? ("z=" + str.tostring(z, "#.00")) : "no anchor"
// 3) Rail-hug（0.5c〜1.0c帯を High/Low の“タッチ”で判定）
// ← 初期バー安全：参照本数を bar_index にクリップ
int effLookback = math.min(railLookback, bar_index) // bar_index 本目までは 0..bar_index しか参照不可
int upTouch = 0, dnTouch = 0
if anchorOK and effLookback > 0
for i = 0 to effLookback - 1
int barsFA = math.max(1, (bar_index - i) - anchorBar)
float growI = f_growth(math.min(barsFA, horizon))
float dyPerI = (wickMode == "Wick (High/Low)") ? (mult * baseATR * 0.5) : (mult * baseATR)
float up05I = anchorPrice + dyPerI * 0.5 * growI
float up10I = anchorPrice + dyPerI * 1.0 * growI
float dn05I = anchorPrice - dyPerI * 0.5 * growI
float dn10I = anchorPrice - dyPerI * 1.0 * growI
upTouch += (high >= up05I and low <= up10I) ? 1 : 0
dnTouch += (low <= dn05I and high >= dn10I) ? 1 : 0
float upRatio = effLookback > 0 ? (upTouch * 1.0) / effLookback : 0.0
float dnRatio = effLookback > 0 ? (dnTouch * 1.0) / effLookback : 0.0
bool railUp = upRatio > railPct
bool railDn = dnRatio > railPct
int scRail = railUp ? 1 : (railDn ? -1 : 0)
string stRail = anchorOK ? (railUp ? ("Up " + str.tostring(upRatio*100, "#") + "%") : (railDn ? ("Dn " + str.tostring(dnRatio*100, "#") + "%") : "—")) : "no anchor"
// 4) Stripe entry → 最初のフラクタル（帯を出た後確定も拾う）
var bool stripeIn = false
var int stripeIdxActive = na
var int stripeEnterBar = na
var int stripeLastStart = na
var int stripeLastEnd = na
var int stripeLastIdx = na
var string firstFrac = "" // "PL" or "PH" or ""
int nowIdx = f_stripe_index(bar_index)
bool nowInStripe = not na(nowIdx)
if nowInStripe and not stripeIn
stripeIn := true
stripeIdxActive := nowIdx
stripeEnterBar := bar_index
firstFrac := ""
else if not nowInStripe and stripeIn
stripeIn := false
stripeLastStart := stripeEnterBar
stripeLastEnd := bar_index - 1
stripeLastIdx := stripeIdxActive
if (isPH or isPL)
int pc = pivotCenter
int pcIdx = f_stripe_index(pc)
bool inActive = stripeIn and not na(stripeIdxActive) and pcIdx == stripeIdxActive and pc >= nz(stripeEnterBar, pc)
bool inClosed = (not stripeIn) and not na(stripeLastIdx) and pcIdx == stripeLastIdx and pc >= nz(stripeLastStart, pc) and pc <= nz(stripeLastEnd, pc)
if firstFrac == "" and (inActive or inClosed)
firstFrac := isPL ? "PL" : (isPH ? "PH" : "")
int scFrac = firstFrac == "PL" ? 1 : (firstFrac == "PH" ? -1 : 0)
string stFrac = firstFrac == "" ? "—" : ("1st " + firstFrac + (not stripeIn and not na(stripeLastIdx) ? " @m=" + str.tostring(stripeLastIdx) : (not na(stripeIdxActive) ? " @m=" + str.tostring(stripeIdxActive) : "")))
// 5) Structure break（簡易）
var float lastPH = na
var float lastPL = na
float ph = ta.pivothigh(high, 2, 2)
float pl = ta.pivotlow (low , 2, 2)
if not na(ph)
lastPH := ph
if not na(pl)
lastPL := pl
bool bullBreak = not na(lastPH) and close > lastPH
bool bearBreak = not na(lastPL) and close < lastPL
int scStruct = bullBreak ? 1 : (bearBreak ? -1 : 0)
string stStruct = bullBreak ? "Break ↑" : (bearBreak ? "Break ↓" : "—")
// ---- Total ----
int biasScore = scHTF + scZ + scRail + scFrac + scStruct
string biasDir = biasScore >= 3 ? "UP" : (biasScore <= -3 ? "DOWN" : "NEUTRAL")
//==================== Bias Panel (table, corner selectable) ====================//
var table tbBias = na
color colG = color.new(color.green, 10)
color colR = color.new(color.red, 10)
color colN = color.new(color.gray, 70)
f_col(v) =>
v > 0 ? colG : (v < 0 ? colR : colN)
if showBiasPanel and barstate.islast
if na(tbBias)
tbBias := table.new(f_pos(panelCorner), 3, 8, border_width=1)
table.cell(tbBias, 0, 0, "Bias Panel", text_color=color.white, bgcolor=color.new(color.blue, 20), text_halign=text.align_center)
table.merge_cells(tbBias, 0, 0, 2, 0)
table.cell(tbBias, 0, 1, "Card", text_halign=text.align_center)
table.cell(tbBias, 1, 1, "State", text_halign=text.align_center)
table.cell(tbBias, 2, 1, "±1", text_halign=text.align_center)
// rows
table.cell(tbBias, 0, 2, "HTF ("+biasTf+")")
table.cell(tbBias, 1, 2, stHTF)
table.cell(tbBias, 2, 2, str.tostring(scHTF), bgcolor=f_col(scHTF), text_halign=text.align_center)
table.cell(tbBias, 0, 3, "Cone z")
table.cell(tbBias, 1, 3, stZ)
table.cell(tbBias, 2, 3, str.tostring(scZ), bgcolor=f_col(scZ), text_halign=text.align_center)
table.cell(tbBias, 0, 4, "Rail 0.5c")
table.cell(tbBias, 1, 4, stRail)
table.cell(tbBias, 2, 4, str.tostring(scRail), bgcolor=f_col(scRail), text_halign=text.align_center)
table.cell(tbBias, 0, 5, "Fractal")
table.cell(tbBias, 1, 5, stFrac)
table.cell(tbBias, 2, 5, str.tostring(scFrac), bgcolor=f_col(scFrac), text_halign=text.align_center)
table.cell(tbBias, 0, 6, "Structure")
table.cell(tbBias, 1, 6, stStruct)
table.cell(tbBias, 2, 6, str.tostring(scStruct), bgcolor=f_col(scStruct), text_halign=text.align_center)
color totCol = biasScore>=3?colG:(biasScore<=-3?colR:colN)
table.cell(tbBias, 0, 7, "TOTAL", bgcolor=color.new(color.black, 0), text_color=color.white, text_halign=text.align_center)
table.cell(tbBias, 1, 7, biasDir, bgcolor=totCol, text_color=color.white, text_halign=text.align_center)
table.cell(tbBias, 2, 7, str.tostring(biasScore), bgcolor=totCol, text_color=color.white, text_halign=text.align_center)
//==================== Alerts ====================//
alertcondition(biasScore >= 3, "Bias UP", "Bias score >= +3")
alertcondition(biasScore <= -3, "Bias DOWN", "Bias score <= -3")
alertcondition(hitPH, "Fractal High in Convergence", "Pivot High detected inside √n convergence stripe.")
alertcondition(hitPL, "Fractal Low in Convergence", "Pivot Low detected inside √n convergence stripe.")
BTCUSD Dual Thrust (1H)BTCUSD Dual Thrust (1H) — Indicator
Overview
The Dual Thrust is a classic breakout-type strategy designed to capture strong directional moves when markets show imbalance between buyers and sellers. This indicator adapts the method specifically for BTCUSD on the 1-Hour timeframe, showing dynamic Buy/Sell trigger levels and live signals.
Origin
The Dual Thrust system was originally introduced by Michael Vitucci and has been widely used in futures and high-volatility markets. It was designed as a day-trading breakout framework, where daily high/low and close data define the range for the next session’s trade triggers.
How it Works
Each new day, the indicator calculates a “breakout range” using daily price data.
Two trigger levels are projected from the daily open:
Buy Trigger: Open + Range × KUp
Sell Trigger: Open - Range × KDn
Range can be built from either:
Classic Dual Thrust formula: max(High - Close , Close - Low) over a lookback period, or
ATR-based range: for volatility-adaptive signals.
A LONG signal fires when price crosses above the Buy Trigger.
An EXIT signal fires when price crosses below the Sell Trigger.
Buy/Sell lines step forward across each intraday bar until recalculated at the next daily open.
Practical Use
Optimized for BTCUSD 1-Hour charts (crypto’s volatility provides stronger follow-through).
Use the Buy/Sell levels as dynamic breakout lines or as confluence with your own setups.
Alerts are built in, so you can receive notifications when a LONG or EXIT condition triggers.
Designed as an indicator only (not a backtest strategy).
Key Features
✅ Daily Buy/Sell trigger lines auto-calculated and forward-filled
✅ LONG / EXIT labels on signals
✅ Optional ATR mode for volatility regimes
✅ Optional bar coloring for easy visual scanning
✅ Alerts ready for live monitoring
⚡️ Tip: While this indicator highlights breakout opportunities, effectiveness can improve when combined with trend filters (e.g., 200-SMA) or when aligned with higher timeframe supply/demand zones.
Hidden Divergence with S/R & TP// This source code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// © Gemini
// @version=5
// This indicator combines Hidden RSI Divergence with Support & Resistance detection
// and provides dynamic take-profit targets based on ATR. It also includes alerts.
indicator("Hidden Divergence with S/R & TP", overlay=true)
// === INPUTS ===
rsiLengthInput = input.int(14, "RSI Length", minval=1)
rsiSMALengthInput = input.int(5, "RSI SMA Length", minval=1)
pivotLookbackLeft = input.int(5, "Pivot Left Bars", minval=1)
pivotLookbackRight = input.int(5, "Pivot Right Bars", minval=1)
atrPeriodInput = input.int(14, "ATR Period", minval=1)
atrMultiplierTP1 = input.float(1.5, "TP1 ATR Multiplier", minval=0.1)
atrMultiplierTP2 = input.float(3.0, "TP2 ATR Multiplier", minval=0.1)
atrMultiplierTP3 = input.float(5.0, "TP3 ATR Multiplier", minval=0.1)
// === CALCULATIONS ===
// Calculate RSI and its SMA
rsiValue = ta.rsi(close, rsiLengthInput)
rsiSMA = ta.sma(rsiValue, rsiSMALengthInput)
// Calculate Average True Range for Take Profits
atrValue = ta.atr(atrPeriodInput)
// Identify pivot points for Support and Resistance
pivotLow = ta.pivotlow(pivotLookbackLeft, pivotLookbackRight)
pivotHigh = ta.pivothigh(pivotLookbackLeft, pivotLookbackRight)
// Define variables to track divergence and TP levels
var bool bullishDivergence = false
var bool bearishDivergence = false
var float tp1Buy = na
var float tp2Buy = na
var float tp3Buy = na
var float tp1Sell = na
var float tp2Sell = na
var float tp3Sell = na
// Reset divergence flags at each new bar
bullishDivergence := false
bearishDivergence := false
// === HIDDEN DIVERGENCE LOGIC ===
// Hidden Bullish Divergence (Higher low in price, lower low in RSI)
// Price makes a higher low, while RSI makes a lower low, suggesting trend continuation.
for i = 1 to 50 // Look back up to 50 bars for a confirmed pivot low
if not na(pivotLow ) and close < close and rsiValue < rsiValue
// Check if price is making a higher low than the pivot low, and RSI is making a lower low
if low > low and rsiValue < rsiValue
bullishDivergence := true
break // Exit loop once divergence is found
// Hidden Bearish Divergence (Lower high in price, higher high in RSI)
// Price makes a lower high, while RSI makes a higher high, suggesting trend continuation.
for i = 1 to 50 // Look back up to 50 bars for a confirmed pivot high
if not na(pivotHigh ) and close > close and rsiValue > rsiValue
// Check if price is making a lower high than the pivot high, and RSI is making a higher high
if high < high and rsiValue > rsiValue
bearishDivergence := true
break // Exit loop once divergence is found
// === SETTING TP LEVELS AND ALERTS ===
if bullishDivergence
buySignalPrice = low - atrValue * 0.5 // Entry below the low
tp1Buy := buySignalPrice + atrValue * atrMultiplierTP1
tp2Buy := buySignalPrice + atrValue * atrMultiplierTP2
tp3Buy := buySignalPrice + atrValue * atrMultiplierTP3
// Alert for buying signal
alert("Hidden Bullish Divergence Detected on " + syminfo.ticker + " - Buy Signal", alert.freq_once_per_bar_close)
else
tp1Buy := na
tp2Buy := na
tp3Buy := na
if bearishDivergence
sellSignalPrice = high + atrValue * 0.5 // Entry above the high
tp1Sell := sellSignalPrice - atrValue * atrMultiplierTP1
tp2Sell := sellSignalPrice - atrValue * atrMultiplierTP2
tp3Sell := sellSignalPrice - atrValue * atrMultiplierTP3
// Alert for selling signal
alert("Hidden Bearish Divergence Detected on " + syminfo.ticker + " - Sell Signal", alert.freq_once_per_bar_close)
else
tp1Sell := na
tp2Sell := na
tp3Sell := na
// === PLOTTING SIGNALS AND TAKE PROFITS ===
// Plotting shapes for buy/sell signals
plotshape(bullishDivergence, title="Buy Signal", style=shape.triangleup, location=location.belowbar, color=color.new(color.green, 0), text="Buy", textcolor=color.black)
plotshape(bearishDivergence, title="Sell Signal", style=shape.triangledown, location=location.abovebar, color=color.new(color.red, 0), text="Sell", textcolor=color.black)
// Plotting take-profit lines
plot(tp1Buy, "TP1 Buy", color=color.new(color.lime, 0), style=plot.style_linebr)
plot(tp2Buy, "TP2 Buy", color=color.new(color.lime, 0), style=plot.style_linebr)
plot(tp3Buy, "TP3 Buy", color=color.new(color.lime, 0), style=plot.style_linebr)
plot(tp1Sell, "TP1 Sell", color=color.new(color.orange, 0), style=plot.style_linebr)
plot(tp2Sell, "TP2 Sell", color=color.new(color.orange, 0), style=plot.style_linebr)
plot(tp3Sell, "TP3 Sell", color=color.new(color.orange, 0), style=plot.style_linebr)
// Plotting the RSI and its SMA on a sub-pane
plot(rsiValue, "RSI", color.new(color.fuchsia, 0))
plot(rsiSMA, "RSI SMA", color.new(color.yellow, 0))
hline(50, "50 Midline", color=color.new(color.gray, 50))
// Plotting background for signals
bullishColor = color.new(color.green, 90)
bearishColor = color.new(color.red, 90)
bgcolor(bullishDivergence ? bullishColor : na, title="Bullish Divergence Zone")
bgcolor(bearishDivergence ? bearishColor : na, title="Bearish Divergence Zone")
// === EXPLANATION OF CONCEPTS ===
// Deep Knowledge of Market from AI:
// This indicator is based on a powerful, yet often misunderstood, concept: divergence.
// While standard divergence signals a potential trend reversal, hidden divergence signals a
// continuation of the prevailing trend. This is crucial for traders who want to capitalize
// on the momentum of a move rather than trying to catch tops and bottoms.
// Hidden Bullish Divergence: Occurs in an uptrend when price makes a higher low, but the
// RSI makes a lower low. This suggests that while there was a brief period of weakness, the
// underlying buying pressure is returning to push the trend higher. It’s a "re-energizing"
// of the bullish momentum.
// Hidden Bearish Divergence: Occurs in a downtrend when price makes a lower high, but the
// RSI makes a higher high. This indicates that while the sellers paused, the underlying
// selling pressure remains strong and is likely to continue pushing the price down. It's a
// subtle signal that the bears are regaining control.
// Combining Divergence with S/R: The true power of this indicator comes from its
// "confluence" principle. A divergence signal alone can be noisy. By requiring it to occur
// at a key support or resistance level (identified using pivot points), we are filtering
// out weaker signals and only focusing on high-probability setups where the market is
// likely to respect a previous area of interest. This tells us that not only is the trend
// likely to continue, but it is doing so from a strategic, well-defined point on the chart.
// Dynamic Take-Profit Targets: The take-profit targets are based on the Average True Range (ATR).
// ATR is a measure of market volatility. Using it to set targets ensures that your profit
// levels are dynamic and adapt to current market conditions. In a volatile market, your
// targets will be wider, while in a calm market, they will be tighter, helping you avoid
// unrealistic expectations and improving your risk management.
SPPO - Statistical Price Position OscillatorSPPO - Statistical Price Position Oscillator - Time-Weighted
Based on a time-weighted statistical model, this indicator quantifies price deviation from its recent mean. It uses a Z-Score to normalize price position and calculates the statistical probability of its occurrence, helping traders identify over-extended market conditions and mean-reversion opportunities with greater sensitivity.
- Time-Weighted Model: Reacts more quickly to recent price changes by using a Weighted Moving Average (WMA) and a weighted standard deviation.
- Statistical Foundation: Utilizes Z-Score standardization and a probability calculation to provide an objective measure of risk and price extremity.
- Dynamic Adaptation: Automatically adjusts its calculation period and sensitivity based on market volatility, making it versatile across different market conditions.
- Intelligent Visuals: Dynamic line thickness and gradient color-coding intuitively display the intensity of price deviations.
- Multi-Dimensional Analysis: Combines the main line's position (Z-Score), a momentum histogram, and real-time probability for a comprehensive view.
1. Time-Weighted Statistical Model (Z-Score Calculation)
- Weighted Mean (μ_w): Instead of a simple average, the indicator uses a Weighted Moving Average (ta.wma) to calculate the price mean, giving more weight to recent data points.
- Weighted Standard Deviation (σ_w): A custom weighted_std function calculates the standard deviation, also prioritizing recent prices. This ensures that the measure of dispersion is more responsive to the latest market behavior.
- Z-Score: The core of the indicator is the Z-Score, calculated as Z = (Price - μ_w) / σ_w. This value represents how many weighted standard deviations the current price is from its weighted mean. A higher absolute Z-Score indicates a more statistically significant price deviation.
2. Probability Calculation
- The indicator uses an approximation of the Normal Cumulative Distribution Function (normal_cdf_approx) to calculate the probability of a Z-Score occurring.
- The final price_probability is a two-tailed probability, calculated as 2 * (1 - CDF(|Z-Score|)). This value quantifies the statistical rarity of the current price deviation. For example, a probability of 0.05 (or 5%) means that a deviation of this magnitude or greater is expected to occur only 5% of the time, signaling a potential market extreme.
3. Dynamic Parameter Adjustment
- Volatility Measurement: The system measures market volatility using the standard deviation of price changes (ta.stdev(ta.change(src))) over a specific lookback period.
- Volatility Percentile: It then calculates the percentile rank (ta.percentrank) of the current volatility relative to its history. This contextualizes whether the market is in a high-volatility or low-volatility state.
- Adaptive Adjustment:
- If volatility is high (e.g., >75th percentile), the indicator can shorten its distribution_period and increase its position_sensitivity. This makes it more responsive to fast-moving markets.
- If volatility is low (e.g., <25th percentile), it can lengthen the period and decrease sensitivity, making it more stable in calmer markets. This adaptive mechanism helps maintain the indicator's relevance across different market regimes.
4. Momentum and Cycle Analysis (Histogram)
- The indicator does not use a Hilbert Transform. Instead, it analyzes momentum cycles by calculating a histogram: Histogram = (Z-Score - EMA(Z-Score)) * Sensitivity.
- This histogram represents the rate of change of the Z-Score. A positive and rising histogram indicates accelerating upward deviation, while a negative and falling histogram indicates accelerating downward deviation. Divergences between the price and the histogram can signal a potential exhaustion of the current deviation trend, often preceding a reversal.
- Reversal Signals: Look for the main line in extreme zones (e.g., Z-Score > 2 or < -2), probability below a threshold (e.g., 5%), and divergence or contraction in the momentum histogram.
- Trend Filtering: The main line's direction indicates the trend of price deviation, while the histogram confirms its momentum.
- Risk Management: Enter a high-alert state when probability drops below 5%; consider risk control when |Z-Score| > 2.
- Gray, thin line: Price is within a normal statistical range (~1 sigma, ~68% probability).
- Orange/Yellow, thick line: Price is moderately deviated (1 to 2 sigma).
- Cyan/Purple, thick line: Price is extremely deviated (>2 sigma, typically <5% probability).
- Distribution Period: 50 (for weighted calculation)
- Position Sensitivity: 2.5
- Volatility Lookback: 10
- Probability Threshold: 0.03
Suitable for all financial markets and timeframes, especially in markets that exhibit mean-reverting tendencies.
This indicator is a technical analysis tool and does not constitute investment advice. Always use in conjunction with other analysis methods and a strict risk management strategy.
Copyright (c) 2025 | Pine Script v6 Compatible
---
统计价格位置振荡器 (SPPO) - 时间加权版
基于时间加权统计学模型，该指标量化了当前价格与其近期均值的偏离程度。它使用Z分数对价格位置进行标准化，并计算其出现的统计概率，帮助交易者更灵敏地识别市场过度延伸和均值回归的机会。
- 时间加权模型：通过使用加权移动平均（WMA）和加权标准差，对近期价格变化反应更迅速。
- 统计学基础：利用Z分数标准化和概率计算，为风险和价格极端性提供了客观的衡量标准。
- 动态自适应：根据市场波动率自动调整其计算周期和敏感度，使其在不同市场条件下都具有通用性。
- 智能视觉：动态线条粗细和渐变颜色编码，直观地展示价格偏离的强度。
- 多维分析：结合了主线位置（Z分数）、动能柱和实时概率，提供了全面的市场视角。
1. 时间加权统计模型 (Z分数计算)
- 加权均值 (μ_w)：指标使用加权移动平均 (ta.wma) 而非简单平均来计算价格均值，赋予近期数据点更高的权重。
- 加权标准差 (σ_w)：通过一个自定义的 weighted_std 函数计算标准差，同样优先考虑近期价格。这确保了离散度的衡量对最新的市场行为更敏感。
- Z分数：指标的核心是Z分数，计算公式为 Z = (价格 - μ_w) / σ_w。该值表示当前价格偏离其加权均值的加权标准差倍数。Z分数的绝对值越高，表示价格偏离在统计上越显著。
2. 概率计算
- 指标使用正态累积分布函数 (normal_cdf_approx) 的近似值来计算特定Z分数出现的概率。
- 最终的 price_probability 是一个双尾概率，计算公式为 2 * (1 - CDF(|Z分数|))。该值量化了当前价格偏离的统计稀有性。例如，0.05（或5%）的概率意味着这种幅度或更大的偏离预计只在5%的时间内发生，这预示着一个潜在的市场极端。
3. 动态参数调整
- 波动率测量：系统通过计算特定回溯期内价格变化的标准差 (ta.stdev(ta.change(src))) 来测量市场波动率。
- 波动率百分位：然后，它计算当前波动率相对于其历史的百分位排名 (ta.percentrank)。这将当前市场背景定义为高波动率或低波动率状态。
- 自适应调整：
- 如果波动率高（例如，>75百分位），指标可以缩短其 distribution_period（分布周期）并增加其 position_sensitivity（位置敏感度），使其对快速变化的市场反应更灵敏。
- 如果波动率低（例如，<25百分位），它可以延长周期并降低敏感度，使其在较平静的市场中更稳定。这种自适应机制有助于保持指标在不同市场制度下的有效性。
4. 动能与周期分析 (动能柱)
- 该指标不使用希尔伯特变换。相反，它通过计算一个动能柱来分析动量周期：动能柱 = (Z分数 - Z分数的EMA) * 敏感度。
- 该动能柱代表Z分数的变化率。一个正向且不断增长的动能柱表示向上的偏离正在加速，而一个负向且不断下降的动能柱表示向下的偏离正在加速。价格与动能柱之间的背离可以预示当前偏离趋势的衰竭，通常发生在反转之前。
- 反转信号：寻找主线进入极端区域（如Z分数 > 2 或 < -2）、概率低于阈值（如5%）以及动能柱出现背离或收缩。
- 趋势过滤：主线的方向指示价格偏离的趋势，而动能柱确认其动量。
- 风险管理：当概率降至5%以下时进入高度警惕状态；当|Z分数| > 2时考虑风险控制。
- 灰色细线：价格处于正常统计范围内（约1个标准差，约68%概率）。
- 橙色/黄色粗线：价格中度偏离（1到2个标准差）。
- 青色/紫色粗线：价格极端偏离（>2个标准差，通常概率<5%）。
- 分布周期：50（用于加权计算）
- 位置敏感度：2.5
- 波动率回溯期：10
- 概率阈值：0.03
适用于所有金融市场和时间框架，尤其是在表现出均值回归特性的市场中。
本指标为技术分析辅助工具，不构成任何投资建议。请务必结合其他分析方法和严格的风险管理策略使用。
版权所有 (c) 2025 | Pine Script v6 兼容
Day 3 PlayDay 3 Play — Indicator Summary
The Day 3 Play indicator is designed to identify outsized moves on Day 1 with a consolidation on Day 2 and are primed for a breakout on Day 3.
Day-1: A stock makes an outsized move (configurable, default = ±3% from prior close) on above-average relative volume (default = ≥3× 30-day average).
Day-2: The stock consolidates inside the Day-1 range (an inside bar).
Day-3: Price is primed for a breakout beyond the Day-2 high (bullish) or Day-2 low (bearish).
How It Works in the Pine Screener
The script computes Day-1 moves, Day-2 ranges, and checks volume requirements in the daily timeframe.
In the Screener, add a watchlist that includes your custom list of stocks. Then, add the custom Day 3 Play indicator. Select the time frame and the parameters from the indicator.
Screener columns (hidden by default) report whether a setup is found, whether it’s bullish or bearish, and the precise trigger/offset levels.
Alerts and Offsets
Alerts are available for:
Breakout at the Day-2 high/low (the trigger).
Approaching within an offset (configurable, default = 0.25%) from the Day-2 high or low.
This lets you catch moves as they’re forming intraday, even in extended hours, and not just after the breakout occurs.
Customization
Thresholds: Adjust the Day-1 % move (default 3%) and minimum relative volume (default 3×).
Alert Offset: Change the proximity level (default 0.25%) where alerts should fire before the breakout.
Visibility: Toggle chart lines (levels and offsets) and a debug panel separately.
Lookback: Control how many past days are scanned for the most recent valid setup.
On-Chart Levels
Day-2 High/Low: Shown as reference levels.
Bull/Bear Level: The breakout level (Day-2 high or low depending on setup).
Alert Offset Lines: Offset from the breakout level by your chosen % for early alerts.
Key Calculations
Relative Volume (RVOL): Day-1 volume ÷ 30-day average (excluding the day itself).
Inside Bar: Day-2 high ≤ Day-1 high and Day-2 low ≥ Day-1 low.
Breakout Levels:
Bullish = Day-2 High (with offset below).
Bearish = Day-2 Low (with offset above).
دستیار ترید(By Vahid.Jafarzadeh) 🇮🇷🎉 The first Persian indicator on TradingView, released for free to celebrate my daughter's birthday. 🎉
Trading Assistant (By Vahid.Jz) is an all-in-one tool designed to simplify analysis and improve accuracy. It acts as an intelligent trading partner.
Features:
- Market Structure detection
- Multi-Timeframe "Third Eye" analysis
- Professional Order Blocks recognition
- Fair Value Gaps (FVGs) detection
- Customizable alerts
- Fully Persian interface
Free to use. Contact on Telegram: @vahidjz
“Trading is not a destination; it’s the journey — a path of learning, growth, and experience.”
دستیار ترید (By Vahid.Jafarzadeh) 🇮🇷🎉 The first Persian indicator on TradingView, released for free to celebrate my daughter's birthday. 🎉
Trading Assistant (By Vahid.Jz) is an all-in-one tool designed to simplify analysis and improve accuracy. It acts as an intelligent trading partner.
Features:
- Market Structure detection
- Multi-Timeframe "Third Eye" analysis
- Professional Order Blocks recognition
- Fair Value Gaps (FVGs) detection
- Customizable alerts
- Fully Persian interface
Free to use. Contact on Telegram: @vahidjz
“Trading is not a destination; it’s the journey — a path of learning, growth, and experience.”
[DEM] RMEMA Bars RMEMA Bars is a multi-factor trend confirmation indicator that combines a double-smoothed moving average with momentum, trend direction, and price position analysis to generate color-coded bar signals. The indicator uses an RMA-smoothed EMA (21-period EMA smoothed by 5-period RMA) as its primary trend filter, while incorporating four additional technical conditions: price position relative to recent highs/lows over a 20-period window, Parabolic SAR directional bias, relative positioning of recent highs versus lows, and MACD momentum direction using extended parameters (50/100/21). Green bars appear when price is above SAR, recent highs dominate recent lows, MACD is positive, and the smoothed moving average is rising, while red bars signal the opposite conditions with price below SAR, recent lows dominating, negative MACD, and falling moving average. Purple bars indicate mixed or transitional conditions where not all criteria align, creating a comprehensive visual system that requires multiple technical factors to confirm before signaling strong bullish or bearish conditions.
[DEM] Relative Strength Signal (With Backtesting) Relative Strength Signal (With Backtesting) is a momentum indicator that generates trading signals based on when an asset reaches its highest or lowest relative strength compared to the SPY benchmark over a 20-period lookback window. The indicator calculates relative strength by dividing the current asset's price by SPY's price, then triggers buy signals when this ratio hits a 20-period high (indicating maximum outperformance) and sell signals when it reaches a 20-period low (indicating maximum underperformance). To prevent signal clustering and improve practical utility, the indicator includes a built-in filter that requires a minimum number of bars (default 20) to pass between signals of the same type, ensuring adequate spacing for meaningful trade opportunities. The system includes comprehensive backtesting functionality that tracks signal accuracy, average returns, and signal frequency over time, displaying these performance metrics in a detailed statistics table to help traders evaluate the effectiveness of trading on relative strength extremes versus the broader market.
[DEM] Pullback Signal (With Backtesting) Pullback Signal (With Backtesting) is a sophisticated fractal-based indicator that identifies potential reversal opportunities by detecting swing highs and lows followed by pullback conditions in the opposite direction. The indicator uses complex fractal logic to identify pivot points where price forms a local high or low over a customizable period (default 3 bars), then generates buy signals when an upward fractal is identified and the current close is below the previous close, or sell signals when a downward fractal occurs and the current close is above the previous close. This approach captures the classic pullback scenario where price retraces after forming a swing point, potentially offering favorable risk-reward entry opportunities. The indicator includes comprehensive backtesting functionality that tracks signal accuracy, average returns, and signal frequency over time, displaying these performance metrics in a detailed statistics table to help traders evaluate the historical effectiveness of the pullback strategy across different market conditions.
[DEM] Parabolic SAR Moving Average (PSARMA) Parabolic SAR Moving Average is a smoothed trend-following indicator that applies a moving average filter to traditional Parabolic SAR values to create a more stable directional signal with reduced whipsaws. The indicator calculates standard Parabolic SAR using customizable acceleration parameters (start, increment, and maximum values), then applies a 200-period RMA smoothing to eliminate the frequent reversals that can occur with raw SAR signals in sideways or volatile markets. This smoothed approach transforms the typically jagged SAR plot into a flowing yellow line that better represents the underlying trend direction while maintaining the SAR's inherent ability to accelerate during strong trending moves. The result is a hybrid indicator that combines the trend-following characteristics of moving averages with the acceleration-based logic of Parabolic SAR, making it particularly useful for identifying major trend changes and providing cleaner entry and exit signals in trending markets.
