ZigZag█ Overview
This Pine Script™ library provides a comprehensive implementation of the ZigZag indicator using advanced object-oriented programming techniques. It serves as a developer resource rather than a standalone indicator, enabling Pine Script™ programmers to incorporate sophisticated ZigZag calculations into their own scripts.
Pine Script™ libraries contain reusable code that can be imported into indicators, strategies, and other libraries. For more information, consult the Libraries section of the Pine Script™ User Manual.
█ About the Original
This library is based on TradingView's official ZigZag implementation .
The original code provides a solid foundation with user-defined types and methods for calculating ZigZag pivot points.
█ What is ZigZag?
The ZigZag indicator filters out minor price movements to highlight significant market trends.
It works by:
1. Identifying significant pivot points (local highs and lows)
2. Connecting these points with straight lines
3. Ignoring smaller price movements that fall below a specified threshold
Traders typically use ZigZag for:
- Trend confirmation
- Identifying support and resistance levels
- Pattern recognition (such as Elliott Waves)
- Filtering out market noise
The algorithm identifies pivot points by analyzing price action over a specified number of bars, then only changes direction when price movement exceeds a user-defined percentage threshold.
█ My Enhancements
This modified version extends the original library with several key improvements:
1. Support and Resistance Visualization
- Adds horizontal lines at pivot points
- Customizable line length (offset from pivot)
- Adjustable line width and color
- Option to extend lines to the right edge of the chart
2. Support and Resistance Zones
- Creates semi-transparent zone areas around pivot points
- Customizable width for better visibility of important price levels
- Separate colors for support (lows) and resistance (highs)
- Visual representation of price areas rather than just single lines
3. Zig Zag Lines
- Separate colors for upward and downward ZigZag movements
- Visually distinguishes between bullish and bearish price swings
- Customizable colors for text
- Width customization
4. Enhanced Settings Structure
- Added new fields to the Settings type to support the additional features
- Extended Pivot type with supportResistance and supportResistanceZone fields
- Comprehensive configuration options for visual elements
These enhancements make the ZigZag more useful for technical analysis by clearly highlighting support/resistance levels and zones, and providing clearer visual cues about market direction.
█ Technical Implementation
This library leverages Pine Script™'s user-defined types (UDTs) to create a robust object-oriented architecture:
- Settings : Stores configuration parameters for calculation and display
- Pivot : Represents pivot points with their visual elements and properties
- ZigZag : Manages the overall state and behavior of the indicator
The implementation follows best practices from the Pine Script™ User Manual's Style Guide and uses advanced language features like methods and object references. These UDTs represent Pine Script™'s most advanced feature set, enabling sophisticated data structures and improved code organization.
For newcomers to Pine Script™, it's recommended to understand the language fundamentals before working with the UDT implementation in this library.
█ Usage Example
//@version=6
indicator("ZigZag Example", overlay = true, shorttitle = 'ZZA', max_bars_back = 5000, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500)
import andre_007/ZigZag/1 as ZIG
var group_1 = "ZigZag Settings"
//@variable Draw Zig Zag on the chart.
bool showZigZag = input.bool(true, "Show Zig-Zag Lines", group = group_1, tooltip = "If checked, the Zig Zag will be drawn on the chart.", inline = "1")
// @variable The deviation percentage from the last local high or low required to form a new Zig Zag point.
float deviationInput = input.float(5.0, "Deviation (%)", minval = 0.00001, maxval = 100.0,
tooltip = "The minimum percentage deviation from a previous pivot point required to change the Zig Zag's direction.", group = group_1, inline = "2")
// @variable The number of bars required for pivot detection.
int depthInput = input.int(10, "Depth", minval = 1, tooltip = "The number of bars required for pivot point detection.", group = group_1, inline = "3")
// @variable registerPivot (series bool) Optional. If `true`, the function compares a detected pivot
// point's coordinates to the latest `Pivot` object's `end` chart point, then
// updates the latest `Pivot` instance or adds a new instance to the `ZigZag`
// object's `pivots` array. If `false`, it does not modify the `ZigZag` object's
// data. The default is `true`.
bool allowZigZagOnOneBarInput = input.bool(true, "Allow Zig Zag on One Bar", tooltip = "If checked, the Zig Zag calculation can register a pivot high and pivot low on the same bar.",
group = group_1, inline = "allowZigZagOnOneBar")
var group_2 = "Display Settings"
// @variable The color of the Zig Zag's lines (up).
color lineColorUpInput = input.color(color.green, "Line Colors for Up/Down", group = group_2, inline = "4")
// @variable The color of the Zig Zag's lines (down).
color lineColorDownInput = input.color(color.red, "", group = group_2, inline = "4",
tooltip = "The color of the Zig Zag's lines")
// @variable The width of the Zig Zag's lines.
int lineWidthInput = input.int(1, "Line Width", minval = 1, tooltip = "The width of the Zig Zag's lines.", group = group_2, inline = "w")
// @variable If `true`, the Zig Zag will also display a line connecting the last known pivot to the current `close`.
bool extendInput = input.bool(true, "Extend to Last Bar", tooltip = "If checked, the last pivot will be connected to the current close.",
group = group_1, inline = "5")
// @variable If `true`, the pivot labels will display their price values.
bool showPriceInput = input.bool(true, "Display Reversal Price",
tooltip = "If checked, the pivot labels will display their price values.", group = group_2, inline = "6")
// @variable If `true`, each pivot label will display the volume accumulated since the previous pivot.
bool showVolInput = input.bool(true, "Display Cumulative Volume",
tooltip = "If checked, the pivot labels will display the volume accumulated since the previous pivot.", group = group_2, inline = "7")
// @variable If `true`, each pivot label will display the change in price from the previous pivot.
bool showChgInput = input.bool(true, "Display Reversal Price Change",
tooltip = "If checked, the pivot labels will display the change in price from the previous pivot.", group = group_2, inline = "8")
// @variable Controls whether the labels show price changes as raw values or percentages when `showChgInput` is `true`.
string priceDiffInput = input.string("Absolute", "", options = ,
tooltip = "Controls whether the labels show price changes as raw values or percentages when 'Display Reversal Price Change' is checked.",
group = group_2, inline = "8")
// @variable If `true`, the Zig Zag will display support and resistance lines.
bool showSupportResistanceInput = input.bool(true, "Show Support/Resistance Lines",
tooltip = "If checked, the Zig Zag will display support and resistance lines.", group = group_2, inline = "9")
// @variable The number of bars to extend the support and resistance lines from the last pivot point.
int supportResistanceOffsetInput = input.int(50, "Support/Resistance Offset", minval = 0,
tooltip = "The number of bars to extend the support and resistance lines from the last pivot point.", group = group_2, inline = "10")
// @variable The width of the support and resistance lines.
int supportResistanceWidthInput = input.int(1, "Support/Resistance Width", minval = 1,
tooltip = "The width of the support and resistance lines.", group = group_2, inline = "11")
// @variable The color of the support lines.
color supportColorInput = input.color(color.red, "Support/Resistance Color", group = group_2, inline = "12")
// @variable The color of the resistance lines.
color resistanceColorInput = input.color(color.green, "", group = group_2, inline = "12",
tooltip = "The color of the support/resistance lines.")
// @variable If `true`, the support and resistance lines will be drawn as zones.
bool showSupportResistanceZoneInput = input.bool(true, "Show Support/Resistance Zones",
tooltip = "If checked, the support and resistance lines will be drawn as zones.", group = group_2, inline = "12-1")
// @variable The color of the support zones.
color supportZoneColorInput = input.color(color.new(color.red, 70), "Support Zone Color", group = group_2, inline = "12-2")
// @variable The color of the resistance zones.
color resistanceZoneColorInput = input.color(color.new(color.green, 70), "", group = group_2, inline = "12-2",
tooltip = "The color of the support/resistance zones.")
// @variable The width of the support and resistance zones.
int supportResistanceZoneWidthInput = input.int(10, "Support/Resistance Zone Width", minval = 1,
tooltip = "The width of the support and resistance zones.", group = group_2, inline = "12-3")
// @variable If `true`, the support and resistance lines will extend to the right of the chart.
bool supportResistanceExtendInput = input.bool(false, "Extend to Right",
tooltip = "If checked, the lines will extend to the right of the chart.", group = group_2, inline = "13")
// @variable References a `Settings` instance that defines the `ZigZag` object's calculation and display properties.
var ZIG.Settings settings =
ZIG.Settings.new(
devThreshold = deviationInput,
depth = depthInput,
lineColorUp = lineColorUpInput,
lineColorDown = lineColorDownInput,
textUpColor = lineColorUpInput,
textDownColor = lineColorDownInput,
lineWidth = lineWidthInput,
extendLast = extendInput,
displayReversalPrice = showPriceInput,
displayCumulativeVolume = showVolInput,
displayReversalPriceChange = showChgInput,
differencePriceMode = priceDiffInput,
draw = showZigZag,
allowZigZagOnOneBar = allowZigZagOnOneBarInput,
drawSupportResistance = showSupportResistanceInput,
supportResistanceOffset = supportResistanceOffsetInput,
supportResistanceWidth = supportResistanceWidthInput,
supportColor = supportColorInput,
resistanceColor = resistanceColorInput,
supportResistanceExtend = supportResistanceExtendInput,
supportResistanceZoneWidth = supportResistanceZoneWidthInput,
drawSupportResistanceZone = showSupportResistanceZoneInput,
supportZoneColor = supportZoneColorInput,
resistanceZoneColor = resistanceZoneColorInput
)
// @variable References a `ZigZag` object created using the `settings`.
var ZIG.ZigZag zigZag = ZIG.newInstance(settings)
// Update the `zigZag` on every bar.
zigZag.update()
//#endregion
The example code demonstrates how to create a ZigZag indicator with customizable settings. It:
1. Creates a Settings object with user-defined parameters
2. Instantiates a ZigZag object using these settings
3. Updates the ZigZag on each bar to detect new pivot points
4. Automatically draws lines and labels when pivots are detected
This approach provides maximum flexibility while maintaining readability and ease of use.
Cerca negli script per "摩根标普500指数基金的收益如何"
Money Flow Divergence IndicatorOverview
The Money Flow Divergence Indicator is designed to help traders and investors identify key macroeconomic turning points by analyzing the relationship between U.S. M2 money supply growth and the S&P 500 Index (SPX). By comparing these two crucial economic indicators, the script highlights periods where market liquidity is outpacing or lagging behind stock market growth, offering potential buy and sell signals based on macroeconomic trends.
How It Works
1. Data Sources
S&P 500 Index (SPX500USD): Tracks the stock market performance.
U.S. M2 Money Supply (M2SL - Federal Reserve Economic Data): Represents available liquidity in the economy.
2. Growth Rate Calculation
SPX Growth: Percentage change in the S&P 500 index over time.
M2 Growth: Percentage change in M2 money supply over time.
Growth Gap (Delta): The difference between M2 growth and SPX growth, showing whether liquidity is fueling or lagging behind market performance.
3. Visualization
A histogram displays the growth gap over time:
Green Bars: M2 growth exceeds SPX growth (potential bullish signal).
Red Bars: SPX growth exceeds M2 growth (potential bearish signal).
A zero line helps distinguish between positive and negative growth gaps.
How to Use It
✅ Bullish Signal: When green bars appear consistently, indicating that liquidity is outpacing stock market growth. This suggests a favorable environment for buying or holding positions.
❌ Bearish Signal: When red bars appear consistently, meaning stock market growth outpaces liquidity expansion, signaling potential overvaluation or a market correction.
Best Timeframes for Analysis
This indicator works best on monthly timeframes (M) since it is designed for long-term investors and macro traders who focus on broad economic cycles.
Who Should Use This Indicator?
📈 Long-term investors looking for macroeconomic trends.
📊 Swing traders who incorporate liquidity analysis in their strategies.
💰 Portfolio managers assessing market liquidity conditions.
🚀 Use this indicator to stay ahead of market trends and make informed investment decisions based on macroeconomic liquidity shifts! 🚀
real_time_candlesIntroduction
The Real-Time Candles Library provides comprehensive tools for creating, manipulating, and visualizing custom timeframe candles in Pine Script. Unlike standard indicators that only update at bar close, this library enables real-time visualization of price action and indicators within the current bar, offering traders unprecedented insight into market dynamics as they unfold.
This library addresses a fundamental limitation in traditional technical analysis: the inability to see how indicators evolve between bar closes. By implementing sophisticated real-time data processing techniques, traders can now observe indicator movements, divergences, and trend changes as they develop, potentially identifying trading opportunities much earlier than with conventional approaches.
Key Features
The library supports two primary candle generation approaches:
Chart-Time Candles: Generate real-time OHLC data for any variable (like RSI, MACD, etc.) while maintaining synchronization with chart bars.
Custom Timeframe (CTF) Candles: Create candles with custom time intervals or tick counts completely independent of the chart's native timeframe.
Both approaches support traditional candlestick and Heikin-Ashi visualization styles, with options for moving average overlays to smooth the data.
Configuration Requirements
For optimal performance with this library:
Set max_bars_back = 5000 in your script settings
When using CTF drawing functions, set max_lines_count = 500, max_boxes_count = 500, and max_labels_count = 500
These settings ensure that you will be able to draw correctly and will avoid any runtime errors.
Usage Examples
Basic Chart-Time Candle Visualization
// Create real-time candles for RSI
float rsi = ta.rsi(close, 14)
Candle rsi_candle = candle_series(rsi, CandleType.candlestick)
// Plot the candles using Pine's built-in function
plotcandle(rsi_candle.Open, rsi_candle.High, rsi_candle.Low, rsi_candle.Close,
"RSI Candles", rsi_candle.candle_color, rsi_candle.candle_color)
Multiple Access Patterns
The library provides three ways to access candle data, accommodating different programming styles:
// 1. Array-based access for collection operations
Candle candles = candle_array(source)
// 2. Object-oriented access for single entity manipulation
Candle candle = candle_series(source)
float value = candle.source(Source.HLC3)
// 3. Tuple-based access for functional programming styles
= candle_tuple(source)
Custom Timeframe Examples
// Create 20-second candles with EMA overlay
plot_ctf_candles(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 20,
timezone = -5,
tied_open = true,
ema_period = 9,
enable_ema = true
)
// Create tick-based candles (new candle every 15 ticks)
plot_ctf_tick_candles(
source = close,
candle_type = CandleType.heikin_ashi,
number_of_ticks = 15,
timezone = -5,
tied_open = true
)
Advanced Usage with Custom Visualization
// Get custom timeframe candles without automatic plotting
CandleCTF my_candles = ctf_candles_array(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 30
)
// Apply custom logic to the candles
float ema_values = my_candles.ctf_ema(14)
// Draw candles and EMA using time-based coordinates
my_candles.draw_ctf_candles_time()
ema_values.draw_ctf_line_time(line_color = #FF6D00)
Library Components
Data Types
Candle: Structure representing chart-time candles with OHLC, polarity, and visualization properties
CandleCTF: Extended candle structure with additional time metadata for custom timeframes
TickData: Structure for individual price updates with time deltas
Enumerations
CandleType: Specifies visualization style (candlestick or Heikin-Ashi)
Source: Defines price components for calculations (Open, High, Low, Close, HL2, etc.)
SampleType: Sets sampling method (Time-based or Tick-based)
Core Functions
get_tick(): Captures current price as a tick data point
candle_array(): Creates an array of candles from price updates
candle_series(): Provides a single candle based on latest data
candle_tuple(): Returns OHLC values as a tuple
ctf_candles_array(): Creates custom timeframe candles without rendering
Visualization Functions
source(): Extracts specific price components from candles
candle_ctf_to_float(): Converts candle data to float arrays
ctf_ema(): Calculates exponential moving averages for candle arrays
draw_ctf_candles_time(): Renders candles using time coordinates
draw_ctf_candles_index(): Renders candles using bar index coordinates
draw_ctf_line_time(): Renders lines using time coordinates
draw_ctf_line_index(): Renders lines using bar index coordinates
Technical Implementation Notes
This library leverages Pine Script's varip variables for state management, creating a sophisticated real-time data processing system. The implementation includes:
Efficient tick capturing: Samples price at every execution, maintaining temporal tracking with time deltas
Smart state management: Uses a hybrid approach with mutable updates at index 0 and historical preservation at index 1+
Temporal synchronization: Manages two time domains (chart time and custom timeframe)
The tooltip implementation provides crucial temporal context for custom timeframe visualizations, allowing users to understand exactly when each candle formed regardless of chart timeframe.
Limitations
Custom timeframe candles cannot be backtested due to Pine Script's limitations with historical tick data
Real-time visualization is only available during live chart updates
Maximum history is constrained by Pine Script's array size limits
Applications
Indicator visualization: See how RSI, MACD, or other indicators evolve in real-time
Volume analysis: Create custom volume profiles independent of chart timeframe
Scalping strategies: Identify short-term patterns with precisely defined time windows
Volatility measurement: Track price movement characteristics within bars
Custom signal generation: Create entry/exit signals based on custom timeframe patterns
Conclusion
The Real-Time Candles Library bridges the gap between traditional technical analysis (based on discrete OHLC bars) and the continuous nature of market movement. By making indicators more responsive to real-time price action, it gives traders a significant edge in timing and decision-making, particularly in fast-moving markets where waiting for bar close could mean missing important opportunities.
Whether you're building custom indicators, researching price patterns, or developing trading strategies, this library provides the foundation for sophisticated real-time analysis in Pine Script.
Implementation Details & Advanced Guide
Core Implementation Concepts
The Real-Time Candles Library implements a sophisticated event-driven architecture within Pine Script's constraints. At its heart, the library creates what's essentially a reactive programming framework handling continuous data streams.
Tick Processing System
The foundation of the library is the get_tick() function, which captures price updates as they occur:
export get_tick(series float source = close, series float na_replace = na)=>
varip float price = na
varip int series_index = -1
varip int old_time = 0
varip int new_time = na
varip float time_delta = 0
// ...
This function:
Samples the current price
Calculates time elapsed since last update
Maintains a sequential index to track updates
The resulting TickData structure serves as the fundamental building block for all candle generation.
State Management Architecture
The library employs a sophisticated state management system using varip variables, which persist across executions within the same bar. This creates a hybrid programming paradigm that's different from standard Pine Script's bar-by-bar model.
For chart-time candles, the core state transition logic is:
// Real-time update of current candle
candle_data := Candle.new(Open, High, Low, Close, polarity, series_index, candle_color)
candles.set(0, candle_data)
// When a new bar starts, preserve the previous candle
if clear_state
candles.insert(1, candle_data)
price.clear()
// Reset state for new candle
Open := Close
price.push(Open)
series_index += 1
This pattern of updating index 0 in real-time while inserting completed candles at index 1 creates an elegant solution for maintaining both current state and historical data.
Custom Timeframe Implementation
The custom timeframe system manages its own time boundaries independent of chart bars:
bool clear_state = switch settings.sample_type
SampleType.Ticks => cumulative_series_idx >= settings.number_of_ticks
SampleType.Time => cumulative_time_delta >= settings.number_of_seconds
This dual-clock system synchronizes two time domains:
Pine's execution clock (bar-by-bar processing)
The custom timeframe clock (tick or time-based)
The library carefully handles temporal discontinuities, ensuring candle formation remains accurate despite irregular tick arrival or market gaps.
Advanced Usage Techniques
1. Creating Custom Indicators with Real-Time Candles
To develop indicators that process real-time data within the current bar:
// Get real-time candles for your data
Candle rsi_candles = candle_array(ta.rsi(close, 14))
// Calculate indicator values based on candle properties
float signal = ta.ema(rsi_candles.first().source(Source.Close), 9)
// Detect patterns that occur within the bar
bool divergence = close > close and rsi_candles.first().Close < rsi_candles.get(1).Close
2. Working with Custom Timeframes and Plotting
For maximum flexibility when visualizing custom timeframe data:
// Create custom timeframe candles
CandleCTF volume_candles = ctf_candles_array(
source = volume,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 60
)
// Convert specific candle properties to float arrays
float volume_closes = volume_candles.candle_ctf_to_float(Source.Close)
// Calculate derived values
float volume_ema = volume_candles.ctf_ema(14)
// Create custom visualization
volume_candles.draw_ctf_candles_time()
volume_ema.draw_ctf_line_time(line_color = color.orange)
3. Creating Hybrid Timeframe Analysis
One powerful application is comparing indicators across multiple timeframes:
// Standard chart timeframe RSI
float chart_rsi = ta.rsi(close, 14)
// Custom 5-second timeframe RSI
CandleCTF ctf_candles = ctf_candles_array(
source = close,
candle_type = CandleType.candlestick,
sample_type = SampleType.Time,
number_of_seconds = 5
)
float fast_rsi_array = ctf_candles.candle_ctf_to_float(Source.Close)
float fast_rsi = fast_rsi_array.first()
// Generate signals based on divergence between timeframes
bool entry_signal = chart_rsi < 30 and fast_rsi > fast_rsi_array.get(1)
Final Notes
This library represents an advanced implementation of real-time data processing within Pine Script's constraints. By creating a reactive programming framework for handling continuous data streams, it enables sophisticated analysis typically only available in dedicated trading platforms.
The design principles employed—including state management, temporal processing, and object-oriented architecture—can serve as patterns for other advanced Pine Script development beyond this specific application.
------------------------
Library "real_time_candles"
A comprehensive library for creating real-time candles with customizable timeframes and sampling methods.
Supports both chart-time and custom-time candles with options for candlestick and Heikin-Ashi visualization.
Allows for tick-based or time-based sampling with moving average overlay capabilities.
get_tick(source, na_replace)
Captures the current price as a tick data point
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
na_replace (float) : Optional - Value to use when source is na
Returns: TickData structure containing price, time since last update, and sequential index
candle_array(source, candle_type, sync_start, bullish_color, bearish_color)
Creates an array of candles based on price updates
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
sync_start (simple bool) : Optional - Whether to synchronize with the start of a new bar
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Array of Candle objects ordered with most recent at index 0
candle_series(source, candle_type, wait_for_sync, bullish_color, bearish_color)
Provides a single candle based on the latest price data
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: A single Candle object representing the current state
candle_tuple(source, candle_type, wait_for_sync, bullish_color, bearish_color)
Provides candle data as a tuple of OHLC values
Parameters:
source (float) : Optional - Price source to sample (defaults to close)
candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)
wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Tuple representing current candle values
method source(self, source, na_replace)
Extracts a specific price component from a Candle
Namespace types: Candle
Parameters:
self (Candle)
source (series Source) : Type of price data to extract (Open, High, Low, Close, or composite values)
na_replace (float) : Optional - Value to use when source value is na
Returns: The requested price value from the candle
method source(self, source)
Extracts a specific price component from a CandleCTF
Namespace types: CandleCTF
Parameters:
self (CandleCTF)
source (simple Source) : Type of price data to extract (Open, High, Low, Close, or composite values)
Returns: The requested price value from the candle as a varip
method candle_ctf_to_float(self, source)
Converts a specific price component from each CandleCTF to a float array
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
Returns: Array of float values extracted from the candles, ordered with most recent at index 0
method ctf_ema(self, ema_period)
Calculates an Exponential Moving Average for a CandleCTF array
Namespace types: array
Parameters:
self (array)
ema_period (simple float) : Period for the EMA calculation
Returns: Array of float values representing the EMA of the candle data, ordered with most recent at index 0
method draw_ctf_candles_time(self, sample_type, number_of_ticks, number_of_seconds, timezone)
Renders custom timeframe candles using bar time coordinates
Namespace types: array
Parameters:
self (array)
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips
Returns: void - Renders candles on the chart using time-based x-coordinates
method draw_ctf_candles_index(self, sample_type, number_of_ticks, number_of_seconds, timezone)
Renders custom timeframe candles using bar index coordinates
Namespace types: array
Parameters:
self (array)
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips
Returns: void - Renders candles on the chart using index-based x-coordinates
method draw_ctf_line_time(self, source, line_size, line_color)
Renders a line representing a price component from the candles using time coordinates
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
line_size (simple int) : Optional - Width of the line
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using time-based x-coordinates
method draw_ctf_line_time(self, line_size, line_color)
Renders a line from a varip float array using time coordinates
Namespace types: array
Parameters:
self (array)
line_size (simple int) : Optional - Width of the line, defaults to 2
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using time-based x-coordinates
method draw_ctf_line_index(self, source, line_size, line_color)
Renders a line representing a price component from the candles using index coordinates
Namespace types: array
Parameters:
self (array)
source (simple Source) : Optional - Type of price data to extract (defaults to Close)
line_size (simple int) : Optional - Width of the line
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using index-based x-coordinates
method draw_ctf_line_index(self, line_size, line_color)
Renders a line from a varip float array using index coordinates
Namespace types: array
Parameters:
self (array)
line_size (simple int) : Optional - Width of the line, defaults to 2
line_color (simple color) : Optional - Color of the line
Returns: void - Renders a connected line on the chart using index-based x-coordinates
plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)
Plots tick-based candles with moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_ticks (simple int) : Number of ticks per candle
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
ema_period (simple float) : Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with EMA overlay
plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)
Plots tick-based candles without moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_ticks (simple int) : Number of ticks per candle
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart without moving average
plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)
Plots time-based candles with moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_seconds (simple float) : Time duration per candle in seconds
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
ema_period (simple float) : Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with EMA overlay
plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)
Plots time-based candles without moving average
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to display
number_of_seconds (simple float) : Time duration per candle in seconds
timezone (simple int) : Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart without moving average
plot_ctf_candles(source, candle_type, sample_type, number_of_ticks, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, enable_ema, line_width, ema_color, use_time_indexing)
Unified function for plotting candles with comprehensive options
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Optional - Type of candle chart to display
sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks)
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)
timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12)
tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle
ema_period (simple float) : Optional - Period for the exponential moving average
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
enable_ema (bool) : Optional - Whether to display the EMA overlay
line_width (simple int) : Optional - Width of the moving average line, defaults to 2
ema_color (color) : Optional - Color of the moving average line
use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index
Returns: void - Creates visual candle chart with optional EMA overlay
ctf_candles_array(source, candle_type, sample_type, number_of_ticks, number_of_seconds, tied_open, bullish_color, bearish_color)
Creates an array of custom timeframe candles without rendering them
Parameters:
source (float) : Input price source to sample
candle_type (simple CandleType) : Type of candle chart to create (candlestick or Heikin-Ashi)
sample_type (simple SampleType) : Method for sampling data (Time or Ticks)
number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)
number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)
tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle
bullish_color (color) : Optional - Color for bullish candles
bearish_color (color) : Optional - Color for bearish candles
Returns: Array of CandleCTF objects ordered with most recent at index 0
Candle
Structure representing a complete candle with price data and display properties
Fields:
Open (series float) : Opening price of the candle
High (series float) : Highest price of the candle
Low (series float) : Lowest price of the candle
Close (series float) : Closing price of the candle
polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)
series_index (series int) : Sequential index identifying the candle in the series
candle_color (series color) : Color to use when rendering the candle
ready (series bool) : Boolean indicating if candle data is valid and ready for use
TickData
Structure for storing individual price updates
Fields:
price (series float) : The price value at this tick
time_delta (series float) : Time elapsed since the previous tick in milliseconds
series_index (series int) : Sequential index identifying this tick
CandleCTF
Structure representing a custom timeframe candle with additional time metadata
Fields:
Open (series float) : Opening price of the candle
High (series float) : Highest price of the candle
Low (series float) : Lowest price of the candle
Close (series float) : Closing price of the candle
polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)
series_index (series int) : Sequential index identifying the candle in the series
open_time (series int) : Timestamp marking when the candle was opened (in Unix time)
time_delta (series float) : Duration of the candle in milliseconds
candle_color (series color) : Color to use when rendering the candle
Mogwai Method with RSI and EMA - BTCUSD 15mThis is a custom TradingView indicator designed for trading Bitcoin (BTCUSD) on a 15-minute timeframe. It’s based on the Mogwai Method—a mean-reversion strategy—enhanced with the Relative Strength Index (RSI) for momentum confirmation. The indicator generates buy and sell signals, visualized as green and red triangle arrows on the chart, to help identify potential entry and exit points in the volatile cryptocurrency market.
Components
Bollinger Bands (BB):
Purpose: Identifies overextended price movements, signaling potential reversions to the mean.
Parameters:
Length: 20 periods (standard for mean-reversion).
Multiplier: 2.2 (slightly wider than the default 2.0 to suit BTCUSD’s volatility).
Role:
Buy signal when price drops below the lower band (oversold).
Sell signal when price rises above the upper band (overbought).
Relative Strength Index (RSI):
Purpose: Confirms momentum to filter out false signals from Bollinger Bands.
Parameters:
Length: 14 periods (classic setting, effective for crypto).
Overbought Level: 70 (price may be overextended upward).
Oversold Level: 30 (price may be overextended downward).
Role:
Buy signal requires RSI < 30 (oversold).
Sell signal requires RSI > 70 (overbought).
Exponential Moving Averages (EMAs) (Plotted but not currently in signal logic):
Purpose: Provides trend context (included in the script for visualization, optional for signal filtering).
Parameters:
Fast EMA: 9 periods (short-term trend).
Slow EMA: 50 periods (longer-term trend).
Role: Can be re-added to filter signals (e.g., buy only when Fast EMA > Slow EMA).
Signals (Triangles):
Buy Signal: Green upward triangle below the bar when price is below the lower Bollinger Band and RSI is below 30.
Sell Signal: Red downward triangle above the bar when price is above the upper Bollinger Band and RSI is above 70.
How It Works
The indicator combines Bollinger Bands and RSI to spot mean-reversion opportunities:
Buy Condition: Price breaks below the lower Bollinger Band (indicating oversold conditions), and RSI confirms this with a reading below 30.
Sell Condition: Price breaks above the upper Bollinger Band (indicating overbought conditions), and RSI confirms this with a reading above 70.
The strategy assumes that extreme price movements in BTCUSD will often revert to the mean, especially in choppy or ranging markets.
Visual Elements
Green Upward Triangles: Appear below the candlestick to indicate a buy signal.
Red Downward Triangles: Appear above the candlestick to indicate a sell signal.
Bollinger Bands: Gray lines (upper, middle, lower) plotted for reference.
EMAs: Blue (Fast) and Orange (Slow) lines for trend visualization.
How to Use the Indicator
Setup
Open TradingView:
Log into TradingView and select a BTCUSD chart from a supported exchange (e.g., Binance, Coinbase, Bitfinex).
Set Timeframe:
Switch the chart to a 15-minute timeframe (15m).
Add the Indicator:
Open the Pine Editor (bottom panel in TradingView).
Copy and paste the script provided.
Click “Add to Chart” to apply it.
Verify Display:
You should see Bollinger Bands (gray), Fast EMA (blue), Slow EMA (orange), and buy/sell triangles when conditions are met.
Trading Guidelines
Buy Signal (Green Triangle Below Bar):
What It Means: Price is oversold, potentially ready to bounce back toward the Bollinger Band middle line.
Action:
Enter a long position (buy BTCUSD).
Set a take-profit near the middle Bollinger Band (bb_middle) or a resistance level.
Place a stop-loss 1-2% below the entry (or based on ATR, e.g., ta.atr(14) * 2).
Best Context: Works well in ranging markets; avoid during strong downtrends.
Sell Signal (Red Triangle Above Bar):
What It Means: Price is overbought, potentially ready to drop back toward the middle line.
Action:
Enter a short position (sell BTCUSD) or exit a long position.
Set a take-profit near the middle Bollinger Band or a support level.
Place a stop-loss 1-2% above the entry.
Best Context: Effective in ranging markets; avoid during strong uptrends.
Trend Filter (Optional):
To reduce false signals in trending markets, you can modify the script:
Add and ema_fast > ema_slow to the buy condition (only buy in uptrends).
Add and ema_fast < ema_slow to the sell condition (only sell in downtrends).
Check the Fast EMA (blue) vs. Slow EMA (orange) alignment visually.
Tips for BTCUSD on 15-Minute Charts
Volatility: BTCUSD can be erratic. If signals are too frequent, increase bb_mult (e.g., to 2.5) or adjust RSI levels (e.g., 75/25).
Confirmation: Use volume spikes or candlestick patterns (e.g., doji, engulfing) to confirm signals.
Time of Day: Mean-reversion works best during low-volume periods (e.g., Asian session in crypto).
Backtesting: Use TradingView’s Strategy Tester (convert to a strategy by adding entry/exit logic) to evaluate performance with historical BTCUSD data up to March 13, 2025.
Risk Management
Position Size: Risk no more than 1-2% of your account per trade.
Stop Losses: Always use stops to protect against BTCUSD’s sudden moves.
Avoid Overtrading: Wait for clear signals; don’t force trades in choppy or unclear conditions.
Example Scenario
Chart: BTCUSD, 15-minute timeframe.
Buy Signal: Price drops to $58,000, below the lower Bollinger Band, RSI at 28. A green triangle appears.
Action: Buy at $58,000, target $59,000 (middle BB), stop at $57,500.
Sell Signal: Price rises to $60,500, above the upper Bollinger Band, RSI at 72. A red triangle appears.
Action: Sell at $60,500, target $59,500 (middle BB), stop at $61,000.
This indicator is tailored for mean-reversion trading on BTCUSD. Let me know if you’d like to tweak it further (e.g., add filters, alerts, or alternative indicators)!
2xSPYTIPS Strategy by Fra public versionThis is a test strategy with S&P500, open source so everyone can suggest everything, I'm open to any advice.
Rules of the "2xSPYTIPS" Strategy :
This trading strategy is designed to operate on the S&P 500 index and the TIPS ETF. Here’s how it works:
1. Buy Conditions ("BUY"):
- The S&P 500 must be above its **200-day simple moving average (SMA 200)**.
- This condition is checked at the **end of each month**.
2. Position Management:
- If leverage is enabled (**2x leverage**), the purchase quantity is increased based on a configurable percentage.
3. Take Profit:
- A **Take Profit** is set at a fixed percentage above the entry price.
4. Visualization & Alerts:
- The **SMA 200** for both S&P 500 and TIPS is plotted on the chart.
- A **BUY signal** appears visually and an alert is triggered.
What This Strategy Does NOT Do
- It does not use a **Stop Loss** or **Trailing Stop**.
- It does not directly manage position exits except through Take Profit.
PT Least Squares Moving AveragePT LSMA Multi-Period Indicator
The PT Least Squares Moving Average (LSMA) Multi-Period Indicator is a powerful tool designed for investors who want to track market trends across multiple time horizons in a single, convenient indicator. This indicator calculates the LSMA for four different periods— 25 bars, 50 bars, 450 bars, and 500 bars providing a comprehensive view of short-term and long-term market movements.
Key Features:
- Multi-Timeframe Trend Analysis: Tracks both short-term (25 & 50 bars) and long-term (450 & 500 bars) market trends, helping investors make informed decisions.
- Smoothing Capability: The LSMA reduces noise by fitting a linear regression line to past price data, offering a clearer trend direction compared to traditional moving averages.
- One-Indicator Solution: Combines multiple LSMA periods into a single chart, reducing clutter and enhancing visual clarity.
- Versatile Applications: Suitable for trend identification, market timing, and spotting potential reversals across different timeframes.
- Customizable Styling: Allows users to customize colors and line styles for each period to suit their preferences.
How to Use:
1. Short-Term Trends (25 & 50 bars):Ideal for identifying recent price movements and short-term trade opportunities.
2. Long-Term Trends (450 & 500 bars): Helps investors gauge broader market sentiment and position themselves accordingly for longer holding periods.
3. Trend Confirmation: When shorter LSMA periods cross above longer ones, it may signal bullish momentum, whereas the opposite may indicate bearish sentiment.
4. Support and Resistance: The LSMA lines can act as dynamic support and resistance levels during trending markets.
Best For:
- Long-term investors looking to align their positions with dominant market trends.
- Swing traders seeking confirmation from multiple time horizons.
- Portfolio managers tracking price momentum across various investment durations.
This LSMA Multi-Period Indicator equips investors with a well-rounded perspective on price movements, offering a strategic edge in navigating market cycles with confidence.
Created by Prince Thomas
Master Bitcoin & Litecoin Stock To Flow (S2F) ModelMaster Bitcoin & Litecoin Stock-to-Flow (S2F) Model
This indicator visualizes the Stock-to-Flow (S2F) models for Bitcoin (BTC) and Litecoin (LTC) based on Plan B's methodology. It calculates S2F and projects price models for both assets, incorporating daily changes in circulating supply. The script is designed exclusively for daily timeframes.
Features:
LTC & BTC S2F Models:
Calculates Stock-to-Flow values for both assets using daily new supply and circulating supply data.
Models S2F values with a customizable multiplier for precise adjustments.
500-Day Moving Average Models:
Smoothens the S2F model by applying a 500-day (18-month) moving average, providing a long-term trend perspective.
Customizable Inputs:
Adjust LTC and BTC multipliers to fine-tune the models.
Alert for Timeframe:
Alerts users to switch to the daily timeframe if another period is selected.
Plots:
LTC S2F Model: Blue line representing Litecoin’s calculated S2F-based price model.
BTC S2F Model: Orange line representing Bitcoin’s calculated S2F-based price model.
500-Day Avg Models: Smoothened S2F models for both LTC and BTC.
Notes:
Requires daily timeframe (1D) for accurate calculations.
Supply data is sourced from GLASSNODE:LTC_SUPPLY and GLASSNODE:BTC_SUPPLY.
Disclaimer:
This model is derived from Plan B's S2F methodology and is intended for educational and entertainment purposes only. It does not reflect official predictions or financial advice. Always conduct your own research before making investment decisions.
TICK Charting & DivergencesOverview
The TICK index measures the number of NYSE stocks making an uptick versus a downtick. This indicator identifies divergences between price action and TICK readings, potentially signaling trend reversals.
Key Features
Real-time TICK monitoring during market hours (9:30 AM - 4:00 PM ET)
Customizable smoothing factor for TICK values
Regular and hidden divergences detection
Reference lines at ±500 and ±1000 levels
Current TICK value display
TICK Internals Interpretation
Above +1000: Strong buying pressure, potential exhaustion
Above +500: Moderate buying pressure
Below -500: Moderate selling pressure
Below -1000: Strong selling pressure, potential exhaustion
Best Practices
Use in conjunction with support/resistance levels, market trend direction, and time of day.
Higher probability setups with multiple timeframe confirmation, divergence at key price levels, and extreme TICK readings (±1000).
Settings Optimization
Smoothing Factor: 1-3 (lower for faster signals)
Pivot Lookback: 5-10 bars (adjust based on timeframe)
Range: 5-60 bars (wider for longer-term signals)
Warning Signs
Multiple failed divergences
Choppy price action
Low volume periods
Major news events pending
Remember: TICK divergences are not guaranteed signals. Always use proper risk management and combine with other technical analysis tools.
Psychological Levels- Rounding Numbers Psychological Levels Indicator
Overview:
The Psychological Levels Indicator automatically identifies and plots significant price levels based on psychological thresholds, which are key areas where market participants often focus their attention. These levels act as potential support or resistance zones due to human behavioral tendencies to round off numbers. This indicator dynamically adjusts the levels based on the stock's price range and ensures seamless visibility across the chart.
Key Features:
Dynamic Step Sizes:
The indicator adjusts the levels dynamically based on the stock price:
For prices below 500: Levels are spaced at 10.
For prices between 500 and 3000: Levels are spaced at 50, 100, and 1000.
For prices between 3000 and 10,000: Levels are spaced at 100 and 1000.
For prices above 10,000: Levels are spaced at 500 and 1000.
Extended Visibility:
The plotted levels are extended across the entire chart for improved visualization, ensuring traders can easily monitor these critical zones over time.
Customization Options:
Line Color: Choose the color for the levels to suit your charting style.
Line Style: Select from solid, dashed, or dotted lines.
Line Width: Adjust the thickness of the lines for better clarity.
Clean and Efficient Design:
The indicator only plots levels relevant to the visible chart range, avoiding unnecessary clutter and ensuring a clean workspace.
How It Works:
It calculates the relevant step sizes based on the price:
Smaller step sizes for lower-priced stocks.
Larger step sizes for higher-priced stocks.
Primary, secondary, and (if applicable) tertiary levels are plotted dynamically:
Primary Levels: The most granular levels based on the stock price.
Secondary Levels: Higher-order levels for broader significance.
Tertiary Levels: Additional levels for lower-priced stocks to enhance detail.
These levels are plotted across the chart, allowing traders to visualize key psychological areas effortlessly.
Use Cases:
Day Trading: Identify potential intraday support and resistance levels.
Swing Trading: Recognize key price zones where trends may pause or reverse.
Long-Term Investing: Gain insights into significant price zones for entry or exit strategies.
Scatter PlotThe Price Volume Scatter Plot publication aims to provide intrabar detail as a Scatter Plot .
🔶 USAGE
A dot is drawn at every intrabar close price and its corresponding volume , as can seen in the following example:
Price is placed against the white y-axis, where volume is represented on the orange x-axis.
🔹 More detail
A Scatter Plot can be beneficial because it shows more detail compared with a Volume Profile (seen at the right of the Scatter Plot).
The Scatter Plot is accompanied by a "Line of Best Fit" (linear regression line) to help identify the underlying direction, which can be helpful in interpretation/evaluation.
It can be set as a screener by putting multiple layouts together.
🔹 Easier Interpretation
Instead of analysing the 1-minute chart together with volume, this can be visualised in the Scatter Plot, giving a straightforward and easy-to-interpret image of intrabar volume per price level.
One of the scatter plot's advantages is that volumes at the same price level are added to each other.
A dot on the scatter plot represents the cumulated amount of volume at that particular price level, regardless of whether the price closed one or more times at that price level.
Depending on the setting "Direction" , which sets the direction of the Volume-axis, users can hoover to see the corresponding price/volume.
🔹 Highest Intrabar Volume Values
Users can display up to 5 last maximum intrabar volume values, together with the intrabar timeframe (Res)
🔹 Practical Examples
When we divide the recent bar into three parts, the following can be noticed:
Price spends most of its time in the upper part, with relative medium-low volume, since the intrabar close prices are mostly situated in the upper left quadrant.
Price spends a shorter time in the middle part, with relative medium-low volume.
Price moved rarely below 61800 (the lowest part), but it was associated with high volume. None of the intrabar close prices reached the lowest area, and the price bounced back.
In the following example, the latest weekly candle shows a rejection of the 45.8 - 48.5K area, with the highest volume at the 45.8K level.
The next three successive candles show a declining maximum intrabar volume, after which the price broke through the 45.8K area.
🔹 Visual Options
There are many visual options available.
🔹 Change Direction
The Scatter Plot can be set in 4 different directions.
🔶 NOTES
🔹 Notes
The script uses the maximum available resources to draw the price/volume dots, which are 500 boxes and 500 labels. When the population size exceeds 1000, a warning is provided ( Not all data is shown ); otherwise, only the population size is displayed.
The Scatter Plot ideally needs a chart which contains at least 100 bars. When it contains less, a warning will be shown: bars < 100, not all data is shown
🔹 LTF Settings
When 'Auto' is enabled ( Settings , LTF ), the LTF will be the nearest possible x times smaller TF than the current TF. When 'Premium' is disabled, the minimum TF will always be 1 minute to ensure TradingView plans lower than Premium don't get an error.
Examples with current Daily TF (when Premium is enabled):
500 : 3 minute LTF
1500 (default): 1 minute LTF
5000: 30 seconds LTF (1 minute if Premium is disabled)
🔶 SETTINGS
Direction: Direction of Volume-axis; Left, Right, Up or Down
🔹 LTF
LTF: LTF setting
Auto + multiple: Adjusts the initial set LTF
Premium: Enable when your TradingView plan is Premium or higher
🔹 Character
Character: Style of Price/Volume dot
Fade: Increasing this number fades dots at lower price/volume
Color
🔹 Linear Regression
Toggle (enable/disable), color, linestyle
Center Cross: Toggle, color
🔹 Background Color
Fade: Increasing this number fades the background color near lower values
Volume: Background color that intensifies as the volume value on the volume-axis increases
Price: Background color that intensifies as the price value on the price-axis increases
🔹 Labels
Size: Size of price/volume labels
Volume: Color for volume labels/axis
Price: Color for price labels/axis
Display Population Size: Show the population size + warning if it exceeds 1000
🔹 Dashboard
Location: Location of dashboard
Size: Text size
Display LTF: Display the intrabar Lower Timeframe used
Highest IB volume: Display up to 5 previous highest Intrabar Volume values
Percentage price changeThis indicator marks bars whose values increase or decrease by an amount greater than or equal to the value of the specified parameter as a percentage. Bars that meet the condition are marked with labels, boxes and colors. In addition to the standard method of calculating the percentage change at the closing price of the current and previous bars, the indicator allows you to choose non-standard calculation methods (at the prices of opening and closing the current bar, as well as at the prices of the maximum at the minimum of the current bar). You can choose to display the percentage changes of individual bars as well as a series of bars. You can select the number of bars in a series of bars. You can also apply filters by the direction of the bars in the series or by the percentage of individual bars in the series.
It is important to remember that in version 5 of Pine Script™, the maximum possible number of labels and the maximum possible number of boxes cannot exceed 500!
There are several main parameters that can be changed in section PARAMETERS FOR CALCULATION:
1. 'Bars count' - The number of bars for which the percentage rise or fall is calculated.
2. ‘Percentage change’ - sets the price change as a percentage. Bars with a price range above or equal to the specified value will be marked on the chart.
3. ‘First and second points of calculation’ - the first and second points for calculating the percentage change. Here you can set several different values for the calculation:
- 'Cl.pr., Close' - Closing price of the previous bar and closing price of the current bar (or a series of bars) (these values are used for the standard calculation of the percentage change on the chart).
- 'Open, Close' - Opening and closing prices of the current bar (or a series of bars).
- 'High|Low' - Highest and lowest price of the current bar (or a series of bars).
- 'Cl.pr.|High|Low' - Highest or lowest price of the current bar (or a series of bars) (depending on whether the bar is going up or down) or closing price of the previous bar for first point (one of these values is automatically selected, which gives a larger result, depending on whether there is a gap between these values). Highest or lowest price of the current bar for second point.
In the LIMITS section, you can set the following parameters.
1. ‘Only for the last bar’ - If this option is selected, the indicator will be applied only for the last bar (or series of bars).
2. 'Only bars in one direction' - A condition that takes into account sequences from the selected number of bars going in only one direction. If at least one bar has a different direction from the other bars, then such a sequence will not be taken into account. This only works if the 'Bars count' is > 1.
3. "Cut off higher values" - This field cuts off higher values. Bars with a price range above or equal to the specified value will not be marked on the chart. This can be used in some cases to make the chart less loaded with data and more visual. Of course, you can also use this option however you want.
4. ‘Min percent in series of bars’ - If the value 'Number of bars' is > 1, then a series of bars is taken into account, in which the percentage change of individual bars is greater than or equal to the set value.
In the DATE RANGE section, you can set the limits of the time and date range in which the calculation will be performed. In some cases, this can be used in order not to exceed the limit on the number of labels or boxes, which cannot exceed 500. Of course, you can also use this option however you want. By default, the date range is unlimited.
'Timezone offset, hours' - It is used only for the correct display of the limits of the date range in the parameter table.
In the PRICE INCREASE LABELS and PRICE REDUCTION LABELS section, you can define the design of labels bars and boxes, such as colors, shapes, sizes, and location. You can set the colors of the bars separately on the Style tab. On the Style tab, you can also turn on/off the display of frames, labels and color markings of bars.
The PARAMETER TABLE section is designed to adjust the display of the table for a more visual display of the selected values of all parameters on the Arguments tab. Depending on which values have been set and which parameters have been enabled or disabled, the table will change its appearance, display or hide some rows. A single line 'Total found' will be displayed all the time. It shows the count of bars that meet the condition and count of labels or boxes used in the diagram. Since the bars are labeled with labels or boxes, their number cannot exceed 500 for Pine script version 5.
1. 'Pos.' - sets the main position of the table on the screen.
2. 'X off.', 'Y off.' - You can set the offset of the table along the X and Y axes. This option can be useful to avoid overlapping multiple tables if you want to use two or more instances of this indicator on your chart. The minimum value is -30, the maximum is 30. Positive values shift the table to the right on the X axis and up on the Y axis. Negative values shift the table to the left on the X axis and down on the Y axis.
3. 'Font color' - The font color in the table.
'Warn. font color', 'Warn. backgr. color' - The font and background colors in the 'Total found' row in the table. If the number of labels or boxes exceeds 500, the font and background will be colored in these colors.
4. ‘Font size’ – Sets the font size in the table.
5. 'Show hours and minutes in date/time range' - changes the date and time format of time range from {yyyy.MM.dd HH:mm} to {yyyy.MM.dd}.
6. 'View all params' - used to display all parameters, even those duplicated in the main line of the indicator.
7. ‘Title’ – If desired, you can make a header for the table.
The last row of the table shows the number of bars found that meet the conditions. Since these bars are marked with labels (in the case of one bar) or boxes (in the case of series of bars), the limit that can be marked on the chart is 500. Exceeding this value will be displayed in the table and additionally highlighted in red font. This will signal that not all bars found are displayed on the chart.
On the Style tab, you can turn the table display on/off.
FTMO Rules MonitorFTMO Rules Monitor: Stay on Track with Your FTMO Challenge Goals
TLDR; You can test with this template whether your strategy for one asset would pass the FTMO challenges step 1 then step 2, then with real money conditions.
Passing a prop firm challenge is ... challenging.
I believe a toolkit allowing to test in minutes whether a strategy would have passed a prop firm challenge in the past could be very powerful.
The FTMO Rules Monitor is designed to help you stay within FTMO’s strict risk management guidelines directly on your chart. Whether you’re aiming for the $10,000 or the $200,000 account challenge, this tool provides real-time tracking of your performance against FTMO’s rules to ensure you don’t accidentally breach any limits.
NOTES
The connected indicator for this post doesn't matter.
It's just a dummy double supertrends (see below)
The strategy results for this script post does not matter as I'm posting a FTMO rules template on which you can connect any indicator/strategy.
//@version=5
indicator("Supertrends", overlay=true)
// Supertrend 1 Parameters
var string ST1 = "Supertrend 1 Settings"
st1_atrPeriod = input.int(10, "ATR Period", minval=1, maxval=50, group=ST1)
st1_factor = input.float(2, "Factor", minval=0.5, maxval=10, step=0.5, group=ST1)
// Supertrend 2 Parameters
var string ST2 = "Supertrend 2 Settings"
st2_atrPeriod = input.int(14, "ATR Period", minval=1, maxval=50, group=ST2)
st2_factor = input.float(3, "Factor", minval=0.5, maxval=10, step=0.5, group=ST2)
// Calculate Supertrends
= ta.supertrend(st1_factor, st1_atrPeriod)
= ta.supertrend(st2_factor, st2_atrPeriod)
// Entry conditions
longCondition = direction1 == -1 and direction2 == -1 and direction1 == 1
shortCondition = direction1 == 1 and direction2 == 1 and direction1 == -1
// Optional: Plot Supertrends
plot(supertrend1, "Supertrend 1", color = direction1 == -1 ? color.green : color.red, linewidth=3)
plot(supertrend2, "Supertrend 2", color = direction2 == -1 ? color.lime : color.maroon, linewidth=3)
plotshape(series=longCondition, location=location.belowbar, color=color.green, style=shape.triangleup, title="Long")
plotshape(series=shortCondition, location=location.abovebar, color=color.red, style=shape.triangledown, title="Short")
signal = longCondition ? 1 : shortCondition ? -1 : na
plot(signal, "Signal", display = display.data_window)
To connect your indicator to this FTMO rules monitor template, please update it as follow
Create a signal variable to store 1 for the long/buy signal or -1 for the short/sell signal
Plot it in the display.data_window panel so that it doesn't clutter your chart
signal = longCondition ? 1 : shortCondition ? -1 : na
plot(signal, "Signal", display = display.data_window)
In the FTMO Rules Monitor template, I'm capturing this external signal with this input.source variable
entry_connector = input.source(close, "Entry Connector", group="Entry Connector")
longCondition = entry_connector == 1
shortCondition = entry_connector == -1
🔶 USAGE
This indicator displays essential FTMO Challenge rules and tracks your progress toward meeting each one. Here’s what’s monitored:
Max Daily Loss
• 10k Account: $500
• 25k Account: $1,250
• 50k Account: $2,500
• 100k Account: $5,000
• 200k Account: $10,000
Max Total Loss
• 10k Account: $1,000
• 25k Account: $2,500
• 50k Account: $5,000
• 100k Account: $10,000
• 200k Account: $20,000
Profit Target
• 10k Account: $1,000
• 25k Account: $2,500
• 50k Account: $5,000
• 100k Account: $10,000
• 200k Account: $20,000
Minimum Trading Days: 4 consecutive days for all account sizes
🔹 Key Features
1. Real-Time Compliance Check
The FTMO Rules Monitor keeps track of your daily and total losses, profit targets, and trading days. Each metric updates in real-time, giving you peace of mind that you’re within FTMO’s rules.
2. Color-Coded Visual Feedback
Each rule’s status is shown clearly with a ✓ for compliance or ✗ if the limit is breached. When a rule is broken, the indicator highlights it in red, so there’s no confusion.
3. Completion Notification
Once all FTMO requirements are met, the indicator closes all open positions and displays a celebratory message on your chart, letting you know you’ve successfully completed the challenge.
4. Easy-to-Read Table
A table on your chart provides an overview of each rule, your target, current performance, and whether you’re meeting each goal. The table adjusts its color scheme based on your chart settings for optimal visibility.
5. Dynamic Position Sizing
Integrated ATR-based position sizing helps you manage risk and avoid large drawdowns, ensuring each trade aligns with FTMO’s risk management principles.
Daveatt
US Sentiment Index [CryptoSea]The US Sentiment Index is an advanced analytical tool designed for traders seeking to uncover patterns, correlations, and potential leading signals across key market tickers. This indicator surpasses traditional sentiment measures, providing a data-driven approach that offers deeper insights compared to conventional indices like the Fear and Greed Index.
Key Features
Multi-Ticker Analysis: Integrates data from a diverse set of market indicators, including gold, S&P 500, U.S. Dollar Index, Volatility Index, and more, to create a comprehensive view of market sentiment.
Customisable Sensitivity Settings: Allows users to adjust the moving average period to fine-tune the sensitivity of sentiment calculations, adapting the tool to various market conditions and trading strategies.
Detailed Sentiment Scaling: Utilises a 0-100 scale to quantify sentiment strength, with colour gradients that visually represent bearish, neutral, and bullish conditions, aiding in quick decision-making.
Below is an example where the sentiment index can give leading signals. We see a first sign of wekaness in the index as it drops below its moving average. Shortly after we see it dip below our median 50 level, another sign of weakeness. We see the SPX price action to take a hit following the sentiment index decrease.
Tickers Used and Their Impact on Sentiment
The impact of each ticker on sentiment can be bullish or bearish, depending on their behaviour:
Gold (USGD): Typically seen as a safe-haven asset, rising gold prices often indicate increased market fear or bearish sentiment. Conversely, falling gold prices can signal reduced fear and a shift towards bullish sentiment in riskier assets.
S&P 500 (SPX): A rising S&P 500 is usually a sign of bullish sentiment, reflecting confidence in economic growth and market stability. A decline, however, suggests bearish sentiment and a potential move towards risk aversion.
U.S. Dollar Index (DXY): A strengthening U.S. Dollar can be a sign of fear as investors seek safety in the dollar, which is bearish for risk assets. A weakening dollar, on the other hand, can signal bullish sentiment as capital flows into riskier assets.
Volatility Index (VIX): Known as the "fear gauge," a rising VIX indicates increased market fear and bearish sentiment. A falling VIX suggests a calm, bullish market environment.
Junk Bonds (JNK): Rising junk bond prices often reflect bullish sentiment as investors take on more risk for higher returns. Conversely, falling junk bond prices signal increased fear and bearish sentiment.
Long-Term Treasury Bonds (TLT): Higher prices for long-term treasuries usually indicate a flight to safety, reflecting bearish sentiment. Lower prices suggest a shift towards riskier assets, indicating bullish sentiment.
Financial Sector ETF (XLF): Strength in the financial sector is typically bullish, indicating confidence in economic conditions. Weakness in this sector can reflect bearish sentiment and concerns about financial stability.
Unemployment Rate (USUR): A rising unemployment rate is a bearish signal, indicating economic weakness. A declining unemployment rate is bullish, reflecting economic strength and job growth.
U.S. Interest Rates (USINTR, USIRYY): Higher interest rates can be bearish, as they increase borrowing costs and reduce spending. Lower rates are generally bullish, promoting economic growth and risk-taking.
How it Works
Sentiment Calculation: The US Sentiment Index combines data from multiple tickers, calculating sentiment by scaling the distance from their respective moving averages. Each asset's behaviour is interpreted within the context of market fear or greed, providing a refined sentiment reading that adjusts dynamically.
Market Strength Analysis: When the index is above 50 and also above its moving average, it indicates particularly strong or bullish market conditions, driven by greed. Conversely, when the index is below 50 and under its moving average, it signals bearish or weak market conditions, associated with fear.
Correlation and Pattern Detection: The indicator analyses correlations among the included assets to detect patterns that might signal potential market movements, giving traders a leading edge over simpler sentiment measures.
Adaptive Background Colouring: Utilises a colour gradient that dynamically adjusts based on sentiment values, highlighting extreme fear, neutral, and extreme greed levels directly on the chart.
Flexible Display Options: Offers settings to toggle the moving average plot and adjust its period, giving users the ability to tailor the indicator's sensitivity and display to their specific needs.
In this example below, we can see the Sentiment rise above the Moving Average (MA). Price action goes on to follow this, although there is an instance where it dips below the MA, it quickly rises back above again as a sign of strength.
Another way you can use this index is by simply using the MA, if its trending up, we know the macro sentiment is bullish.
Application
Data-Driven Insights: Offers traders a detailed, data-driven approach to sentiment analysis, incorporating a broad spectrum of market indicators to deliver actionable insights.
Pattern Recognition: Helps identify patterns and correlations that may lead to market reversals or continuations, providing a nuanced view that goes beyond simple sentiment gauges.
Enhanced Decision-Making: Equips traders with a robust tool to validate trading strategies and make informed decisions based on comprehensive sentiment analysis.
The US Sentiment Index by is an essential addition to the toolkit of any trader looking to navigate market complexities with precision and confidence. Its advanced features and data-driven approach offer unparalleled insights into market sentiment, setting it apart from conventional sentiment indicators.
Ultimate ZonesThe story is simple: I didn't find a support/resistance zones indicator that I actually liked, so I made my own.
Features:
Independent of the chart timeframe (zones don't change if you switch timeframes) - very important for practical use
Live mode (repainting) plus historic mode (non-repainting)
Selectable timeframe for zone calculation (default: daily)
Can adjust how far the indicator looks back into the past (default: 500 days)
Can adjust pivot period to find more or fewer zones
Zone heights are based on long-term ATR (to adapt to the asset's volatility automatically)
Price tolerance multiplier is adjustable
Option to merge zones which are close together into one ("fat zones")
I find that together these options (especially those in the "sensitivity" section) allow me to automatically generate almost all the zones I want to see. Occasionally, I do draw some additional zones to get the perfect image I'm looking for on the chart.
Explanation
We detect pivot points on the selected zone timeframe (taking pivot period and lookback limit into account). Then we combine these pivot points into a zone if they are close enough together in price (here the tolerance parameter comes into play). If "fat zones" is selected, we perform these merges more aggressively even if the resulting zone becomes taller than the standard tolerance.
The ATR used for the tolerance is a 500 period ATR, but if there are less than 500 bars available, we use the average of the bars available so far, so we always have a value to work with.
In order for a zone to be displayed, it must have been touched by at least 2 separate pivot points. We do not distinguish between pivot highs and pivot lows because support is known to turn into resistance and vice versa.
In live mode, we draw the currently active zones as boxes.
In historic mode, we plot the active zones at each bar using "plot" and "fill", so there is no repainting or erasing, and you can see which zones were active at any past date. For practical reasons, we draw a maximum of 15 zones around the current price (i.e. 7-8 zones above and 7-8 zones below the price).
Money Flow DivergenceThe Money Flow Divergence indicator is designed to help traders identify periods when there is a significant divergence between the growth of the U.S. M2 money supply and the S&P 500 index (SPX).
This divergence can provide insights into potential market turning points, making it a valuable tool for long-term investors and traders looking to capitalize on macroeconomic trends.
How It Works:
Data Sources:
S&P 500 Index (SPX) and U.S. M2 Money Supply.
Calculating Growth Rates:
SPX Growth: The script calculates the percentage growth of the S&P 500 index by comparing the current closing price with the previous period's closing price.
M2 Growth: Similarly, it calculates the percentage growth of the U.S. M2 money supply by comparing the current value with the previous period's value.
Growth Gap/Delta:
Growth Gap: The core of the indicator is the "growth gap" or "delta," which is the difference between the M2 money supply growth and the SPX growth. This gap indicates whether liquidity in the economy (represented by M2) is outpacing or lagging behind the performance of the stock market.
Interpretation:
Positive Gap (Green Bars): When the M2 growth outpaces SPX growth, the gap is positive, indicating that there is more liquidity in the system than what is being reflected in the stock market. This scenario often signals potential upward momentum in the market, making it a good time to consider buying.
Negative Gap (Red Bars): When the SPX growth outpaces M2 growth, the gap is negative, suggesting that the market may be overextended relative to the available liquidity. This can be a warning sign of potential market corrections or downturns.
Visualization:
The indicator plots the growth gap as a histogram with bars colored based on the gap value:
Green Bars: Indicate a positive gap where M2 growth is higher than SPX growth.
Red Bars: Indicate a negative gap where SPX growth is higher than M2 growth.
The bars are thickened for better visibility, and a horizontal line at zero is plotted to help users easily distinguish between positive and negative gaps.
How To Use It:
Time Frame Selection: Users can select the desired time frame (e.g., monthly, weekly) for the data. This flexibility allows traders to analyze the indicator over different periods, depending on their investment horizon.
Monthly time frames seem to work best.
Interpreting the Indicator:
Bullish Signals: Look for sustained periods of positive growth gaps (green bars), which may indicate a favorable environment for buying or holding long positions.
Bearish Signals: Be cautious during periods of negative growth gaps (red bars), which could signal overvaluation in the market or potential pullbacks.
Enjoy and let me know if you have any questions.
VIX Percentile Rank HistogramVIX Percentile Rank Histogram
The VIX Percentile Rank Histogram provides a visual representation of the CBOE Volatility Index (VIX) percentile rank over a customizable lookback period, helping traders gauge market sentiment and make informed trading decisions.
Overview:
This indicator calculates the percentile rank of the VIX over a specified lookback period and displays it as a histogram. The histogram helps traders understand whether the current VIX level is relatively high or low compared to its recent history. This information is particularly useful for timing entries and exits in the S&P 500 or related ETFs and Mega Caps.
How It Works:
VIX Data Integration: The script fetches daily VIX close prices, regardless of the chart you are viewing, to analyze market volatility.
Percentile Rank Calculation: The indicator calculates the rank percentile of the VIX over the chosen lookback period.
Histogram Visualization: The histogram plots the difference between the flipped VIX percentile rank and 50, showing green bars for ranks below 50 (indicating lower market volatility) and red bars for ranks above 50 (indicating higher market volatility).
Usage:
This indicator is most effective when trading the S&P 500 (SPX, SPY, ES1!) or ETFs and Mega Caps that closely follow the S&P 500. It provides insight into market sentiment, helping traders make more informed decisions.
Timing Entries and Exits: Green histogram readings suggest it's a good time to enter or hold long positions, while red readings suggest considering exits or short positions.
Market Sentiment: A high VIX percentile rank (red bars) indicates market fear and uncertainty, while a low percentile rank (green bars) suggests investor confidence and reduced volatility.
Key Features:
Customizable Lookback Period: The default lookback period is set to 20 days, but can be adjusted based on the trader's average trade duration. For example, if your trades typically last 20 days, a 20-day lookback period helps contextualize the VIX level relative to its recent history.
Histogram Visualization: The histogram provides a clear visual representation of market volatility.
Green Bars: Indicate a lower-than-median VIX percentile rank, suggesting reduced market volatility.
Red Bars: Indicate a higher-than-median VIX percentile rank, suggesting increased market volatility.
Threshold Line: A dashed gray line at the 0 level serves as a visual reference for the median VIX rank.
Important Note:
This indicator always shows readings from the VIX, regardless of the chart you are viewing. For example, if you are looking at Natural Gas futures, this indicator will provide no relevant data. It works best when trading the S&P 500 or related ETFs and Mega Caps.
Zone TP SL [By Gone]It creates a price zone for TP 3 Level, increasing from the price by 500 points and setting an SL zone of 500 points of the price.
You must enter the price range yourself, recommended to be 500 points apart.
1. select Type Bay And Sell
2. Input Price Start And End
suitable for gold
Made to help with hitting the price zone. For use in making decisions about trading.
1995-Present - Inflation and Purchasing PowerGood day, everyone! Today, we're going to look at a chart that's a bit different from the usual price charts we analyse. This isn't just any chart; it's a lens into the past, adjusted for the reality of inflation—a concept we often hear about but seldom see directly applied to our trading charts.
What we have here is an 'Inflation Adjusted Price' indicator on TradingView, and it's doing something quite special. It's showing us the price of our asset, let's say the S&P 500, not just in today's dollars, but in the dollars of 1995. Why 1995, you ask? Well, it's the starting point we've chosen to measure how much actual buying power has changed since then.
So, every point on this red line we see represents what the S&P 500's value would be if we stripped away the effects of inflation. This is the price in terms of what your money could actually buy you back in 1995.
As traders and investors, we're always looking at prices going up and thinking, 'Great! My investment is growing!' But the real question we should ask is, 'Is my money growing in real terms? Can it buy me more than it did last year, or five, ten, or twenty-five years ago?'
This chart tells us exactly that. If the red line is above the actual price, it means that the S&P 500 has not just grown in nominal terms, but it has actually outpaced inflation. Your investment has grown in real terms; it can buy you more now than it could back in 1995.
On the flip side, if the red line is below the actual price, that's a sign that while the nominal price might be up, the real value, the purchasing power, hasn't grown as much or could even have fallen.
This view is crucial, especially for the long-term investors among us. It gives us a reality check on our investments and savings. Are we truly growing our wealth, or are we just keeping up with the cost of living? This indicator answers that.
Remember, the true measure of financial growth is not just the numbers on a chart. It's what you can do with those numbers—how much bread, or eggs, or yes, even houses, you can buy with your hard-earned money
Historical Price Projection [LuxAlgo]The Historical Price Projection tool aims to project future price behavior based on historical price behavior plus a user defined growth factor.
The main feature of this tool is to plot a future price forecast with a surrounding area that exactly matches the price behavior of the selected period, with or without added drift.
Other features of the tool include:
User-selected period up to 500 bars anywhere on the chart within 5000 bars
User selected growth factor from 0 (no growth) to 100, this is the percentage of drift to be used in the forecast.
User selected area wide
Show/hide forecast area
🔶 USAGE
This tool generates a price projection with exactly the same price behavior over the period selected by the user, plus a growth factor .
The user must confirm the selection of the anchor point in order for the tool to be executed; this can be done directly on the chart by clicking on any bar, or via the date field in the settings panel.
As we can see on this chart, the four phases of the market cycle are clearly defined and marked, so we choose the distribution phase as our anchor point because in our analysis, we want to see how the market would behave if we were currently at the same point in the cycle.
In the image above, the growth factor parameter is set to 0 so that the projection matches the selection. The tool will use up to 500 bars after the selection point.
The growth factor is defined as the percentage of drift that the tool will use.
Drift is defined as follows:
For periods with a positive return: average negative return within the period
For negative return periods: average positive return within the period
On the chart above, we have selected the same period but added a growth factor of 10, so that the tool uses a 10% drift in its calculations of future prices.
As the return in the selected period is negative, the added drift will make the projection more bearish than the prices from the selection.
On this chart we have changed the selected period, we have chosen the accumulation phase of the last cycle as the anchor point, again with a growth factor of 10%.
As we can see, prices explode higher, making the projection very bullish, as the added effect of both the bullish selected period and the 10% drift is taken into account.
This last chart is a long-term chart, a quarterly chart of the Dow, and it will serve as a review exercise.
What if... everything goes south and the crash of '29 is repeated?
The answer is in the chart, and it is not for the faint of heart
In this case we have chosen a growth factor of 0 to see exactly the same price behaviour projected into the future.
🔶 SETTINGS
🔹 Data Gathering
Anchor point: Starting point for data collection, up to 500 bars will be used.
🔹 Data Transformation
Growth Factor: Values from 0 to 100, is the amount of drift used to calculate the next price in the series.
Area Width: Values from 0 to 100, controls the width of the area around the forecast as an increment/decrement of the growth factor.
🔹 Style
Price line width: Size of the price line.
Bullish color
Bearish color
Show Area: Show forecast area.
Area color
Spot-Vol CorrelationSpot-Vol Correlation Script Guide
Purpose:
This TradingView script measures the correlation between percentage changes in the spot price (e.g., for SPY, an ETF that tracks the S&P 500 index) and the changes in volatility (e.g., as indicated by the VIX, the Volatility Index). Its primary objective is to discern whether the relationship between spot price and volatility behaves as expected ("normal" condition) or diverges from the expected pattern ("abnormal" condition).
Normal vs. Abnormal Correlation:
Normal Correlation: Historically, the VIX (or volatility) and the spot price of major indices like the S&P 500 have an inverse relationship. When the spot price of the index goes up, the VIX tends to go down, indicating lower volatility. Conversely, when the index drops, the VIX generally rises, signaling increased volatility.
Abnormal Correlation: There are instances when this inverse relationship doesn't hold, and both the spot price and the VIX move in the same direction. This is considered an "abnormal" condition and might indicate unusual market dynamics, potential uncertainty, or impending shifts in market sentiment.
Using the Script:
Inputs:
First Symbol: This is set by default to VIX, representing volatility. However, users can input any other volatility metric they prefer.
Second Symbol: This is set to SPY by default, representing the spot price of the S&P 500 index. Like the first symbol, users can substitute SPY with any other asset or index of their choice.
Length of Calculation Period: Users can define the lookback period for the correlation calculation. By default, it's set to 10 periods (e.g., days for a daily chart).
Upper & Lower Bounds of Normal Zone: These parameters define the range of correlation values that are considered "normal" or expected. By default, this is set between -0.60 and -1.00.
Visuals:
Correlation Line: The main line plot shows the correlation coefficient between the two input symbols. When this line is within the "normal zone", it indicates that the spot price and volatility are inversely correlated. If it's outside this zone, the correlation is considered "abnormal".
Green Color: Indicates a period when the spot price and VIX are behaving as traditionally expected (i.e., one rises while the other falls).
Red Color: Denotes a period when the spot price and VIX are both moving in the same direction, which is an abnormal condition.
Shaded Area (Normal Zone): The area between the user-defined upper and lower bounds is shaded in green, highlighting the range of "normal" correlation values.
Interpretation:
Monitor the color and position of the correlation line relative to the shaded area:
If the line is green and within the shaded area, the market dynamics are as traditionally expected.
If the line is red or outside the shaded area, users should exercise caution as this indicates a divergence from typical behavior, which can precede significant market moves or heightened uncertainty.
Liquidity Heatmap [BigBeluga]The Liquidity Heatmap is an indicator designed to spot possible resting liquidity or potential stop loss using volume or Open interest.
The Open interest is the total number of outstanding derivative contracts for an asset—such as options or futures—that have not been settled. Open interest keeps track of every open position in a particular contract rather than tracking the total volume traded.
The Volume is the total quantity of shares or contracts traded for the current timeframe.
🔶 HOW IT WORKS
Based on the user choice between Volume or OI, the idea is the same for both.
On each candle, we add the data (volume or OI) below or above (long or short) that should be the hypothetical liquidation levels; More color of the liquidity level = more reaction when the price goes through it.
Gradient color is calculated between an average of 2 points that the user can select. For example: 500, and the script will take the average of the highest data between 500 and 250 (half of the user's choice), and the gradient will be based on that.
If we take volume as an example, a big volume spike will mean a lot of long or short activity in that candle. A liquidity level will be displayed below/above the set leverage (4.5 = 20x leverage as an example) so when the price revisits that zone, all the 20x leverage should be liquidated.
Huge volume = a lot of activity
Huge OI = a lot of positions opened
More volume / OI will result in a stronger color that will generate a stronger reaction.
🔶 ROUTE
Here's an example of a route for long liquidity:
Enable the filter = consider only green candles.
Set the leverage to 4.5 (20x).
Choose Data = Volume.
Process:
A green candle is formed.
A liquidity level is established.
The level is placed below to simulate the 20x leverage.
Color is applied, considering the average volume within the chosen area.
Route completed.
🔶 FEATURE
Possibility to change the color of both long and short liquidity
Manual opacity value
Manual opacity average
Leverage
Autopilot - set a good average automatically of the opacity value
Enable both long or short liquidity visualization
Filtering - grab only red/green candle of the corresponding side or grab every candle
Data - nzVolume - Volume - nzOI - OI
🔶 TIPS
Since the limit of the line is 500, it's best to plot 2 scripts: one with only long and another with only short.
🔶 CONCLUSION
The liquidity levels are an interesting way to think about possible levels, and those are not real levels.
Angled Volume Profile [Trendoscope]Volume profile is useful tool to understand the demand and supply zones on horizontal level. But, what if you want to measure the volume levels over trend line? In trending markets, the feature to measure volume over angled levels can be very useful for traders who use these measures. Here is an attempt to provide such tool.
🎲 How to use
🎯 Interactive input for selecting starting point and angle.
Upon loading the script, you will be prompted to select
Start time and price - this is a point which you can select by moving the maroon highlighted label.
End price - though this is shown as maroon bullet, this is price only input. Hence, when you click on the bullet, a horizontal line will appear. Users can move the line to use different End price.
Start and End price are used for identifying the angle at which volume profile need to be calculated. Whereas start time is used as starting time of the volume profile. Last bar of the chart is considered as ending bar.
🎯 Other settings.
From settings, users can select the colour of volume profile and style. Step multiplier defines the distance at which the profile lines needs to be drawn. Higher multiplier leads to less dense profile lines whereas lower multiplier leads to higher density of profile lines.
🎲 Limitations
🎯 Max 500 lines
Pinescript only allows max 500 lines on an indicator. Due to this, if we set very low multiplier - this can lead to more than 500 profile lines. Due to this some lines can get removed.
On the contrary, if multiplier is too high, then you will see very few lines which may not be meaningful.
Hence, it is important to select optimal multiplier based on your timeframe
🎯 No updates on new bar
Since the profile can spawn many bars, it is not possible to recalculate the whole volume profile when price creates new bars. Hence, there will not be visual update when new bars are created. But, to update the chart, users only need to make another movement of Start or ending point on interactive input.
Centred Moving AverageBased around the Centered Moving Average as published by Vailant-Hero this script is revised and improved to aid with execution time & server load. For full description follow the link as above, as Valiant-Hero explains the idea perfectly well.
While the original script worked fine for small values of length, once length was extended significantly or chart timeframe set to short values then the script is prone to exceeding computation requirements. The original script was attempting to delete and re-draw (length x 3) lines on the chart for each tick. In addition to server load, once length is greater than 167 (500/3) then the first drawn lines start disappearing, so the predicted values no longer appear connected to the offset averages calculated from the candle data. A further error resulted with larger values of "length" and future data selected, in that the script would try and move lines more than 500 bars into the future.
Improvements and major code changes
All values for the predicted moving average lines are calculated from a single run through of the data, rather than having to loop back through the data "length" times (and then through it again "length" times if you selected double moving average). Each loop also inefficiently calculated the sum of "length" values by recalling each one individually.
Number of lines are thus reduced so that we're never attempting to plot more than "max_lines_count" onto the chart. User is able to select the granularity of the lines - more sections will mean a smoother line but at the expense of processing speed.
No matter the combination of "length" and the selected granularity of the lines, no line will be drawn if its endpoint would be more than 500 bars in the future.
Code for "Double SMA" only affected the predicted data values, rather than affecting the historic calculations (and standard deviation calcs) as well as the predictions. This has been included and results in much smoother lines when "Double Moving Average" is selected.
Striped lines for the predicted values - firstly to make it obvious where the "predictions" begin, and also because they look funky.
