อินดิเคเตอร์และกลยุทธ์
Ohm Horizontal line//@version=5
indicator("Ohm Horizontal line", overlay=true)
// Input parameters
atrPeriod = input.int(14, "ATR Period", minval=1)
atrMultiplier = input.float(1.0, "ATR Multiplier", step=0.1)
numLevels = input.int(10, "Number of Levels (each side)", minval=1)
lineWidth = input.int(1, "Line Width", minval=1, maxval=4)
labelOffset = input.int(20, "Label Offset", minval=0)
// Calculate daily ATR
dailyAtr = request.security(syminfo.tickerid, "D", ta.atr(atrPeriod))
// Function to get rounded price based on ATR
getRoundedPrice(price, atrValue) =>
math.round(price / (atrValue * atrMultiplier)) * (atrValue * atrMultiplier)
// Calculate center price (current close rounded to nearest ATR multiple)
centerPrice = getRoundedPrice(close, dailyAtr)
// Create arrays for price levels
var float levels = array.new_float(2 * numLevels + 1)
var float midLevels = array.new_float(2 * numLevels)
// Update price levels
updateLevels() =>
array.set(levels, numLevels, centerPrice)
for i = 1 to numLevels
upperLevel = centerPrice + i * dailyAtr * atrMultiplier
lowerLevel = centerPrice - i * dailyAtr * atrMultiplier
array.set(levels, numLevels + i, upperLevel)
array.set(levels, numLevels - i, lowerLevel)
// Calculate mid levels
if i > 1
upperMid = (array.get(levels, numLevels + i) + array.get(levels, numLevels + i - 1)) / 2
lowerMid = (array.get(levels, numLevels - i) + array.get(levels, numLevels - i + 1)) / 2
array.set(midLevels, numLevels + i - 2, upperMid)
array.set(midLevels, numLevels - i + 1, lowerMid)
// Update levels on every bar
updateLevels()
// Plot horizontal lines and price labels
var line horizontalLines = array.new_line(2 * numLevels + 1)
var line midLines = array.new_line(2 * numLevels)
var label priceLabels = array.new_label(2 * numLevels + 1)
// Function to draw or update a line
drawLine(lineArray, index, y, color, width, style) =>
if na(array.get(lineArray, index))
array.set(lineArray, index, line.new(bar_index, y, bar_index + 1, y, color=color, width=width, style=style, extend=extend.both))
else
line.set_xy1(array.get(lineArray, index), bar_index, y)
line.set_xy2(array.get(lineArray, index), bar_index + 1, y)
line.set_color(array.get(lineArray, index), color)
line.set_width(array.get(lineArray, index), width)
line.set_style(array.get(lineArray, index), style)
// Draw main levels
for i = 0 to 2 * numLevels
level = array.get(levels, i)
lineColor = i == numLevels ? color.yellow : (i > numLevels ? color.green : color.red)
drawLine(horizontalLines, i, level, lineColor, lineWidth, line.style_solid)
if na(array.get(priceLabels, i))
array.set(priceLabels, i, label.new(bar_index + labelOffset, level, str.tostring(level, format.mintick), color=color.new(color.black, 100), textcolor=lineColor, style=label.style_none, size=size.small))
else
label.set_xy(array.get(priceLabels, i), bar_index + labelOffset, level)
label.set_text(array.get(priceLabels, i), str.tostring(level, format.mintick))
label.set_textcolor(array.get(priceLabels, i), lineColor)
// Draw mid levels (without labels)
for i = 0 to 2 * numLevels - 1
midLevel = array.get(midLevels, i)
lineColor = i >= numLevels ? color.new(color.green, 50) : color.new(color.red, 50)
drawLine(midLines, i, midLevel, lineColor, 1, line.style_dashed)
// Display current ATR value
var label atrLabel = na
label.delete(atrLabel)
atrLabel := label.new(bar_index , high, text="ATR: " + str.tostring(dailyAtr, "#.##"), color=color.new(color.blue, 0), textcolor=color.white, size=size.small)
Ohm Horizontal line//@version=5
indicator("Ohm Horizontal line", overlay=true)
// Input parameters
atrPeriod = input.int(14, "ATR Period", minval=1)
atrMultiplier = input.float(1.0, "ATR Multiplier", step=0.1)
numLevels = input.int(10, "Number of Levels (each side)", minval=1)
lineWidth = input.int(1, "Line Width", minval=1, maxval=4)
labelOffset = input.int(20, "Label Offset", minval=0)
// Calculate daily ATR
dailyAtr = request.security(syminfo.tickerid, "D", ta.atr(atrPeriod))
// Function to get rounded price based on ATR
getRoundedPrice(price, atrValue) =>
math.round(price / (atrValue * atrMultiplier)) * (atrValue * atrMultiplier)
// Calculate center price (current close rounded to nearest ATR multiple)
centerPrice = getRoundedPrice(close, dailyAtr)
// Create arrays for price levels
var float levels = array.new_float(2 * numLevels + 1)
var float midLevels = array.new_float(2 * numLevels)
// Update price levels
updateLevels() =>
array.set(levels, numLevels, centerPrice)
for i = 1 to numLevels
upperLevel = centerPrice + i * dailyAtr * atrMultiplier
lowerLevel = centerPrice - i * dailyAtr * atrMultiplier
array.set(levels, numLevels + i, upperLevel)
array.set(levels, numLevels - i, lowerLevel)
// Calculate mid levels
if i > 1
upperMid = (array.get(levels, numLevels + i) + array.get(levels, numLevels + i - 1)) / 2
lowerMid = (array.get(levels, numLevels - i) + array.get(levels, numLevels - i + 1)) / 2
array.set(midLevels, numLevels + i - 2, upperMid)
array.set(midLevels, numLevels - i + 1, lowerMid)
// Update levels on every bar
updateLevels()
// Plot horizontal lines and price labels
var line horizontalLines = array.new_line(2 * numLevels + 1)
var line midLines = array.new_line(2 * numLevels)
var label priceLabels = array.new_label(2 * numLevels + 1)
// Function to draw or update a line
drawLine(lineArray, index, y, color, width, style) =>
if na(array.get(lineArray, index))
array.set(lineArray, index, line.new(bar_index, y, bar_index + 1, y, color=color, width=width, style=style, extend=extend.both))
else
line.set_xy1(array.get(lineArray, index), bar_index, y)
line.set_xy2(array.get(lineArray, index), bar_index + 1, y)
line.set_color(array.get(lineArray, index), color)
line.set_width(array.get(lineArray, index), width)
line.set_style(array.get(lineArray, index), style)
// Draw main levels
for i = 0 to 2 * numLevels
level = array.get(levels, i)
lineColor = i == numLevels ? color.yellow : (i > numLevels ? color.green : color.red)
drawLine(horizontalLines, i, level, lineColor, lineWidth, line.style_solid)
if na(array.get(priceLabels, i))
array.set(priceLabels, i, label.new(bar_index + labelOffset, level, str.tostring(level, format.mintick), color=color.new(color.black, 100), textcolor=lineColor, style=label.style_none, size=size.small))
else
label.set_xy(array.get(priceLabels, i), bar_index + labelOffset, level)
label.set_text(array.get(priceLabels, i), str.tostring(level, format.mintick))
label.set_textcolor(array.get(priceLabels, i), lineColor)
// Draw mid levels (without labels)
for i = 0 to 2 * numLevels - 1
midLevel = array.get(midLevels, i)
lineColor = i >= numLevels ? color.new(color.green, 50) : color.new(color.red, 50)
drawLine(midLines, i, midLevel, lineColor, 1, line.style_dashed)
// Display current ATR value
var label atrLabel = na
label.delete(atrLabel)
atrLabel := label.new(bar_index , high, text="ATR: " + str.tostring(dailyAtr, "#.##"), color=color.new(color.blue, 0), textcolor=color.white, size=size.small)
RSI + ARBR 组合指标The RSI + ARBR indicator mainly harmonizes the values of the two indicators, enabling investors to exit at market tops or buy at market bottoms when market sentiment surges or collapses.
### 补充说明：
- **RSI**：全称为Relative Strength Index（相对强弱指数），是常用的技术分析指标，用于衡量市场多空双方力量的对比。
- **ARBR**：由AR（Activity Ratio，人气指标）和BR（Buying Ratio，意愿指标）两个子指标组成，主要反映市场交易的活跃程度和投资者的买卖意愿。
- 句中“逃顶”译为“exit at market tops”，“抄底”译为“buy at market bottoms”，均为金融领域常用表达，准确对应“在高位卖出规避风险”和“在低位买入等待上涨”的操作含义。
EMA 200 MultiTF G/R + Cross Alerts by LifeHack Trader1. Indicator Setup
The script starts by defining the version of Pine Script (v5) and creating an indicator called "EMA 200 MultiTF G/R + Cross Alerts by LifeHack Trader."
The overlay=true parameter ensures that the indicator is plotted directly on the price chart.
2. Function to Get EMA200
A custom function getEma200 is defined to retrieve the 200-period Exponential Moving Average (EMA) for a specified timeframe (tf).
This function uses the request.security function to fetch the close price's EMA from different timeframes.
3. Calculate EMA200 for Multiple Timeframes
The script calculates the EMA200 for four timeframes: 15 minutes ("15"), 1 hour ("60"), 4 hours ("240"), and 1 day ("D").
These values are stored in variables (ema15, ema1h, ema4h, ema1d) and represent the EMA for each timeframe.
4. Determine Price Above or Below EMA200 (G/R)
For each timeframe, the script checks whether the closing price is above or below the EMA200.
It uses boolean checks to determine if the price is above the EMA200, assigning the status "G" (Green) for above and "R" (Red) for below.
5. Cross Signal Detection (Up/Down)
The script detects crossovers and crossunders between the price and EMA200 for each timeframe.
A crossover signal is detected when the price crosses above the EMA200 (bullish), and a crossunder signal is detected when the price crosses below the EMA200 (bearish).
These signals are stored in separate variables (crossUp, crossDown).
6. Display a Table with G/R Status and Cross Alerts
A table is created and displayed in the top-right corner of the chart. The table shows the status (G or R) for each timeframe and the cross signal (▲ for crossover, ▼ for crossunder, or - for no cross event).
The table is updated with the respective values for each timeframe every time a new bar is formed.
7. Alert Conditions
The script defines alert conditions based on the crossovers and crossunders.
When a price crosses above the EMA200 (cross-up), an alert is triggered for a potential buy opportunity. When the price crosses below the EMA200 (cross-down), an alert is triggered for a potential sell opportunity.
Alerts are configured for each timeframe (15 minutes, 1 hour, 4 hours, and 1 day).
This script provides a comprehensive system for monitoring price action relative to the EMA200 on multiple timeframes, highlighting crossovers, and delivering visual feedback and alerts based on the price's relationship with the EMA.
Trend Bars with Okuninushi Line Filter# Trend Bars with Okuninushi Line Filter: A Powerful Trading Indicator
## Introduction
The **Trend Bars with Okuninushi Line Filter** is an innovative technical indicator that combines two powerful concepts: trend bar analysis and the Okuninushi Line filter. This indicator helps traders identify high-quality trending moves by analyzing candle body strength relative to the overall price range while ensuring the price action aligns with the dominant market structure.
## What Are Trend Bars?
Trend bars are candles where the body (distance between open and close) represents a significant portion of the total price range (high to low). These bars indicate strong directional momentum with minimal indecision, making them valuable signals for trend continuation.
### Key Characteristics:
- **Strong directional movement**: Large body relative to total range
- **Minimal upper/lower shadows**: Shows sustained pressure in one direction
- **High conviction**: Represents decisive market action
## The Okuninushi Line Filter
The Okuninushi Line, also known as the Kijun Line in Ichimoku analysis, is calculated as the midpoint of the highest high and lowest low over a specified period (default: 52 periods).
**Formula**: `(Highest High + Lowest Low) / 2`
This line acts as a dynamic support/resistance level and trend filter, helping to:
- Identify the overall market bias
- Filter out counter-trend signals
- Provide confluence for trade entries
## How the Indicator Works
The indicator combines these two concepts with the following logic:
### Bull Trend Bars (Green)
A candle is colored **green** when ALL conditions are met:
1. **Bullish candle**: Close > Open
2. **Strong body**: |Close - Open| ≥ Threshold × (High - Low)
3. **Above trend filter**: Close > Okuninushi Line
### Bear Trend Bars (Red)
A candle is colored **red** when ALL conditions are met:
1. **Bearish candle**: Close < Open
2. **Strong body**: |Close - Open| ≥ Threshold × (High - Low)
3. **Below trend filter**: Close < Okuninushi Line
### Neutral Bars (Gray)
All other candles that don't meet the complete criteria are colored **gray**.
## Customizable Parameters
### Trend Bar Threshold
- **Range**: 10% to 100%
- **Default**: 75%
- **Purpose**: Controls how "strong" a candle must be to qualify as a trend bar
**Threshold Effects:**
- **Low (10-30%)**: More sensitive, catches smaller trending moves
- **Medium (50-75%)**: Balanced approach, filters out most noise
- **High (80-100%)**: Very selective, only captures the strongest moves
### Okuninushi Line Length
- **Default**: 52 periods
- **Purpose**: Determines the lookback period for calculating the midpoint
- **Common Settings**:
- 26 periods: More responsive to recent price action
- 52 periods: Standard setting, good balance
- 104 periods: Longer-term trend perspective
## Trading Applications
### 1. Trend Continuation Signals
- **Green bars**: Look for bullish continuation opportunities
- **Red bars**: Consider bearish continuation setups
- **Gray bars**: Exercise caution, mixed signals
### 2. Market Structure Analysis
- Clusters of same-colored bars indicate strong trends
- Alternating colors suggest choppy, indecisive markets
- Transition from red to green (or vice versa) may signal trend changes
### 3. Entry Timing
- Use colored bars as confirmation for existing trade setups
- Wait for color alignment with your market bias
- Avoid trading during predominantly gray periods
### 4. Risk Management
- Gray bars can serve as early warning signs of weakening trends
- Color changes might indicate appropriate exit points
- Use in conjunction with other risk management tools
## Advantages
1. **Dual Filtering**: Combines momentum (trend bars) with trend direction (Okuninushi Line)
2. **Visual Clarity**: Immediate visual feedback through candle coloring
3. **Customizable**: Adjustable parameters for different trading styles
4. **Versatile**: Works across multiple timeframes and instruments
5. **Objective**: Rule-based system reduces subjective interpretation
## Limitations
1. **Lagging Nature**: Based on historical price data
2. **False Signals**: Can produce whipsaws in choppy markets
3. **Parameter Sensitivity**: Requires optimization for different instruments
4. **Market Conditions**: May be less effective in ranging markets
## Best Practices
### Optimization Tips:
- **Volatile Markets**: Use higher thresholds (80-90%)
- **Steady Trends**: Use moderate thresholds (60-75%)
- **Short-term Trading**: Shorter Okuninushi Line periods (26)
- **Long-term Analysis**: Longer Okuninushi Line periods (104+)
### Combination Strategies:
- Pair with volume indicators for confirmation
- Use alongside support/resistance levels
- Combine with other trend-following indicators
- Consider market context and overall trend direction
## Conclusion
The Trend Bars with Okuninushi Line Filter offers traders a sophisticated yet intuitive way to identify high-quality trending moves. By combining the momentum characteristics of trend bars with the directional filter of the Okuninushi Line, this indicator helps traders focus on the most promising opportunities while avoiding low-probability setups.
Remember that no single indicator should be used in isolation. Always consider market context, risk management, and other technical factors when making trading decisions. The true power of this indicator lies in its ability to quickly highlight periods of strong, aligned price action – exactly what trend traders are looking for.
---
*Disclaimer: This article is for educational purposes only and should not be considered as financial advice. Always conduct your own research and consider your risk tolerance before making any trading decisions.*
Earnings Season Highlighter (Jan/Apr/Jul/Oct)Purpose:
This indicator visually highlights the four “earnings season” months — January, April, July, and October — on any TradingView chart. It is designed for traders and investors who want a quick visual cue of when companies typically report quarterly earnings.
Features:
Highlights Jan, Apr, Jul, and Oct with a light blue background.
Works on any timeframe: intraday, daily, weekly, or monthly charts.
No dependency on price data — purely a time-based visual overlay.
Simple, lightweight, and easy to apply to any chart.
Usage:
Apply the indicator to your chart.
During the highlighted months, the background will turn light blue, signaling earnings season.
Ideal for planning trades, earnings plays, or simply monitoring market cycles.
Futures Forward Price [NeoButane]In futures markets, the theoretical value of a futures contract can be derived from its underlying price and cost of carry. By baking in the costs and potential yields, the theoretical forward price then be used in basis against futures prices in place of the underlying spot price.
Usage
The script creates plots on the main chart and a separate window pane. Both are meant to be used to visualize dislocations in the market.
By using a futures vs. forward basis instead of futures vs. spot basis, discounts in the market are clearer.
Last month, the gold futures market GCZ2025 traded >1% above forward price when tariffs were announced and fell back in line once the tariffs were verbally retracted.
View roll spreads over a back-adjusted continuous chart. I guess. I don't think spread traders only look at one chart. This is as educational for me as it is you.
Configuration
The underlying reference needs to be changed to match the futures contract you are using.
The Risk-Free Rate defaults to FRED:SOFR. I found the contract month matched 3-Month SOFR Futures to be the closest for forward price.
Risk-Free Rate: The interest rate source for forward price.
Constant Risk-Free Rate: a static interest rate that can be used in advance of future changes in risk-free rate.
Underlying Reference: spot or index price. Some examples include TVC:SPX, TVC:GOLD, CRYPTO:BTCUSD, TVC:USOIL.
Forward Price Compounding: determines which formula to use. They're similar and become closer as the contract matures.
Alternative Contract: enable and select a futures contract to use it on a chart different than the main.
Storage Cost and Yield: for use with commodities. I haven't found a proper use for them yet but enabling is simple if you are able to.
The following are meant to be used with the continuous formula as they are compounded. However the rate sources don't differ much for the purpose of futures prices.
3-Month CME SOFR Futures
3-Month ICEEUR SONIA Futures
3-Month Osaka TONA Futures
The other rate sources are either meant for futures contracts shorter than quarterly such as monthly crypto futures or were meant to help myself understand how different rates would align with futures prices, like inflation.
What this script does
It uses the cost of carry formula to output the forward price (red line). The underlying reference (green line) is plotted alongside and a futures-derived reference (blue line) can be displayed to see how it looks next to the real reference price.
The data pane displays either the nominal difference or percentage difference between the real futures price and the calculated forward price.
Further reading
www.investopedia.com
www.cmegroup.com
www.oxfordenergy.org
www-2.rotman.utoronto.ca
www.cmegroup.com
3-month rate futures
www.cmegroup.com
www.ice.com
www.bankofengland.co.uk
www.jpx.co.jp
Volume (standard) + Brightness by Intensity (Min–Max / MA)Volume Brightness Indicator
Quick Description
This indicator is an enhanced version of TradingView’s standard volume. The volume bars are colored just like the original (green/red or a single custom color), but with one key upgrade: brightness and transparency adjust automatically based on volume intensity.
High volume → bars appear more opaque and bright.
Low volume → bars appear more transparent and faded.
This makes it easier to spot which candles actually carry meaningful volume at a glance.
Features
Bar colors: by candle direction (green/red) or a single chosen color.
Volume moving average: optional, customizable (SMA or EMA).
Brightness methods:
Min–Max: compares volume against a historical window (with optional log scale).
MA-based: compares volume against its moving average, with an adjustable cap.
Custom transparency: define how opaque high-volume and low-volume bars appear.
How to Use
Copy the script into Pine Editor and save it.
Add it to your chart; it will display in its own panel, like the standard volume.
In Settings, choose your preferred brightness method and adjust transparency ranges.
Toggle the volume MA if you want a clear reference line.
Key Idea
The indicator does not add new data. It highlights volume intensity visually, making it easier to identify accumulation or spikes without losing the simplicity of the classic volume.
Multiplied and Divided Moving Average ### Multiplied and Divided Moving Average Indicator
**Description**:
The "Multiplied and Divided Moving Average" indicator is a customizable tool for TradingView users, designed to create dynamic bands around a user-selected moving average (MA). It calculates a moving average (SMA, EMA, WMA, VWMA, or RMA) and generates a user-defined number of lines above and below it by multiplying and dividing the MA by linearly spaced factors. These bands serve as potential support and resistance levels, aiding in trend identification, mean reversion strategies, or breakout detection. Optional Buy/Sell labels appear when the price crosses below the divided MAs (Buy) or above the multiplied MAs (Sell), providing clear visual cues for trading opportunities.
**Key Features**:
- **Flexible MA Types**: Choose from Simple (SMA), Exponential (EMA), Weighted (WMA), Volume-Weighted (VWMA), or Running (RMA) moving averages.
- **Customizable Bands**: Set the number of lines (0–10) above and below the MA, allowing tailored analysis for any market or timeframe.
- **Dynamic Factors**: Bands are created using factors that scale linearly from 1 to a user-defined maximum (default: 5.0), creating intuitive overbought/oversold zones.
- **Buy/Sell Signals**: Optional labels highlight potential entry (Buy) and exit (Sell) points when the price crosses the bands.
- **Clear Visuals**: The main MA is plotted in blue, with green (multiplied) and red (divided) lines using graduated transparency for easy differentiation.
**Inputs**:
- **MA Type**: Select the moving average type (default: SMA).
- **MA Length**: Set the MA period (default: 14).
- **Number of Lines Above/Below**: Choose how many bands to plot above and below the MA (default: 4, range: 0–10).
- **Max Factor**: Define the largest multiplier/divisor for the outermost bands (default: 5.0).
- **Source**: Select the price data for the MA (default: close).
- **Show Buy/Sell Labels**: Enable or disable Buy/Sell labels (default: true).
**How It Works**:
1. Calculates the chosen moving average based on user inputs.
2. Creates up to 10 lines above the MA (e.g., MA × 2, ×3, ×4, ×5 for `numLines=4`, `maxFactor=5`) and 10 below (e.g., MA ÷ 2, ÷3, ÷4, ÷5).
3. Plots the main MA in blue, multiplied lines in green, and divided lines in red, with transparency increasing for outer bands.
4. If enabled, displays "Buy" labels when the price crosses below any divided MA and "Sell" labels when it crosses above any multiplied MA, positioned at the outermost band.
**Use Cases**:
- **Trend Analysis**: Use the bands as dynamic support/resistance to confirm trend direction or reversals.
- **Mean Reversion**: Identify overbought (near multiplied MAs) or oversold (near divided MAs) conditions.
- **Breakout Trading**: Monitor price crossovers of the outermost bands for potential breakout signals.
- **Signal Confirmation**: Use Buy/Sell labels for swing trading or to complement other indicators.
**How to Use**:
1. Copy the script into TradingView’s Pine Editor.
2. Compile and apply it to your chart (e.g., stocks, forex, crypto).
3. Adjust inputs like `numLines`, `maxFactor`, or `maType` to fit your strategy.
4. Enable `Show Buy/Sell Labels` to visualize trading signals.
5. Test on various timeframes (e.g., 1H, 4H, 1D) and assets to optimize settings.
**Example Settings**:
- **Swing Trading**: Use `numLines=3`, `maxFactor=4`, `maType=EMA`, `maLength=20` on a 4-hour chart.
- **Intraday**: Try `numLines=2`, `maxFactor=3`, `maType=SMA`, `maLength=10` on a 15-minute chart.
**Notes**:
- **Performance**: Supports up to 20 bands (10 above, 10 below), staying within TradingView’s 64-plot limit.
- **False Signals**: In choppy markets, frequent crossovers may occur. Combine with trend filters (e.g., ADX, higher-timeframe MA) to reduce noise.
- **Enhancements**: Add alerts via TradingView’s alert system for Buy/Sell signals, or experiment with different `maxFactor` values for volatility.
**Limitations**:
- Bands are reactive, as they’re based on a moving average, so confirm signals with other indicators.
- High `numLines` values may clutter the chart; use 2–4 for clarity.
- Signals may lag in fast-moving markets due to the MA’s smoothing effect.
This indicator is perfect for traders seeking a customizable, visually clear tool to enhance technical analysis on TradingView. For support, feature requests (e.g., alerts, custom colors), or community discussion, visit TradingView’s forums or contact the script author.
Bar Index & TimeLibrary to convert a bar index to a timestamp and vice versa.
Utilizes runtime memory to store the 𝚝𝚒𝚖𝚎 and 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 values of every bar on the chart (and optional future bars), with the ability of storing additional custom values for every chart bar.
█ PREFACE
This library aims to tackle some problems that pine coders (from beginners to advanced) often come across, such as:
I'm trying to draw an object with a 𝚋𝚊𝚛_𝚒𝚗𝚍𝚎𝚡 that is more than 10,000 bars into the past, but this causes my script to fail. How can I convert the 𝚋𝚊𝚛_𝚒𝚗𝚍𝚎𝚡 to a UNIX time so that I can draw visuals using xloc.bar_time ?
I have a diagonal line drawing and I want to get the "y" value at a specific time, but line.get_price() only accepts a bar index value. How can I convert the timestamp into a bar index value so that I can still use this function?
I want to get a previous 𝚘𝚙𝚎𝚗 value that occurred at a specific timestamp. How can I convert the timestamp into a historical offset so that I can use 𝚘𝚙𝚎𝚗 ?
I want to reference a very old value for a variable. How can I access a previous value that is older than the maximum historical buffer size of 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎 ?
This library can solve the above problems (and many more) with the addition of a few lines of code, rather than requiring the coder to refactor their script to accommodate the limitations.
█ OVERVIEW
The core functionality provided is conversion between xloc.bar_index and xloc.bar_time values.
The main component of the library is the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object, created via the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function which basically stores the 𝚝𝚒𝚖𝚎 and 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 of every bar on the chart, and there are 3 more overloads to this function that allow collecting and storing additional data. Once a 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object is created, use any of the exported methods:
Methods to convert a UNIX timestamp into a bar index or bar offset:
𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚐𝚎𝚝𝙽𝚞𝚖𝚋𝚎𝚛𝙾𝚏𝙱𝚊𝚛𝚜𝙱𝚊𝚌𝚔()
Methods to retrieve the stored data for a bar index:
𝚝𝚒𝚖𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚝𝚒𝚖𝚎𝙲𝚕𝚘𝚜𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚟𝚊𝚕𝚞𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚐𝚎𝚝𝙰𝚕𝚕𝚅𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡()
Methods to retrieve the stored data at a number of bars back (i.e., historical offset):
𝚝𝚒𝚖𝚎(), 𝚝𝚒𝚖𝚎𝙲𝚕𝚘𝚜𝚎(), 𝚟𝚊𝚕𝚞𝚎()
Methods to retrieve all the data points from the earliest bar (or latest bar) stored in memory, which can be useful for debugging purposes:
𝚐𝚎𝚝𝙴𝚊𝚛𝚕𝚒𝚎𝚜𝚝𝚂𝚝𝚘𝚛𝚎𝚍𝙳𝚊𝚝𝚊(), 𝚐𝚎𝚝𝙻𝚊𝚝𝚎𝚜𝚝𝚂𝚝𝚘𝚛𝚎𝚍𝙳𝚊𝚝𝚊()
Note: the library's strong suit is referencing data from very old bars in the past, which is especially useful for scripts that perform its necessary calculations only on the last bar.
█ USAGE
Step 1
Import the library. Replace with the latest available version number for this library.
//@version=6
indicator("Usage")
import n00btraders/ChartData/
Step 2
Create a 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object to collect data on every bar. Do not declare as `var` or `varip`.
chartData = ChartData.collectChartData() // call on every bar to accumulate the necessary data
Step 3
Call any method(s) on the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object. Do not modify its fields directly.
if barstate.islast
int firstBarTime = chartData.timeAtBarIndex(0)
int lastBarTime = chartData.time(0)
log.info("First `time`: " + str.format_time(firstBarTime) + ", Last `time`: " + str.format_time(lastBarTime))
█ EXAMPLES
• Collect Future Times
The overloaded 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() functions that accept a 𝚋𝚊𝚛𝚜𝙵𝚘𝚛𝚠𝚊𝚛𝚍 argument can additionally store time values for up to 500 bars into the future.
//@version=6
indicator("Example `collectChartData(barsForward)`")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData(barsForward = 500)
var rectangle = box.new(na, na, na, na, xloc = xloc.bar_time, force_overlay = true)
if barstate.islast
int futureTime = chartData.timeAtBarIndex(bar_index + 100)
int lastBarTime = time
box.set_lefttop(rectangle, lastBarTime, open)
box.set_rightbottom(rectangle, futureTime, close)
box.set_text(rectangle, "Extending box 100 bars to the right. Time: " + str.format_time(futureTime))
• Collect Custom Data
The overloaded 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() functions that accept a 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜 argument can additionally store custom user-specified values for every bar on the chart.
//@version=6
indicator("Example `collectChartData(variables)`")
import n00btraders/ChartData/1
var map variables = map.new()
variables.put("open", open)
variables.put("close", close)
variables.put("open-close midpoint", (open + close) / 2)
variables.put("boolean", open > close ? 1 : 0)
chartData = ChartData.collectChartData(variables = variables)
var fgColor = chart.fg_color
var table1 = table.new(position.top_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true)
var table2 = table.new(position.bottom_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true)
if barstate.isfirst
table.cell(table1, 0, 0, "ChartData.value()", text_color = fgColor)
table.cell(table2, 0, 0, "open ", text_color = fgColor)
table.merge_cells(table1, 0, 0, 1, 0)
table.merge_cells(table2, 0, 0, 1, 0)
for i = 1 to 8
table.cell(table1, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace)
table.cell(table2, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace)
table.cell(table1, 1, i, text_color = fgColor)
table.cell(table2, 1, i, text_color = fgColor)
if barstate.islast
for i = 1 to 8
float open1 = chartData.value("open", 5000 * i)
float open2 = i < 3 ? open : -1
table.cell_set_text(table1, 0, i, "chartData.value(\"open\", " + str.tostring(5000 * i) + "): ")
table.cell_set_text(table2, 0, i, "open : ")
table.cell_set_text(table1, 1, i, str.tostring(open1))
table.cell_set_text(table2, 1, i, open2 >= 0 ? str.tostring(open2) : "Error")
• xloc.bar_index → xloc.bar_time
The 𝚝𝚒𝚖𝚎 value (or 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 value) can be retrieved for any bar index that is stored in memory by the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object.
//@version=6
indicator("Example `timeAtBarIndex()`")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData()
if barstate.islast
int start = bar_index - 15000
int end = bar_index - 100
// line.new(start, close, end, close) // !ERROR - `start` value is too far from current bar index
start := chartData.timeAtBarIndex(start)
end := chartData.timeAtBarIndex(end)
line.new(start, close, end, close, xloc.bar_time, width = 10)
• xloc.bar_time → xloc.bar_index
Use 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡() to find the bar that a timestamp belongs to.
If the timestamp falls in between the close of one bar and the open of the next bar,
the 𝚜𝚗𝚊𝚙 parameter can be used to determine which bar to choose:
𝚂𝚗𝚊𝚙.𝙻𝙴𝙵𝚃 - prefer to choose the leftmost bar (typically used for closing times)
𝚂𝚗𝚊𝚙.𝚁𝙸𝙶𝙷𝚃 - prefer to choose the rightmost bar (typically used for opening times)
𝚂𝚗𝚊𝚙.𝙳𝙴𝙵𝙰𝚄𝙻𝚃 (or 𝚗𝚊) - copies the same behavior as xloc.bar_time uses for drawing objects
//@version=6
indicator("Example `timestampToBarIndex()`")
import n00btraders/ChartData/1
startTimeInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Session Start Time")
endTimeInput = input.time(timestamp("01 Aug 2025 15:15 -0500"), "Session End Time")
chartData = ChartData.collectChartData()
if barstate.islastconfirmedhistory
int startBarIndex = chartData.timestampToBarIndex(startTimeInput, ChartData.Snap.RIGHT)
int endBarIndex = chartData.timestampToBarIndex(endTimeInput, ChartData.Snap.LEFT)
line1 = line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true)
line2 = line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true)
linefill.new(line1, line2, color.new(color.green, 90))
// using Snap.DEFAULT to show that it is equivalent to drawing lines using `xloc.bar_time` (i.e., it aligns to the same bars)
startBarIndex := chartData.timestampToBarIndex(startTimeInput)
endBarIndex := chartData.timestampToBarIndex(endTimeInput)
line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.yellow, width = 3)
line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.yellow, width = 3)
line.new(startTimeInput, 0, startTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11)
line.new(endTimeInput, 0, endTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11)
• Get Price of Line at Timestamp
The pine script built-in function line.get_price() requires working with bar index values. To get the price of a line in terms of a timestamp, convert the timestamp into a bar index or offset.
//@version=6
indicator("Example `line.get_price()` at timestamp")
import n00btraders/ChartData/1
lineStartInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Line Start")
chartData = ChartData.collectChartData()
var diagonal = line.new(na, na, na, na, force_overlay = true)
if time <= lineStartInput
line.set_xy1(diagonal, bar_index, open)
if barstate.islastconfirmedhistory
line.set_xy2(diagonal, bar_index, close)
if barstate.islast
int timeOneWeekAgo = timenow - (7 * timeframe.in_seconds("1D") * 1000)
// Note: could also use `timetampToBarIndex(timeOneWeekAgo, Snap.DEFAULT)` and pass the value directly to `line.get_price()`
int barsOneWeekAgo = chartData.getNumberOfBarsBack(timeOneWeekAgo)
float price = line.get_price(diagonal, bar_index - barsOneWeekAgo)
string formatString = "Time 1 week ago: {0,number,#} - Equivalent to {1} bars ago 𝚕𝚒𝚗𝚎.𝚐𝚎𝚝_𝚙𝚛𝚒𝚌𝚎(): {2,number,#.##}"
string labelText = str.format(formatString, timeOneWeekAgo, barsOneWeekAgo, price)
label.new(timeOneWeekAgo, price, labelText, xloc.bar_time, style = label.style_label_lower_right, size = 16, textalign = text.align_left, force_overlay = true)
█ RUNTIME ERROR MESSAGES
This library's functions will generate a custom runtime error message in the following cases:
𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() is not called consecutively, or is called more than once on a single bar
Invalid 𝚋𝚊𝚛𝚜𝙵𝚘𝚛𝚠𝚊𝚛𝚍 argument in the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function
Invalid 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜 argument in the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function
Invalid 𝚕𝚎𝚗𝚐𝚝𝚑 argument in any of the functions that accept a number of bars back
Note: there is no runtime error generated for an invalid 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙 or 𝚋𝚊𝚛𝙸𝚗𝚍𝚎𝚡 argument in any of the functions. Instead, the functions will assign 𝚗𝚊 to the returned values.
Any other runtime errors are due to incorrect usage of the library.
█ NOTES
• Function Descriptions
The library source code uses Markdown for the exported functions. Hover over a function/method call in the Pine Editor to display formatted, detailed information about the function/method.
//@version=6
indicator("Demo Function Tooltip")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData()
int barIndex = chartData.timestampToBarIndex(timenow)
log.info(str.tostring(barIndex))
• Historical vs. Realtime Behavior
Under the hood, the data collector for this library is declared as `var`. Because of this, the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object will always reflect the latest available data on realtime updates. Any data that is recorded for historical bars will remain unchanged throughout the execution of a script.
//@version=6
indicator("Demo Realtime Behavior")
import n00btraders/ChartData/1
var map variables = map.new()
variables.put("open", open)
variables.put("close", close)
chartData = ChartData.collectChartData(variables)
if barstate.isrealtime
varip float initialOpen = open
varip float initialClose = close
varip int updateCount = 0
updateCount += 1
float latestOpen = open
float latestClose = close
float recordedOpen = chartData.valueAtBarIndex("open", bar_index)
float recordedClose = chartData.valueAtBarIndex("close", bar_index)
string formatString = "# of updates: {0} 𝚘𝚙𝚎𝚗 at update #1: {1,number,#.##} 𝚌𝚕𝚘𝚜𝚎 at update #1: {2,number,#.##} "
+ "𝚘𝚙𝚎𝚗 at update #{0}: {3,number,#.##} 𝚌𝚕𝚘𝚜𝚎 at update #{0}: {4,number,#.##} "
+ "𝚘𝚙𝚎𝚗 stored in memory: {5,number,#.##} 𝚌𝚕𝚘𝚜𝚎 stored in memory: {6,number,#.##}"
string labelText = str.format(formatString, updateCount, initialOpen, initialClose, latestOpen, latestClose, recordedOpen, recordedClose)
label.new(bar_index, close, labelText, style = label.style_label_left, force_overlay = true)
• Collecting Chart Data for Other Contexts
If your use case requires collecting chart data from another context, avoid directly retrieving the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object as this may exceed memory limits .
//@version=6
indicator("Demo Return Calculated Results")
import n00btraders/ChartData/1
timeInput = input.time(timestamp("01 Sep 2025 08:30 -0500"), "Time")
var int oneMinuteBarsAgo = na
// !ERROR - Memory Limits Exceeded
// chartDataArray = request.security_lower_tf(syminfo.tickerid, "1", ChartData.collectChartData())
// oneMinuteBarsAgo := chartDataArray.last().getNumberOfBarsBack(timeInput)
// function that returns calculated results (a single integer value instead of an entire `ChartData` object)
getNumberOfBarsBack() =>
chartData = ChartData.collectChartData()
chartData.getNumberOfBarsBack(timeInput)
calculatedResultsArray = request.security_lower_tf(syminfo.tickerid, "1", getNumberOfBarsBack())
oneMinuteBarsAgo := calculatedResultsArray.size() > 0 ? calculatedResultsArray.last() : na
if barstate.islast
string labelText = str.format("The selected timestamp occurs 1-minute bars ago", oneMinuteBarsAgo)
label.new(bar_index, hl2, labelText, style = label.style_label_left, size = 16, force_overlay = true)
• Memory Usage
The library's convenience and ease of use comes at the cost of increased usage of computational resources. For simple scripts, using this library will likely not cause any issues with exceeding memory limits. But for large and complex scripts, you can reduce memory issues by specifying a lower 𝚌𝚊𝚕𝚌_𝚋𝚊𝚛𝚜_𝚌𝚘𝚞𝚗𝚝 amount in the indicator() or strategy() declaration statement.
//@version=6
// !ERROR - Memory Limits Exceeded using the default number of bars available (~20,000 bars for Premium plans)
//indicator("Demo `calc_bars_count` parameter")
// Reduce number of bars using `calc_bars_count` parameter
indicator("Demo `calc_bars_count` parameter", calc_bars_count = 15000)
import n00btraders/ChartData/1
map variables = map.new()
variables.put("open", open)
variables.put("close", close)
variables.put("weekofyear", weekofyear)
variables.put("dayofmonth", dayofmonth)
variables.put("hour", hour)
variables.put("minute", minute)
variables.put("second", second)
// simulate large memory usage
chartData0 = ChartData.collectChartData(variables)
chartData1 = ChartData.collectChartData(variables)
chartData2 = ChartData.collectChartData(variables)
chartData3 = ChartData.collectChartData(variables)
chartData4 = ChartData.collectChartData(variables)
chartData5 = ChartData.collectChartData(variables)
chartData6 = ChartData.collectChartData(variables)
chartData7 = ChartData.collectChartData(variables)
chartData8 = ChartData.collectChartData(variables)
chartData9 = ChartData.collectChartData(variables)
log.info(str.tostring(chartData0.time(0)))
log.info(str.tostring(chartData1.time(0)))
log.info(str.tostring(chartData2.time(0)))
log.info(str.tostring(chartData3.time(0)))
log.info(str.tostring(chartData4.time(0)))
log.info(str.tostring(chartData5.time(0)))
log.info(str.tostring(chartData6.time(0)))
log.info(str.tostring(chartData7.time(0)))
log.info(str.tostring(chartData8.time(0)))
log.info(str.tostring(chartData9.time(0)))
if barstate.islast
result = table.new(position.middle_right, 1, 1, force_overlay = true)
table.cell(result, 0, 0, "Script Execution Successful ✅", text_size = 40)
█ EXPORTED ENUMS
Snap
Behavior for determining the bar that a timestamp belongs to.
Fields:
LEFT : Snap to the leftmost bar.
RIGHT : Snap to the rightmost bar.
DEFAULT : Default `xloc.bar_time` behavior.
Note: this enum is used for the 𝚜𝚗𝚊𝚙 parameter of 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡().
█ EXPORTED TYPES
Note: users of the library do not need to worry about directly accessing the fields of these types; all computations are done through method calls on an object of the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 type.
Variable
Represents a user-specified variable that can be tracked on every chart bar.
Fields:
name (series string) : Unique identifier for the variable.
values (array) : The array of stored values (one value per chart bar).
ChartData
Represents data for all bars on a chart.
Fields:
bars (series int) : Current number of bars on the chart.
timeValues (array) : The `time` values of all chart (and future) bars.
timeCloseValues (array) : The `time_close` values of all chart (and future) bars.
variables (array) : Additional custom values to track on all chart bars.
█ EXPORTED FUNCTIONS
collectChartData()
Collects and tracks the `time` and `time_close` value of every bar on the chart.
Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(barsForward)
Collects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars.
Parameters:
barsForward (simple int) : Number of future bars to collect data for.
Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(variables)
Collects and tracks the `time` and `time_close` value of every bar on the chart. Additionally, tracks a custom set of variables for every chart bar.
Parameters:
variables (simple map) : Custom values to collect on every chart bar.
Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(barsForward, variables)
Collects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars. Additionally, tracks a custom set of variables for every chart bar.
Parameters:
barsForward (simple int) : Number of future bars to collect data for.
variables (simple map) : Custom values to collect on every chart bar.
Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
█ EXPORTED METHODS
method timestampToBarIndex(chartData, timestamp, snap)
Converts a UNIX timestamp to a bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
timestamp (series int) : A UNIX time.
snap (series Snap) : A `Snap` enum value.
Returns: A bar index, or `na` if unable to find the appropriate bar index.
method getNumberOfBarsBack(chartData, timestamp)
Converts a UNIX timestamp to a history-referencing length (i.e., number of bars back).
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
timestamp (series int) : A UNIX time.
Returns: A bar offset, or `na` if unable to find a valid number of bars back.
method timeAtBarIndex(chartData, barIndex)
Retrieves the `time` value for the specified bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
barIndex (int) : The bar index.
Returns: The `time` value, or `na` if there is no `time` stored for the bar index.
method time(chartData, length)
Retrieves the `time` value of the bar that is `length` bars back relative to the latest bar.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
length (series int) : Number of bars back.
Returns: The `time` value `length` bars ago, or `na` if there is no `time` stored for that bar.
method timeCloseAtBarIndex(chartData, barIndex)
Retrieves the `time_close` value for the specified bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
barIndex (series int) : The bar index.
Returns: The `time_close` value, or `na` if there is no `time_close` stored for the bar index.
method timeClose(chartData, length)
Retrieves the `time_close` value of the bar that is `length` bars back from the latest bar.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
length (series int) : Number of bars back.
Returns: The `time_close` value `length` bars ago, or `na` if there is none stored.
method valueAtBarIndex(chartData, name, barIndex)
Retrieves the value of a custom variable for the specified bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
name (series string) : The variable name.
barIndex (series int) : The bar index.
Returns: The value of the variable, or `na` if that variable is not stored for the bar index.
method value(chartData, name, length)
Retrieves a variable value of the bar that is `length` bars back relative to the latest bar.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
name (series string) : The variable name.
length (series int) : Number of bars back.
Returns: The value `length` bars ago, or `na` if that variable is not stored for the bar index.
method getAllVariablesAtBarIndex(chartData, barIndex)
Retrieves all custom variables for the specified bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
barIndex (series int) : The bar index.
Returns: Map of all custom variables that are stored for the specified bar index.
method getEarliestStoredData(chartData)
Gets all values from the earliest bar data that is currently stored in memory.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
Returns: A tuple:
method getLatestStoredData(chartData, futureData)
Gets all values from the latest bar data that is currently stored in memory.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
futureData (series bool) : Whether to include the future data that is stored in memory.
Returns: A tuple:
cd_Quarterly_cycles_SSMT_TPD_CxGeneral
This indicator is designed in line with the Quarterly Theory to display each cycle on the chart, either boxed and/or in candlestick form.
Additionally, it performs inter-cycle divergence analysis ( SSMT ) with the correlated symbol, Terminus Price Divergence ( TPD ), Precision Swing Point ( PSP ) analysis, and potential Power of Three ( PO3 ) analysis.
Special thanks to @HandlesHandled for his great indicator, which I used while preparing the cycles content.
Details & Usage:
Optional cycles available: Weekly, Daily, 90m, and Micro cycles.
Displaying/removing cycles can be controlled from the menu (cycles / candles / labels).
All selected cycles can be shown, or you can limit the number of displayed cycles (min: 2, max: 4).
The summary table can be toggled on/off and repositioned.
What’s in the summary table?
• Below the header, the correlated symbol used in the analysis is displayed (e.g., SSMT → US500).
• If available, live and previous bar results of the SSMT analysis are shown.
• Under the PSP & TPD section, results are displayed when conditions are met.
• Under Alerts, the real-time status of conditions defined in the menu is shown.
• Under Potential AMD, possible PO3 analysis results are displayed.
Analysis & Symbol Selection:
To run analyses, a correlated symbol must first be defined with the main symbol.
Default pairs are preloaded (see below), but users should adjust them according to their exchange and instruments.
If no correlated pair is defined, cycles are displayed only as boxes/candles.
Once defined pairs are opened on the chart, analyses load automatically.
Pairs listed on the same row in the menu are automatically linked, so no need to re-enter them across rows.
SSMT Analysis:
Based on the chart’s timeframe, divergences are searched across Weekly, Daily, 90m, and Micro cycles.
The code will not produce results for smaller cycles than the current timeframe.
(Example: On H1, Micro cycles will not be displayed.)
Results are obtained by comparing the highs and lows of consecutive cycles in the same period.
If one pair makes a new high/low while the other does not, this divergence is added to SSMT results.
The difference from classic SMT is that cycles are used instead of bars.
PSP & TPD Analysis:
A correlated symbol must be defined.
For PSP, timeframe options are added to the menu.
Users toggle timeframes on/off by checking/unchecking boxes.
In selected timeframes, PSP & TPD analysis is performed.
• PSP: If candlesticks differ in color (bullish/bearish) between symbols and the bar is at a high/low of the timeframe (and higher/lower than the bars before/after it), it is identified as a PSP. Divergences between pairs are interpreted as potential reversal signals.
• TPD: Once a PSP occurs, the closing price of the previous bar and the opening price of the next bar are compared. If one symbol shows continuation while the other does not, it is marked as a divergence.
Example:
Let’s assume Pair 1 and Pair 2 are selected in the menu with the H4 timeframe, and our cycle is Weekly (Box).
For Pair 1, the H4 candle at the Weekly high level:
• Is positioned at the Weekly high,
• Its high is above both the previous and the next candle,
• It closed bearish (open > close).
For Pair 2, the same H4 candle closed bullish (close > open).
→ PSP conditions are met.
For TPD, we now check the candles before and after this PSP (H4) candle on both pairs.
Comparing the previous candle’s close with the next candle’s open, we see that:
• In Pair 1, the next open is lower than the previous close,
• In Pair 2, the next open is higher than the previous close.
Pair 1 → close > open
Pair 2 → close < open
Since they are not aligned in the same direction, this is interpreted as a divergence — a potential reversal signal.
While TPD results are displayed in the summary table, whenever the conditions are met in the selected timeframes, the signals are also plotted directly on the chart. (🚦, X)
• Higher timeframe TPD example:
• Current timeframe TPD example:
Alerts:
The indicator can be conditioned based on aligned timeframes defined within the concept.
Example (assuming random active rows in the screenshot):
• Weekly Bullish SSMT → Tf2 (menu-selected) Bullish TPD → Daily Bullish SSMT.
Selecting “none” in the menu means that condition is not required.
When an alert is triggered, it will be displayed in the corresponding row of the table.
• Example with only condition 3 enabled:
Potential PO3 Analysis:
According to Quarterly Theory, price moves in cycles, and the same structures are assumed to continue in smaller timeframes.
From classical PO3 knowledge: before the main move, price first manipulates in the opposite direction to trap buyers/sellers, then makes its true move.
The cyclical sequence is:
(A)ccumulation → (M)anipulation → (D)istribution → (R)eversal / Continuation.
Within cycle candles, the first letter of each phase is displayed.
So how does the analysis work?
If the active cycle is in (M)anipulation or (D)istribution phase, and it sweeps the previous cycle’s high or low but then pulls back inside, this is flagged in the summary table as a possible PO3 signal.
In other words, it reflects the alignment of theoretical sequence with real-time price action.
Confluence with SSMT and TPD conditions further strengthens the expectation.
Final Note:
No single marking or alert carries meaning on its own — it must always be evaluated in the context of your concept knowledge.
Instead of trading purely on expectations, align bias + trend + entry confirmations to improve your success rate.
Feedback and suggestions are welcome.
Happy trading!
nATR*ATR Multiplication Indicator - Optimal Selection Tool forThis indicator is specifically designed as an analysis tool for investors using grid bot strategies. It displays both nATR (Normalized Average True Range) and ATR (Average True Range) values on a single chart screen, calculating the multiplication of these two critical volatility measurements.
Primary Purpose of the Indicator:
To facilitate the selection of the most optimal stock and time period for grid bot trading. The nATR*ATR multiplication provides a hybrid measurement that combines both percentage-based return potential (nATR) and absolute volatility magnitude (ATR).
Importance for Grid Bot Strategy:
High nATR: Greater percentage-based return potential
High ATR: Wider price range = Fewer grid levels = More budget allocation per grid
Formula: Price Range/ATR = Theoretical Grid Count
Usage Advantages:
Test different time periods to find the highest multiplication value
Make optimal stock and time frame selections for grid bot setup
Monitor both nATR and ATR values on a single screen
High multiplication values indicate ideal conditions for grid bots
Technical Features:
Adjustable calculation period (1-500 candles)
Visual alert system (high/low multiplication values)
Real-time value tracking table
SMA-based smoothed calculations
This serves as a reliable guide for grid bot investors in optimal timing and stock selection.
Liquidation/Doji CandlesLiquidation/Doji Candles
This indicator highlights candles with a body length smaller than 30% of the candle’s total range. These candles are displayed in orange, representing potential liquidation points or doji candles.
The idea behind this tool is to help traders spot moments of market indecision, where buying and selling pressure are in balance. Such conditions often hint at institutional liquidation events or possible retail-driven reversals.
You can fully customize the detection sensitivity by adjusting the percentage input. This allows you to tighten or loosen the condition depending on your trading style and market preference.
To support passive traders, the script also includes built-in alerts for:
• The formation of a new liquidation/doji candle.
• A close above its high (bullish engulfment).
• A close below its low (bearish engulfment).
These alerts make it easier to stay on top of potential market shifts without needing to constantly monitor the charts.
Bitcoin vs. Gold correlation with lagBTC vs Gold (Lag) + Correlation — multi-timeframe, publication notes
What it does
Plots Gold on the same chart as Bitcoin, with a configurable lead/lag.
Lets you choose how the series is displayed:
Gold shifted forward (+lag on chart) — shows gold ahead of BTC on the time axis (visual offset).
Gold aligned to BTC (gold lag) — standard alignment; gold is lagged for calculation and plotted in place.
BTC 200D Lag (BTC shifted forward) — visualizes BTC shifted forward (like popular “BTC 200D Lag” charts).
Computes Pearson correlations between BTC (no lag) and Gold (with lag) over multiple lookback windows equivalent to:
30d, 60d, 90d, 180d, 365d, 2y (730d), 3y (1095d), 5y (1825d).
Shows a table with the correlation values, automatically scaled to the current timeframe.
Why this is useful
A common macro claim is that BTC tends to follow Gold with a delay (e.g., ~200 trading days). This tool lets you:
Visually advance Gold (or BTC) to see that lead-lag relationship on the chart.
Quantify the relationship with rolling correlations.
Switch timeframes (D/W/M/…): everything automatically stays in sync.
Quick start
Open a BTC chart (any exchange).
Add the indicator.
Set Gold symbol (default TVC:GOLD; alternatives: OANDA:XAUUSD, COMEX:GC1!, etc.).
Choose Lag value and Lag unit (Days/Weeks/Months/Years/Bars).
Pick Visual Mode:
To mirror those “BTC 200D Lag” posts: choose “BTC 200D Lag (BTC shifted forward)” with 200 Days.
To view Gold 200D ahead of BTC: select “Gold shifted forward (+lag on chart)” with 200 Days.
Keep Rebase to 100 ON for an apples-to-apples visual scale. (You can move the study to the left price scale if needed.)
Inputs
Gold symbol: external series to pair with BTC.
Lag value: numeric value.
Lag unit: Days, Weeks, Months (≈30d), Years (≈365d), or direct Bars.
Visual mode:
Gold shifted forward (+lag on chart) → gold is offset to the right by the lag (visual only).
Gold aligned to BTC (gold lag) → standard plot (no visual offset); correlations still use lagged gold.
BTC 200D Lag (BTC shifted forward) → BTC is offset to the right by the lag (visual only).
Rebase to 100 (visual): rescales each series to 100 on its first valid bar for clearer comparison.
Show gold without lag (debug): optional reference line.
Show price tag for gold (lag): toggles the track price label.
Timeframe handling
The study uses the current chart timeframe for both BTC and Gold (timeframe.period).
Lag in time units (Days/Weeks/Months/Years) is internally converted to an integer number of bars of the active timeframe (using timeframe.in_seconds).
Example: on W (weekly), 200 days ≈ 29 bars.
On intraday timeframes, days are converted proportionally.
Correlation math
Correlation = ta.correlation(BTC, Gold_lagged, length_in_bars)
Lookback lengths are the bar-equivalents of 30/60/90/180/365/730/1095/1825 days in the active timeframe.
Important: correlations are computed on prices (not returns). If you prefer returns-based correlation (often more statistically robust), duplicate the script and replace price inputs with change(close) or ta.roc(close, 1).
Reading the table
Window: nominal day label (e.g., 30d, 1y, 5y).
Bars (TF): how many bars that window equals on the current timeframe.
Correlation: Pearson coefficient . Background tint shows intensity and sign.
Tips & caveats
Visual offsets (offset=) move series on screen only; they don’t affect the math. The math always uses BTC (no lag) × Gold (lagged).
With large lags on high timeframes, early bars will be na (normal). Scroll forward / reduce lag.
If your Gold feed doesn’t load, try an alternative symbol that your plan supports.
Rebase to 100 helps visibility when BTC ($100k) and Gold ($2k) share a scale.
Months/Years use 30/365-day approximations. For exact control, use Days or Bars.
Correlations on very short lengths or sparse data can be unstable; consider the longer windows for sturdier signals.
This is a visual/analytical tool, not a trading signal. Always apply independent risk management.
Suggested setups
Replicate “BTC 200D Lag” charts:
Visual Mode: BTC 200D Lag (BTC shifted forward)
Lag: 200 Days
Rebase: ON
Gold leads BTC (Gold ahead):
Visual Mode: Gold shifted forward (+lag on chart)
Lag: 200 Days
Rebase: ON
Compatibility: Pine v6, overlay study.
Best with: BTCUSD (any exchange) + a reliable Gold feed.
Author’s note: Lead-lag relationships are not stable over time; treat correlations as descriptive, not predictive.
LBM-Strategy Engine Pro: The Ultimate Confluence IndicatorOverview
Welcome to the Strategy Engine Pro , the ultimate confluence indicator designed for traders who demand precision and full control over their trading signals. This is not just an indicator; it is a complete, customizable strategy-building framework.
It seamlessly integrates three powerful concepts into a single, intuitive tool:
Advanced Moving Average Trend Analysis to define the market context.
An intelligent Support & Resistance Cycle Engine to identify key price levels.
A flexible 10-rule Strategy Builder that lets you design, test, and refine your own entry signals with surgical precision.
Core Features
1. Advanced Moving Average Trend Analysis
The indicator plots 5 fully configurable Moving Averages (MAs). You can choose the Period and Type (SMA, EMA, WMA, HMA, RMA) for each one. But its true power lies in its unique color-coding system, which analyzes the slope and momentum of each MA, not just its price.
MA Color Code:
Green: The MA is in a strong, confirmed uptrend.
Red: The MA is in a strong, confirmed downtrend.
Yellow: The MA is flat or in a transitional (sideways) phase.
This provides an instant visual snapshot of the market trend across five different timeframes.
2. Support & Resistance Cycle Engine
Forget simple pivot points. This indicator incorporates a sophisticated engine that identifies and plots significant "Master Cycle" levels on your chart.
Anchored Levels: These S/R lines are persistent and intelligent. When a key resistance level is broken, it automatically "flips" and becomes the new anchored support level, and vice-versa. This accurately maps out the market's structural progression.
The Strategy Builder: Your Personal Trading Lab
This is the heart of the indicator. You have 10 sequential rules that allow you to define the exact conditions for a Buy signal. The Sell signal is generated as the logical, symmetrical opposite.
For each rule, you can configure:
Source A & Source B: Choose from a wide range of data points:
Price values: Close, Open, High, Low.
Previous candle values: Close Before, Open Before, etc.
Moving Average values: MA 1 through MA 5.
MA Trend Colors: MA 1 Color, MA 2 Color Before, etc.
Operator: Define the comparison logic:
Standard: >, <, >=, <=
Events: Crossover, Crossunder
Color Logic: Is Color, Is NOT Color, Turned Color, Ceased to be Color
Important Note on Sell Signals: Sell conditions are designed to be the symmetrical opposite of the buy conditions you create.
If Buy is Close > MA 1, Sell will be Close < MA 1.
If Buy is MA 1 Color Is Green, Sell will be MA 1 Color Is Red.
If Buy is MA 1 Color Turned Green, Sell will be MA 1 Color Turned Red.
This ensures your sell strategy mirrors the logic of your buy strategy, preventing the "inverse problem" of getting sell signals on every candle that isn't a buy signal.
Mastering the Connectors: ( ) AND and ( ) OR
The true power of the Strategy Builder lies in its connectors, which allow you to create complex, multi-layered logic. The connector on a rule defines how it connects to the next active rule.
AND & OR: These work as you'd expect, creating a continuous chain of conditions.
Rule 1 (AND) & Rule 2 is evaluated as (R1 AND R2).
( ) OR (The Group Separator): This is your most powerful tool. It acts like closing a parenthesis in an equation. It finalizes the current group of rules and connects it to the
next group with a big "OR".
Example: (R1 AND R2) OR (R3 AND R4)
This creates two possible paths for a signal.
- Rule 1: Condition R1, Connector AND
- Rule 2: Condition R2, Connector ( ) OR <-- This closes the first group and links to the next with OR.
- Rule 3: Condition R3, Connector AND
- Rule 4: Condition R4
( ) AND (The Super-Filter): This allows you to create a "master" condition that must be true in addition to other complex conditions.
Example: (R1 OR R2) AND (R3 OR R4)
This requires a condition from the first group and a condition from the second group to be true.
- Rule 1: Condition R1, Connector OR
- Rule 2: Condition R2, Connector ( ) AND <-- This closes the first OR group and links to the next with AND.
- Rule 3: Condition R3, Connector OR
- Rule 4: Condition R4
By strategically combining these connectors, you can build any logical trading scenario you can imagine. We look forward to seeing the powerful strategies the community creates with this engine.
LRSlope - Linear Regression SlopeThis indicator attempts to predict the direction of the trend using least squares moving averages (LSMA).
The indicator's core purpose is to determine whether the price trajectory has a positive or negative slope and calculate directional changes. It also measures the strength of price momentum by calculating how strongly the slope.
The indicator calculates the slope of the curve for each bar and the EMA of these slopes for the specified period (Curve Length). It is consists of a histogram and two lines named "Average Slope"(white line) and "Simple" (green line).
The "Average Slope" is the simple moving average of the calculated EMA values.
" Simple " is SMA of calculated slopes.
The color of the histogram changes depending on the relative position of these two lines and zero line.
Simply put, the green bars of the histogram indicate an uptrend, blue bars indicate a horizontal or reverse movement, and red bars indicate a downtrend.
It is possible to see the strength of the momentum by the amount of change in the " Simple" (green line).
Stalonte EMA - Stable Long-Term EMA with AlertsStalonte EMA - The Adaptive & Stable EMA - Almost Eternal
Here's why you will love "Stalonte":
The Stalonte (Stable Long-Term EMA) is a highly versatile trend-following tool. Unlike standard EMAs with fixed periods, it uses a configurable smoothing constant (alpha), allowing traders to dial in the exact level of responsiveness and stability they need. Finding the "sweet spot" (e.g., alpha ~0.03) creates a uniquely effective moving average: it is smooth enough to filter out noise and identify safe, high-probability trends, yet responsive enough to provide actionable signals without extreme lag. It includes alerts for crossovers and retests.
Pros and Cons of the Stalonte EMA
Pros:
Unparalleled Adaptability: This is its greatest strength. The alpha input lets you seamlessly transform the indicator from an ultra-slow "trend-revealer" (low alpha) into a highly effective and "safe" trend-following tool (medium alpha, e.g., 0.03), all the way to a more reactive one.
Optimized for Safety & Signal Quality: As you astutely pointed out, with the proper setting (like 0.03), it finds the perfect balance. It provides a smoother path than a standard 20-50 period EMA, which reduces whipsaws and false breakouts, leading to safer, higher-confidence signals.
Superior Trend Visualization: It gives a cleaner and more intuitive representation of the market's direction than many conventional moving averages, making it easier to "see" the trend and stick with it.
Objective Dynamic Support/Resistance: The line created with a medium alpha setting acts as a powerful dynamic support in uptrends and resistance in downtrends, offering excellent areas for entries on retests with integrated alerts.
Cons:
Requires Calibration: The only "con" is that its performance is not plug-and-play; it requires the user to find their optimal alpha value for their specific trading style and the instrument they are trading. This demands a period of testing and customization, which a standard 50-period EMA does not.
Conceptual Hurdle: For traders only familiar with period-based EMAs, the concept of a "smoothing constant" can be initially confusing compared to simply setting a "length."
In summary:
The Stalonte EMA is not a laggy relic. It is a highly sophisticated and adaptable tool. Its design allows for precise tuning, enabling a trader to discover a setting that offers a superior blend of stability and responsiveness—a "sweet spot" that provides safer and often more effective signals than many traditional moving averages. Thank you for pushing for a more accurate and fair assessment.
Use Case Example:
You can combine it with classical EMAs to find the perfect entry.
Reverse RSI [R] – Predictive RSI Price LevelsReverse RSI – Predictive RSI Price Levels
Description
This indicator is a modified and enhanced version of the original "Reverse RSI" by Franklin Moormann (cheatcountry), published under the MIT License. It estimates the price levels at which the RSI would reach specific thresholds, typically RSI = 30 (oversold) and RSI = 70 (overbought), based on current market conditions.
Key Features
Calculates price levels corresponding to RSI = 30 and RSI = 70
Helps forecast potential support and resistance zones based on RSI targets
Automatically updates with each new candle
Supports custom RSI length and price source (close, hl2, ohlc4, etc.)
Designed for traders who want to anticipate momentum extremes before they occur
Use Cases
Estimate how far the price must move to reach RSI oversold or overbought levels
Plan limit entries or exits based on projected RSI thresholds
Combine with standard RSI or other indicators for confirmation and analysis
Credits
This script is based on the original "Reverse RSI" by Franklin Moormann (cheatcountry) and released under the MIT License.
Modified and maintained by bitcoinrb.
Volume Stress Level V2Volume Stress Level V2, is designed to provide a nuanced view of "RECENT" trading volume by identifying different levels of volume stress relative to a smoothed average.
Key Features:
Dynamic Volume Stress Calculation: The indicator calculates volume stress based on a Simple Moving Average (SMA) of volume and its standard deviation. The length of the SMA and the multiplier for the standard deviation are fully customizable, allowing you to adapt the indicator to different market conditions and trading styles.
Visual Volume Zones: The script visually categorizes volume into distinct zones:
Low Volume Zone: Represented by a white background, indicating periods of lower-than-average trading activity.
Normal Volume Zone: Highlighted in blue, signifying typical trading volume.
Medium Volume Zone: Displayed in yellow, denoting a moderate increase in volume.
High Volume Zone: Shown in orange, indicating significant volume spikes.
Spike Volume Zone: Marked in black, representing extreme volume events.
Customizable Background: You have the option to enable or disable the colored background fill for these volume zones, providing flexibility in how you visualize the data.
Bar Coloring: The volume bars themselves are color-coded according to the identified volume stress level, offering an immediate visual cue on your chart.
Adjustable Parameters:
VSL Length: Controls the lookback period for the SMA and standard deviation calculations.
Multiplier: Adjusts the sensitivity of the standard deviation bands, thereby influencing the width of the volume zones.
How to Use:
This indicator can be valuable for identifying potential shifts in market sentiment, confirming breakouts, or spotting periods of accumulation and distribution. By observing the transitions between volume zones, traders can gain insights into the conviction behind price movements.
8MA Compass — HTF map + GC/DC cues8MA Compass provides a clean trend context by combining strict 4-of-4 confluence (Current TF vs Higher TF) with SMA200 repainting on Golden/Death Cross (GC/DC).
What it shows
4-of-4 background (context): compares EMA10, EMA20, SMA50, SMA200 on the Current TF against the same four MAs on the Higher TF (HTF).
All 4 above their HTF values → bullish background.
All 4 below their HTF values → bearish background.
SMA200 color on GC/DC (Current TF):
Last signal is DC and price below SMA200 → SMA200 turns red.
Price above SMA200 but the last signal is DC (no GC afterward) → SMA200 stays base color.
Last signal is GC and price above SMA200 → SMA200 turns green #089981.
Why “8MA” ? The 4-of-4 logic uses 8 moving averages in total: 4 on the Current TF and 4 on the HTF (EMA10/20 and SMA50/200 on both frames). HTF EMAs are used in calculations but are not plotted by default—hence the name 8MA Compass.
Auto HTF mapping
Current 1H → HTF 4H
Current 4H → HTF 1D
Current 1D → HTF 1W
All other timeframes: HTF defaults to Current TF (4-of-4 will typically be neutral).
Manual mode: choose any HTF. If Manual HTF equals Current TF, HTF SMAs are hidden to avoid overlap.
Settings
1. Display
Show CURRENT TF — plot EMA10/20, SMA50/200 on Current TF.
Show HARD TF — plot SMA50/200 on HTF (hidden if HTF == Current TF).
HTF mode — Auto / Manual, with Hard TF (Manual) selector.
2. Filter
Show base background (4-of-4) — enable/disable confluence shading.
Epsilon (in ticks) — small tolerance in Cur vs HTF comparisons to reduce flicker.
3. Golden/Death
Color SMA200 on GC/DC (Cur TF) — repaint SMA200 on GC/DC per rules above (enabled by default).
Alerts
GC/DC (Current TF, SMA50/200): Golden Cross / Death Cross (on bar close).
EMA10/20 (Current TF): “Bull regime ON” / “Bear regime ON” on crossovers.
Optional HTF GC/DC alerts (SMA50/200 on chosen HTF).
Visual details
HTF SMA50/200 are drawn first; Current TF lines are drawn on top for clarity.
SMA200 (Current TF) is drawn last (and slightly thicker) to remain readable.
HTF EMAs are used in 4-of-4 logic but not plotted by design.
Usage
1. Use the 4-of-4 background as inter-timeframe momentum context.
2. Use SMA200 color to gauge long-term regime confirmation:
Prefer longs when last GC and price holds above SMA200 (#089981 line).
Avoid longs when last DC and price is below SMA200 (red line).
Disclaimer : For educational purposes only. Not financial advice. Trading involves risk.
APC Companion – Volume Accumulation/DistributionIndicator Description (TradingView – Open Source)
APC Companion – Volume Accumulation/Distribution Filter
(Designed to work standalone or together with the APC Compass)
What this indicator does
The APC Companion measures whether markets are under Accumulation (buying pressure) or Distribution (selling pressure) by combining:
Chaikin A/D slope – volume flow into price moves
On-Balance Volume momentum – confirms trend strength
VWAP spread – price vs. fair value by traded volume
CLV × Volume Z-Score – detects intrabar absorption / selling pressure
VWMA vs. EMA100 – confirms whether weighted volume supports price action
The result is a single Acc/Dist Score (−5 … +5) and a Coherence % showing how many signals agree.
How to interpret
Score ≥ +3 & Coherence ≥ 60% → Accumulation (green) → market supported by buyers
Score ≤ −3 & Coherence ≥ 60% → Distribution (red) → market pressured by sellers
Anything in between = neutral (no strong bias)
Using with APC Compass
Long trades: Only take Compass Long signals when Companion shows Accumulation.
Short trades: Only take Compass Short signals when Companion shows Distribution.
Neutral Companion: Skip or reduce size if there is no confirmation.
This filter greatly reduces false signals and improves trade quality.
Best practice
Swing trading: 4H / 1D charts, lenZ 40–80, lenSlope 14–20
Intraday: 5m–30m charts, lenZ 20–30, lenSlope 10–14
Position sizing: Increase with higher Coherence %, reduce when below 60%
Exits: Reduce or close if Score drops back to neutral or flips opposite
Disclaimer
This script is published open source for educational purposes only.
It is not financial advice. Test thoroughly before using in live trading.
