EMA & VWAP Indicator with Trend Bars & Separate Time FramesEMA & VWAP Trend Indicator with Custom Time Frames + Volume Visualization
This powerful all-in-one indicator is designed for traders who rely on dynamic price action, trend confirmation, and multi-timeframe analysis.
Key Features:
7 EMAs with Custom Time Frames: Track short to long-term trends by setting individual time frames and lengths for each EMA.
VWAP Plot: Stay aligned with institutional average pricing for intraday decision-making.
Trend EMA with Color-Coded Bars: Visually identify uptrends and downtrends with automatic bar coloring based on a customizable trend EMA.
Volume with EMA Overlay: Volume spikes or fades? Instantly spot them! Includes an optional EMA on volume to help detect unusual activity or quiet zones.
Whether you're scalping intraday or riding trends across higher time frames, this indicator gives you a clear, color-coded market structure with no fluff.
指標和策略
stockan – Oscillator Matrixstockan – Oscillator Matrix
A multi-layer RSI-based momentum & trend tool with signal smoothing, short-segment regression lines, fade-style histogram, reversal markers, and a blocky heat-bar.
stockan is designed to give you a crystal-clear view of short-term momentum shifts and trend bias all in one pane. It builds upon the classic 0–100 RSI by:
Smoothing it with a quick SMA to generate a clean crossover signal.
Drawing tiny linear-regression segments on both RSI and its signal line to highlight the slope (i.e. local trend direction) over a handful of bars.
Filling between RSI and signal in green/red so you can instantly see when momentum flips.
Plotting a soft-fade histogram of (RSI – signal), where stronger moves produce more opaque bars, while smaller divergences fade into the background.
Marking local peaks and troughs on the RSI curve with dots—perfect for fine-tuning entries or exits.
Rendering a bottom “heat” strip as blocky columns that switch from red to green once RSI crosses your chosen threshold, giving you a persistent bias indicator.
🔧Inputs & Settings
You can customize every aspect of stockan in the Indicator Settings:
Price Source (default = Close)
Choose which price series (Open, High, Low, Close, or a custom series) you want the RSI to use.
Oscillator Length (RSI) (default = 14)
The look-back period for the RSI calculation. Shorter values make the oscillator more sensitive.
Signal Smoothing (default = 3)
The length of the simple moving average applied to the RSI. Higher values produce slower, cleaner signals.
Trend-LR Length (default = 20)
Number of bars used in each linear-regression segment. Longer lengths smooth trends but react more slowly.
Heat Threshold (default = 50)
The cutoff level (on the 0–100 RSI scale) above which the bottom heat-blocks turn green.
Histogram Max for Fade (default = 20)
The absolute difference (RSI – signal) that maps to 100% opacity in the histogram. Smaller differences fade out; larger ones stand out.
🚀 How to Use stockan
Identify Momentum Shifts
Watch for the green/red fill to flip—when the RSI line crosses above its signal, green fill indicates building bullish momentum; red indicates bearish pressure.
Sense Short-Term Trend with Mini-Regression Lines
The tiny sloping segments on both RSI and signal lines give an immediate visual cue: upward-tilted segments = short-term uptrend, downward = downtrend.
Gauge Strength with the Fade-Style Histogram
Opaque bars mean strong momentum divergence; faint bars mean weak or consolidating moves. Use these to avoid low-conviction signals.
Fine-Tune Entries & Exits Using Reversal Dots
Gray dots mark local RSI highs (possible short setups), green dots mark local lows (possible long entries).
Confirm Bias with the Heat-Bar
A steady green row at the bottom tells you RSI has been above your threshold consistently—ideal for trend-following. A red row suggests caution or counter-trend trades.
🎯 Benefits
All-in-One Pane: No need to juggle RSI, MA, histogram and custom script separately.
Clean Visuals: Soft fades and blocky heat bars reduce clutter and highlight what matters.
Non-Repainting: Uses only closed-bar data; once a bar is closed, nothing moves or disappears.
Highly Customizable: Every length, threshold, color and transparency can be adjusted in Settings.
Lightweight & Self-Contained: Pure Pine v5—no external libraries, no proprietary code—fully compliant with TradingView’s policies.
pymath█ OVERVIEW
This library ➕ enhances Pine Script's built-in types (`float`, `int`, `array`, `array`) with mathematical methods, mirroring 🪞 many functions from Python's `math` module. Import this library to overload or add to built-in capabilities, enabling calls like `myFloat.sin()` or `myIntArray.gcd()`.
█ CONCEPTS
This library wraps Pine's built-in `math.*` functions and implements others where necessary, expanding the mathematical toolkit available within Pine Script. It provides a more object-oriented approach to mathematical operations on core data types.
█ HOW TO USE
• Import the library: i mport kaigouthro/pymath/1
• Call methods directly on variables: myFloat.sin() , myIntArray.gcd()
• For raw integer literals, you MUST use parentheses: `(1234).factorial()`.
█ FEATURES
• **Infinity Handling:** Includes `isinf()` and `isfinite()` for robust checks. Uses `POS_INF_PROXY` to represent infinity.
• **Comprehensive Math Functions:** Implements a wide range of methods, including trigonometric, logarithmic, hyperbolic, and array operations.
• **Object-Oriented Approach:** Allows direct method calls on `int`, `float`, and arrays for cleaner code.
• **Improved Accuracy:** Some functions (e.g., `remainder()`) offer improved accuracy compared to default Pine behavior.
• **Helper Functions:** Internal helper functions optimize calculations and handle edge cases.
█ NOTES
This library improves upon Pine Script's built-in `math` functions by adding new ones and refining existing implementations. It handles edge cases such as infinity, NaN, and zero values, enhancing the reliability of your Pine scripts. For Speed, it wraps and uses built-ins, as thy are fastest.
█ EXAMPLES
//@version=6
indicator("My Indicator")
// Import the library
import kaigouthro/pymath/1
// Create some Vars
float myFloat = 3.14159
int myInt = 10
array myIntArray = array.from(1, 2, 3, 4, 5)
// Now you can...
plot( myFloat.sin() ) // Use sin() method on a float, using built in wrapper
plot( (myInt).factorial() ) // Factorial of an integer (note parentheses)
plot( myIntArray.gcd() ) // GCD of an integer array
method isinf(self)
isinf: Checks if this float is positive or negative infinity using a proxy value.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) value to check.
Returns: (bool) `true` if the absolute value of `self` is greater than or equal to the infinity proxy, `false` otherwise.
method isfinite(self)
isfinite: Checks if this float is finite (not NaN and not infinity).
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The value to check.
Returns: (bool) `true` if `self` is not `na` and not infinity (as defined by `isinf()`), `false` otherwise.
method fmod(self, divisor)
fmod: Returns the C-library style floating-point remainder of `self / divisor` (result has the sign of `self`).
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) Dividend `x`.
divisor (float) : (float) Divisor `y`. Cannot be zero or `na`.
Returns: (float) The remainder `x - n*y` where n is `trunc(x/y)`, or `na` if divisor is 0, `na`, or inputs are infinite in a way that prevents calculation.
method factorial(self)
factorial: Calculates the factorial of this non-negative integer.
Namespace types: series int, simple int, input int, const int
Parameters:
self (int) : (int) The integer `n`. Must be non-negative.
Returns: (float) `n!` as a float, or `na` if `n` is negative or overflow occurs (based on `isinf`).
method isqrt(self)
isqrt: Calculates the integer square root of this non-negative integer (floor of the exact square root).
Namespace types: series int, simple int, input int, const int
Parameters:
self (int) : (int) The non-negative integer `n`.
Returns: (int) The greatest integer `a` such that a² <= n, or `na` if `n` is negative.
method comb(self, k)
comb: Calculates the number of ways to choose `k` items from `self` items without repetition and without order (Binomial Coefficient).
Namespace types: series int, simple int, input int, const int
Parameters:
self (int) : (int) Total number of items `n`. Must be non-negative.
k (int) : (int) Number of items to choose. Must be non-negative.
Returns: (float) The binomial coefficient nCk, or `na` if inputs are invalid (n<0 or k<0), `k > n`, or overflow occurs.
method perm(self, k)
perm: Calculates the number of ways to choose `k` items from `self` items without repetition and with order (Permutations).
Namespace types: series int, simple int, input int, const int
Parameters:
self (int) : (int) Total number of items `n`. Must be non-negative.
k (simple int) : (simple int = na) Number of items to choose. Must be non-negative. Defaults to `n` if `na`.
Returns: (float) The number of permutations nPk, or `na` if inputs are invalid (n<0 or k<0), `k > n`, or overflow occurs.
method log2(self)
log2: Returns the base-2 logarithm of this float. Input must be positive. Wraps `math.log(self) / math.log(2.0)`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number. Must be positive.
Returns: (float) The base-2 logarithm, or `na` if input <= 0.
method trunc(self)
trunc: Returns this float with the fractional part removed (truncates towards zero).
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (int) The integer part, or `na` if input is `na` or infinite.
method abs(self)
abs: Returns the absolute value of this float. Wraps `math.abs()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (float) The absolute value, or `na` if input is `na`.
method acos(self)
acos: Returns the arccosine of this float, in radians. Wraps `math.acos()`. Input must be between -1 and 1.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number. Must be between -1 and 1.
Returns: (float) Angle in radians , or `na` if input is outside or `na`.
method asin(self)
asin: Returns the arcsine of this float, in radians. Wraps `math.asin()`. Input must be between -1 and 1.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number. Must be between -1 and 1.
Returns: (float) Angle in radians , or `na` if input is outside or `na`.
method atan(self)
atan: Returns the arctangent of this float, in radians. Wraps `math.atan()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (float) Angle in radians , or `na` if input is `na`.
method ceil(self)
ceil: Returns the ceiling of this float (smallest integer >= self). Wraps `math.ceil()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (int) The ceiling value, or `na` if input is `na` or infinite.
method cos(self)
cos: Returns the cosine of this float (angle in radians). Wraps `math.cos()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The angle in radians.
Returns: (float) The cosine, or `na` if input is `na`.
method degrees(self)
degrees: Converts this float from radians to degrees. Wraps `math.todegrees()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The angle in radians.
Returns: (float) The angle in degrees, or `na` if input is `na`.
method exp(self)
exp: Returns e raised to the power of this float. Wraps `math.exp()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The exponent.
Returns: (float) `e**self`, or `na` if input is `na`.
method floor(self)
floor: Returns the floor of this float (largest integer <= self). Wraps `math.floor()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (int) The floor value, or `na` if input is `na` or infinite.
method log(self)
log: Returns the natural logarithm (base e) of this float. Wraps `math.log()`. Input must be positive.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number. Must be positive.
Returns: (float) The natural logarithm, or `na` if input <= 0 or `na`.
method log10(self)
log10: Returns the base-10 logarithm of this float. Wraps `math.log10()`. Input must be positive.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number. Must be positive.
Returns: (float) The base-10 logarithm, or `na` if input <= 0 or `na`.
method pow(self, exponent)
pow: Returns this float raised to the power of `exponent`. Wraps `math.pow()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The base.
exponent (float) : (float) The exponent.
Returns: (float) `self**exponent`, or `na` if inputs are `na` or lead to undefined results.
method radians(self)
radians: Converts this float from degrees to radians. Wraps `math.toradians()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The angle in degrees.
Returns: (float) The angle in radians, or `na` if input is `na`.
method round(self)
round: Returns the nearest integer to this float. Wraps `math.round()`. Ties are rounded away from zero.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (int) The rounded integer, or `na` if input is `na` or infinite.
method sign(self)
sign: Returns the sign of this float (-1, 0, or 1). Wraps `math.sign()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (int) -1 if negative, 0 if zero, 1 if positive, `na` if input is `na`.
method sin(self)
sin: Returns the sine of this float (angle in radians). Wraps `math.sin()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The angle in radians.
Returns: (float) The sine, or `na` if input is `na`.
method sqrt(self)
sqrt: Returns the square root of this float. Wraps `math.sqrt()`. Input must be non-negative.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number. Must be non-negative.
Returns: (float) The square root, or `na` if input < 0 or `na`.
method tan(self)
tan: Returns the tangent of this float (angle in radians). Wraps `math.tan()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The angle in radians.
Returns: (float) The tangent, or `na` if input is `na`.
method acosh(self)
acosh: Returns the inverse hyperbolic cosine of this float. Input must be >= 1.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number. Must be >= 1.
Returns: (float) The inverse hyperbolic cosine, or `na` if input < 1 or `na`.
method asinh(self)
asinh: Returns the inverse hyperbolic sine of this float.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (float) The inverse hyperbolic sine, or `na` if input is `na`.
method atanh(self)
atanh: Returns the inverse hyperbolic tangent of this float. Input must be between -1 and 1 (exclusive).
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number. Must be between -1 and 1 (exclusive).
Returns: (float) The inverse hyperbolic tangent, or `na` if input is outside (-1, 1) or `na`.
method cosh(self)
cosh: Returns the hyperbolic cosine of this float.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (float) The hyperbolic cosine, or `na` if input is `na`.
method sinh(self)
sinh: Returns the hyperbolic sine of this float.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (float) The hyperbolic sine, or `na` if input is `na`.
method tanh(self)
tanh: Returns the hyperbolic tangent of this float.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The input number.
Returns: (float) The hyperbolic tangent, or `na` if input is `na`.
method atan2(self, dx)
atan2: Returns the angle in radians between the positive x-axis and the point (dx, self). Wraps `math.atan2()`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The y-coordinate `y`.
dx (float) : (float) The x-coordinate `x`.
Returns: (float) The angle in radians , result of `math.atan2(self, dx)`. Returns `na` if inputs are `na`. Note: `math.atan2(0, 0)` returns 0 in Pine.
Optimization: Use built-in math.atan2()
method cbrt(self)
cbrt: Returns the cube root of this float.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The value to find the cube root of.
Returns: (float) The real cube root. Handles negative inputs correctly, or `na` if input is `na`.
method exp2(self)
exp2: Returns 2 raised to the power of this float. Calculated as `2.0.pow(self)`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The exponent.
Returns: (float) `2**self`, or `na` if input is `na` or results in non-finite value.
method expm1(self)
expm1: Returns `e**self - 1`. Calculated as `self.exp() - 1.0`. May offer better precision for small `self` in some environments, but Pine provides no guarantee over `self.exp() - 1.0`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The exponent.
Returns: (float) `e**self - 1`, or `na` if input is `na` or `self.exp()` is `na`.
method log1p(self)
log1p: Returns the natural logarithm of (1 + self). Calculated as `(1.0 + self).log()`. Pine provides no specific precision guarantee for self near zero.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) Value to add to 1. `1 + self` must be positive.
Returns: (float) Natural log of `1 + self`, or `na` if input is `na` or `1 + self <= 0`.
method modf(self)
modf: Returns the fractional and integer parts of this float as a tuple ` `. Both parts have the sign of `self`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The number `x` to split.
Returns: ( ) A tuple containing ` `, or ` ` if `x` is `na` or non-finite.
method remainder(self, divisor)
remainder: Returns the IEEE 754 style remainder of `self` with respect to `divisor`. Result `r` satisfies `abs(r) <= 0.5 * abs(divisor)`. Uses round-half-to-even.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) Dividend `x`.
divisor (float) : (float) Divisor `y`. Cannot be zero or `na`.
Returns: (float) The IEEE 754 remainder, or `na` if divisor is 0, `na`, or inputs are non-finite in a way that prevents calculation.
method copysign(self, signSource)
copysign: Returns a float with the magnitude (absolute value) of `self` but the sign of `signSource`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) Value providing the magnitude `x`.
signSource (float) : (float) Value providing the sign `y`.
Returns: (float) `abs(x)` with the sign of `y`, or `na` if either input is `na`.
method frexp(self)
frexp: Returns the mantissa (m) and exponent (e) of this float `x` as ` `, such that `x = m * 2^e` and `0.5 <= abs(m) < 1` (unless `x` is 0).
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) The number `x` to decompose.
Returns: ( ) A tuple ` `, or ` ` if `x` is 0, or ` ` if `x` is non-finite or `na`.
method isclose(self, other, rel_tol, abs_tol)
isclose: Checks if this float `a` and `other` float `b` are close within relative and absolute tolerances.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) First value `a`.
other (float) : (float) Second value `b`.
rel_tol (simple float) : (simple float = 1e-9) Relative tolerance. Must be non-negative and less than 1.0.
abs_tol (simple float) : (simple float = 0.0) Absolute tolerance. Must be non-negative.
Returns: (bool) `true` if `abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)`. Handles `na`/`inf` appropriately. Returns `na` if tolerances are invalid.
method ldexp(self, exponent)
ldexp: Returns `self * (2**exponent)`. Inverse of `frexp`.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : (float) Mantissa part `x`.
exponent (int) : (int) Exponent part `i`.
Returns: (float) The result of `x * pow(2, i)`, or `na` if inputs are `na` or result is non-finite.
method gcd(self)
gcd: Calculates the Greatest Common Divisor (GCD) of all integers in this array.
Namespace types: array
Parameters:
self (array) : (array) An array of integers.
Returns: (int) The largest positive integer that divides all non-zero elements, 0 if all elements are 0 or array is empty. Returns `na` if any element is `na`.
method lcm(self)
lcm: Calculates the Least Common Multiple (LCM) of all integers in this array.
Namespace types: array
Parameters:
self (array) : (array) An array of integers.
Returns: (int) The smallest positive integer that is a multiple of all non-zero elements, 0 if any element is 0, 1 if array is empty. Returns `na` on potential overflow or if any element is `na`.
method dist(self, other)
dist: Returns the Euclidean distance between this point `p` and another point `q` (given as arrays of coordinates).
Namespace types: array
Parameters:
self (array) : (array) Coordinates of the first point `p`.
other (array) : (array) Coordinates of the second point `q`. Must have the same size as `p`.
Returns: (float) The Euclidean distance, or `na` if arrays have different sizes, are empty, or contain `na`/non-finite values.
method fsum(self)
fsum: Returns an accurate floating-point sum of values in this array. Uses built-in `array.sum()`. Note: Pine Script does not guarantee the same level of precision tracking as Python's `math.fsum`.
Namespace types: array
Parameters:
self (array) : (array) The array of floats to sum.
Returns: (float) The sum of the array elements. Returns 0.0 for an empty array. Returns `na` if any element is `na`.
method hypot(self)
hypot: Returns the Euclidean norm (distance from origin) for this point given by coordinates in the array. `sqrt(sum(x*x for x in coordinates))`.
Namespace types: array
Parameters:
self (array) : (array) Array of coordinates defining the point.
Returns: (float) The Euclidean norm, or 0.0 if the array is empty. Returns `na` if any element is `na` or non-finite.
method prod(self, start)
prod: Calculates the product of all elements in this array.
Namespace types: array
Parameters:
self (array) : (array) The array of values to multiply.
start (simple float) : (simple float = 1.0) The starting value for the product (returned if the array is empty).
Returns: (float) The product of array elements * start. Returns `na` if any element is `na`.
method sumprod(self, other)
sumprod: Returns the sum of products of values from this array `p` and another array `q` (dot product).
Namespace types: array
Parameters:
self (array) : (array) First array of values `p`.
other (array) : (array) Second array of values `q`. Must have the same size as `p`.
Returns: (float) The sum of `p * q ` for all i, or `na` if arrays have different sizes or contain `na`/non-finite values. Returns 0.0 for empty arrays.
FeraTrading Sessions High/LowThe FeraTradiang Sessions High/Low Indicator plots precise high and low levels for the New York, London, and Asian trading sessions — without any clutter.
We designed this tool for simplicity, clarity and accuracy, automatically adjusting to any timeframe and time zone — no manual setup required.
🔍 Key Features:
Clean horizontal lines marking session highs and lows
Lines start at the actual high/low
Session times:
New York: 09:30 – 17:00
London: 03:00 – 08:00
Asian: 18:00 – 03:00
Real-time updates that trail live candles
Only shows the most relevant sessions:
Yesterday’s NY
Last night’s Asia + morning continuation
Today’s London
Fully customizable:
Session colors
Label toggle
Line extension settings
Enable extended trading hours on your chart for best results.
Whether you're trading futures, forex, or crypto, this indicator provides clean session context without the mess. Open-source for extra customization and designed for real-time usability.
Pivot ATR Zones [v6]🟩 Pivot ATR Zones
Overview:
The Pivot ATR Zones indicator plots dynamic support and resistance zones based on pivot highs and lows, combined with ATR (Average True Range) volatility levels. It helps traders visually identify potential long and short trade areas, along with realistic target and stop loss zones based on market conditions.
Features:
Automatically detects pivot highs and lows
Draws ATR-based entry zones on the chart
Plots dynamic take-profit and stop-loss levels using ATR multipliers
Color-coded long (green) and short (red) zones
Entry arrow markers for clearer trade visualization
Real-time alerts when new zones form
Best For:
Scalpers, intraday traders, and swing traders who want a visual, volatility-aware way to mark potential trade areas based on key pivot structures.
How to Use:
Look for newly formed green zones for long opportunities and red zones for short setups.
Use the dashed lines as dynamic take-profit and stop levels, tuned to the current ATR value.
Combine with other confirmation tools or indicators for optimal results.
Stockan Momentum MeterStockan Momentum Meter (SMM)
Advanced Momentum Acceleration Oscillator
Version: 1.0 | Category: Momentum Oscillator | Type: Open Source
Detailed Technical Specification
Key Features
Dual-Layer Momentum Calculation
Calculates momentum using double derivative of price (ROC of ROC)
First Layer: Standard Rate of Change (ROC)
Second Layer: Momentum of Momentum (ROC applied to first ROC)
Signal Smoothing System
EMA filtering of raw momentum values
Adaptive smoothing based on user-defined length
4-State Color Coding
Quadrant-based visualization system:
Strong Bullish (Green): Histogram > Threshold
Moderate Bullish (Blue): 0 < Histogram ≤ Threshold
Moderate Bearish (Orange): -Threshold ≤ Histogram < 0
Strong Bearish (Red): Histogram < -Threshold
Dynamic Threshold System
Adjustable baseline levels for sensitivity control
Symmetrical upper/lower boundaries
Detailed Working Mechanism
Calculation Pipeline
Raw Momentum (momo):
momo = ROC(ROC(close, length), length)
Measures acceleration/deceleration in price movements
Double derivation filters out noise while capturing momentum shifts
Smoothed Signal (ema_momo):
ema_momo = EMA(momo, length)
Creates reference line for momentum comparison
Reduces whipsaws in volatile markets
Histogram Value:
histogram = momo - ema_momo
Visualizes difference between raw and smoothed momentum
Positive values = accelerating momentum
Negative values = decelerating momentum
PARAMETER CONFIGURATION
Momentum Length (Default: 14)
Range: 1-100 | Controls historical window for momentum calculations
Base Line Threshold (Default: 0.0)
Range: 0-100 | Determines sensitivity for color changes
COLOR CODING SYSTEM
GREEN Signals:
Histogram value ABOVE threshold level = Strong bullish momentum
BLUE Signals:
Positive values BETWEEN 0 and threshold = Moderate bullish pressure
ORANGE Signals:
Negative values BETWEEN 0 and -threshold = Moderate bearish pressure
RED Signals:
Histogram value BELOW -threshold = Strong bearish momentum
Key Benefits for Traders
Early Reversal Detection
Identifies momentum exhaustion before price reversal occurs
Divergence Spotting
Clear visualization of:
Bullish divergence (Price ↓ + Histogram ↑)
Bearish divergence (Price ↑ + Histogram ↓)
Trend Strength Measurement
Histogram height indicates momentum intensity
Multi-Timeframe Compatibility
Works effectively on:
Scalping (1-15min)
Swing Trading (1H-4H)
Position Trading (Daily-Weekly)
Customizable Sensitivity
Adjust threshold levels for:
Day traders (higher threshold = fewer signals)
Long-term investors (lower threshold = more sensitivity)
Usage Scenarios
Bullish Signal
Green histogram crossing above threshold
Blue → Green color transition
Bearish Signal
Red histogram crossing below negative threshold
Orange → Red color transition
Confirmation Tool
Use with trend indicators (EMA, MACD):
Green histogram + Price above 200 EMA = Strong uptrend
Red histogram + Price below 200 EMA = Strong downtrend
KEY ADVANTAGES OVER POPULAR INDICATORS
Faster Signals vs RSI
Detects momentum shifts earlier through double ROC calculation
Clearer Visuals vs MACD
Four-color system replaces confusing line crossovers with instant visual cues
Better Filtering vs Stochastic
Dual-layer calculation reduces market noise more effectively
Custom Sensitivity
Adjustable threshold outperforms fixed settings in traditional oscillators
How to Use
Add to chart from TradingView Public Library
Default settings work for most timeframes
Adjust parameters based on:
Aggressive trading: Reduce length (10-12)
Conservative trading: Increase length (20-25)
Combine with:
Trendlines for breakout confirmation
Volume indicators for signal validation
Notes
Best Performance: Ranging markets with clear support/resistance
Risk Management: Use with stop-loss (2x ATR recommended)
Limitations: May give false signals during low-volume periods
Extended Hours Volume Analysis (AVOL)Extended Hours Volume Analysis Indicator (AVOL)
This Pine Script indicator calculates and visualizes the extended hours trading volume (premarket + after hours) as a percentage of the stock's average daily volume.
What This Indicator Does
The script:
1. Tracks volume during different market sessions (premarket: 4:00-9:30 AM, regular: 9:30 AM-4:00 PM, and after hours: 4:00-8:00 PM, Eastern Time)
2. Calculates the 21-day simple moving average of daily trading volume
3. Computes the ratio: (Premarket Volume + After Hours Volume) / Average Daily Volume
4. Displays this ratio as a percentage in a histogram format
5. Colors the histogram based on configurable thresholds to indicate low, medium, or high extended hours activity
6. Provides a detailed data table with current volume metrics
Key Features
- **Session Tracking**: Automatically detects and tracks volume in premarket, regular, and after-hours sessions
- **21-Day Average Volume**: Uses a 21-day lookback period (configurable) to establish the baseline average daily volume
- **Visual Alerts**: Color-coded histogram bars change from green to yellow to red as the extended hours volume percentage increases
- **Comprehensive Data Table**: Shows premarket volume, after hours volume, average daily volume, and the extended hours percentage
- **Customizable Thresholds**: Adjustable color-change thresholds to match your specific trading preferences
How to Use This Indicator
This indicator can help traders identify unusual extended hours activity relative to the stock's normal trading pattern. Higher-than-normal extended hours volume often precedes significant price movements in the regular session, potentially indicating where institutional interest lies or where retail traders are reacting to news events.
The color-coding system provides an immediate visual cue about the significance of the current extended hours volume:
- Green: Low extended hours activity (below first threshold)
- Yellow: Moderate extended hours activity (between first and second thresholds)
- Red: High extended hours activity (above second threshold)
Traders can use this information to prepare for potentially volatile opening moves or to identify stocks where significant news or events might be affecting after-hours trading sentiment.
Zero Lag MTF Moving Average by CoffeeshopCryptoBased on Moving Average Types supplied by @TradingView www.tradingview.com
Ideas and code enhanced to show higher timeframe by @CoffeeShopCrypto
It’s time to take the guesswork out of moving averages and multiple timeframes when day trading. Moving averages are a cornerstone of many trading strategies, often viewed as dynamic support and resistance levels. Traders rely on these levels to anticipate price reactions, whether it’s a bounce in a trending market or a reversal in a ranging one. Additionally, the direction and alignment of multi timeframe moving averages—whether they’re moving in the same direction or diverging—provide critical clues about market momentum and potential reversals. However, the traditional higher timeframe moving average indicators force traders to wait for higher timeframe candles to close, creating lag and missed opportunities.
The Old Way
For example: If you are on a 5 minute chart and you want to observe the location and direction of a 30 minute chart Moving Average, you'll need to wait for a total of 6 candles to close, and again every 6 candles after that. This only creates more lag.
The New Way
Now there is no waiting for high timeframe session candles to close. No matter what timeframe Moving Average you want to know about, this indicator will show you its location on your current chart at any time in real time.
For those who prefer Bollinger Bands, this indicator adds a whole new dimension to your strategy. Traders often wait for price action to break outside the lower time frame Bollinger bands before considering a trade, while still seeking key support or resistance levels beyond them. But if you don't know the position of your higher time frame Bollinger, you could be trading into a trap. With Zero Lag Multi Timeframe Moving Average, you can view both your current and higher timeframe Bollinger Bands simultaneously with zero waiting. This lets you instantly see when price action is traveling between the bands of either timeframe or breaking through both—indicating a strong trend in that direction. Additionally, when both sets of Bollinger Bands overlap at the same price levels, it highlights areas of strong consolidation and ranging conditions, giving you a clear picture of market dynamics. This is a key element in price action that tells you there is currently no direction to the market and both the current and higher time frames are flat.
Enter Zero Lag Multi Timeframe Moving Average—the ultimate tool for real-time higher timeframe moving averages and Bollinger Bands. This innovative indicator eliminates the delay, delivering instant, precise values for higher timeframe averages and bands, even on open candles. Seamlessly combining current and higher timeframe data, it allows traders to identify key moments where moving averages or Bollinger Bands align or diverge, signaling market conditions. Whether you’re gauging the strength of a trend, pinpointing potential reversals, or identifying consolidation zones, Zero Lag Multi Timeframe Moving Average gives you the clarity needed to make better trading decisions according to market conditions.
Why is this "Mashup" of moving averages different and important?
Honestly its really about the calculation thats imported through the "import library" function.
Heres what it does:
The ZLMTF-MA is designed to help traders easily see where higher timeframe moving averages and Bollinger Bands are—without needing to switch chart timeframes or wait for those larger candles to close. It works by adjusting common moving average types like SMA, EMA, and VWMA to show what they would look like if they were based on a higher timeframe, right on your current chart. This helps users stay focused on their main timeframe while still having a clear view of the bigger picture, making it easier to spot trend direction, key support and resistance levels, and overall market structure. The goal is to keep things simple, fast, and more visually informative for everyday traders.
Bollinger Bands
When working with Bollinger Bands, a common strategy is to take the trades once price action has escaped through the top or bottom of your current Bollinger Band.
A false breakout occurs when both Bollinger Bands are not moving in the same direction as eachother or when they are overlapping.
Moving Averages as Support and Resistance:
Traders who use Moving Averages as support or resistance, looking for rejections or failures of these areas can now see multiple timeframe price action instantly and simultaneously.
Trading Setup Examples:
Price Action Scenario 1:
Higher Timeframe Ranging-
When price action breaks through a current moving average headed toward a higher timeframe moving average, trades are taken with caution if the moving averages are converging.
Price Action Scenario 2:
Strong Trending Market -
If the moving averages are in the same direction, and your price action is now leading the low timeframe moving average, you have re-entered a strong trend.
Price Action Scenario 3:
High Timeframe Rejections -
If you have a rejection of a higher timeframe moving average, and your both averages are still diverging, this is the end of a pullback as you re-enter a strong trend in the original direction
Price Action Scenario 4:
Trend Reversals -
If you close beyond both the low and high timeframe moving averages, you can consider that price action is strong enough to change direction here and you should prepare for trade setups in the opposite direction of the previous.
HTF MA Label Information:
Even if your high timeframe moving average is turned off, you can still see this label.
It gives you a quick reminder of what high timeframe settings you have used to see MA values.
SMPivot Gaussian Trend Strategy [Js.K]This open-source strategy combines a Gaussian-weighted moving average with “Smart Money” swing-pivot breaks (BoS = Break-of-Structure) to capture trend continuations and early reversals. It is intended for educational and research purposes only and must not be interpreted as financial advice.
How the logic works
-------------------
1. Gaussian Moving Average (GMA)
• A custom Gaussian kernel (length = 30 by default) smooths price while preserving turning points.
• A second pass (“Smoothed GMA”) further filters noise; only its direction is used for bias.
2. Swing-Pivot detection
• High/Low pivots are found with a symmetric look-back/forward window (Pivot Length = 20).
• The most recent confirmed pivot creates a dynamic structure level (UpdatedHigh / UpdatedLow).
3. Entry rules
Long
• Price closes above the most recent pivot high **and** above Smoothed GMA.
Short
• Price closes below the most recent pivot low **and** below Smoothed GMA.
4. Exit rules
• Fixed stop-loss and take-profit in percent of current price (user-defined).
• Separate parameters and on/off switches for longs and shorts.
5. Visuals
• GMA (dots) and Smoothed GMA (line).
• Structure break lines plus “BoS PH/PL” labels at the midpoint between pivot and break.
Inputs
------
Gaussian
• Gaussian Length (default 30) – smoothing window.
• Gaussian Scatterplot – toggle GMA dots.
Smart-Money Pivot
• Pivot Length (default 20).
• Bull / Bear colors.
Risk settings
• Long / Short enable.
• Individual SL % and TP % (default 1 % SL, 30 % TP).
• Strategy uses percent-of-equity sizing; initial capital defaults to 10 000 USD.
Adjust these to reflect your own account size, realistic commission and slippage.
Best practice & compliance notes
--------------------------------
• Test on a data sample that yields ≥ 100 trades to obtain statistically relevant results.
• Keep risk per trade below 5–10 % of equity; the default values comply with this guideline.
• Explain any custom settings you publish that differ from the defaults.
• Do **not** remove the code header or licence notice (MPL-2.0).
• Include realistic commission and slippage in your back-test before publishing.
• The script does **not** repaint; orders are processed on bar close.
Usage
-----
1. Add the script to any symbol / timeframe; intraday and swing timeframes both work—adjust lengths accordingly.
2. Configure SL/TP and position size to match your personal risk management.
3. Run “List of trades” and the performance summary to evaluate expectancy; forward-test before live use.
Disclaimer
----------
Trading involves substantial risk. Past performance based on back-testing is not necessarily indicative of future results. The author is **not** responsible for any financial losses arising from the use of this script.
Vietnamese Market Structure With CountersThis indicator is designed to track Market Structure with Swing-Low Breakdowns and Swing-High Breakups specifically tailored for the Vietnamese stock market, though it can be applied elsewhere too. By default, it uses a 10-period EMA to dynamically detect key turning points in price action and count significant breakdowns or breakups from previous swing levels.
As an open source, you can modify the source code to match your needs.
What it does:
Detects when price breaks below previous swing lows or above previous swing highs.
Plots swing levels for both highs and lows.
Displays labeled counters on the chart to show how many consecutive breakdowns or breakups have occurred.
Helps traders identify trend shifts and possible exhaustion in moves.
Why it's useful:
This tool is great for visually tracking market momentum and structure changes — especially in trending or volatile environments. It emphasizes structure over indicators, helping you understand price behavior in a simplified, intuitive way.
License:
This script is published under the Mozilla Public License 2.0. Feel free to use, modify, and contribute!
Created with care by @doqkhanh.
If you find it useful, consider leaving a comment or sharing it with others!
SMCDrawingLibrary "SMCDrawing"
drawSwingPointLabel(bar_index, price, swing_type, text_color, size)
Parameters:
bar_index (int)
price (float)
swing_type (string)
text_color (color)
size (string)
drawBOSLabel(start_bar, price, end_bar, bos_text, line_color, line_style, line_width, text_color, size)
Parameters:
start_bar (int)
price (float)
end_bar (int)
bos_text (string)
line_color (color)
line_style (string)
line_width (int)
text_color (color)
size (string)
drawRetracementLine(start_bar, price, end_bar, line_color, line_style, line_width)
Parameters:
start_bar (int)
price (float)
end_bar (int)
line_color (color)
line_style (string)
line_width (int)
drawFVG(high_time, low_time, high_price, low_price, is_bullish, line_color, line_width, bar_time)
Parameters:
high_time (int)
low_time (int)
high_price (float)
low_price (float)
is_bullish (bool)
line_color (color)
line_width (int)
bar_time (int)
drawBPRLabel(bar_time, price, is_bullish, text_color)
Parameters:
bar_time (int)
price (float)
is_bullish (bool)
text_color (color)
drawVolumeSpike(bar_time, price, percent_oi, normalized_volume, spike_color)
Parameters:
bar_time (int)
price (float)
percent_oi (float)
normalized_volume (float)
spike_color (color)
drawCandle(bar_index, open, high, low, close, up_color, down_color, wick_color, up_border_color, down_border_color)
Parameters:
bar_index (int)
open (float)
high (float)
low (float)
close (float)
up_color (color)
down_color (color)
wick_color (color)
up_border_color (color)
down_border_color (color)
Relative After-Hours AVOLThis script calculates and plots the relative after-hours volume (AVOL) as a percentage of the stock’s average daily volume, helping you measure how active a stock is during extended trading hours (premarket + after-hours) compared to its normal daily activity.
Futures Globex SessionThis is a simple indicator that will highlight the globex range based on the unique trading hours of each product. To get this to work correctly, you will need to use it on a continuous unadjusted chart (MES1!). Here are the start and stop times for each futures contract:
ES1!
18:00 to 09:30 ET
NQ1!
18:00 to 09:30 ET
RTY1!
18:00 to 09:30 ET
YM1!
18:00 to 09:30 ET
ZN1!
18:00 to 08:20 ET
ZB1!
18:00 to 08:20 ET
GC1!
18:00 to 08:20 ET
CL1!
18:00 to 09:00 ET
NG1!
18:00 to 09:00 ET
ZS1!
20:00 to 09:30 ET
ZW1!
20:00 to 09:30 ET
MES1!
18:00 to 09:30 ET
MYM1!
18:00 to 09:30 ET
MNQ1!
18:00 to 09:30 ET
M2K1!
18:00 to 09:30 ET
MCL1!
18:00 to 09:00 ET
MGC1!
18:00 to 08:20 ET
Bitcoin Impact AnalyzerSummary of the "Bitcoin Impact Analyzer" script, the adjustments users can make, and an explanation of what the chart and table represent:
Script Summary:
The "Bitcoin Impact Analyzer" script is designed to help traders and analysts understand the relationship between a chosen altcoin and Bitcoin (BTC). It does this by:
Fetching price data for the specified altcoin and Bitcoin.
Calculating several key comparative metrics:
Normalized Prices: Shows the percentage performance of both assets from a common starting point.
Price Correlation: Measures how similarly the two assets' prices move over a defined period.
Beta: Indicates the altcoin's volatility relative to Bitcoin.
Altcoin/BTC Ratio: Shows the altcoin's value expressed in Bitcoin.
Fetching and displaying Bitcoin Dominance (BTC.D) data.
Visualizing these metrics on the chart as distinct plots.
Displaying the current values of these key metrics in a data table on the chart for quick reference.
The script aims to provide insights into whether an altcoin is outperforming or underperforming Bitcoin, how closely its price movements are tied to Bitcoin's, and its relative volatility.
User Adjustments:
Users can customize the script's behavior through several input settings:
Symbol Inputs:
Altcoin Symbol: Users can enter the ticker symbol for any altcoin they wish to analyze (e.g., BINANCE:ETHUSDT, KUCOIN:SOLUSDT).
Bitcoin Reference Symbol: Users can specify the Bitcoin pair to use as a reference, though BINANCE:BTCUSDT is a common default.
Lookback for Correlation/Beta:
Lookback Period: This integer value (default 50 periods) determines how many past candles are used to calculate the price correlation and beta.
A shorter lookback makes the metrics more sensitive to recent price action.
A longer lookback provides a smoother, more stable indication of the longer-term relationship.
Plot Visibility Options:
Users can toggle on or off the display of each individual plot on the chart:
Normalized BTC & Altcoin Prices
Altcoin/BTC Ratio
Correlation Plot
Bitcoin Dominance (BTC.D)
Beta Plot
This allows users to focus on specific metrics and reduce chart clutter.
What the Chart Represents:
The chart visually displays the historical trends and relationships of the selected metrics:
Normalized Prices Plot: Two lines (typically orange for BTC, blue for the altcoin) show the percentage growth of each asset from the start of the loaded chart data (or the first available data point for each symbol). This makes it easy to see which asset has performed better over time on a relative basis.
Correlation Plot: A single line (purple) oscillates between -1 and +1.
Values near +1 indicate a strong positive correlation (altcoin and BTC prices tend to move in the same direction).
Values near -1 indicate a strong negative correlation (they tend to move in opposite directions).
Values near 0 indicate little to no linear relationship.
Lines at +0.7 and -0.7 are often plotted as thresholds for "strong" correlation.
Beta Plot (if enabled): A single line (teal) shows the altcoin's volatility relative to BTC.
A Beta of 1 (often marked by a dashed line) means the altcoin has, on average, the same volatility as BTC.
Beta > 1 suggests the altcoin is more volatile than BTC (moves by a larger percentage for a given BTC move).
Beta < 1 suggests the altcoin is less volatile than BTC.
Bitcoin Dominance Plot: An area plot (gray) shows the percentage of the total cryptocurrency market capitalization that Bitcoin holds. This helps understand broader market sentiment and capital flows.
Altcoin/BTC Ratio Plot: A line (fuchsia) shows the price of the altcoin denominated in BTC.
An upward trend means the altcoin is gaining value against Bitcoin (outperforming).
A downward trend means the altcoin is losing value against Bitcoin (underperforming).
What the Table Represents:
The data table, typically located in the bottom-right corner of the chart, provides a snapshot of the current values for the most important calculated metrics. It includes:
Altcoin: The ticker symbol of the analyzed altcoin.
Bitcoin Ref: The ticker symbol of the Bitcoin reference.
Correlation (lookback): The current correlation coefficient between the altcoin and BTC, based on the specified lookback period. The value is color-coded (e.g., green for strong positive, red for strong negative).
Beta (lookback): The current beta value of the altcoin relative to BTC, based on the specified lookback period. The value may be color-coded to highlight significantly high or low volatility.
BTC.D Current: The current Bitcoin Dominance percentage.
ALT/BTC Ratio: The current price of the altcoin expressed in Bitcoin.
The table offers a quick, at-a-glance summary of the present market dynamics between the two assets without needing to interpret the lines on the chart for their exact current values.
New York Open Markerheyo,
surprisingly there aren't many indicators available which does the simple thing of just marking the 9:30 EST open or 10:00 am. also just having them present while backtesting makes it so much more easier to understand the pa.
you can turn off 10:00am marker if you don't use it.
good luck.
WAD LineThis is Williams Advance Decline Line as proposed in the book, Technical Analysis from A to Z by Steven B. Achelis. I have tweaked it slightly, or you might say updated it. It works like OBV, but is more responsive to the price volatility.
market_trend_libLibrary "market_trend_lib"
market_trend(adxPeriod, adxThresh)
Parameters:
adxPeriod (simple int)
adxThresh (float)
Forex Fire Sling Shot with Trade ManagementForex Fire Sling Shot Indicator with Trade Management
Description
The Forex Fire Sling Shot Indicator is a comprehensive trading system designed specifically for forex markets. It combines trend analysis, momentum confirmation, and advanced trade management features to help traders identify high-probability trading opportunities.
This indicator provides clear entry signals based on multiple EMA crossovers with MACD confirmation, while incorporating professional trade management tools including automatic stop loss calculation, take profit targets, and breakeven management.
Key Features
Triple EMA Trend Analysis: Uses 15, 50, and 200 EMAs to identify trend direction and entry points
MACD Confirmation: Optional MACD filter for enhanced signal reliability
Premium Signals: Strict entry criteria combining EMA crossover with MACD crossover
Automatic Trade Management: Calculates entry, stop loss, and take profit levels
Breakeven Management: Automatically adjusts stop loss to breakeven at predetermined profit levels
Visual Trade Setup: Displays trade management levels with clear labels
Status Dashboard: Real-time display of current market conditions
Alert System: Built-in alerts for premium trading signals
How to Use
Setup
Add the indicator to any forex chart (recommended timeframes: 1H, 4H, Daily)
Ensure your chart is clean without overlapping indicators
Configure input parameters according to your trading style
Signal Identification
Premium Buy Signal (Diamond Below Bar)
15 EMA crosses above 50 EMA
Price is above 200 EMA (bullish trend)
MACD line crosses above signal line
Green diamond appears below candle
Premium Sell Signal (Diamond Above Bar)
15 EMA crosses below 50 EMA
Price is below 200 EMA (bearish trend)
MACD line crosses below signal line
Fuchsia diamond appears above candle
Trade Execution
When a premium signal appears:
Entry:
Buy: Place order above the signal candle's high
Sell: Place order below the signal candle's low
Stop Loss:
Buy: Lowest low of the past 5 candles (adjustable)
Sell: Highest high of the past 5 candles (adjustable)
Take Profit:
Automatically calculated based on your Risk-Reward ratio (default 1:1.5)
Breakeven Management:
Stop loss moves to breakeven when trade reaches 50% of target (adjustable)
Input Parameters
EMA Settings
Short EMA Period (default: 15)
Long EMA Period (default: 50)
Trend EMA Period (default: 200)
MACD Settings
MACD Fast Length (default: 12)
MACD Slow Length (default: 26)
MACD Signal Length (default: 9)
Require MACD Confirmation (default: true)
Trade Management
Risk-Reward Ratio (default: 1.5)
Stop Loss Lookback Candles (default: 5)
Move SL to Breakeven at % of TP (default: 0.5)
Show Trade Management Labels (default: true)
Alert Settings
Enable Premium Signal Alerts (default: true)
Status Dashboard
The top-right dashboard displays:
MACD Signal status (Bullish/Bearish/Cross)
Overall Trend direction
Current Signal status
Trade Setup details (if active)
Risk-Reward information
Breakeven status
Visual Elements
Green Line: 15 EMA (Fast)
Red Line: 50 EMA (Medium)
Black Line: 200 EMA (Trend)
Yellow Lines: Entry levels
Red Lines: Stop loss levels
Green Lines: Take profit levels
Blue Lines: Breakeven levels
Purple Lines: Breakeven trigger levels
Trading Tips
Only trade premium signals in the direction of the trend (above/below 200 EMA)
Wait for candle close before entering trades
Use higher timeframes for better signal reliability (4H, Daily)
Consider market sessions and major news events
Always use proper position sizing based on your account risk
Risk Disclaimer
This indicator is for educational and informational purposes only. Trading forex involves substantial risk of loss and is not suitable for all investors. Past performance is not indicative of future results. Always conduct your own analysis and risk management.
Updates and Support
The indicator includes built-in alerts for premium signals. To set up alerts:
Right-click on the chart
Select "Add Alert"
Choose "Forex Fire Sling Shot with Trade Management"
Select either "Premium Fire Sling Shot Buy" or "Premium Fire Bear Sling Sell"
For questions or support, please use the comments section below the indicator.
Fib + OB Confluence Zones [Jose Tristan Optimized]Fib + OB Confluence Zones
This indicator plots Fibonacci zones from 60m, 90m, and 4H candles, highlighting confluence areas where multiple fib levels align. It also detects bullish and bearish order blocks on 15m, 5m, and 3m timeframes. Confluence zones and OBs are only shown when overlapping conditions are met, helping identify high-probability reversal or continuation zones. Optional trend filtering using the 200 EMA is included to refine signals based on market direction.
On Balance Volume W DivergenceOBV With Divergence Indicator
A comprehensive On Balance Volume (OBV) indicator enhanced with divergence detection capabilities.
Core Features:
Classic OBV calculation with volume-based price movement tracking
Advanced divergence detection system
Multiple smoothing options for OBV
Bollinger Bands integration
Technical Components:
Volume-based price movement analysis
Pivot point detection for divergence
Customizable lookback periods
Adjustable divergence range parameters
Customization Options:
Multiple Moving Average types (SMA, EMA, SMMA, WMA, VWMA)
Bollinger Bands with adjustable standard deviation
Divergence sensitivity settings
Visual customization for signals and alerts
The indicator combines traditional OBV analysis with modern divergence detection, offering traders a powerful tool for identifying potential trend reversals and market momentum shifts.
Key Parameters:
- Pivot Lookback Right/Left: 5 (default)
- Divergence Range: 5-60 bars
- MA Length: 14 (default)
- BB StdDev: 2.0 (default)
Alert System:
- Bullish divergence alerts
- Bearish divergence alerts
- Customizable alert messages
Note: The indicator requires volume data to function properly and will display an error if volume data is not available.
Ultimate Adaptive Multi-Regime Trading System🧩 What is the UA-MTS Indicator?
UA-MTS is an intelligent trading indicator built for scalping, day trading, and adaptive decision-making. It analyzes price action, trend, volatility, volume, and patterns across multiple timeframes to give traders clear, context-aware buy and sell signals.
It’s like having a smart assistant on your chart that tells you:
What kind of market you’re in (trend, range, volatility, etc.)
What patterns are forming and how reliable they are
When a high-confidence trade opportunity appears
How far price might go next (via projection lines)
⚙️ What Does It Do?
Detects Market Regime
Identifies whether the market is Trending, Ranging, Volatile, Accumulating, or Distributing
Adjusts strategy logic based on the regime
Scans for Patterns
Finds smart price patterns (like engulfing, divergences, fractals, head & shoulders)
Evaluates pattern quality and importance
Uses AI-like Logic
Includes a mini neural network that digests market data and projects price movement
Confirms with Volume and Volatility
Filters out weak signals based on how strong the volume and volatility are
Gives Trade Signals
Shows Buy or Sell markers with scores and confidence %
Highlights high-quality trades with a star (★)
Visual Tools
Confidence bands (projected price range)
Prediction lines
Color-coded market regime
🕹 How to Use It (in TradingView)
Use the Regime Label
Bottom of chart will say "Regime: Trending (80%)" or similar
Trust trend signals more in Trending regime, reversal patterns more in Ranging
Enable Multi-Timeframe Analysis (optional)
It blends data from multiple timeframes (like 1m + 5m + 15m) to sharpen signal logic
Confirm Before Entering
Look at the Score and Confidence %
Use it with other tools like support/resistance or price structure for even better entries
📈 Best Use Cases
Scalping on 1m/5m/15m charts
Day trading breakouts or reversals
Filtering trades during sideways markets
Avoiding traps in high volatility
Projecting short-term price direction
