BOCS AdaptiveBOCS Adaptive Strategy - Automated Volatility Breakout System
WHAT THIS STRATEGY DOES:
This is an automated trading strategy that detects consolidation patterns through volatility analysis and executes trades when price breaks out of these channels. Take-profit and stop-loss levels are calculated dynamically using Average True Range (ATR) to adapt to current market volatility. The strategy closes positions partially at the first profit target and exits the remainder at the second target or stop loss.
TECHNICAL METHODOLOGY:
Price Normalization Process:
The strategy begins by normalizing price to create a consistent measurement scale. It calculates the highest high and lowest low over a user-defined lookback period (default 100 bars). The current close price is then normalized using the formula: (close - lowest_low) / (highest_high - lowest_low). This produces values between 0 and 1, allowing volatility analysis to work consistently across different instruments and price levels.
Volatility Detection:
A 14-period standard deviation is applied to the normalized price series. Standard deviation measures how much prices deviate from their average - higher values indicate volatility expansion, lower values indicate consolidation. The strategy uses ta.highestbars() and ta.lowestbars() functions to track when volatility reaches peaks and troughs over the detection length period (default 14 bars).
Channel Formation Logic:
When volatility crosses from a high level to a low level, this signals the beginning of a consolidation phase. The strategy records this moment using ta.crossover(upper, lower) and begins tracking the highest and lowest prices during the consolidation. These become the channel boundaries. The duration between the crossover and current bar must exceed 10 bars minimum to avoid false channels from brief volatility spikes. Channels are drawn using box objects with the recorded high/low boundaries.
Breakout Signal Generation:
Two detection modes are available:
Strong Closes Mode (default): Breakout occurs when the candle body midpoint math.avg(close, open) exceeds the channel boundary. This filters out wick-only breaks.
Any Touch Mode: Breakout occurs when the close price exceeds the boundary.
When price closes above the upper channel boundary, a bullish breakout signal generates. When price closes below the lower boundary, a bearish breakout signal generates. The channel is then removed from the chart.
ATR-Based Risk Management:
The strategy uses request.security() to fetch ATR values from a specified timeframe, which can differ from the chart timeframe. For example, on a 5-minute chart, you can use 1-minute ATR for more responsive calculations. The ATR is calculated using ta.atr(length) with a user-defined period (default 14).
Exit levels are calculated at the moment of breakout:
Long Entry Price = Upper channel boundary
Long TP1 = Entry + (ATR × TP1 Multiplier)
Long TP2 = Entry + (ATR × TP2 Multiplier)
Long SL = Entry - (ATR × SL Multiplier)
For short trades, the calculation inverts:
Short Entry Price = Lower channel boundary
Short TP1 = Entry - (ATR × TP1 Multiplier)
Short TP2 = Entry - (ATR × TP2 Multiplier)
Short SL = Entry + (ATR × SL Multiplier)
Trade Execution Logic:
When a breakout occurs, the strategy checks if trading hours filter is satisfied (if enabled) and if position size equals zero (no existing position). If volume confirmation is enabled, it also verifies that current volume exceeds 1.2 times the 20-period simple moving average.
If all conditions are met:
strategy.entry() opens a position using the user-defined number of contracts
strategy.exit() immediately places a stop loss order
The code monitors price against TP1 and TP2 levels on each bar
When price reaches TP1, strategy.close() closes the specified number of contracts (e.g., if you enter with 3 contracts and set TP1 close to 1, it closes 1 contract). When price reaches TP2, it closes all remaining contracts. If stop loss is hit first, the entire position exits via the strategy.exit() order.
Volume Analysis System:
The strategy uses ta.requestUpAndDownVolume(timeframe) to fetch up volume, down volume, and volume delta from a specified timeframe. Three display modes are available:
Volume Mode: Shows total volume as bars scaled relative to the 20-period average
Comparison Mode: Shows up volume and down volume as separate bars above/below the channel midline
Delta Mode: Shows net volume delta (up volume - down volume) as bars, positive values above midline, negative below
The volume confirmation logic compares breakout bar volume to the 20-period SMA. If volume ÷ average > 1.2, the breakout is classified as "confirmed." When volume confirmation is enabled in settings, only confirmed breakouts generate trades.
INPUT PARAMETERS:
Strategy Settings:
Number of Contracts: Fixed quantity to trade per signal (1-1000)
Require Volume Confirmation: Toggle to only trade signals with volume >120% of average
TP1 Close Contracts: Exact number of contracts to close at first target (1-1000)
Use Trading Hours Filter: Toggle to restrict trading to specified session
Trading Hours: Session input in HHMM-HHMM format (e.g., "0930-1600")
Main Settings:
Normalization Length: Lookback bars for high/low calculation (1-500, default 100)
Box Detection Length: Period for volatility peak/trough detection (1-100, default 14)
Strong Closes Only: Toggle between body midpoint vs close price for breakout detection
Nested Channels: Allow multiple overlapping channels vs single channel at a time
ATR TP/SL Settings:
ATR Timeframe: Source timeframe for ATR calculation (1, 5, 15, 60, etc.)
ATR Length: Smoothing period for ATR (1-100, default 14)
Take Profit 1 Multiplier: Distance from entry as multiple of ATR (0.1-10.0, default 2.0)
Take Profit 2 Multiplier: Distance from entry as multiple of ATR (0.1-10.0, default 3.0)
Stop Loss Multiplier: Distance from entry as multiple of ATR (0.1-10.0, default 1.0)
Enable Take Profit 2: Toggle second profit target on/off
VISUAL INDICATORS:
Channel boxes with semi-transparent fill showing consolidation zones
Green/red colored zones at channel boundaries indicating breakout areas
Volume bars displayed within channels using selected mode
TP/SL lines with labels showing both price level and distance in points
Entry signals marked with up/down triangles at breakout price
Strategy status table showing position, contracts, P&L, ATR values, and volume confirmation status
HOW TO USE:
For 2-Minute Scalping:
Set ATR Timeframe to "1" (1-minute), ATR Length to 12, TP1 Multiplier to 2.0, TP2 Multiplier to 3.0, SL Multiplier to 1.5. Enable volume confirmation and strong closes only. Use trading hours filter to avoid low-volume periods.
For 5-15 Minute Day Trading:
Set ATR Timeframe to match chart or use 5-minute, ATR Length to 14, TP1 Multiplier to 2.0, TP2 Multiplier to 3.5, SL Multiplier to 1.2. Volume confirmation recommended but optional.
For Hourly+ Swing Trading:
Set ATR Timeframe to 15-30 minute, ATR Length to 14-21, TP1 Multiplier to 2.5, TP2 Multiplier to 4.0, SL Multiplier to 1.5. Volume confirmation optional, nested channels can be enabled for multiple setups.
BACKTEST CONSIDERATIONS:
Strategy performs best during trending or volatility expansion phases
Consolidation-heavy or choppy markets produce more false signals
Shorter timeframes require wider stop loss multipliers due to noise
Commission and slippage significantly impact performance on sub-5-minute charts
Volume confirmation generally improves win rate but reduces trade frequency
ATR multipliers should be optimized for specific instrument characteristics
COMPATIBLE MARKETS:
Works on any instrument with price and volume data including forex pairs, stock indices, individual stocks, cryptocurrency, commodities, and futures contracts. Requires TradingView data feed that includes volume for volume confirmation features to function.
KNOWN LIMITATIONS:
Stop losses execute via strategy.exit() and may not fill at exact levels during gaps or extreme volatility
request.security() on lower timeframes requires higher-tier TradingView subscription
False breakouts inherent to breakout strategies cannot be completely eliminated
Performance varies significantly based on market regime (trending vs ranging)
Partial closing logic requires sufficient position size relative to TP1 close contracts setting
RISK DISCLOSURE:
Trading involves substantial risk of loss. Past performance of this or any strategy does not guarantee future results. This strategy is provided for educational purposes and automated backtesting. Thoroughly test on historical data and paper trade before risking real capital. Market conditions change and strategies that worked historically may fail in the future. Use appropriate position sizing and never risk more than you can afford to lose. Consider consulting a licensed financial advisor before making trading decisions.
ACKNOWLEDGMENT & CREDITS:
This strategy is built upon the channel detection methodology created by AlgoAlpha in the "Smart Money Breakout Channels" indicator. Full credit and appreciation to AlgoAlpha for pioneering the normalized volatility approach to identifying consolidation patterns and sharing this innovative technique with the TradingView community. The enhancements added to the original concept include automated trade execution, multi-timeframe ATR-based risk management, partial position closing by contract count, volume confirmation filtering, and real-time position monitoring.
"黄金近20年走势" için komut dosyalarını ara
ATR Enhanced [DCAUT]█ ATR Enhanced
📊 OVERVIEW
Standard ATR uses only RMA smoothing, while ATR Enhanced provides 20+ professional smoothing algorithms , offering precise volatility measurement solutions for different trading scenarios and market environments.
💡 CORE VALUE
- 20+ algorithm choices : SMA, EMA, RMA, WMA, HMA, T3, KAMA, FRAMA, Kalman Filter, etc.
📋 PARAMETER SETUP
ATR Length : Calculation period (default: 14)
Moving Average Type : Choose the most suitable smoothing method from 20+ algorithms
🎨 COLOR CODING
Green : Rising volatility
Red : Falling volatility
TA█ TA Library
📊 OVERVIEW
TA is a Pine Script technical analysis library. This library provides 25+ moving averages and smoothing filters , from classic SMA/EMA to Kalman Filters and adaptive algorithms, implemented based on academic research.
🎯 Core Features
Academic Based - Algorithms follow original papers and formulas
Performance Optimized - Pre-calculated constants for faster response
Unified Interface - Consistent function design
Research Based - Integrates technical analysis research
🎯 CONCEPTS
Library Design Philosophy
This technical analysis library focuses on providing:
Academic Foundation
Algorithms based on published research papers and academic standards
Implementations that follow original mathematical formulations
Clear documentation with research references
Developer Experience
Unified interface design for consistent usage patterns
Pre-calculated constants for optimal performance
Comprehensive function collection to reduce development time
Single import statement for immediate access to all functions
Each indicator encapsulated as a simple function call - one line of code simplifies complexity
Technical Excellence
25+ carefully implemented moving averages and filters
Support for advanced algorithms like Kalman Filter and MAMA/FAMA
Optimized code structure for maintainability and reliability
Regular updates incorporating latest research developments
🚀 USING THIS LIBRARY
Import Library
//@version=6
import DCAUT/TA/1 as dta
indicator("Advanced Technical Analysis", overlay=true)
Basic Usage Example
// Classic moving average combination
ema20 = ta.ema(close, 20)
kama20 = dta.kama(close, 20)
plot(ema20, "EMA20", color.red, 2)
plot(kama20, "KAMA20", color.green, 2)
Advanced Trading System
// Adaptive moving average system
kama = dta.kama(close, 20, 2, 30)
= dta.mamaFama(close, 0.5, 0.05)
// Trend confirmation and entry signals
bullTrend = kama > kama and mamaValue > famaValue
bearTrend = kama < kama and mamaValue < famaValue
longSignal = ta.crossover(close, kama) and bullTrend
shortSignal = ta.crossunder(close, kama) and bearTrend
plot(kama, "KAMA", color.blue, 3)
plot(mamaValue, "MAMA", color.orange, 2)
plot(famaValue, "FAMA", color.purple, 2)
plotshape(longSignal, "Buy", shape.triangleup, location.belowbar, color.green)
plotshape(shortSignal, "Sell", shape.triangledown, location.abovebar, color.red)
📋 FUNCTIONS REFERENCE
ewma(source, alpha)
Calculates the Exponentially Weighted Moving Average with dynamic alpha parameter.
Parameters:
source (series float) : Series of values to process.
alpha (series float) : The smoothing parameter of the filter.
Returns: (float) The exponentially weighted moving average value.
dema(source, length)
Calculates the Double Exponential Moving Average (DEMA) of a given data series.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the moving average calculation.
Returns: (float) The calculated Double Exponential Moving Average value.
tema(source, length)
Calculates the Triple Exponential Moving Average (TEMA) of a given data series.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the moving average calculation.
Returns: (float) The calculated Triple Exponential Moving Average value.
zlema(source, length)
Calculates the Zero-Lag Exponential Moving Average (ZLEMA) of a given data series. This indicator attempts to eliminate the lag inherent in all moving averages.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the moving average calculation.
Returns: (float) The calculated Zero-Lag Exponential Moving Average value.
tma(source, length)
Calculates the Triangular Moving Average (TMA) of a given data series. TMA is a double-smoothed simple moving average that reduces noise.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the moving average calculation.
Returns: (float) The calculated Triangular Moving Average value.
frama(source, length)
Calculates the Fractal Adaptive Moving Average (FRAMA) of a given data series. FRAMA adapts its smoothing factor based on fractal geometry to reduce lag. Developed by John Ehlers.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the moving average calculation.
Returns: (float) The calculated Fractal Adaptive Moving Average value.
kama(source, length, fastLength, slowLength)
Calculates Kaufman's Adaptive Moving Average (KAMA) of a given data series. KAMA adjusts its smoothing based on market efficiency ratio. Developed by Perry J. Kaufman.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the efficiency calculation.
fastLength (simple int) : Fast EMA length for smoothing calculation. Optional. Default is 2.
slowLength (simple int) : Slow EMA length for smoothing calculation. Optional. Default is 30.
Returns: (float) The calculated Kaufman's Adaptive Moving Average value.
t3(source, length, volumeFactor)
Calculates the Tilson Moving Average (T3) of a given data series. T3 is a triple-smoothed exponential moving average with improved lag characteristics. Developed by Tim Tillson.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the moving average calculation.
volumeFactor (simple float) : Volume factor affecting responsiveness. Optional. Default is 0.7.
Returns: (float) The calculated Tilson Moving Average value.
ultimateSmoother(source, length)
Calculates the Ultimate Smoother of a given data series. Uses advanced filtering techniques to reduce noise while maintaining responsiveness. Based on digital signal processing principles by John Ehlers.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the smoothing calculation.
Returns: (float) The calculated Ultimate Smoother value.
kalmanFilter(source, processNoise, measurementNoise)
Calculates the Kalman Filter of a given data series. Optimal estimation algorithm that estimates true value from noisy observations. Based on the Kalman Filter algorithm developed by Rudolf Kalman (1960).
Parameters:
source (series float) : Series of values to process.
processNoise (simple float) : Process noise variance (Q). Controls adaptation speed. Optional. Default is 0.05.
measurementNoise (simple float) : Measurement noise variance (R). Controls smoothing. Optional. Default is 1.0.
Returns: (float) The calculated Kalman Filter value.
mcginleyDynamic(source, length)
Calculates the McGinley Dynamic of a given data series. McGinley Dynamic is an adaptive moving average that adjusts to market speed changes. Developed by John R. McGinley Jr.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the dynamic calculation.
Returns: (float) The calculated McGinley Dynamic value.
mama(source, fastLimit, slowLimit)
Calculates the Mesa Adaptive Moving Average (MAMA) of a given data series. MAMA uses Hilbert Transform Discriminator to adapt to market cycles dynamically. Developed by John F. Ehlers.
Parameters:
source (series float) : Series of values to process.
fastLimit (simple float) : Maximum alpha (responsiveness). Optional. Default is 0.5.
slowLimit (simple float) : Minimum alpha (smoothing). Optional. Default is 0.05.
Returns: (float) The calculated Mesa Adaptive Moving Average value.
fama(source, fastLimit, slowLimit)
Calculates the Following Adaptive Moving Average (FAMA) of a given data series. FAMA follows MAMA with reduced responsiveness for crossover signals. Developed by John F. Ehlers.
Parameters:
source (series float) : Series of values to process.
fastLimit (simple float) : Maximum alpha (responsiveness). Optional. Default is 0.5.
slowLimit (simple float) : Minimum alpha (smoothing). Optional. Default is 0.05.
Returns: (float) The calculated Following Adaptive Moving Average value.
mamaFama(source, fastLimit, slowLimit)
Calculates Mesa Adaptive Moving Average (MAMA) and Following Adaptive Moving Average (FAMA).
Parameters:
source (series float) : Series of values to process.
fastLimit (simple float) : Maximum alpha (responsiveness). Optional. Default is 0.5.
slowLimit (simple float) : Minimum alpha (smoothing). Optional. Default is 0.05.
Returns: ( ) Tuple containing values.
laguerreFilter(source, length, gamma, order)
Calculates the standard N-order Laguerre Filter of a given data series. Standard Laguerre Filter uses uniform weighting across all polynomial terms. Developed by John F. Ehlers.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Length for UltimateSmoother preprocessing.
gamma (simple float) : Feedback coefficient (0-1). Lower values reduce lag. Optional. Default is 0.8.
order (simple int) : The order of the Laguerre filter (1-10). Higher order increases lag. Optional. Default is 8.
Returns: (float) The calculated standard Laguerre Filter value.
laguerreBinomialFilter(source, length, gamma)
Calculates the Laguerre Binomial Filter of a given data series. Uses 6-pole feedback with binomial weighting coefficients. Developed by John F. Ehlers.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Length for UltimateSmoother preprocessing.
gamma (simple float) : Feedback coefficient (0-1). Lower values reduce lag. Optional. Default is 0.5.
Returns: (float) The calculated Laguerre Binomial Filter value.
superSmoother(source, length)
Calculates the Super Smoother of a given data series. SuperSmoother is a second-order Butterworth filter from aerospace technology. Developed by John F. Ehlers.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Period for the filter calculation.
Returns: (float) The calculated Super Smoother value.
rangeFilter(source, length, multiplier)
Calculates the Range Filter of a given data series. Range Filter reduces noise by filtering price movements within a dynamic range.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the average range calculation.
multiplier (simple float) : Multiplier for the smooth range. Higher values increase filtering. Optional. Default is 2.618.
Returns: ( ) Tuple containing filtered value, trend direction, upper band, and lower band.
qqe(source, rsiLength, rsiSmooth, qqeFactor)
Calculates the Quantitative Qualitative Estimation (QQE) of a given data series. QQE is an improved RSI that reduces noise and provides smoother signals. Developed by Igor Livshin.
Parameters:
source (series float) : Series of values to process.
rsiLength (simple int) : Number of bars for the RSI calculation. Optional. Default is 14.
rsiSmooth (simple int) : Number of bars for smoothing the RSI. Optional. Default is 5.
qqeFactor (simple float) : QQE factor for volatility band width. Optional. Default is 4.236.
Returns: ( ) Tuple containing smoothed RSI and QQE trend line.
sslChannel(source, length)
Calculates the Semaphore Signal Level (SSL) Channel of a given data series. SSL Channel provides clear trend signals using moving averages of high and low prices.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the moving average calculation.
Returns: ( ) Tuple containing SSL Up and SSL Down lines.
ma(source, length, maType)
Calculates a Moving Average based on the specified type. Universal interface supporting all moving average algorithms.
Parameters:
source (series float) : Series of values to process.
length (simple int) : Number of bars for the moving average calculation.
maType (simple MaType) : Type of moving average to calculate. Optional. Default is SMA.
Returns: (float) The calculated moving average value based on the specified type.
atr(length, maType)
Calculates the Average True Range (ATR) using the specified moving average type. Developed by J. Welles Wilder Jr.
Parameters:
length (simple int) : Number of bars for the ATR calculation.
maType (simple MaType) : Type of moving average to use for smoothing. Optional. Default is RMA.
Returns: (float) The calculated Average True Range value.
macd(source, fastLength, slowLength, signalLength, maType, signalMaType)
Calculates the Moving Average Convergence Divergence (MACD) with customizable MA types. Developed by Gerald Appel.
Parameters:
source (series float) : Series of values to process.
fastLength (simple int) : Period for the fast moving average.
slowLength (simple int) : Period for the slow moving average.
signalLength (simple int) : Period for the signal line moving average.
maType (simple MaType) : Type of moving average for main MACD calculation. Optional. Default is EMA.
signalMaType (simple MaType) : Type of moving average for signal line calculation. Optional. Default is EMA.
Returns: ( ) Tuple containing MACD line, signal line, and histogram values.
dmao(source, fastLength, slowLength, maType)
Calculates the Dual Moving Average Oscillator (DMAO) of a given data series. Uses the same algorithm as the Percentage Price Oscillator (PPO), but can be applied to any data series.
Parameters:
source (series float) : Series of values to process.
fastLength (simple int) : Period for the fast moving average.
slowLength (simple int) : Period for the slow moving average.
maType (simple MaType) : Type of moving average to use for both calculations. Optional. Default is EMA.
Returns: (float) The calculated Dual Moving Average Oscillator value as a percentage.
continuationIndex(source, length, gamma, order)
Calculates the Continuation Index of a given data series. The index represents the Inverse Fisher Transform of the normalized difference between an UltimateSmoother and an N-order Laguerre filter. Developed by John F. Ehlers, published in TASC 2025.09.
Parameters:
source (series float) : Series of values to process.
length (simple int) : The calculation length.
gamma (simple float) : Controls the phase response of the Laguerre filter. Optional. Default is 0.8.
order (simple int) : The order of the Laguerre filter (1-10). Optional. Default is 8.
Returns: (float) The calculated Continuation Index value.
📚 RELEASE NOTES
v1.0 (2025.09.24)
✅ 25+ technical analysis functions
✅ Complete adaptive moving average series (KAMA, FRAMA, MAMA/FAMA)
✅ Advanced signal processing filters (Kalman, Laguerre, SuperSmoother, UltimateSmoother)
✅ Performance optimized with pre-calculated constants and efficient algorithms
✅ Unified function interface design following TradingView best practices
✅ Comprehensive moving average collection (DEMA, TEMA, ZLEMA, T3, etc.)
✅ Volatility and trend detection tools (QQE, SSL Channel, Range Filter)
✅ Continuation Index - Latest research from TASC 2025.09
✅ MACD and ATR calculations supporting multiple moving average types
✅ Dual Moving Average Oscillator (DMAO) for arbitrary data series analysis
EvoTrend-X Indicator — Evolutionary Trend Learner ExperimentalEvoTrend-X Indicator — Evolutionary Trend Learner
NOTE: This is an experimental Pine Script v6 port of a Python prototype. Pine wasn’t the original research language, so there may be small quirks—your feedback and bug reports are very welcome. The model is non-repainting, MTF-safe (lookahead_off + gaps_on), and features an adaptive (fitness-based) candidate selector, confidence gating, and a volatility filter.
⸻
What it is
EvoTrend-X is adaptive trend indicator that learns which moving-average length best fits the current market. It maintains a small “population” of fast EMA candidates, rewards those that align with price momentum, and continuously selects the best performer. Signals are gated by a multi-factor Confidence score (fitness, strength vs. ATR, MTF agreement) and a volatility filter (ATR%). You get a clean Fast/Slow pair (for the currently best candidate), optional HTF filter, a fitness ribbon for transparency, and a themed info panel with a one-glance STATUS readout.
Core outputs
• Selected Fast/Slow EMAs (auto-chosen from candidates via fitness learning)
• Spread cross (Fast – Slow) → visual BUY/SELL markers + alert hooks
• Confidence % (0–100): Fitness ⊕ Distance vs. ATR ⊕ MTF agreement
• Gates: Trend regime (Kaufman ER), Volatility (ATR%), MTF filter (optional)
• Candidate Fitness Ribbon: shows which lengths the learner currently prefers
• Export plot: hidden series “EvoTrend-X Export (spread)” for downstream use
⸻
Why it’s different
• Evolutionary learning (on-chart): Each candidate EMA length gets rewarded if its slope matches price change and penalized otherwise, with a gentle decay so the model forgets stale regimes. The best fitness wins the right to define the displayed Fast/Slow pair.
• Confidence gate: Signals don’t light up unless multiple conditions concur: learned fitness, spread strength vs. volatility, and (optionally) higher-timeframe trend.
• Volatility awareness: ATR% filter blocks low-energy environments that cause death-by-a-thousand-whipsaws. Your “why no signal?” answer is always visible in the STATUS.
• Preset discipline, Custom freedom: Presets set reasonable baselines for FX, equities, and crypto; Custom exposes all knobs and honors your inputs one-to-one.
• Non-repainting rigor: All MTF calls use lookahead_off + gaps_on. Decisions use confirmed bars. No forward refs. No conditional ta.* pitfalls.
⸻
Presets (and what they do)
• FX 1H (Conservative): Medium candidates, slightly higher MinConf, modest ATR% floor. Good for macro sessions and cleaner swings.
• FX 15m (Active): Shorter candidates, looser MinConf, higher ATR% floor. Designed for intraday velocity and decisive sessions.
• Equities 1D: Longer candidates, gentler volatility floor. Suits index/large-cap trend waves.
• Crypto 1H: Mid-short candidates, higher ATR% floor for 24/7 chop, stronger MinConf to avoid noise.
• Custom: Your inputs are used directly (no override). Ideal for systematic tuning or bespoke assets.
⸻
How the learning works (at a glance)
1. Candidates: A small set of fast EMA lengths (e.g., 8/12/16/20/26/34). Slow = Fast × multiplier (default ×2.0).
2. Reward/decay: If price change and the candidate’s Fast slope agree (both up or both down), its fitness increases; otherwise decreases. A decay constant slowly forgets the distant past.
3. Selection: The candidate with highest fitness defines the displayed Fast/Slow pair.
4. Signal engine: Crosses of the spread (Fast − Slow) across zero mark potential regime shifts. A Confidence score and gates decide whether to surface them.
⸻
Controls & what they mean
Learning / Regime
• Slow length = Fast ×: scales the Slow EMA relative to each Fast candidate. Larger multiplier = smoother regime detection, fewer whipsaws.
• ER length / threshold: Kaufman Efficiency Ratio; above threshold = “Trending” background.
• Learning step, Decay: Larger step reacts faster to new behavior; decay sets how quickly the past is forgotten.
Confidence / Volatility gate
• Min Confidence (%): Minimum score to show signals (and fire alerts). Raising it filters noise; lowering it increases frequency.
• ATR length: The ATR window for both the ATR% filter and strength normalization. Shorter = faster, but choppier.
• Min ATR% (percent): ATR as a percentage of price. If ATR% < Min ATR% → status shows BLOCK: low vola.
MTF Trend Filter
• Use HTF filter / Timeframe / Fast & Slow: HTF Fast>Slow for longs, Fast threshold; exit when spread flips or Confidence decays below your comfort zone.
2) FX index/majors, 15m (active intraday)
• Preset: FX 15m (Active).
• Gate: MinConf 60–70; Min ATR% 0.15–0.30.
• Flow: Focus on session opens (LDN/NY). The ribbon should heat up on shorter candidates before valid crosses appear—good early warning.
3) SPY / Index futures, 1D (positioning)
• Preset: Equities 1D.
• Gate: MinConf 55–65; Min ATR% 0.05–0.12.
• Flow: Use spread crosses as regime flags; add timing from price structure. For adds, wait for ER to remain trending across several bars.
4) BTCUSD, 1H (24/7)
• Preset: Crypto 1H.
• Gate: MinConf 70–80; Min ATR% 0.20–0.35.
• Flow: Crypto chops—volatility filter is your friend. When ribbon and HTF OK agree, favor continuation entries; otherwise stand down.
⸻
Reading the Info Panel (and fixing “no signals”)
The panel is your self-diagnostic:
• HTF OK? False means the higher-timeframe EMAs disagree with your intended side.
• Regime: If “Chop”, ER < threshold. Consider raising the threshold or waiting.
• Confidence: Heat-colored; if below MinConf, the gate blocks signals.
• ATR% vs. Min ATR%: If ATR% < Min ATR%, status shows BLOCK: low vola.
• STATUS (composite):
• BLOCK: low vola → increase Min ATR% down (i.e., allow lower vol) or wait for expansion.
• BLOCK: HTF filter → disable HTF or align with the HTF tide.
• BLOCK: confidence → lower MinConf slightly or wait for stronger alignment.
• OK → you’ll see markers on valid crosses.
⸻
Alerts
Two static alert hooks:
• BUY cross — spread crosses up and all gates (ER, Vol, MTF, Confidence) are open.
• SELL cross — mirror of the above.
Create them once from “Add Alert” → choose the condition by name.
⸻
Exporting to other scripts
In your other Pine indicators/strategies, add an input.source and select EvoTrend-X → “EvoTrend-X Export (spread)”. Common uses:
• Build a rule: only trade when exported spread > 0 (trend filter).
• Combine with your oscillator: oscillator oversold and spread > 0 → buy bias.
⸻
Best practices
• Let it learn: Keep Learning step moderate (0.4–0.6) and Decay close to 1.0 (e.g., 0.99–0.997) for smooth regime memory.
• Respect volatility: Tune Min ATR% by asset and timeframe. FX 1H ≈ 0.10–0.20; crypto 1H ≈ 0.20–0.35; equities 1D ≈ 0.05–0.12.
• MTF discipline: HTF filter removes lots of “almost” trades. If you prefer aggressive entries, turn it off and rely more on Confidence.
• Confidence as throttle:
• 40–60%: exploratory; expect more signals.
• 60–75%: balanced; good daily driver.
• 75–90%: selective; catch the clean stuff.
• 90–100%: only A-setups; patient mode.
• Watch the ribbon: When shorter candidates heat up before a cross, momentum is forming. If long candidates dominate, you’re in a slower trend cycle.
⸻
Non-repainting & safety notes
• All request.security() calls use lookahead=barmerge.lookahead_off, gaps=barmerge.gaps_on.
• No forward references; decisions rely on confirmed bar data.
• EMA lengths are simple ints (no series-length errors).
• Confidence components are computed every bar (no conditional ta.* traps).
⸻
Limitations & tips
• Chop happens: ER helps, but sideways microstructure can still flicker—use Confidence + Vol filter as brakes.
• Presets ≠ oracle: They’re sensible baselines; always tune MinConf and Min ATR% to your venue and session.
• Theme “Auto”: Pine cannot read chart theme; “Auto” defaults to a Dark-friendly palette.
⸻
Publisher’s Screenshots Checklist
1) FX swing — EURUSD 1H
• Preset: FX 1H (Conservative)
• Params: MinConf=70, ATR Len=14, Min ATR%=0.12, MTF ON (TF=4H, 20/50)
• Show: Clear BUY cross, STATUS=OK, green regime background; Fitness Ribbon visible.
2) FX intraday — GBPUSD 15m
• Preset: FX 15m (Active)
• Params: MinConf=60, ATR Len=14, Min ATR%=0.20, MTF ON (TF=60m)
• Show: SELL cross near London session open. HTF lines enabled (translucent).
• Caption: “GBPUSD 15m • Active session sell with MTF alignment.”
3) Indices — SPY 1D
• Preset: Equities 1D
• Params: MinConf=60, ATR Len=14, Min ATR%=0.08, MTF ON (TF=1W, 20/50)
• Show: Longer trend run after BUY cross; regime shading shows persistence.
• Caption: “SPY 1D • Trend run after BUY cross; weekly filter aligned.”
4) Crypto — BINANCE:BTCUSDT 1H
• Preset: Crypto 1H
• Params: MinConf=75, ATR Len=14, Min ATR%=0.25, MTF ON (TF=4H)
• Show: BUY cross + quick follow-through; Ribbon warming (reds/yellows → greens).
• Caption: “BTCUSDT 1H • Momentum break with high confidence and ribbon turning.”
JFC 21:52JFC 21:52 — Brief Description
Concept: Pure time/price rule, no indicators.
Reference: Close at 21:20 (chart/exchange timezone).
Entry (21:52):
– LONG if price is below the 21:20 close.
– SHORT if price is above the 21:20 close.
– Equal → no trade.
Exit: Force close at 22:13.
Frequency: Max one trade per day.
Note: Use 1-minute resolution and the correct chart timezone; market must be trading at those times.
EMA ± ATR Channel (True Range)EMA ± ATR Channel (True Range)
Tagline: Adaptive EMA channel with ATR-based volatility bands — perfect for swing trading, intraday setups, and managing risk on high-volatility stocks.
This script plots a dynamic price channel around a configurable EMA using the Average True Range (ATR, Wilder’s True Range) as a volatility buffer.
Upper band = EMA + (ATR × multiplier)
Lower band = EMA – (ATR × multiplier)
📊 Features:
Adjustable EMA length, ATR length, and ATR multiplier
Visual channel fill between upper and lower bands
Optional on-chart help panel with practical combos
⚡ Practical Combos for Volatile Stocks:
EMA 20 + ATR 14 × 2.0 → most common swing trading setup
EMA 10 + ATR 14 × 1.5 → very responsive, good for intraday/high-beta names
EMA 20 + ATR 20 × 2.5 → smoother, wider channel, avoids whipsaws in chaotic stocks
✅ Use cases:
Identify dynamic support/resistance zones
Volatility-based stop-loss & take-profit placement
Spot overextensions from the trend midline
🔖 Tags:
ema, atr, channel, volatility, trend, support resistance, stop loss, swing trading, intraday, risk management, indicator
Supertrend DashboardOverview
This dashboard is a multi-timeframe technical indicator dashboard based on Supertrend. It combines:
Trend detection via Supertrend
Momentum via RSI and OBV (volume)
Volatility via a basic candle-based metric (bs)
Trend strength via ADX
Multi-timeframe analysis to see whether the trend is bullish across different timeframes
It then displays this info in a table on the chart with colors for quick visual interpretation.
2️⃣ Inputs
Dashboard settings:
enableDashboard: Toggle the dashboard on/off
locationDashboard: Where the table appears (Top right, Bottom left, etc.)
sizeDashboard: Text size in the table
strategyName: Custom name for the strategy
Indicator settings:
factor (Supertrend factor): Controls how far the Supertrend lines are from price
atrLength: ATR period for Supertrend calculation
rsiLength: Period for RSI calculation
Visual settings:
colorBackground, colorFrame, colorBorder: Control dashboard style
3️⃣ Core Calculations
a) Supertrend
Supertrend is a trend-following indicator that generates bullish or bearish signals.
Logic:
Compute ATR (atr = ta.atr(atrLength))
Compute preliminary bands:
upperBand = src + factor * atr
lowerBand = src - factor * atr
Smooth bands to avoid false flips:
lowerBand := lowerBand > prevLower or close < prevLower ? lowerBand : prevLower
upperBand := upperBand < prevUpper or close > prevUpper ? upperBand : prevUpper
Determine direction (bullish / bearish):
dir = 1 → bullish
dir = -1 → bearish
Supertrend line = lowerBand if bullish, upperBand if bearish
Output:
st → line to plot
bull → boolean (true = bullish)
b) Buy / Sell Trigger
Logic:
bull = ta.crossover(close, supertrend) → close crosses above Supertrend → buy signal
bear = ta.crossunder(close, supertrend) → close crosses below Supertrend → sell signal
trigger → checks which signal was most recent:
trigger = ta.barssince(bull) < ta.barssince(bear) ? 1 : 0
1 → Buy
0 → Sell
c) RSI (Momentum)
rsi = ta.rsi(close, rsiLength)
Logic:
RSI > 50 → bullish
RSI < 50 → bearish
d) OBV / Volume Trend (vosc)
OBV tracks whether volume is pushing price up or down.
Manual calculation (safe for all Pine versions):
obv = ta.cum( math.sign( nz(ta.change(close), 0) ) * volume )
vosc = obv - ta.ema(obv, 20)
Logic:
vosc > 0 → bullish
vosc < 0 → bearish
e) Volatility (bs)
Measures how “volatile” the current candle is:
bs = ta.ema(math.abs((open - close) / math.max(high - low, syminfo.mintick) * 100), 3)
Higher % → stronger candle moves
Displayed on dashboard as a number
f) ADX (Trend Strength)
= ta.dmi(14, 14)
Logic:
adx > 20 → Trending
adx < 20 → Ranging
g) Multi-Timeframe Supertrend
Timeframes: 1m, 3m, 5m, 10m, 15m, 30m, 1H, 2H, 4H, 12H, 1D
Logic:
for tf in timeframes
= request.security(syminfo.tickerid, tf, f_supertrend(ohlc4, factor, atrLength))
array.push(tf_bulls, bull_tf ? 1.0 : 0.0)
bull_tf ? 1.0 : 0.0 → converts boolean to number
Then we calculate user rating:
userRating = (sum of bullish timeframes / total timeframes) * 10
0 → Strong Sell, 10 → Strong Buy
4️⃣ Dashboard Table Layout
Row Column 0 (Label) Column 1 (Value)
0 Strategy strategyName
1 Technical Rating textFromRating(userRating) (color-coded)
2 Current Signal Buy / Sell (based on last Supertrend crossover)
3 Current Trend Bullish / Bearish (based on Supertrend)
4 Trend Strength bs %
5 Volume vosc → Bullish/Bearish
6 Volatility adx → Trending/Ranging
7 Momentum RSI → Bullish/Bearish
8 Timeframe Trends 📶 Merged cell
9-19 1m → Daily Bullish/Bearish for each timeframe (green/red)
5️⃣ Color Logic
Green shades → bullish / trending / buy
Red / orange → bearish / weak / sell
Yellow → neutral / ranging
Example:
dashboard_cell_bg(1, 1, colorFromRating(userRating))
dashboard_cell_bg(1, 2, trigger ? color.green : color.red)
dashboard_cell_bg(1, 3, superBull ? color.green : color.red)
Makes the dashboard visually intuitive
6️⃣ Key Logic Flow
Calculate Supertrend on current timeframe
Detect buy/sell triggers based on crossover
Calculate RSI, OBV, Volatility, ADX
Request Supertrend on multiple timeframes → convert to 1/0
Compute user rating (percentage of bullish timeframes)
Populate dashboard table with colors and values
✅ The result: You get a compact, fast, multi-timeframe trend dashboard that shows:
Current signal (Buy/Sell)
Current trend (Bullish/Bearish)
Momentum, volatility, and volume cues
Trend across multiple timeframes
Overall technical rating
It’s essentially a full trend-strength scanner directly on your chart.
SATHYA SMA SignalThis indicator overlays 20, 50, and 200 Simple Moving Averages (SMAs) on the chart. It generates bullish signals when the 20 SMA crosses above the 200 SMA before the 50 SMA, with both above 200 SMA. Bearish signals occur when the 20 SMA crosses below the 200 SMA before the 50 SMA, with both below 200 SMA. Signals appear as distinct triangles on the chart, helping traders identify trend reversals based on systematic SMA crossovers and order of crossing.
SATHYA SMA Signal)This indicator overlays 20, 50, and 200 Simple Moving Averages (SMAs) on the chart. It generates bullish signals when the 20 SMA crosses above the 200 SMA before the 50 SMA, with both above 200 SMA. Bearish signals occur when the 20 SMA crosses below the 200 SMA before the 50 SMA, with both below 200 SMA. Signals appear as distinct triangles on the chart, helping traders identify trend reversals based on systematic SMA crossovers and order of crossing.
DrFX Reversal Algo - MACD-RSI System with Dynamic Zone Filtering**DrFX Reversal Algo** is a sophisticated reversal detection system that combines MACD momentum analysis with RSI confirmation and dynamic support/resistance zone filtering. This indicator employs advanced mathematical filtering techniques to identify high-probability reversal points while minimizing false signals through intelligent zone-based filtering.
**Core Innovation & Originality**
This system uniquely integrates four key analytical components:
1. **Enhanced MACD Engine** - Customizable fast (20), slow (50), and signal (12) lengths with crossover/crossunder detection optimized for reversal identification
2. **RSI Power Classification** - 14-period RSI used to classify signal strength and trend bias, distinguishing between "Strong" and regular signals
3. **Kalman-Filtered Dynamic Zones** - Advanced mathematical smoothing of support/resistance levels using Kalman filter algorithms for noise reduction
4. **Gradient-Based Visual System** - Power-weighted bar coloring that visualizes trend strength using MACD histogram and RSI signal intensity
**System Architecture & Functionality**
**Signal Generation Methodology:**
The core algorithm detects MACD line crossovers above and below the signal line, then applies RSI-based classification. When RSI signal (RSI-50) is positive during bullish MACD crossovers, the system generates "Strong Buy" signals. When RSI signal is negative or neutral, it produces regular "Buy" signals. The inverse logic applies for sell signals.
**Dynamic Zone Calculation:**
Support and resistance zones are calculated using a multi-step process:
1. **Volatility Bands**: ATR-based upper/lower bands using (high+low)/2 ± ATR * multiplier
2. **Precise Zone Definition**: Integration of 20-period highest/lowest calculations with volatility bands
3. **Kalman Filter Smoothing**: Advanced noise reduction using configurable Q (0.01) and R (0.1) parameters
4. **Zone Validation**: Real-time adjustment based on price action and volatility changes
**Kalman Filter Implementation:**
The system employs a custom Kalman filter function for zone smoothing:
```
kf_k = kf_p / (kf_p + kf_r)
kf_x = kf_k * input + (1 - kf_k) * previous_estimate
kf_p = (1 - kf_k) * kf_p + kf_q
```
This mathematical approach reduces zone boundary noise while maintaining responsiveness to genuine support/resistance level changes.
**Unique Visual Features**
**Power-Based Gradient System:**
Bar coloring utilizes a sophisticated gradient calculation based on MACD histogram power (absolute value) and RSI signal strength. The system creates dynamic color transitions:
- **Bullish Gradient**: Green spectrum (0-255 intensity) based on histogram power
- **Bearish Gradient**: Red spectrum (0-255 intensity) based on histogram power
- **Consolidation**: Mixed gradient indicating uncertain market conditions
**Dynamic Zone Visualization:**
- **Support Zones**: Blue-filled areas between smoothed support boundaries
- **Resistance Zones**: Red-filled areas between smoothed resistance boundaries
- **Zone Adaptation**: Real-time boundary adjustment based on volatility and price action
**Signal Classification System**
**Signal Strength Hierarchy:**
1. **Strong Buy**: MACD bullish crossover + RSI signal > 0 (above 50-line)
2. **Regular Buy**: MACD bullish crossover + RSI signal ≤ 0 (below 50-line)
3. **Strong Sell**: MACD bearish crossover + RSI signal < 0 (below 50-line)
4. **Regular Sell**: MACD bearish crossover + RSI signal ≥ 0 (above 50-line)
**Optional Zone Filtering:**
When enabled, the system only displays signals when:
- Buy signals: Price above smoothed support zone end
- Sell signals: Price below smoothed resistance zone start
**Usage Instructions**
**Primary Signal Interpretation:**
- **Large Green Triangles**: Strong buy signals with RSI confirmation above 50
- **Small Green Triangles**: Regular buy signals with RSI below 50
- **Large Red Triangles**: Strong sell signals with RSI confirmation below 50
- **Small Red Triangles**: Regular sell signals with RSI above 50
**Zone Analysis:**
- **Blue Zones**: Dynamic support areas where buying interest may emerge
- **Red Zones**: Dynamic resistance areas where selling pressure may increase
- **Zone Breaks**: Price movement outside zones indicates potential trend continuation
**Bar Color Interpretation:**
- **Bright Green**: Strong bullish momentum (high MACD histogram power + positive RSI)
- **Dark Green**: Moderate bullish momentum
- **Bright Red**: Strong bearish momentum (high MACD histogram power + negative RSI)
- **Dark Red**: Moderate bearish momentum
- **Mixed Colors**: Consolidation or uncertain trend direction
**Optimal Usage Strategies:**
1. **Reversal Trading**: Focus on signals occurring near zone boundaries
2. **Confirmation Trading**: Use zone filter to reduce false signals in trending markets
3. **Momentum Trading**: Prioritize "Strong" signals with bright gradient bar coloring
4. **Multi-Timeframe**: Combine with higher timeframe trend analysis for context
**Parameter Customization**
**MACD Settings:**
- **Fast Length (20)**: Shorter periods increase sensitivity
- **Slow Length (50)**: Longer periods reduce noise
- **Signal Smoothing (12)**: Affects crossover signal timing
**Support/Resistance Settings:**
- **Volatility Period (10)**: ATR calculation period for zone width
- **Multiplier (5.0)**: Zone expansion factor based on volatility
**Visual Settings:**
- **Gradient Range (2000)**: Controls color intensity scaling
- **Zone Filtering**: Enables/disables signal filtering based on zone position
**Advanced Features**
**Alert System:**
Comprehensive alert functionality with detailed messages including symbol, timeframe, current price, and signal type. Separate enable/disable options for long and short alerts.
**Mathematical Precision:**
The Kalman filter implementation provides superior noise reduction compared to simple moving averages while maintaining responsiveness to genuine market structure changes.
**Important Considerations**
This system works optimally in markets with clear support/resistance levels and moderate volatility. The Kalman filter smoothing may introduce slight lag during rapid market movements. Strong signals generally provide higher probability setups but may be less frequent than regular signals.
The algorithm combines established techniques (MACD, RSI) with advanced filtering and zone detection methodologies. The integration of multiple confirmation methods helps reduce false signals while maintaining sensitivity to genuine reversal opportunities.
**Disclaimer**: This indicator is designed for educational and analytical purposes. Past performance does not guarantee future results. The system's effectiveness varies across different market conditions and timeframes. Always implement proper risk management and consider multiple confirmation methods before making trading decisions.
Candle Suite PRO – Engulf + Pin + Regime Filters + Trigger//@version=5
indicator("Candle Suite PRO – Engulf + Pin + Regime Filters + Trigger", overlay=true, max_labels_count=500)
//===================== Inputs =====================
grpPtn = "Patterns"
useEngulf = input.bool(true, "Enable Engulfing", group=grpPtn)
usePin = input.bool(true, "Enable Pin Bar", group=grpPtn)
pinRatio = input.float(2.0, "PinBar shadow >= body ×", group=grpPtn, step=0.1, minval=1)
minBodyP = input.float(0.15, "Min Body% of Range (0~1)", group=grpPtn, step=0.01, minval=0, maxval=1)
coolBars = input.int(3, "Cooldown bars", group=grpPtn, minval=0)
grpReg = "Regime Filters"
useHTF = input.bool(true, "Use HTF EMA50 Filter", group=grpReg)
htfTF = input.timeframe("60", "HTF timeframe", group=grpReg) // 5m/15m → 60 권장
useADX = input.bool(true, "Use ADX Trend Filter", group=grpReg)
adxLen = input.int(14, "ADX Length", group=grpReg, minval=5)
adxMin = input.int(18, "ADX Min Threshold", group=grpReg, minval=5)
useVOL = input.bool(true, "Use Volume Filter (> SMA×k)",group=grpReg)
volMult = input.float(1.10, "k for Volume", group=grpReg, step=0.05)
emaPinchPc = input.float(0.15, "No-Trade if |EMA20-50| < %", group=grpReg, step=0.05)/100.0
maxDistATR = input.float(1.5, "No-Trade if |Close-EMA20| > ATR×", group=grpReg, step=0.1)
useVWAP = input.bool(true, "Require close above/below VWAP", group=grpReg)
//===================== Helpers ====================
ema20 = ta.ema(close, 20)
ema50 = ta.ema(close, 50)
atr14 = ta.atr(14)
vwap = ta.vwap(hlc3)
rng = high - low
body = math.abs(close - open)
upper = high - math.max(open, close)
lower = math.min(open, close) - low
bull = close > open
bear = close < open
bodyOK = rng > 0 ? (body / rng) >= minBodyP : false
//===================== Patterns ===================
prevOpen = open
prevClose = close
prevBull = prevClose > prevOpen
prevBear = prevClose < prevOpen
bullEngulf_raw = useEngulf and prevBear and bull and (open <= prevClose) and (close >= prevOpen) and bodyOK
bearEngulf_raw = useEngulf and prevBull and bear and (open >= prevClose) and (close <= prevOpen) and bodyOK
bullPin_raw = usePin and (lower >= pinRatio * body) and (upper <= body) and bodyOK // Hammer
bearPin_raw = usePin and (upper >= pinRatio * body) and (lower <= body) and bodyOK // Shooting Star
//================= Regime & No-trade ===============
// HTF trend (EMA50 on higher TF)
emaHTF50 = request.security(syminfo.tickerid, htfTF, ta.ema(close, 50))
htfLong = not useHTF or close > emaHTF50
htfShort = not useHTF or close < emaHTF50
// ADX (manual, version-safe)
len = adxLen
upMove = high - high
downMove = low - low
plusDM = (upMove > downMove and upMove > 0) ? upMove : 0.0
minusDM = (downMove > upMove and downMove > 0) ? downMove : 0.0
trur = ta.rma(ta.tr(true), len)
plusDI = 100 * ta.rma(plusDM, len) / trur
minusDI = 100 * ta.rma(minusDM, len) / trur
dx = 100 * math.abs(plusDI - minusDI) / math.max(plusDI + minusDI, 1e-10)
adxVal = ta.rma(dx, len)
trendOK = not useADX or adxVal >= adxMin
// Volume
volOK = not useVOL or (volume >= ta.sma(volume, 20) * volMult)
// Alignment & slope
slopeUp = ema20 > ema20
slopeDown = ema20 < ema20
alignLong = ema20 > ema50 and slopeUp
alignShort = ema20 < ema50 and slopeDown
// Chop / distance / VWAP
pinch = math.abs(ema20 - ema50) / close < emaPinchPc
tooFar = math.abs(close - ema20) / atr14 > maxDistATR
vwapOKL = not useVWAP or close > vwap
vwapOKS = not useVWAP or close < vwap
//================= Final Setups ====================
longSetup_raw = bullEngulf_raw or bullPin_raw
shortSetup_raw = bearEngulf_raw or bearPin_raw
longSetup = longSetup_raw and alignLong and htfLong and trendOK and volOK and not pinch and not tooFar and vwapOKL
shortSetup = shortSetup_raw and alignShort and htfShort and trendOK and volOK and not pinch and not tooFar and vwapOKS
// Trigger: 다음 봉이 전봉의 고/저 돌파 + 종가 확인
longTrig = longSetup and high > high and close > ema20
shortTrig = shortSetup and low < low and close < ema20
// Cooldown & final signals
var int lastLong = na
var int lastShort = na
canLong = na(lastLong) or (bar_index - lastLong > coolBars)
canShort = na(lastShort) or (bar_index - lastShort > coolBars)
finalLong = longTrig and canLong
finalShort = shortTrig and canShort
if finalLong
lastLong := bar_index
if finalShort
lastShort := bar_index
//==================== Plots ========================
plot(ema20, "EMA 20", color=color.new(color.orange, 0))
plot(ema50, "EMA 50", color=color.new(color.blue, 0))
plot(useVWAP ? vwap : na, "VWAP", color=color.new(color.purple, 0))
plotshape(finalLong, title="LONG ▶", style=shape.labelup, location=location.belowbar, text="Long▶", color=color.new(color.blue, 0), size=size.tiny)
plotshape(finalShort, title="SHORT ▶", style=shape.labeldown, location=location.abovebar, text="Short▶", color=color.new(color.red, 0), size=size.tiny)
// Alerts
alertcondition(finalLong, "LONG ▶", "Long trigger")
alertcondition(finalShort, "SHORT ▶", "Short trigger")
// 시각적 노트레이드 힌트
bgcolor(pinch ? color.new(color.gray, 92) : na)
Tape Speed Pulse (Pace + Direction) [v6 + Climax]Tape Speed Pulse (Pace + Direction)
One-liner:
A lightweight “tape pulse” that turns intraday bursts of buying/selling into an easy-to-read histogram, with surge, slowdown, and climax (exhaustion) markers for fast decision-making. Use on sec and min charts.
What it measures
Pace (RVOL): current bar volume vs the recent average (smoothed).
Direction proxy: uptick/downtick by comparing close to close .
Pulse (histogram): direction × pace, so you see who’s pushing and how fast.
Colors
- Lime = Buy surge (pace ≥ threshold & upticking)
- Red = Sell surge (pace ≥ threshold & downticking)
- Teal = Buy pressure, sub-threshold
- Orange = Sell pressure, sub-threshold
- Faded/gray = Near-neutral pace (below the Neutral Band)
Lines (toggleable)
-White = Pace (RVOL)
- Yellow = Slowdown line = a drop of X% from the last 30-bar peak pace
Background tint mirrors the current state so you can glance risk: greenish for buy pressure, reddish for sell pressure.
Signals & alerts
- BUY surge – fires when pace crosses above the surge threshold with uptick direction (optional acceleration & uptick streak filters; cooldown prevents spam).
- SELL surge – mirror logic to downside.
- Slowdown – fires when pace crosses below the yellow slowdown line while direction ≤ 0 (early fade warning).
Climax (exhaustion)
- Buy Climax: previous bar was a buy surge with a large upper wick; current bar slows (below slowdown line) and direction ≤ 0.
- Sell Climax: mirror (large lower wick → slowdown → direction ≥ 0).
- Great for trimming/tight stops or fade setups at obvious spikes.
- Create alerts via Add alert → Condition: this indicator → choose the specific alert (BUY surge, SELL surge, Slowdown, Buy Climax, Sell Climax).
How to use it (playbook)
- Longs (e.g., VWAP reclaim / micro pullback)
- Only take entries when the pulse is teal→lime (buy pressure to buy surge).
- Into prior highs/VWAP bands, take partials on lime spikes.
- If you get a Slowdown dot and bars turn orange/red, tighten or exit.
Shorts (failed reclaim / lower-high)
- Look for teal→orange→red with rising pace at a level.
- Add confidence if a Buy Climax printed right before (exhaustion).
- Risk above the spike; don’t fight true ignitions out of bases.
Simple guardrails
- Avoid new longs when the histogram is orange/red; avoid new shorts when teal/lime.
- Use with VWAP + 9/20 EMA or your levels. The pulse is confirmation, not the whole thesis.
Inputs (what they do & when to tweak)
- Pace lookback (bars) – window for average volume. Lower = faster; higher = steadier.
Too jumpy? raise it. Missing quick bursts? lower it.
- Smoothing EMA (bars) – smooths pace. Higher = calmer.
Use 4–6 during the open; 3–4 midday.
- Surge threshold (× RVOL) – how fast counts as a surge.
Too many surges? raise it. Too late? lower it slightly.
- Slowdown drop from 30-bar max (%) – how far below the recent peak pace to call a slowdown.
Higher % = later slowdown; lower % = earlier warning.
- Neutral band (× RVOL) – paces below this fade to gray.
Raise to clean up noise; lower to see subtle pressure.
- Min seconds between signals – cooldown to prevent spam.
Increase in chop; reduce if you want more pings.
- BUY/SELL: min consecutive upticks/downticks – tiny streak filter.
Raise to avoid wiggles; lower for earlier signals.
Require pace accelerating into signal – ON = avoid stall breakouts; OFF = earlier pings.
Climax options: wick % threshold & “require slowdown cross”.
Raise wick% / require cross to be stricter; lower to catch more fades.
Quick presets
- Low-float runner, 5–10s chart
- Lookback 20, Smoothing 3–4, Surge 2.2–2.8, Slowdown 35–45, Neutral 1.0–1.2, Cooldown 15–25s, Streaks 2–3, Accel ON.
- Thick large-cap, 1-min
- Lookback 20–30, Smoothing 5–7, Surge 1.5–1.9, Slowdown 25–35, Neutral 0.8–1.0, Cooldown 30–60s, Streaks 2, Accel ON.
- Open vs Midday vs Power Hour
- Open: higher Surge, more Smoothing, longer Cooldown.
- Midday: lower Surge, less Smoothing to catch subtler pushes.
- Power hour: moderate Surge; keep Slowdown on for exits.
Reading common patterns
- Ignition (likely continuation): lime spike out of a base that holds above a level while pace stays above yellow.
- Exhaustion (likely fade): lime spike late in a run with upper wick → Slowdown → orange/red. The Buy Climax diamond is your tell.
Limits / notes
This is an OHLCV-based proxy (TradingView Pine can’t read raw tape/DOM). It won’t match Bookmap/Jigsaw tick-for-tick, but it’s fast and objective.
Use with levels and a risk plan. Past performance ≠ future results. Educational only.
Extremum Range MA Crossover Strategy1. Principle of Work & Strategy Logic ⚙️📈
Main idea: The strategy tries to catch the moment of a breakout from a price consolidation range (flat) and the start of a new trend. It combines two key elements:
Moving Average (MA) 📉: Acts as a dynamic support/resistance level and trend filter.
Range Extremes (Range High/Low) 🔺🔻: Define the borders of the recent price channel or consolidation.
The strategy does not attempt to catch absolute tops and bottoms. Instead, it enters an already formed move after the breakout, expecting continuation.
Type: Trend-following, momentum-based.
Timeframes: Works on different TFs (H1, H4, D), but best suited for H4 and higher, where breakouts are more meaningful.
2. Justification of Indicators & Settings ⚙️
A. Moving Average (MA) 📊
Why used: Core of the strategy. It smooths price fluctuations and helps define the trend. The price (via extremes) must cross the MA → signals a potential trend shift or strengthening.
Parameters:
maLength = 20: Default length (≈ one trading month, 20-21 days). Good balance between sensitivity & smoothing.
Lower TF → reduce (10–14).
Higher TF → increase (50).
maSource: Defines price source (default = Close). Alternatives (HL2, HLC3) → smoother, less noisy MA.
maType: Default = EMA (Exponential MA).
Why EMA? Faster reaction to recent price changes vs SMA → useful for breakout strategies.
Other options:
SMA 🟦 – classic, slowest.
WMA 🟨 – weights recent data stronger.
HMA 🟩 – near-zero lag, but “nervous,” more false signals.
DEMA/TEMA 🟧 – even faster & more sensitive than EMA.
VWMA 🔊 – volume-weighted.
ZLEMA ⏱ – reduced lag.
👉 Choice = tradeoff between speed of reaction & false signals.
B. Range Extremes (Previous High/Low) 📏
Why used: Define borders of recent trading range.
prevHigh = local resistance.
prevLow = local support.
Break of these levels on close = trigger.
Parameters:
lookbackPeriod = 5: Searches for highest high / lowest low of last 5 candles. Very recent range.
Higher value (10–20) → wider, stronger ranges but rarer signals.
3. Entry & Exit Rules 🎯
Long signals (BUY) 🟢📈
Condition (longCondition): Previous Low crosses MA from below upwards.
→ Price bounced from the bottom & strong enough to push range border above MA.
Execution: Auto-close short (if any) → open long.
Short signals (SELL) 🔴📉
Condition (shortCondition): Previous High crosses MA from above downwards.
→ Price rejected from the top, upper border failed above MA.
Execution: Auto-close long (if any) → open short.
Exit conditions 🚪
Exit Long (exitLongCondition): Close below prevLow.
→ Uptrend likely ended, range shifts down.
Exit Short (exitShortCondition): Close above prevHigh.
→ Downtrend likely ended, range shifts up.
⚠️ Important: Exit = only on candle close beyond extremes (not just wick).
4. Trading Settings ⚒️
overlay = true → indicators shown on chart.
initial_capital = 10000 💵.
default_qty_type = strategy.cash, default_qty_value = 100 → trades fixed $100 per order (not lots). Can switch to % of equity.
commission_type = strategy.commission.percent, commission_value = 0.1 → default broker fee = 0.1%. Adjust for your broker!
slippage = 3 → slippage = 3 ticks. Adjust to asset liquidity.
currency = USD.
margin_long = 100, margin_short = 100 → no leverage (100% margin).
5. Visualization on Chart 📊
The strategy draws 3 lines:
🔵 MA line (thickness 2).
🔴 Previous High (last N candles).
🟢 Previous Low (last N candles).
Also: entry/exit arrows & equity curve shown in backtest.
Disclaimer ⚠️📌
Risk Warning: This description & code are for educational purposes only. Not financial advice. Trading (Forex, Stocks, Crypto) carries high risk and may lead to full capital loss. You trade at your own risk.
Testing: Always backtest & demo test first. Past results ≠ future profits.
Responsibility: Author of this strategy & description is not responsible for your trading decisions or losses.
8MA Compass — HTF map + GC/DC cues8MA Compass provides a clean trend context by combining strict 4-of-4 confluence (Current TF vs Higher TF) with SMA200 repainting on Golden/Death Cross (GC/DC).
What it shows
4-of-4 background (context): compares EMA10, EMA20, SMA50, SMA200 on the Current TF against the same four MAs on the Higher TF (HTF).
All 4 above their HTF values → bullish background.
All 4 below their HTF values → bearish background.
SMA200 color on GC/DC (Current TF):
Last signal is DC and price below SMA200 → SMA200 turns red.
Price above SMA200 but the last signal is DC (no GC afterward) → SMA200 stays base color.
Last signal is GC and price above SMA200 → SMA200 turns green #089981.
Why “8MA” ? The 4-of-4 logic uses 8 moving averages in total: 4 on the Current TF and 4 on the HTF (EMA10/20 and SMA50/200 on both frames). HTF EMAs are used in calculations but are not plotted by default—hence the name 8MA Compass.
Auto HTF mapping
Current 1H → HTF 4H
Current 4H → HTF 1D
Current 1D → HTF 1W
All other timeframes: HTF defaults to Current TF (4-of-4 will typically be neutral).
Manual mode: choose any HTF. If Manual HTF equals Current TF, HTF SMAs are hidden to avoid overlap.
Settings
1. Display
Show CURRENT TF — plot EMA10/20, SMA50/200 on Current TF.
Show HARD TF — plot SMA50/200 on HTF (hidden if HTF == Current TF).
HTF mode — Auto / Manual, with Hard TF (Manual) selector.
2. Filter
Show base background (4-of-4) — enable/disable confluence shading.
Epsilon (in ticks) — small tolerance in Cur vs HTF comparisons to reduce flicker.
3. Golden/Death
Color SMA200 on GC/DC (Cur TF) — repaint SMA200 on GC/DC per rules above (enabled by default).
Alerts
GC/DC (Current TF, SMA50/200): Golden Cross / Death Cross (on bar close).
EMA10/20 (Current TF): “Bull regime ON” / “Bear regime ON” on crossovers.
Optional HTF GC/DC alerts (SMA50/200 on chosen HTF).
Visual details
HTF SMA50/200 are drawn first; Current TF lines are drawn on top for clarity.
SMA200 (Current TF) is drawn last (and slightly thicker) to remain readable.
HTF EMAs are used in 4-of-4 logic but not plotted by design.
Usage
1. Use the 4-of-4 background as inter-timeframe momentum context.
2. Use SMA200 color to gauge long-term regime confirmation:
Prefer longs when last GC and price holds above SMA200 (#089981 line).
Avoid longs when last DC and price is below SMA200 (red line).
Disclaimer : For educational purposes only. Not financial advice. Trading involves risk.
Confluence Engine Confluence Engine is a practical, non-repainting decision aid that scores market conditions from −100…+100 by combining six proven modules: Trend, Momentum, Volatility, Volume, Structure, and an HTF confirmation. It’s designed for crypto, forex, indices, and stocks, and it fires entries only on confirmed bar closes.
What’s inside
Trend: EMA 20/50/200 alignment plus a Supertrend/KAMA toggle (you choose the baseline).
Momentum: RSI + MACD with confirmed-pivot divergence detection.
Volatility: ATR% and Bollinger Band width vs its average to favor expansion over chop.
Volume: OBV-style cumulative flow slope + volume surge vs SMA×multiplier.
Market Structure: Confirmed pivots, BOS (break of structure) and CHOCH (change of character).
HTF Filter: Closed higher-timeframe context via request.security(..., barmerge.gaps_on, barmerge.lookahead_off).
Why it does not repaint
Signals are computed and plotted on closed bars only.
Pivots/divergences use confirmed pivot points (no forward look).
HTF series are fetched with lookahead_off and use the last closed HTF bar in realtime.
No future bar references are used for entries or alerts.
How to use (3 steps)
Pick a timeframe pair: use a 4–6× HTF multiplier (5m→30m, 15m→1h, 1h→4h, 4h→1D, 1D→1W).
Trade with the HTF: take longs only when the HTF filter is bullish; shorts only when bearish.
Prefer expansion: act when BB width > its average and ATR% is elevated; skip most signals in compression.
Suggested presets (start here)
Crypto (BTC/ETH): 15m→1h, 1h→4h. stLen=10, stMult=3.0, bbLen=20, surgeMul=1.8–2.2, thresholds +40 / −40 (intraday can try +35 / −35).
Forex majors: 15m→1h, 1h→4h. stLen=10–14, stMult=2.5–3.0, surgeMul=1.5–1.8, thresholds +35 / −35 (swing: +45 / −45).
US equities (liquid): 5m→30m/1h, 15m→1h/2h. stMult=3.0–3.5, surgeMul=1.6–2.0, thresholds +45 / −45 to reduce chop.
Indices (ES/NQ): 5m→30m, 15m→1h. Defaults are fine; start at +40 / −40.
Gold/Oil: 15m→1h, 1h→4h. Thresholds +35 / −35, surgeMul=1.6–1.9.
Inputs (plain English)
Use Supertrend (off = KAMA): choose the trend baseline.
EMA Fast/Mid/Slow: 20/50/200 by default for classic stack.
RSI/MACD + divergence pivots: momentum and exhaustion context.
ATR Length & BB Length: volatility regime detection.
Volume SMA & Surge Multiplier: defines “meaningful” volume spikes.
Pivot left/right & “Confirm BOS/CHOCH on Close”: structure strictness.
Enable HTF & Higher Timeframe: confirms the lower timeframe direction.
Thresholds (+long / −short): when the score crosses these, you get signals.
Signals & alerts (IDs preserved)
Entry shapes plot at bar close when the score crosses thresholds.
Alerts you can enable:
CONFLUENCE LONG — long entry signal
CONFLUENCE SHORT — short entry signal
BULLISH BIAS — score turned positive
BEARISH BIAS — score turned negative
Best practices
Focus on signals with HTF agreement and volatility expansion; require volume participation (surge or rising OBV slope) for higher quality.
Raise thresholds (+45/−45 or +50/−50) to reduce whipsaws in choppy sessions.
Lower thresholds (+35/−35) only if you also require volatility/volume filters.
Performance & scope
Works across crypto/FX/equities/indices; no broker data or special feeds required.
No repainting by design; signals/alerts are computed on closed bars.
As with any tool, results vary by regime; always combine with risk management.
Disclosure
This script is for educational purposes only and is not financial advice. Trading involves risk. Test on historical data and paper trade before using live.
Hilly's Advanced Crypto Scalping Strategy - 5 Min ChartTo determine the "best" input parameters for the Advanced Crypto Scalping Strategy on a 5-minute chart, we need to consider the goals of optimizing for profitability, minimizing false signals, and adapting to the volatile nature of cryptocurrencies. The default parameters in the script are a starting point, but the optimal values depend on the specific cryptocurrency pair, market conditions, and your risk tolerance. Below, I'll provide recommended input values based on common practices in crypto scalping, along with reasoning for each parameter. I’ll also suggest how to fine-tune them using TradingView’s backtesting and optimization tools.
Recommended Input Parameters
These values are tailored for a 5-minute chart for liquid cryptocurrencies like BTC/USD or ETH/USD on exchanges like Binance or Coinbase. They aim to balance signal frequency and accuracy for day trading.
Fast EMA Length (emaFastLen): 9
Reasoning: A 9-period EMA is commonly used in scalping to capture short-term price movements while remaining sensitive to recent price action. It reacts faster than the default 10, aligning with the 5-minute timeframe.
Slow EMA Length (emaSlowLen): 21
Reasoning: A 21-period EMA provides a good balance for identifying the broader trend on a 5-minute chart. It’s slightly longer than the default 20 to reduce noise while confirming the trend direction.
RSI Length (rsiLen): 14
Reasoning: The default 14-period RSI is a standard choice for momentum analysis. It works well for detecting overbought/oversold conditions without being too sensitive on short timeframes.
RSI Overbought (rsiOverbought): 75
Reasoning: Raising the overbought threshold to 75 (from 70) reduces false sell signals in strong bullish trends, which are common in crypto markets.
RSI Oversold (rsiOversold): 25
Reasoning: Lowering the oversold threshold to 25 (from 30) filters out weaker buy signals, ensuring entries occur during stronger reversals.
MACD Fast Length (macdFast): 12
Reasoning: The default 12-period fast EMA for MACD is effective for capturing short-term momentum shifts in crypto, aligning with scalping goals.
MACD Slow Length (macdSlow): 26
Reasoning: The default 26-period slow EMA is a standard setting that works well for confirming momentum trends without lagging too much.
MACD Signal Smoothing (macdSignal): 9
Reasoning: The default 9-period signal line is widely used and provides a good balance for smoothing MACD crossovers on a 5-minute chart.
Bollinger Bands Length (bbLen): 20
Reasoning: The default 20-period Bollinger Bands are effective for identifying volatility breakouts, which are key for scalping in crypto markets.
Bollinger Bands Multiplier (bbMult): 2.0
Reasoning: A 2.0 multiplier is standard and captures most price action within the bands. Increasing it to 2.5 could reduce signals but improve accuracy in highly volatile markets.
Stop Loss % (slPerc): 0.8%
Reasoning: A tighter stop loss of 0.8% (from 1.0%) suits the high volatility of crypto, helping to limit losses on false breakouts while keeping risk manageable.
Take Profit % (tpPerc): 1.5%
Reasoning: A 1.5% take-profit target (from 2.0%) aligns with scalping’s goal of capturing small, frequent gains. Crypto markets often see quick reversals, so a smaller target increases the likelihood of hitting profits.
Use Candlestick Patterns (useCandlePatterns): True
Reasoning: Enabling candlestick patterns (e.g., engulfing, hammer) adds confirmation to signals, reducing false entries in choppy markets.
Use Volume Filter (useVolumeFilter): True
Reasoning: The volume filter ensures signals occur during high-volume breakouts, which are more likely to sustain in crypto markets.
Signal Arrow Size (signalSize): 2.0
Reasoning: Increasing the arrow size to 2.0 (from 1.5) makes buy/sell signals more visible on the chart, especially on smaller screens or volatile price action.
Background Highlight Transparency (bgTransparency): 85
Reasoning: A slightly higher transparency (85 from 80) keeps the background highlights subtle but visible, avoiding chart clutter.
How to Apply These Parameters
Copy the Script: Use the Pine Script provided in the previous response.
Paste in TradingView: Open TradingView, go to the Pine Editor, paste the code, and click "Add to Chart."
Set Parameters: In the strategy settings, manually input the recommended values above or adjust them via the input fields.
Test on a 5-Minute Chart: Apply the strategy to a liquid crypto pair (e.g., BTC/USDT, ETH/USDT) on a 5-minute chart.
Fine-Tuning for Optimal Performance
To find the absolute best parameters for your specific trading pair and market conditions, use TradingView’s Strategy Tester and optimization features:
Backtesting:
Run the strategy on historical data for your chosen pair (e.g., BTC/USDT on Binance).
Check metrics like Net Profit, Profit Factor, Win Rate, and Max Drawdown in the Strategy Tester.
Focus on a sample period of at least 1–3 months to capture various market conditions (bull, bear, sideways).
Parameter Optimization:
In the Strategy Tester, click the settings gear next to the strategy name.
Enable optimization for key inputs like emaFastLen (test range: 7–12), emaSlowLen (15–25), slPerc (0.5–1.5), and tpPerc (1.0–3.0).
Run the optimization to find the combination with the highest net profit or best Sharpe ratio, but avoid over-optimization (curve-fitting) by testing on out-of-sample data.
Market-Specific Adjustments:
Volatile Pairs (e.g., DOGE/USDT): Use tighter stop losses (e.g., 0.5–0.7%) and smaller take-profit targets (e.g., 1.0–1.2%) to account for rapid price swings.
Stable Pairs (e.g., BTC/USDT): Slightly wider stop losses (e.g., 1.0–1.2%) and take-profit targets (e.g., 1.8–2.5%) may work better.
Trending Markets: Increase emaSlowLen (e.g., to 25–30) to follow stronger trends.
Choppy Markets: Tighten bbMult (e.g., to 1.8) and lower rsiOverbought/rsiOversold (e.g., to 70/30) to filter noise.
Forward Testing:
After backtesting, run the strategy in real-time on a demo account for 1–2 weeks to validate performance under current market conditions.
Important Notes
No Universal "Best" Numbers: Optimal parameters vary by crypto pair, exchange, and market conditions (e.g., bull vs. bear market). The suggested values are a starting point based on common scalping practices.
Risk Management: Never risk more than 1–2% of your account per trade. Adjust position sizing in TradingView’s strategy settings to align with your risk tolerance.
Market Volatility: Crypto markets are highly volatile. Test the strategy on your specific pair and adjust parameters if signals are too frequent or too rare.
Not Financial Advice: This is an educational tool. Backtest thoroughly and use a demo account before trading with real funds.
If you want me to generate a chart showing backtest performance for specific parameters or to tweak the script further (e.g., adding more indicators or adjusting signal logic), let me know!can you add clear buy ans sell signs above the candles in this codeTo add clear buy and sell signals above the candles in the provided Pine Script, I'll modify the existing code to include prominent text labels directly above (for sell signals) and below (for buy signals) the candles. These labels will be larger, color-coded, and positioned to avoid clutter, ensuring they are easily visible on the chart. The core strategy logic (EMA, RSI, MACD, Bollinger Bands, candlestick patterns, and volume filter) will remain unchanged, and I'll reuse the same artifact_id since this is an update to the previous script.AdvancedCryptoScalpingStrategy.pinex-pine
2ATR / Close %Certainly. Here is the English version of the indicator description you requested.
---
### **2ATR Stop-Loss Ratio**
This indicator provides a straightforward calculation of **what percentage a 2ATR (Average True Range) move represents relative to the current price**. It's a specialized tool designed to help traders set dynamic, volatility-based stop-loss levels.
---
### **Purpose of the Indicator**
Many traders use a **2ATR** as their standard for setting a stop-loss, believing it's a good measure of a stock's typical movement. However, it can be difficult to quickly determine the exact percentage a 2ATR drop represents from the current price. This indicator solves that problem by giving you a clear, single number that shows the **anticipated percentage loss before you even enter a position**.
---
### **How It Works**
The indicator is calculated using a simple formula:
**(2 * ATR(20) / Current Price) * 100**
* `ATR(20)`: The Average True Range over the last 20 periods. This period can be customized in the indicator's settings.
* `Current Price`: The closing price at the time of calculation.
---
### **How to Use It**
* **Assess Risk**: A higher number on the indicator means greater volatility, indicating a wider stop-loss range.
* **Set a Stop-Loss**: If the indicator shows **3%**, it means a 2ATR move is roughly a 3% change from the current price. This gives you a clear understanding of the potential loss.
* **Adjust Position Size**: If the potential percentage loss is larger than you're comfortable with, you can use this information to reduce your position size, effectively managing your risk.
This tool is especially useful for trading highly volatile stocks, as it helps you establish a clear and effective risk management strategy.
Martingale Strategy Simulator [BackQuant]Martingale Strategy Simulator
Purpose
This indicator lets you study how a martingale-style position sizing rule interacts with a simple long or short trading signal. It computes an equity curve from bar-to-bar returns, adapts position size after losing streaks, caps exposure at a user limit, and summarizes risk with portfolio metrics. An optional Monte Carlo module projects possible future equity paths from your realized daily returns.
What a martingale is
A martingale sizing rule increases stake after losses and resets after a win. In its classical form from gambling, you double the bet after each loss so that a single win recovers all prior losses plus one unit of profit. In markets there is no fixed “even-money” payout and returns are multiplicative, so an exact recovery guarantee does not exist. The core idea is unchanged:
Lose one leg → increase next position size
Lose again → increase again
Win → reset to the base size
The expectation of your strategy still depends on the signal’s edge. Sizing does not create positive expectancy on its own. A martingale raises variance and tail risk by concentrating more capital as a losing streak develops.
What it plots
Equity – simulated portfolio equity including compounding
Buy & Hold – equity from holding the chart symbol for context
Optional helpers – last trade outcome, current streak length, current allocation fraction
Optional diagnostics – daily portfolio return, rolling drawdown, metrics table
Optional Monte Carlo probability cone – p5, p16, p50, p84, p95 aggregate bands
Model assumptions
Bar-close execution with no slippage or commissions
Shorting allowed and frictionless
No margin interest, borrow fees, or position limits
No intrabar moves or gaps within a bar (returns are close-to-close)
Sizing applies to equity fraction only and is capped by your setting
All results are hypothetical and for education only.
How the simulator applies it
1) Directional signal
You pick a simple directional rule that produces +1 for long or −1 for short each bar. Options include 100 HMA slope, RSI above or below 50, EMA or SMA crosses, CCI and other oscillators, ATR move, BB basis, and more. The stance is evaluated bar by bar. When the stance flips, the current trade ends and the next one starts.
2) Sizing after losses and wins
Position size is a fraction of equity:
Initial allocation – the starting fraction, for example 0.15 means 15 percent of equity
Increase after loss – multiply the next allocation by your factor after a losing leg, for example 2.00 to double
Reset after win – return to the initial allocation
Max allocation cap – hard ceiling to prevent runaway growth
At a high level the size after k consecutive losses is
alloc(k) = min( cap , base × factor^k ) .
In practice the simulator changes size only when a leg ends and its PnL is known.
3) Equity update
Let r_t = close_t / close_{t-1} − 1 be the symbol’s bar return, d_{t−1} ∈ {+1, −1} the prior bar stance, and a_{t−1} the prior bar allocation fraction. The simulator compounds:
eq_t = eq_{t−1} × (1 + a_{t−1} × d_{t−1} × r_t) .
This is bar-based and avoids intrabar lookahead. Costs, slippage, and borrowing costs are not modeled.
Why traders experiment with martingale sizing
Mean-reversion contexts – if the signal often snaps back after a string of losses, adding size near the tail of a move can pull the average entry closer to the turn
Behavioral or microstructure edges – some rules have modest edge but frequent small whipsaws; size escalation may shorten time-to-recovery when the edge manifests
Exploration and stress testing – studying the relationship between streaks, caps, and drawdowns is instructive even if you do not deploy martingale sizing live
Why martingale is dangerous
Martingale concentrates capital when the strategy is performing worst. The main risks are structural, not cosmetic:
Loss streaks are inevitable – even with a 55 percent win rate you should expect multi-loss runs. The probability of at least one k-loss streak in N trades rises quickly with N.
Size explodes geometrically – with factor 2.0 and base 10 percent, the sequence is 10, 20, 40, 80, 100 (capped) after five losses. Without a strict cap, required size becomes infeasible.
No fixed payout – in gambling, one win at even odds resets PnL. In markets, there is no guaranteed bounce nor fixed profit multiple. Trends can extend and gaps can skip levels.
Correlation of losses – losses cluster in trends and in volatility bursts. A martingale tends to be largest just when volatility is highest.
Margin and liquidity constraints – leverage limits, margin calls, position limits, and widening spreads can force liquidation before a mean reversion occurs.
Fat tails and regime shifts – assumptions of independent, Gaussian returns can understate tail risk. Structural breaks can keep the signal wrong for much longer than expected.
The simulator exposes these dynamics in the equity curve, Max Drawdown, VaR and CVaR, and via Monte Carlo sketches of forward uncertainty.
Interpreting losing streaks with numbers
A rough intuition: if your per-trade win probability is p and loss probability is q=1−p , the chance of a specific run of k consecutive losses is q^k . Over many trades, the chance that at least one k-loss run occurs grows with the number of opportunities. As a sanity check:
If p=0.55 , then q=0.45 . A 6-loss run has probability q^6 ≈ 0.008 on any six-trade window. Across hundreds of trades, a 6 to 8-loss run is not rare.
If your size factor is 1.5 and your base is 10 percent, after 8 losses the requested size is 10% × 1.5^8 ≈ 25.6% . With factor 2.0 it would try to be 10% × 2^8 = 256% but your cap will stop it. The equity curve will still wear the compounded drawdown from the sequence that led to the cap.
This is why the cap setting is central. It does not remove tail risk, but it prevents the sizing rule from demanding impossible positions
Note: The p and q math is illustrative. In live data the win rate and distribution can drift over time, so real streaks can be longer or shorter than the simple q^k intuition suggests..
Using the simulator productively
Parameter studies
Start with conservative settings. Increase one element at a time and watch how the equity, Max Drawdown, and CVaR respond.
Initial allocation – lower base reduces volatility and drawdowns across the board
Increase factor – set modestly above 1.0 if you want the effect at all; doubling is aggressive
Max cap – the most important brake; many users keep it between 20 and 50 percent
Signal selection
Keep sizing fixed and rotate signals to see how streak patterns differ. Trend-following signals tend to produce long wrong-way streaks in choppy ranges. Mean-reversion signals do the opposite. Martingale sizing interacts very differently with each.
Diagnostics to watch
Use the built-in metrics to quantify risk:
Max Drawdown – worst peak-to-trough equity loss
Sharpe and Sortino – volatility and downside-adjusted return
VaR 95 percent and CVaR – tail risk measures from the realized distribution
Alpha and Beta – relationship to your chosen benchmark
If you would like to check out the original performance metrics script with multiple assets with a better explanation on all metrics please see
Monte Carlo exploration
When enabled, the forecast draws many synthetic paths from your realized daily returns:
Choose a horizon and a number of runs
Review the bands: p5 to p95 for a wide risk envelope; p16 to p84 for a narrower range; p50 as the median path
Use the table to read the expected return over the horizon and the tail outcomes
Remember it is a sketch based on your recent distribution, not a predictor
Concrete examples
Example A: Modest martingale
Base 10 percent, factor 1.25, cap 40 percent, RSI>50 signal. You will see small escalations on 2 to 4 loss runs and frequent resets. The equity curve usually remains smooth unless the signal enters a prolonged wrong-way regime. Max DD may rise moderately versus fixed sizing.
Example B: Aggressive martingale
Base 15 percent, factor 2.0, cap 60 percent, EMA cross signal. The curve can look stellar during favorable regimes, then a single extended streak pushes allocation to the cap, and a few more losses drive deep drawdown. CVaR and Max DD jump sharply. This is a textbook case of high tail risk.
Strengths
Bar-by-bar, transparent computation of equity from stance and size
Explicit handling of wins, losses, streaks, and caps
Portable signal inputs so you can A–B test ideas quickly
Risk diagnostics and forward uncertainty visualization in one place
Example, Rolling Max Drawdown
Limitations and important notes
Martingale sizing can escalate drawdowns rapidly. The cap limits position size but not the possibility of extended adverse runs.
No commissions, slippage, margin interest, borrow costs, or liquidity limits are modeled.
Signals are evaluated on closes. Real execution and fills will differ.
Monte Carlo assumes independent draws from your recent return distribution. Markets often have serial correlation, fat tails, and regime changes.
All results are hypothetical. Use this as an educational tool, not a production risk engine.
Practical tips
Prefer gentle factors such as 1.1 to 1.3. Doubling is usually excessive outside of toy examples.
Keep a strict cap. Many users cap between 20 and 40 percent of equity per leg.
Stress test with different start dates and subperiods. Long flat or trending regimes are where martingale weaknesses appear.
Compare to an anti-martingale (increase after wins, cut after losses) to understand the other side of the trade-off.
If you deploy sizing live, add external guardrails such as a daily loss cut, volatility filters, and a global max drawdown stop.
Settings recap
Backtest start date and initial capital
Initial allocation, increase-after-loss factor, max allocation cap
Signal source selector
Trading days per year and risk-free rate
Benchmark symbol for Alpha and Beta
UI toggles for equity, buy and hold, labels, metrics, PnL, and drawdown
Monte Carlo controls for enable, runs, horizon, and result table
Final thoughts
A martingale is not a free lunch. It is a way to tilt capital allocation toward losing streaks. If the signal has a real edge and mean reversion is common, careful and capped escalation can reduce time-to-recovery. If the signal lacks edge or regimes shift, the same rule can magnify losses at the worst possible moment. This simulator makes those trade-offs visible so you can calibrate parameters, understand tail risk, and decide whether the approach belongs anywhere in your research workflow.
Yelober - Market Internal direction+ Key levelsYelober – Market Internals + Key Levels is a focused intraday trading tool that helps you spot high-probability price direction by anchoring decisions to structure that matters: yesterday’s RTH High/Low, today’s pre-market High/Low, and a fast Value Area/POC from the prior session. Paired with a compact market internals dashboard (NYSE/NASDAQ UVOL vs. DVOL ratios, VOLD slopes, TICK/TICKQ momentum, and optional VIX trend), it gives you a real-time read on breadth so you can choose which direction to trade, when to enter (breaks, retests, or fades at PMH/PML/VAH/VAL/POC), and how to plan exits as internals confirm or deteriorate. On top of these intraday decision benefits, it also allows traders—in a very subtle but powerful way—to keep an eye on the VIX and immediately recognize significant spikes or sharp decreases that should be factored in before entering a trade, or used as a quick signal to modify an existing position. In short: clear levels for the chart, live internals for the context, and a smarter, rules-based path to execution.
# Yelober – Market Internals + Key Levels
*A TradingView indicator for session key levels + real‑time market internals (NYSE/NASDAQ TICK, UVOL/DVOL/VOLD, and VIX).*
**Script name in Pine:** `Yelober - Market Internal direction+ Key levels` (Pine v6)
---
## 1) What this indicator does
**Purpose:** Help intraday traders quickly find high‑probability reaction zones and read market internals momentum without switching charts. It overlays yesterday/today’s **automatic price levels** on your active chart and shows a **market breadth table** that summarizes NYSE/NASDAQ buying pressure and TICK direction, with an optional VIX trend read.
### Key features at a glance
* **Automatic Price Levels (overlay on chart)**
* Yesterday’s High/Low of Day (**yHoD**, **yLoD**)
* Extended Hours High/Low (**yEHH**, **yEHL**) across yesterday AH + today pre‑market
* Today’s Pre‑Market High/Low (**PMH**, **PML**)
* Yesterday’s **Value Area High/Low** (**VAH/VAL**) and **Point of Control (POC)** computed from a volume profile of yesterday’s **regular session**
* Smart de‑duplication:
* Shows **only the higher** of (yEHH vs PMH) and **only the lower** of (yEHL vs PML) to avoid redundant bands
* **Market Breadth Table (on‑chart table)**
* **NYSE ratio** = UVOL/DVOL (signed) with **VOLD slope** from session open
* **NASDAQ ratio** = UVOLQ/DVOLQ (signed) with **VOLDQ slope** from session open
* **TICK** and **TICKQ**: live cumulative ratio and short‑term slope
* **VIX** (optional): current value + slope over a configurable lookback/timeframe
* Color‑coded trends with sensible thresholds and optional normalization
---
## 2) How to use it (trader workflow)
1. **Mark your reaction zones**
* Watch **yHoD/yLoD**, **PMH/PML**, and **VAH/VAL/POC** for first touches, break/retest, and failure tests.
* Expect increased responsiveness when multiple levels cluster (e.g., PMH ≈ VAH ≈ daily pivot).
2. **Read the breadth panel for context**
* **NYSE/NASDAQ ratio** (>1 = more up‑volume than down‑volume; <−1 = down‑dominant). Strong green across both favors long setups; red favors short setups.
* **VOLD slopes** (NYSE & NASDAQ): positive and accelerating → broadening participation; negative → persistent pressure.
* **TICK/TICKQ**: cumulative ratio and **slope arrows** (↗ / ↘ / →). Use the slope to gauge **near‑term thrust or fade**.
* **VIX slope**: rising VIX (red) often coincides with risk‑off; falling VIX (green) with risk‑on.
3. **Confluence = higher confidence**
* Example: Price reclaims **PMH** while **NYSE/NASDAQ ratios** print green and **TICK slopes** point ↗ — consider break‑and‑go; if VIX slope is ↘, that adds risk‑on confidence.
* Example: Price rejects **VAH** while **VOLD slopes** roll negative and VIX ↗ — consider fade/reversal.
4. **Risk management**
* Place stops just beyond key levels tested; if breadth flips, tighten or exit.
> **Timeframes:** Works best on 1–15m charts for intraday. Value Area is computed from **yesterday’s RTH**; choose a smaller calculation timeframe (e.g., 5–15m) for stable profiles.
---
## 3) Inputs & settings (what each option controls)
### Global Style
* **Enable all automatic price levels**: master toggle for yHoD/yLoD, yEHH/yEHL, PMH/PML, VAH/VAL/POC.
* **Line style/width**: applies to all drawn levels.
* **Label size/style** and **label color linking**: use the same color as the line or override with a global label color.
* **Maximum bars lookback**: how far the script scans to build yesterday metrics (performance‑sensitive).
### Value Area / Volume Profile
* **Enable Value Area calculations** *(on by default)*: computes yesterday’s **POC**, **VAH**, **VAL** from a simplified intraday volume profile built from yesterday’s **regular session bars**.
* **Max Volume Profile Points** *(default 50)*: lower values = faster; higher = more precise.
* **Value Area Calculation Timeframe** *(default 15)*: the security timeframe used when collecting yesterday’s highs/lows/volumes.
### Individual Level Toggles & Colors
* **yHoD / yLoD** (yesterday high/low)
* **yEHH / yEHL** (yesterday AH + today pre‑market extremes)
* **PMH / PML** (today pre‑market extremes)
* **VAH / VAL / POC** (yesterday RTH value area + point of control)
### Market Breadth Panel
* **Show NYSE / NASDAQ / VIX**: choose which series to display in the table.
* **Table Position / Size / Background Color**: UI placement and legibility.
* **Slope Averaging Periods** *(default 5)*: number of recent TICK/TICKQ ratio points used in slope calculation.
* **Candles for Rate** *(default 10)* & **Normalize Rate**: VIX slope calculation as % change between `now` and `n` candles ago; normalize divides by `n`.
* **VIX Timeframe**: optionally compute VIX on a higher TF (e.g., 15, 30, 60) for a smoother regime read.
* **Volume Normalization** (NYSE & NASDAQ): display VOLD slopes scaled to `tens/thousands/millions/10th millions` for readable magnitudes; color thresholds adapt to your choice.
---
## 4) Data sources & definitions
* **UVOL/VOLD (NYSE)** and **UVOLQ/DVOLQ/VOLDQ (NASDAQ)** via `request.security()`
* **Ratio** = `UVOL/DVOL` (signed; negative when down‑volume dominates)
* **VOLD slope** ≈ `(VOLD_now − VOLD_open) / bars_since_open`, then normalized per your setting
* **TICK/TICKQ**: cumulative sum of prints this session with **positives vs negatives ratio**, plus a simple linear regression **slope** of the last `N` ratio values
* **VIX**: value and slope across a user‑selected timeframe and lookback
* **Sessions (EST/EDT)**
* **Regular:** 09:30–16:00
* **Pre‑Market:** 04:00–09:30
* **After Hours:** 16:00–20:00
* **Extended‑hours extremes** combine **yesterday AH** + **today PM**
> **Note:** All session checks are done with TradingView’s `time(…,"America/New_York")` context. If your broker’s RTH differs (e.g., futures), adjust expectations accordingly.
---
## 5) How the algorithms work (plain English)
### A) Key Levels
* **Yesterday’s RTH High/Low**: scans yesterday’s bars within 09:30–16:00 and records the extremes + bar indices.
* **Extended Hours**: scans yesterday AH and today PM to get **yEHH/yEHL**. Script shows **either yEHH or PMH** (whichever is **higher**) and **either yEHL or PML** (whichever is **lower**) to avoid duplicate bands stacked together.
* **Value Area & POC (RTH only)**
* Build a coarse volume profile with `Max Volume Profile Points` buckets across the price range formed by yesterday’s RTH bars.
* Distribute each bar’s volume uniformly across the buckets it spans (fast approximation to keep Pine within execution limits).
* **POC** = bucket with max volume. **VA** expands from POC outward until **70%** of cumulative volume is enclosed → yields **VAH/VAL**.
### B) Market Breadth Table
* **NYSE/NASDAQ Ratio**: signed UVOL/DVOL with basic coloring.
* **VOLD Slopes**: from session open to current, normalized to human‑readable units; colors flip green/red based on thresholds that map to your normalization setting (e.g., ±2M for NYSE, ±3.5×10M for NASDAQ).
* **TICK/TICKQ Slope**: linear regression over the last `N` ratio points → **↗ / → / ↘** with the rounded slope value.
* **VIX Slope**: % change between now and `n` candles ago (optionally divided by `n`). Red when rising beyond threshold; green when falling.
---
## 6) Recommended presets
* **Stocks (liquid, intraday)**
* Value Area **ON**, `Max Volume Points` = **40–60**, **Timeframe** = **5–15**
* Breadth: show **NYSE & NASDAQ & VIX**, `Slope periods` = **5–8**, `Candles for rate` = **10–20**, **Normalize VIX** = **ON**
* **Index futures / very high‑volume symbols**
* If you see Pine timeouts, set `Max Volume Points` = **20–40** or temporarily **disable Value Area**.
* Keep breadth panel **ON** (it’s light). Consider **VIX timeframe = 15/30** for regime clarity.
---
## 7) Tips, edge cases & performance
* **Performance:** The volume profile is capped (`maxBarsToProcess ≤ 500` and bucketed) to keep it responsive. If you experience slowdowns, reduce `Max Volume Points`, `Maximum bars lookback`, or disable Value Area.
* **Redundant lines:** The script **intentionally suppresses** PMH/PML when yEHH/yEHL are more extreme, and vice‑versa.
* **Label visibility:** Use `Label style = none` if you only want clean lines and read values from the right‑end labels.
* **Futures/RTH differences:** Value Area is from **yesterday’s RTH** only; for 24h instruments the RTH period may not reflect overnight structure.
* **Session transitions:** PMH/PML tracking stops as soon as RTH starts; values persist as static levels for the session.
---
## 8) Known limitations
* Uses public TradingView symbols: `UVOL`, `VOLD`, `UVOLQ`, `DVOLQ`, `VOLDQ`, `TICK`, `TICKQ`, `VIX`. If your data plan or region limits any symbol, the corresponding table rows may show `na`.
* The VA/POC approximation assumes uniform distribution of each bar’s volume across its high–low. That’s fast but not a tick‑level profile.
* Works best on US equities with standard NY session; alternative sessions may need code changes.
---
## 9) Troubleshooting
* **“Script is too slow / timed out”** → Lower `Max Volume Points`, lower `Maximum bars lookback`, or toggle **OFF** `Enable Value Area calculations` for that instrument.
* **Missing breadth values** → Ensure the symbols above load on your account; try reloading chart or switching timeframes once.
* **Overlapping labels** → Set `Label style = none` or reduce label size.
---
## 10) Version / license / contribution
* **Version:** Initial public release (Pine v6).
* **Author:** © yelober
* **License:** Free for community use and enhancement. Please keep author credit.
* **Contributing:** Open PRs/ideas: presets, alert conditions, multi‑day VA composites, optional mid‑value (`(VAH+VAL)/2`), session filter for futures, and alertable state machine for breadth regime transitions.
---
## 11) Quick start (TL;DR)
1. Add the indicator and **keep default settings**.
2. Trade **reactions** at yHoD/yLoD/PMH/PML/VAH/VAL/POC.
3. Use the **breadth table**: look for **green ratios + ↗ slopes** (risk‑on) or **red ratios + ↘ slopes** (risk‑off). Check **VIX** slope for confirmation.
4. Manage risk around levels; when breadth flips against you, tighten or exit.
---
### Changelog (public)
* **v1.0:** First community release with automatic RTH levels, VA/POC approximation, breadth dashboard (NYSE/NASDAQ/TICK/TICKQ/VIX) with normalization and adaptive color thresholds.
Pump/Dump Detector [Modular]//@version=5
indicator("Pump/Dump Detector ", overlay=true)
// ————— Inputs —————
risk_pct = input.float(1.0, "Risk %", minval=0.1)
capital = input.float(100000, "Capital")
stop_multiplier = input.float(1.5, "Stop Multiplier")
target_multiplier = input.float(2.0, "Target Multiplier")
volume_mult = input.float(2.0, "Volume Spike Multiplier")
rsi_low_thresh = input.int(15, "RSI Oversold Threshold")
rsi_high_thresh = input.int(85, "RSI Overbought Threshold")
rsi_len = input.int(2, "RSI Length")
bb_len = input.int(20, "BB Length")
bb_mult = input.float(2.0, "BB Multiplier")
atr_len = input.int(14, "ATR Length")
show_signals = input.bool(true, "Show Entry Signals")
use_orderflow = input.bool(true, "Use Order Flow Proxy")
use_ml_flag = input.bool(false, "Use ML Risk Flag")
use_session_filter = input.bool(true, "Use Volatility Sessions")
// ————— Symbol Filter (Optional) —————
symbol_nq = input.bool(true, "Enable NQ")
symbol_es = input.bool(true, "Enable ES")
symbol_gold = input.bool(true, "Enable Gold")
is_nq = str.contains(syminfo.ticker, "NQ")
is_es = str.contains(syminfo.ticker, "ES")
is_gold = str.contains(syminfo.ticker, "GC")
symbol_filter = (symbol_nq and is_nq) or (symbol_es and is_es) or (symbol_gold and is_gold)
// ————— Calculations —————
rsi = ta.rsi(close, rsi_len)
atr = ta.atr(atr_len)
basis = ta.sma(close, bb_len)
dev = bb_mult * ta.stdev(close, bb_len)
bb_upper = basis + dev
bb_lower = basis - dev
rolling_vol = ta.sma(volume, 20)
vol_spike = volume > volume_mult * rolling_vol
// ————— Session Filter (EST) —————
est_offset = -5
est_hour = (hour + est_offset + 24) % 24
session_filter = (est_hour >= 18 or est_hour < 6) or (est_hour >= 14 and est_hour < 17)
session_ok = not use_session_filter or session_filter
// ————— Order Flow Proxy —————
mfi = ta.mfi(close, 14)
buy_imbalance = ta.crossover(mfi, 50)
sell_imbalance = ta.crossunder(mfi, 50)
reversal_candle = close > open and close > ta.highest(close , 3)
// ————— ML Risk Flag (Placeholder) —————
ml_risk_flag = use_ml_flag and (ta.sma(close, 5) > ta.sma(close, 20))
// ————— Entry Conditions —————
long_cond = symbol_filter and session_ok and vol_spike and rsi < rsi_low_thresh and close < bb_lower and (not use_orderflow or (buy_imbalance and reversal_candle)) and (not use_ml_flag or ml_risk_flag)
short_cond = symbol_filter and session_ok and vol_spike and rsi > rsi_high_thresh and (not use_orderflow or sell_imbalance) and (not use_ml_flag or ml_risk_flag)
// ————— Position Sizing —————
risk_amt = capital * (risk_pct / 100)
position_size = risk_amt / atr
// ————— Plot Signals —————
plotshape(show_signals and long_cond, title="Long Signal", location=location.belowbar, color=color.green, style=shape.triangleup, size=size.small)
plotshape(show_signals and short_cond, title="Short Signal", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.small)
// ————— Alerts —————
alertcondition(long_cond, title="Long Entry Alert", message="Pump fade detected: Long setup triggered")
alertcondition(short_cond, title="Short Entry Alert", message="Dump detected: Short setup triggered")
🏆 AI Gold Master IndicatorsAI Gold Master Indicators - Technical Overview
Core Purpose: Advanced Pine Script indicator that analyzes 20 technical indicators simultaneously for XAUUSD (Gold) trading, generating automated buy/sell signals through a sophisticated scoring system.
Key Features
📊 Multi-Indicator Analysis
Processes 20 indicators: RSI, MACD, Bollinger Bands, EMA crossovers, Stochastic, Williams %R, CCI, ATR, Volume, ADX, Parabolic SAR, Ichimoku, MFI, ROC, Fibonacci retracements, Support/Resistance, Candlestick patterns, MA Ribbon, VWAP, Market Structure, and Cloud MA
Each indicator generates BUY (🟢), SELL (🔴), or NEUTRAL (⚪) signals
⚖️ Dual Scoring Systems
Weighted System: Each indicator has configurable weights (10-200 points, total 1000), with higher weights for critical indicators like RSI (150) and MACD (150)
Simple Count System: Basic counting of BUY vs SELL signals across all indicators
🎯 Signal Generation
Configurable thresholds for both systems (weighted score threshold: 400-600 recommended)
Dynamic risk management with ATR-based TP/SL levels
Signal strength filtering to reduce false positives
📈 Advanced Configuration
Customizable thresholds for all 20 indicators (RSI levels, Stochastic bounds, Williams %R zones, etc.)
Dynamic weight bonuses that adapt to dominant market trends
Risk management with configurable TP1/TP2 multipliers and stop losses
🎛️ Visual Interface
Real-time master table displaying all indicators, their values, weights, and current signals
Visual trading signals (triangles) with detailed labels
Optional TP/SL lines and performance statistics
💡 Optimization Features
Gold-specific parameter tuning
Trend analysis with configurable lookback periods
Volume spike detection and volatility analysis
Multi-timeframe compatibility (15m, 1H, 4H recommended)
The system combines traditional technical analysis with modern weighting algorithms to provide comprehensive market analysis specifically optimized for gold trading.
Ragazzi è una meraviglia, pronto all uso, già configurato provatelo divertitevi e fate tanti soldoni poi magari una piccola donazione spontanea sarebbe molto gradita visto il tempo, risorse e gli insulti della moglie che mi diceva che perdevo tempo, fatemi sapere se vi piace.
nel codice troverete una descrizione del funzionamento se vi vengono in mente delle idee per migliorarlo contattatemi troverete i mie contatti in tabella un saluto.
Asistente de Barra de Estado ADX
// This is an all-in-one indicator designed to visually represent the market environment
// based on the G2 (trend-following) and SMOG (reversal/ranging) trading systems.
// It replaces the need for a separate ADX indicator.
//
// FEATURES:
//
// 1. Multi-Timeframe ADX:
// - 5-Minute ADX (Blue Line - The "Referee"): Determines the overall market environment (Trending or Ranging).
// - 1-Minute ADX (Yellow Line - The "Trigger"): Measures immediate momentum for trade entries.
//
// 2. Environment Background Coloring:
// The indicator's own background panel changes color to provide an instant signal:
// - Green: G2 Bullish Environment (5-min ADX > 25 & Price is Trending Up)
// - Red: G2 Bearish Environment (5-min ADX > 25 & Price is Trending Down)
// - Gray: Gray Zone (Indecisive/Risky Market, 5-min ADX between 20-25)
// - Blue: SMOG Environment (Weak/Ranging Market, 5-min ADX < 20)
//
// 3. Reference Lines:
// Includes horizontal lines at the key 20 and 25 levels for easy reference.
//
// HOW TO USE:
// Use this indicator as the primary tool to decide whether to look for a G2
// (trend-following) or a SMOG (reversal) setup.
//
EMA Range OscillatorEMA Range Oscillator (ERO) - User Guide
Overview
The EMA Range Oscillator (ERO) is a technical indicator that measures the distance between two Exponential Moving Averages (EMAs) and the distance between price and EMA. It normalizes these distances into a 0-100 range, helping traders identify trend strength, market momentum, and potential reversal points.
Components
Main Line
Green Line: EMA20 > EMA50 (Uptrend)
Red Line: EMA20 < EMA50 (Downtrend)
Histogram
White Histogram: Price distance from EMA20
Key Levels
Upper Level (80): High divergence zone
Middle Level (50): Neutral zone
Lower Level (20): Low divergence zone
Parameters
ParameterDefaultDescriptionFast EMA20Short-term EMA periodSlow EMA50Long-term EMA periodNormalization Period100Lookback period for scalingUpper80Upper threshold levelLower20Lower threshold level
How to Read the Indicator
High Values (Above 80)
Strong trend in progress
EMAs are widely separated
High momentum
Potential overbought/oversold conditions
Watch for possible trend exhaustion
Low Values (Below 20)
Consolidation phase
EMAs are close together
Low volatility
Potential breakout setup
Range-bound market conditions
Middle Zone (20-80)
Normal market conditions
Moderate trend strength
Balanced momentum
Look for directional clues from color changes