NextBarColorNextBarColor
This is two-bars pattern search/matching indicator.
This indicator compares multiple values:
current bar high with previous bar open
current bar high with previous bar close
current bar high with previous bar high
current bar high with previous bar low
current bar low with previous bar open
current bar low with previous bar close
current bar low with previous bar high
current bar low with previous bar low
current bar close/current_price with previous bar high
current bar close/current_price with previous bar low
current bar close/current_price with previous bar open
current bar close/current_price with previous bar close
and searches for the same combination of 2 bars (current and previous) in the past.
Then shows as % value how many times the next bar went up or down.
Grey bar compares ups and downs with all results, including cases when price did not move.
My testing is showing better results when current and previous bars colors are also used in the search.
ค้นหาในสคริปต์สำหรับ "bar"
Volume Spread Analysis [TANHEF]Volume Spread Analysis: Understanding Market Intentions through the Interpretation of Volume and Price Movements.
█ Simple Explanation:
The Volume Spread Analysis (VSA) indicator is a comprehensive tool that helps traders identify key market patterns and trends based on volume and spread data. This indicator highlights significant VSA patterns and provides insights into market behavior through color-coded volume/spread bars and identification of bars indicating strength, weakness, and neutrality between buyers and sellers. It also includes powerful volume and spread forecasting capabilities.
█ Laws of Volume Spread Analysis (VSA):
The origin of VSA begins with Richard Wyckoff, a pivotal figure in its development. Wyckoff made significant contributions to trading theory, including the formulation of three basic laws:
The Law of Supply and Demand: This fundamental law states that supply and demand balance each other over time. High demand and low supply lead to rising prices until demand falls to a level where supply can meet it. Conversely, low demand and high supply cause prices to fall until demand increases enough to absorb the excess supply.
The Law of Cause and Effect: This law assumes that a 'cause' will result in an 'effect' proportional to the 'cause'. A strong 'cause' will lead to a strong trend (effect), while a weak 'cause' will lead to a weak trend.
The Law of Effort vs. Result: This law asserts that the result should reflect the effort exerted. In trading terms, a large volume should result in a significant price move (spread). If the spread is small, the volume should also be small. Any deviation from this pattern is considered an anomaly.
█ Volume and Spread Analysis Bars:
Display: Volume and/or spread bars that consist of color coded levels. If both of these are displayed, the number of spread bars can be limited for visual appeal and understanding, with the spread bars scaled to match the volume bars. While automatic calculation of the number of visual bars for auto scaling is possible, it is avoided to prevent the indicator from reloading whenever the number of visual price bars on the chart is adjusted, ensuring uninterrupted analysis. A displayable table (Legend) of bar colors and levels can give context and clarify to each volume/spread bar.
Calculation: Levels are calculated using multipliers applied to moving averages to represent key levels based on historical data: low, normal, high, ultra. This method smooths out short-term fluctuations and focuses on longer-term trends.
Low Level: Indicates reduced volatility and market interest.
Normal Level: Reflects typical market activity and volatility.
High Level: Indicates increased activity and volatility.
Ultra Level: Identifies extreme levels of activity and volatility.
This illustrates the appearance of Volume and Spread bars when scaled and plotted together:
█ Forecasting Capabilities:
Display: Forecasted volume and spread levels using predictive models.
Calculation: Volume and Spread prediction calculations differ as volume is linear and spread is non-linear.
Volume Forecast (Linear Forecasting): Predicts future volume based on current volume rate and bar time till close.
Spread Forecast (Non-Linear Dynamic Forecasting): Predicts future spread using a dynamic multiplier, less near midpoint (consolidation) and more near low or high (trending), reflecting non-linear expansion.
Moving Averages: In forecasting, moving averages utilize forecasted levels instead of actual levels to ensure the correct level is forecasted (low, normal, high, or ultra).
The following compares forecasted volume with actual resulting volume, highlighting the power of early identifying increased volume through forecasted levels:
█ VSA Patterns:
Criteria and descriptions for each VSA pattern are available as tooltips beside them within the indicator’s settings. These tooltips provide explanations of potential developments based on the volume and spread data.
Signs of Strength (🟢): Patterns indicating strong buying pressure and potential market upturns.
Down Thrust
Selling Climax
No Effort → Bearish Result
Bearish Effort → No Result
Inverse Down Thrust
Failed Selling Climax
Bull Outside Reversal
End of Falling Market (Bag Holder)
Pseudo Down Thrust
No Supply
Signs of Weakness (🔴): Patterns indicating strong selling pressure and potential market downturns.
Up Thrust
Buying Climax
No Effort → Bullish Result
Bullish Effort → No Result
Inverse Up Thrust
Failed Buying Climax
Bear Outside Reversal
End of Rising Market (Bag Seller)
Pseudo Up Thrust
No Demand
Neutral Patterns (🔵): Patterns indicating market indecision and potential for continuation or reversal.
Quiet Doji
Balanced Doji
Strong Doji
Quiet Spinning Top
Balanced Spinning Top
Strong Spinning Top
Quiet High Wave
Balanced High Wave
Strong High Wave
Consolidation
Bar Patterns (🟡): Common candlestick patterns that offer insights into market sentiment. These are required in some VSA patterns and can also be displayed independently.
Bull Pin Bar
Bear Pin Bar
Doji
Spinning Top
High Wave
Consolidation
This demonstrates the acronym and descriptive options for displaying bar patterns, with the ability to hover over text to reveal the descriptive text along with what type of pattern:
█ Alerts:
VSA Pattern Alerts: Notifications for identified VSA patterns at bar close.
Volume and Spread Alerts: Alerts for confirmed and forecasted volume/spread levels (Low, High, Ultra).
Forecasted Volume and Spread Alerts: Alerts for forecasted volume/spread levels (High, Ultra) include a minimum percent time elapsed input to reduce false early signals by ensuring sufficient bar time has passed.
█ Inputs and Settings:
Display Volume and/or Spread: Choose between displaying volume bars, spread bars, or both with different lookback periods.
Indicator Bar Color: Select color schemes for bars (Normal, Detail, Levels).
Indicator Moving Average Color: Select schemes for bars (Fill, Lines, None).
Price Bar Colors: Options to color price bars based on VSA patterns and volume levels.
Legend: Display a table of bar colors and levels for context and clarity of volume/spread bars.
Forecast: Configure forecast display and prediction details for volume and spread.
Average Multipliers: Define multipliers for different levels (Low, High, Ultra) to refine the analysis.
Moving Average: Set volume and spread moving average settings.
VSA: Select the VSA patterns to be calculated and displayed (Strength, Weakness, Neutral).
Bar Patterns: Criteria for bar patterns used in VSA (Doji, Bull Pin Bar, Bear Pin Bar, Spinning Top, Consolidation, High Wave).
Colors: Set exact colors used for indicator bars, indicator moving averages, and price bars.
More Display Options: Specify how VSA pattern text is displayed (Acronym, Descriptive), positioning, and sizes.
Alerts: Configure alerts for VSA patterns, volume, and spread levels, including forecasted levels.
█ Usage:
The Volume Spread Analysis indicator is a helpful tool for leveraging volume spread analysis to make informed trading decisions. It offers comprehensive visual and textual cues on the chart, making it easier to identify market conditions, potential reversals, and continuations. Whether analyzing historical data or forecasting future trends, this indicator provides insights into the underlying factors driving market movements.
Delta ZigZag [LuxAlgo]The Delta ZigZag indicator is focused on volume analysis during the development of ZigZag lines. Volume data can be retrieved from a Lower timeframe (LTF) or real-time Tick data.
Our Delta ZigZag publication can be helpful in detecting indications of a trend reversal or potential weakening/strengthening of the trend.
This indicator by its very nature backpaints, meaning that the displayed components are offset in the past.
🔶 USAGE
The ZigZag line is formed by connecting Swings , which can be set by adjusting the Left and Right settings.
Left is the number of bars for evaluation at the left of the evaluated point.
Right is the number of bars for evaluation at the right of the evaluated point.
A valid Swing is a value higher or lower than the bars at the left/right .
A higher Left or Right set number will generally create broader ZigZag ( ZZ ) lines, while the drawing of the ZZ line will be delayed (especially when Right is set higher). On the other hand, when Right is set at 0, ZZ line are drawn quickly. However, this results in a hyperactive switching of the ZZ direction.
To ensure maximum visibility of values, we recommend using " Bars " from the " Bar's style " menu.
🔹 Volume examination
The script provides two options for Volume examination :
Examination per ZigZag line
Examination per bar
Bullish Volume is volume associated with a green bar ( close > open )
Bearish Volume is volume associated with a red bar ( close < open )
Neutral Volume (volume on a " close == open" bar) is not included in this publication.
🔹 Examination per ZigZag line
As long as the price moves in the same direction, the present ZZ line will continue. When the direction of the price changes, the bull/bear volume of the previous ZZ line is evaluated and drawn on the chart.
The ZZ line is divided into two parts: a bullish green line and a bearish red line.
The intercept of these two lines will depend on the ratio of bullish/bearish volume
This ratio is displayed at the intercept as % bullish volume (Settings -> Show % Bullish Volume)
* Note that we cannot draw between 2 bars. Therefore, if a ZZ line is only 1 bar long, the intercept will be at one of those 2 bars and not in between. The percentage can be helpful in interpreting bull/bear volume.
In the example above (2 most right labels), you can see that an overlap of 2 labels is prevented, ensuring the ability to evaluate the bullish % volume of the ZZ line .
The percentage will be colored green when more than 50%, red otherwise. The color will fade when the direction is contradictory; for example, 40% when the ZZ line goes up or 70% when the ZZ line falls.
More details can be visualized by enabling " Show " and choosing 1 of 3 options:
Average Volume Delta/bar
Average Volume/bar
Normalised Volume Delta
For both 'averages', the sum of " Volume "/" Volume Delta " of every bar on the ZZ line is divided by the number of bars (per ZZ line ).
The " Normalised Volume Delta " is calculated by dividing the sum of " Delta Volume " by the sum of " Volume " (neutral volume not included), which is displayed as a percentage.
All three options will display a label at the last point of the ZZ line and be coloured similarly: green when the ratio bullish/bearish volume of the ZZ line is bullish and red otherwise. Here, the colour also fades when it is bullish, but the ZZ line falls or when it is bearish with a rising ZZ line .
A tooltip at each label hints at the chosen option.
You can pick one of the options or combine them together.
🔹 Examination per bar
Besides information about what's happening during the ZZ line , information per bar can be visualized by enabling " Show Details " in Settings .
Split Volume per bar : show the sum of bullish (upV) and bearish (dnV) volume per bar
Volume (bar) : Total Volume per bar (bullish + bearish volume, neutral volume not included)
Δ Volume (bar) : Show Delta Volume (bullish - bearish volume)
🔹 Using Lower Timeframe Data
The ZigZag lines using LTF data are colored brighter. Also note the vertical line where the LTF data starts and the gap between ZZ lines with LTF data and without.
When " LTF " is chosen for the " Data from: " option in Settings , data is retrieved from Lower Timeframe bars (default 1 minute). When the LTF setting is higher than the current chart timeframe, the LTF period will automatically be adjusted to the current timeframe to prevent errors.
As there is a 100K limit to the number of LTF intrabars that can be analyzed by a script, this implies the higher the difference between LTF and current TF; the fewer ZZ lines will be seen.
🔹 Using real-time tick data
The principles are mostly the same as those of LTF data. However, in contrast with LTF data, where you already have LTF ZZ lines when loading the script, real-time tick data-based ZZ lines will only start after loading the chart.
Changing the settings of a ticker will reset everything. However, returning to the same settings/ticker would show the cached data again.
Here, you can see that changing settings reset everything, but returning after 2 minutes to the initial settings shows the cached data. Don't expect it to be cached for hours or days, though.
🔶 DETAILS
The timeframe used for LTF data should always be the same or lower than the current TF; otherwise, an error occurs. This snippet prevents the error and adjusts the LTF to the current TF when LTF is too high:
res = input.timeframe('1')
res := timeframe.from_seconds( math.min( timeframe.in_seconds(timeframe.period), timeframe.in_seconds(res) ) )
🔶 SETTINGS
Data from: LTF (Lower TimeFrame) or Ticks (Real-time ticks)
Res: Lower TimeFrame (only applicable when choosing LTF )
Option: choose " high/low " or " close " for Swing detection
🔹 ZigZag
Left: Lookback period for Swings
Right: Confirmation period after potential Swing
🔹 ZigZag Delta
Show % Bullish Volume : % bullish volume against total volume during the ZZ line
Show:
Average Volume Delta/bar
Average Volume/bar
Normalised Volume Delta
See USAGE for more information
🔹 Bar Data
Split Volume per bar: shows the sum of bullish ( upV ) and bearish ( dnV ) volume per bar
Volume (bar): Total Volume per bar (bullish + bearish volume, neutral volume not included)
Δ Volume (bar): Show Volume Delta (bullish - bearish volume)
LYGLibraryLibrary "LYGLibrary"
A collection of custom tools & utility functions commonly used with my scripts
getDecimals()
Calculates how many decimals are on the quote price of the current market
Returns: The current decimal places on the market quote price
truncate(number, decimalPlaces)
Truncates (cuts) excess decimal places
Parameters:
number (float)
decimalPlaces (simple float)
Returns: The given number truncated to the given decimalPlaces
toWhole(number)
Converts pips into whole numbers
Parameters:
number (float)
Returns: The converted number
toPips(number)
Converts whole numbers back into pips
Parameters:
number (float)
Returns: The converted number
getPctChange(value1, value2, lookback)
Gets the percentage change between 2 float values over a given lookback period
Parameters:
value1 (float)
value2 (float)
lookback (int)
av_getPositionSize(balance, risk, stopPoints, conversionRate)
Calculates OANDA forex position size for AutoView based on the given parameters
Parameters:
balance (float)
risk (float)
stopPoints (float)
conversionRate (float)
Returns: The calculated position size (in units - only compatible with OANDA)
bullFib(priceLow, priceHigh, fibRatio)
Calculates a bullish fibonacci value
Parameters:
priceLow (float) : The lowest price point
priceHigh (float) : The highest price point
fibRatio (float) : The fibonacci % ratio to calculate
Returns: The fibonacci value of the given ratio between the two price points
bearFib(priceLow, priceHigh, fibRatio)
Calculates a bearish fibonacci value
Parameters:
priceLow (float) : The lowest price point
priceHigh (float) : The highest price point
fibRatio (float) : The fibonacci % ratio to calculate
Returns: The fibonacci value of the given ratio between the two price points
getMA(length, maType)
Gets a Moving Average based on type (MUST BE CALLED ON EVERY CALCULATION)
Parameters:
length (simple int)
maType (string)
Returns: A moving average with the given parameters
getEAP(atr)
Performs EAP stop loss size calculation (eg. ATR >= 20.0 and ATR < 30, returns 20)
Parameters:
atr (float)
Returns: The EAP SL converted ATR size
getEAP2(atr)
Performs secondary EAP stop loss size calculation (eg. ATR < 40, add 5 pips, ATR between 40-50, add 10 pips etc)
Parameters:
atr (float)
Returns: The EAP SL converted ATR size
barsAboveMA(lookback, ma)
Counts how many candles are above the MA
Parameters:
lookback (int)
ma (float)
Returns: The bar count of how many recent bars are above the MA
barsBelowMA(lookback, ma)
Counts how many candles are below the MA
Parameters:
lookback (int)
ma (float)
Returns: The bar count of how many recent bars are below the EMA
barsCrossedMA(lookback, ma)
Counts how many times the EMA was crossed recently
Parameters:
lookback (int)
ma (float)
Returns: The bar count of how many times price recently crossed the EMA
getPullbackBarCount(lookback, direction)
Counts how many green & red bars have printed recently (ie. pullback count)
Parameters:
lookback (int)
direction (int)
Returns: The bar count of how many candles have retraced over the given lookback & direction
getBodySize()
Gets the current candle's body size (in POINTS, divide by 10 to get pips)
Returns: The current candle's body size in POINTS
getTopWickSize()
Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's top wick size in POINTS
getBottomWickSize()
Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's bottom wick size in POINTS
getBodyPercent()
Gets the current candle's body size as a percentage of its entire size including its wicks
Returns: The current candle's body size percentage
isHammer(fib, colorMatch)
Checks if the current bar is a hammer candle based on the given parameters
Parameters:
fib (float)
colorMatch (bool)
Returns: A boolean - true if the current bar matches the requirements of a hammer candle
isStar(fib, colorMatch)
Checks if the current bar is a shooting star candle based on the given parameters
Parameters:
fib (float)
colorMatch (bool)
Returns: A boolean - true if the current bar matches the requirements of a shooting star candle
isDoji(wickSize, bodySize)
Checks if the current bar is a doji candle based on the given parameters
Parameters:
wickSize (float)
bodySize (float)
Returns: A boolean - true if the current bar matches the requirements of a doji candle
isBullishEC(allowance, rejectionWickSize, engulfWick)
Checks if the current bar is a bullish engulfing candle
Parameters:
allowance (float)
rejectionWickSize (float)
engulfWick (bool)
Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle
isBearishEC(allowance, rejectionWickSize, engulfWick)
Checks if the current bar is a bearish engulfing candle
Parameters:
allowance (float)
rejectionWickSize (float)
engulfWick (bool)
Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle
isInsideBar()
Detects inside bars
Returns: Returns true if the current bar is an inside bar
isOutsideBar()
Detects outside bars
Returns: Returns true if the current bar is an outside bar
barInSession(sess, useFilter)
Determines if the current price bar falls inside the specified session
Parameters:
sess (simple string)
useFilter (bool)
Returns: A boolean - true if the current bar falls within the given time session
barOutSession(sess, useFilter)
Determines if the current price bar falls outside the specified session
Parameters:
sess (simple string)
useFilter (bool)
Returns: A boolean - true if the current bar falls outside the given time session
dateFilter(startTime, endTime)
Determines if this bar's time falls within date filter range
Parameters:
startTime (int)
endTime (int)
Returns: A boolean - true if the current bar falls within the given dates
dayFilter(monday, tuesday, wednesday, thursday, friday, saturday, sunday)
Checks if the current bar's day is in the list of given days to analyze
Parameters:
monday (bool)
tuesday (bool)
wednesday (bool)
thursday (bool)
friday (bool)
saturday (bool)
sunday (bool)
Returns: A boolean - true if the current bar's day is one of the given days
atrFilter(atrValue, maxSize)
Parameters:
atrValue (float)
maxSize (float)
fillCell(tableID, column, row, title, value, bgcolor, txtcolor)
This updates the given table's cell with the given values
Parameters:
tableID (table)
column (int)
row (int)
title (string)
value (string)
bgcolor (color)
txtcolor (color)
Returns: A boolean - true if the current bar falls within the given dates
CVD - Cumulative Volume Delta (Chart)█ OVERVIEW
This indicator displays cumulative volume delta (CVD) as an on-chart oscillator. It uses intrabar analysis to obtain more precise volume delta information compared to methods that only use the chart's timeframe.
The core concepts in this script come from our first CVD indicator , which displays CVD values as plot candles in a separate indicator pane. In this script, CVD values are scaled according to price ranges and represented on the main chart pane.
█ CONCEPTS
Bar polarity
Bar polarity refers to the position of the close price relative to the open price. In other words, bar polarity is the direction of price change.
Intrabars
Intrabars are chart bars at a lower timeframe than the chart's. Each 1H chart bar of a 24x7 market will, for example, usually contain 60 bars at the lower timeframe of 1min, provided there was market activity during each minute of the hour. Mining information from intrabars can be useful in that it offers traders visibility on the activity inside a chart bar.
Lower timeframes (LTFs)
A lower timeframe is a timeframe that is smaller than the chart's timeframe. This script utilizes a LTF to analyze intrabars, or price changes within a chart bar. The lower the LTF, the more intrabars are analyzed, but the less chart bars can display information due to the limited number of intrabars that can be analyzed.
Volume delta
Volume delta is a measure that separates volume into "up" and "down" parts, then takes the difference to estimate the net demand for the asset. This approach gives traders a more detailed insight when analyzing volume and market sentiment. There are several methods for determining whether an asset's volume belongs in the "up" or "down" category. Some indicators, such as On Balance Volume and the Klinger Oscillator , use the change in price between bars to assign volume values to the appropriate category. Others, such as Chaikin Money Flow , make assumptions based on open, high, low, and close prices. The most accurate method involves using tick data to determine whether each transaction occurred at the bid or ask price and assigning the volume value to the appropriate category accordingly. However, this method requires a large amount of data on historical bars, which can limit the historical depth of charts and the number of symbols for which tick data is available.
In the context where historical tick data is not yet available on TradingView, intrabar analysis is the most precise technique to calculate volume delta on historical bars on our charts. This indicator uses intrabar analysis to achieve a compromise between simplicity and accuracy in calculating volume delta on historical bars. Our Volume Profile indicators use it as well. Other volume delta indicators in our Community Scripts , such as the Realtime 5D Profile , use real-time chart updates to achieve more precise volume delta calculations. However, these indicators aren't suitable for analyzing historical bars since they only work for real-time analysis.
This is the logic we use to assign intrabar volume to the "up" or "down" category:
• If the intrabar's open and close values are different, their relative position is used.
• If the intrabar's open and close values are the same, the difference between the intrabar's close and the previous intrabar's close is used.
• As a last resort, when there is no movement during an intrabar and it closes at the same price as the previous intrabar, the last known polarity is used.
Once all intrabars comprising a chart bar are analyzed, we calculate the net difference between "up" and "down" intrabar volume to produce the volume delta for the chart bar.
█ FEATURES
CVD resets
The "cumulative" part of the indicator's name stems from the fact that calculations accumulate during a period of time. By periodically resetting the volume delta accumulation, we can analyze the progression of volume delta across manageable chunks, which is often more useful than looking at volume delta accumulated from the beginning of a chart's history.
You can configure the reset period using the "CVD Resets" input, which offers the following selections:
• None : Calculations do not reset.
• On a fixed higher timeframe : Calculations reset on the higher timeframe you select in the "Fixed higher timeframe" field.
• At a fixed time that you specify.
• At the beginning of the regular session .
• On trend changes : Calculations reset on the direction change of either the Aroon indicator, Parabolic SAR , or Supertrend .
• On a stepped higher timeframe : Calculations reset on a higher timeframe automatically stepped using the chart's timeframe and following these rules:
Chart TF HTF
< 1min 1H
< 3H 1D
<= 12H 1W
< 1W 1M
>= 1W 1Y
Specifying intrabar precision
Ten options are included in the script to control the number of intrabars used per chart bar for calculations. The greater the number of intrabars per chart bar, the fewer chart bars can be analyzed.
The first five options allow users to specify the approximate amount of chart bars to be covered:
• Least Precise (Most chart bars) : Covers all chart bars by dividing the current timeframe by four.
This ensures the highest level of intrabar precision while achieving complete coverage for the dataset.
• Less Precise (Some chart bars) & More Precise (Less chart bars) : These options calculate a stepped LTF in relation to the current chart's timeframe.
• Very precise (2min intrabars) : Uses the second highest quantity of intrabars possible with the 2min LTF.
• Most precise (1min intrabars) : Uses the maximum quantity of intrabars possible with the 1min LTF.
The stepped lower timeframe for "Less Precise" and "More Precise" options is calculated from the current chart's timeframe as follows:
Chart Timeframe Lower Timeframe
Less Precise More Precise
< 1hr 1min 1min
< 1D 15min 1min
< 1W 2hr 30min
> 1W 1D 60min
The last five options allow users to specify an approximate fixed number of intrabars to analyze per chart bar. The available choices are 12, 24, 50, 100, and 250. The script will calculate the LTF which most closely approximates the specified number of intrabars per chart bar. Keep in mind that due to factors such as the length of a ticker's sessions and rounding of the LTF, it is not always possible to produce the exact number specified. However, the script will do its best to get as close to the value as possible.
As there is a limit to the number of intrabars that can be analyzed by a script, a tradeoff occurs between the number of intrabars analyzed per chart bar and the chart bars for which calculations are possible.
Display
This script displays raw or cumulative volume delta values on the chart as either line or histogram oscillator zones scaled according to the price chart, allowing traders to visualize volume activity on each bar or cumulatively over time. The indicator's background shows where CVD resets occur, demarcating the beginning of new zones. The vertical axis of each oscillator zone is scaled relative to the one with the highest price range, and the oscillator values are scaled relative to the highest volume delta. A vertical offset is applied to each oscillator zone so that the highest oscillator value aligns with the lowest price. This method ensures an accurate, intuitive visual comparison of volume activity within zones, as the scale is consistent across the chart, and oscillator values sit below prices. The vertical scale of oscillator zones can be adjusted using the "Zone Height" input in the script settings.
This script displays labels at the highest and lowest oscillator values in each zone, which can be enabled using the "Hi/Lo Labels" input in the "Visuals" section of the script settings. Additionally, the oscillator's value on a chart bar is displayed as a tooltip when a user hovers over the bar, which can be enabled using the "Value Tooltips" input.
Divergences occur when the polarity of volume delta does not match that of the chart bar. The script displays divergences as bar colors and background colors that can be enabled using the "Color bars on divergences" and "Color background on divergences" inputs.
An information box in the lower-left corner of the indicator displays the HTF used for resets, the LTF used for intrabars, the average quantity of intrabars per chart bar, and the number of chart bars for which there is LTF data. This is enabled using the "Show information box" input in the "Visuals" section of the script settings.
FOR Pine Script™ CODERS
• This script utilizes `ltf()` and `ltfStats()` from the lower_tf library.
The `ltf()` function determines the appropriate lower timeframe from the selected calculation mode and chart timeframe, and returns it in a format that can be used with request.security_lower_tf() .
The `ltfStats()` function, on the other hand, is used to compute and display statistical information about the lower timeframe in an information box.
• The script utilizes display.data_window and display.status_line to restrict the display of certain plots.
These new built-ins allow coders to fine-tune where a script’s plot values are displayed.
• The newly added session.isfirstbar_regular built-in allows for resetting the CVD segments at the start of the regular session.
• The VisibleChart library developed by our resident PineCoders team leverages the chart.left_visible_bar_time and chart.right_visible_bar_time variables to optimize the performance of this script.
These variables identify the opening time of the leftmost and rightmost visible bars on the chart, allowing the script to recalculate and draw objects only within the range of visible bars as the user scrolls.
This functionality also enables the scaling of the oscillator zones.
These variables are just a couple of the many new built-ins available in the chart.* namespace.
For more information, check out this blog post or look them up by typing "chart." in the Pine Script™ Reference Manual .
• Our ta library has undergone significant updates recently, including the incorporation of the `aroon()` indicator used as a method for resetting CVD segments within this script.
Revisit the library to see more of the newly added content!
Look first. Then leap.
Intrabar Efficiency Ratio█ OVERVIEW
This indicator displays a directional variant of Perry Kaufman's Efficiency Ratio, designed to gauge the "efficiency" of intrabar price movement by comparing the sum of movements of the lower timeframe bars composing a chart bar with the respective bar's movement on an average basis.
█ CONCEPTS
Efficiency Ratio (ER)
Efficiency Ratio was first introduced by Perry Kaufman in his 1995 book, titled "Smarter Trading". It is the ratio of absolute price change to the sum of absolute changes on each bar over a period. This tells us how strong the period's trend is relative to the underlying noise. Simply put, it's a measure of price movement efficiency. This ratio is the modulator utilized in Kaufman's Adaptive Moving Average (KAMA), which is essentially an Exponential Moving Average (EMA) that adapts its responsiveness to movement efficiency.
ER's output is bounded between 0 and 1. A value of 0 indicates that the starting price equals the ending price for the period, which suggests that price movement was maximally inefficient. A value of 1 indicates that price had travelled no more than the distance between the starting price and the ending price for the period, which suggests that price movement was maximally efficient. A value between 0 and 1 indicates that price had travelled a distance greater than the distance between the starting price and the ending price for the period. In other words, some degree of noise was present which resulted in reduced efficiency over the period.
As an example, let's say that the price of an asset had moved from $15 to $14 by the end of a period, but the sum of absolute changes for each bar of data was $4. ER would be calculated like so:
ER = abs(14 - 15)/4 = 0.25
This suggests that the trend was only 25% efficient over the period, as the total distanced travelled by price was four times what was required to achieve the change over the period.
Intrabars
Intrabars are chart bars at a lower timeframe than the chart's. Each 1H chart bar of a 24x7 market will, for example, usually contain 60 intrabars at the LTF of 1min, provided there was market activity during each minute of the hour. Mining information from intrabars can be useful in that it offers traders visibility on the activity inside a chart bar.
Lower timeframes (LTFs)
A lower timeframe is a timeframe that is smaller than the chart's timeframe. This script determines which LTF to use by examining the chart's timeframe. The LTF determines how many intrabars are examined for each chart bar; the lower the timeframe, the more intrabars are analyzed, but fewer chart bars can display indicator information because there is a limit to the total number of intrabars that can be analyzed.
Intrabar precision
The precision of calculations increases with the number of intrabars analyzed for each chart bar. As there is a 100K limit to the number of intrabars that can be analyzed by a script, a trade-off occurs between the number of intrabars analyzed per chart bar and the chart bars for which calculations are possible.
Intrabar Efficiency Ratio (IER)
Intrabar Efficiency Ratio applies the concept of ER on an intrabar level. Rather than comparing the overall change to the sum of bar changes for the current chart's timeframe over a period, IER compares single bar changes for the current chart's timeframe to the sum of absolute intrabar changes, then applies smoothing to the result. This gives an indication of how efficient changes are on the current chart's timeframe for each bar of data relative to LTF bar changes on an average basis. Unlike the standard ER calculation, we've opted to preserve directional information by not taking the absolute value of overall change, thus allowing it to be utilized as a momentum oscillator. However, by taking the absolute value of this oscillator, it could potentially serve as a replacement for ER in the design of adaptive moving averages.
Since this indicator preserves directional information, IER can be regarded as similar to the Chande Momentum Oscillator (CMO) , which was presented in 1994 by Tushar Chande in "The New Technical Trader". Both CMO and ER essentially measure the same relationship between trend and noise. CMO simply differs in scale, and considers the direction of overall changes.
█ FEATURES
Display
Three different display types are included within the script:
• Line : Displays the middle length MA of the IER as a line .
Color for this display can be customized via the "Line" portion of the "Visuals" section in the script settings.
• Candles : Displays the non-smooth IER and two moving averages of different lengths as candles .
The `open` and `close` of the candle are the longest and shortest length MAs of the IER respectively.
The `high` and `low` of the candle are the max and min of the IER, longest length MA of the IER, and shortest length MA of the IER respectively.
Colors for this display can be customized via the "Candles" portion of the "Visuals" section in the script settings.
• Circles : Displays three MAs of the IER as circles .
The color of each plot depends on the percent rank of the respective MA over the previous 100 bars.
Different colors are triggered when ranks are below 10%, between 10% and 50%, between 50% and 90%, and above 90%.
Colors for this display can be customized via the "Circles" portion of the "Visuals" section in the script settings.
With either display type, an optional information box can be displayed. This box shows the LTF that the script is using, the average number of lower timeframe bars per chart bar, and the number of chart bars that contain LTF data.
Specifying intrabar precision
Ten options are included in the script to control the number of intrabars used per chart bar for calculations. The greater the number of intrabars per chart bar, the fewer chart bars can be analyzed.
The first five options allow users to specify the approximate amount of chart bars to be covered:
• Least Precise (Most chart bars) : Covers all chart bars by dividing the current timeframe by four.
This ensures the highest level of intrabar precision while achieving complete coverage for the dataset.
• Less Precise (Some chart bars) & More Precise (Less chart bars) : These options calculate a stepped LTF in relation to the current chart's timeframe.
• Very precise (2min intrabars) : Uses the second highest quantity of intrabars possible with the 2min LTF.
• Most precise (1min intrabars) : Uses the maximum quantity of intrabars possible with the 1min LTF.
The stepped lower timeframe for "Less Precise" and "More Precise" options is calculated from the current chart's timeframe as follows:
Chart Timeframe Lower Timeframe
Less Precise More Precise
< 1hr 1min 1min
< 1D 15min 1min
< 1W 2hr 30min
> 1W 1D 60min
The last five options allow users to specify an approximate fixed number of intrabars to analyze per chart bar. The available choices are 12, 24, 50, 100, and 250. The script will calculate the LTF which most closely approximates the specified number of intrabars per chart bar. Keep in mind that due to factors such as the length of a ticker's sessions and rounding of the LTF, it is not always possible to produce the exact number specified. However, the script will do its best to get as close to the value as possible.
Specifying MA type
Seven MA types are included in the script for different averaging effects:
• Simple
• Exponential
• Wilder (RMA)
• Weighted
• Volume-Weighted
• Arnaud Legoux with `offset` and `sigma` set to 0.85 and 6 respectively.
• Hull
Weighting
This script includes the option to weight IER values based on the percent rank of absolute price changes on the current chart's timeframe over a specified period, which can be enabled by checking the "Weigh using relative close changes" option in the script settings. This places reduced emphasis on IER values from smaller changes, which may help to reduce noise in the output.
█ FOR Pine Script™ CODERS
• This script imports the recently published lower_ltf library for calculating intrabar statistics and the optimal lower timeframe in relation to the current chart's timeframe.
• This script uses the recently released request.security_lower_tf() Pine Script™ function discussed in this blog post .
It works differently from the usual request.security() in that it can only be used on LTFs, and it returns an array containing one value per intrabar.
This makes it much easier for programmers to access intrabar information.
• This script implements a new recommended best practice for tables which works faster and reduces memory consumption.
Using this new method, tables are declared only once with var , as usual. Then, on the first bar only, we use table.cell() to populate the table.
Finally, table.set_*() functions are used to update attributes of table cells on the last bar of the dataset.
This greatly reduces the resources required to render tables.
Look first. Then leap.
lower_tf█ OVERVIEW
This library is a Pine programmer’s tool containing functions to help those who use the request.security_lower_tf() function. Its `ltf()` function helps translate user inputs into a lower timeframe string usable with request.security_lower_tf() . Another function, `ltfStats()`, accumulates statistics on processed chart bars and intrabars.
█ CONCEPTS
Chart bars
Chart bars , as referred to in our publications, are bars that occur at the current chart timeframe, as opposed to those that occur at a timeframe that is higher or lower than that of the chart view.
Intrabars
Intrabars are chart bars at a lower timeframe than the chart's. Each 1H chart bar of a 24x7 market will, for example, usually contain 60 intrabars at the LTF of 1min, provided there was market activity during each minute of the hour. Mining information from intrabars can be useful in that it offers traders visibility on the activity inside a chart bar.
Lower timeframes (LTFs)
A lower timeframe is a timeframe that is smaller than the chart's timeframe. This framework exemplifies how authors can determine which LTF to use by examining the chart's timeframe. The LTF determines how many intrabars are examined for each chart bar; the lower the timeframe, the more intrabars are analyzed.
Intrabar precision
The precision of calculations increases with the number of intrabars analyzed for each chart bar. As there is a 100K limit to the number of intrabars that can be analyzed by a script, a trade-off occurs between the number of intrabars analyzed per chart bar and the chart bars for which calculations are possible.
█ `ltf()`
This function returns a timeframe string usable with request.security_lower_tf() . It calculates the returned timeframe by taking into account a user selection between eight different calculation modes and the chart's timeframe. You send it the user's selection, along with the text corresponding to the eight choices from which the user has chosen, and the function returns a corresponding LTF string.
Because the function processes strings and doesn't require recalculation on each bar, using var to declare the variable to which its result is assigned will execute the function only once on bar zero and speed up your script:
var string ltfString = ltf(ltfModeInput, LTF1, LTF2, LTF3, LTF4, LTF5, LTF6, LTF7, LTF8)
The eight choices users can select from are of two types: the first four allow a selection from the desired amount of chart bars to be covered, the last four are choices of a fixed number of intrabars to be analyzed per chart bar. Our example code shows how to structure your input call and then make the call to `ltf()`. By changing the text associated with the `LTF1` to `LTF8` constants, you can tailor it to your preferences while preserving the functionality of `ltf()` because you will be sending those string constants as the function's arguments so it can determine the user's selection. The association between each `LTFx` constant and its calculation mode is fixed, so the order of the arguments is important when you call `ltf()`.
These are the first four modes and the `LTFx` constants corresponding to each:
Covering most chart bars (least precise) — LTF1
Covers all chart bars. This is accomplished by dividing the current timeframe in seconds by 4 and converting that number back to a string in timeframe.period format using secondsToTfString() . Due to the fact that, on premium subscriptions, the typical historical bar count is between 20-25k bars, dividing the timeframe by 4 ensures the highest level of intrabar precision possible while achieving complete coverage for the entire dataset with the maximum allowed 100K intrabars.
Covering some chart bars (less precise) — LTF2
Covering less chart bars (more precise) — LTF3
These levels offer a stepped LTF in relation to the chart timeframe with slightly more, or slightly less precision. The stepped lower timeframe tiers are calculated from the chart timeframe as follows:
Chart Timeframe Lower Timeframe
Less Precise More Precise
< 1hr 1min 1min
< 1D 15min 1min
< 1W 2hr 30min
> 1W 1D 60min
Covering the least chart bars (most precise) — LTF4
Analyzes the maximum quantity of intrabars possible by using the 1min LTF, which also allows the least amount of chart bars to be covered.
The last four modes allow the user to specify a fixed number of intrabars to analyze per chart bar. Users can choose from 12, 24, 50 or 100 intrabars, respectively corresponding to the `LTF5`, `LTF6`, `LTF7` and `LTF8` constants. The value is a target; the function will do its best to come up with a LTF producing the required number of intrabars. Because of considerations such as the length of a ticker's session, rounding of the LTF to the closest allowable timeframe, or the lowest allowable timeframe of 1min intrabars, it is often impossible for the function to find a LTF producing the exact number of intrabars. Requesting 100 intrabars on a 60min chart, for example, can only produce 60 1min intrabars. Higher chart timeframes, tickers with high liquidity or 24x7 markets will produce optimal results.
█ `ltfStats()`
`ltfStats()` returns statistics that will be useful to programmers using intrabar inspection. By analyzing the arrays returned by request.security_lower_tf() in can determine:
• intrabarsInChartBar : The number of intrabars analyzed for each chart bar.
• chartBarsCovered : The number of chart bars where intrabar information is available.
• avgIntrabars : The average number of intrabars analyzed per chart bar. Events like holidays, market activity, or reduced hours sessions can cause the number of intrabars to vary, bar to bar.
The function must be called on each bar to produce reliable results.
█ DEMONSTRATION CODE
Our example code shows how to provide users with an input from which they can select a LTF calculation mode. If you use this library's functions, feel free to reuse our input setup code, including the tooltip providing users with explanations on how it works for them.
We make a simple call to request.security_lower_tf() to fetch the close values of intrabars, but we do not use those values. We simply send the returned array to `ltfStats()` and then plot in the indicator's pane the number of intrabars examined on each bar and its average. We also display an information box showing the user's selection of the LTF calculation mode, the resulting LTF calculated by `ltf()` and some statistics.
█ NOTES
• As in several of our recent publications, this script uses secondsToTfString() to produce a timeframe string in timeframe.period format from a timeframe expressed in seconds.
• The script utilizes display.data_window and display.status_line to restrict the display of certain plots.
These new built-ins allow coders to fine-tune where a script’s plot values are displayed.
• We implement a new recommended best practice for tables which works faster and reduces memory consumption.
Using this new method, tables are declared only once with var , as usual. Then, on bar zero only, we use table.cell() calls to populate the table.
Finally, table.set_*() functions are used to update attributes of table cells on the last bar of the dataset.
This greatly reduces the resources required to render tables. We encourage all Pine Script™ programmers to do the same.
Look first. Then leap.
█ FUNCTIONS
The library contains the following functions:
ltf(userSelection, choice1, choice2, choice3, choice4, choice5, choice6, choice7, choice8)
Selects a LTF from the chart's TF, depending on the `userSelection` input string.
Parameters:
userSelection : (simple string) User-selected input string which must be one of the `choicex` arguments.
choice1 : (simple string) Input selection corresponding to "Least precise, covering most chart bars".
choice2 : (simple string) Input selection corresponding to "Less precise, covering some chart bars".
choice3 : (simple string) Input selection corresponding to "More precise, covering less chart bars".
choice4 : (simple string) Input selection corresponding to "Most precise, 1min intrabars".
choice5 : (simple string) Input selection corresponding to "~12 intrabars per chart bar".
choice6 : (simple string) Input selection corresponding to "~24 intrabars per chart bar".
choice7 : (simple string) Input selection corresponding to "~50 intrabars per chart bar".
choice8 : (simple string) Input selection corresponding to "~100 intrabars per chart bar".
Returns: (simple string) A timeframe string to be used with `request.security_lower_tf()`.
ltfStats()
Returns statistics about analyzed intrabars and chart bars covered by calls to `request.security_lower_tf()`.
Parameters:
intrabarValues : (float [ ]) The ID of a float array containing values fetched by a call to `request.security_lower_tf()`.
Returns: A 3-element tuple: [ (series int) intrabarsInChartBar, (series int) chartBarsCovered, (series float) avgIntrabars ].
HighTimeframeSamplingLibrary "HighTimeframeSampling"
Library for sampling high timeframe (HTF) data. Returns an array of historical values, an arbitrary historical value, or the highest/lowest value in a range, spending a single security() call.
An optional pass-through for the chart timeframe is included. Other than that case, the data is fixed and does not alter over the course of the HTF bar. It behaves consistently on historical and elapsed realtime bars.
The first version returns floating-point numbers only. I might extend it if there's interest.
🙏 Credits: This library is (yet another) attempt at a solution of the problems in using HTF data that were laid out by Pinecoders - to whom, especially to Luc F, many thanks are due - in "security() revisited" - which I recommend you consult first. Go ahead, I'll wait.
All code is my own.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
WHAT'S THE PROBLEM? OR, WHY NOT JUST USE SECURITY()
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
There are many difficulties with using HTF data, and many potential solutions. It's not really possible to convey it only in words: you need to see it on a chart.
Before using this library, please refer to my other HTF library, HighTimeframeTiming: which explains it extensively, compares many different solutions, and demonstrates (what I think are) the advantages of using this very library, namely, that it's stable, accurate, versatile and inexpensive. Then if you agree, come back here and choose your function.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MOAR EXPLANATION
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
🧹 Housekeeping: To see which plot is which, turn line labels on: Settings > Scales > Indicator Name Label. Vertical lines at the top of the chart show the open of a HTF bar: grey for historical and white for real-time bars.
‼ LIMITATIONS: To avoid strange behaviour, use this library on liquid assets and at chart timeframes high enough to reliably produce updates at least once per bar period.
A more conventional and universal limitation is that the library does not offer an unlimited view of historical bars. You need to define upfront how many HTF bars you want to store. Very large numbers might conceivably run into data or performance issues.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
BRING ON THE FUNCTIONS
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@function f_HTF_Value(string _HTF, float _source, int _arrayLength, int _HTF_Offset, bool _useLiveDataOnChartTF=false)
Returns a floating-point number from a higher timeframe, with a historical operator within an abitrary (but limited) number of bars.
@param string _HTF is the string that represents the higher timeframe. It must be in a format that the request.security() function recognises. The input timeframe cannot be lower than the chart timeframe or an error is thrown.
@param float _source is the source value that you want to sample, e.g. close, open, etc., or you can use any floating-point number.
@param int _arrayLength is the number of HTF bars you want to store and must be greater than zero. You can't go back further in history than this number of bars (minus one, because the current/most recent available bar is also stored).
@param int _HTF_Offset is the historical operator for the value you want to return. E.g., if you want the most recent fixed close, _source=close and _HTF_Offset = 0. If you want the one before that, _HTF_Offset=1, etc.
The number of HTF bars to look back must be zero or more, and must be one less than the number of bars stored.
@param bool _useLiveDataOnChartTF uses live data on the chart timeframe.
If the higher timeframe is the same as the chart timeframe, store the live value (i.e., from this very bar). For all truly higher timeframes, store the fixed value (i.e., from the previous bar).
The default is to use live data for the chart timeframe, so that this function works intuitively, that is, it does not fix data unless it has to (i.e., because the data is from a higher timeframe).
This means that on default settings, on the chart timeframe, it matches the raw source values from security(){0}.
You can override this behaviour by passing _useLiveDataOnChartTF as false. Then it will fix all data for all timeframes.
@returns a floating-point value that you requested from the higher timeframe.
@function f_HTF_Array(string _HTF, float _source, int _arrayLength, bool _useLiveDataOnChartTF=false, int _startIn, int _endIn)
Returns an array of historical values from a higher timeframe, starting with the current bar. Optionally, returns a slice of the array. The array is in reverse chronological order, i.e., index 0 contains the most recent value.
@param string _HTF is the string that represents the higher timeframe. It must be in a format that the request.security() function recognises. The input timeframe cannot be lower than the chart timeframe or an error is thrown.
@param float _source is the source value that you want to sample, e.g. close, open, etc., or you can use any floating-point number.
@param int _arrayLength is the number of HTF bars you want to keep in the array.
@param bool _useLiveDataOnChartTF uses live data on the chart timeframe.
If the higher timeframe is the same as the chart timeframe, store the live value (i.e., from this very bar). For all truly higher timeframes, store the fixed value (i.e., from the previous bar).
The default is to use live data for the chart timeframe, so that this function works intuitively, that is, it does not fix data unless it has to (i.e., because the data is from a higher timeframe).
This means that on default settings, on the chart timeframe, it matches raw source values from security().
You can override this behaviour by passing _useLiveDataOnChartTF as false. Then it will fix all data for all timeframes.
@param int _startIn is the array index to begin taking a slice. Must be at least one less than the length of the array; if out of bounds it is corrected to 0.
@param int _endIn is the array index BEFORE WHICH to end the slice. If the ending index of the array slice would take the slice past the end of the array, it is corrected to the end of the array. The ending index of the array slice must be greater than or equal to the starting index. If the end is less than the start, the whole array is returned. If the starting index is the same as the ending index, an empty array is returned. If either the starting or ending index is negative, the entire array is returned (which is the default behaviour; this is effectively a switch to bypass the slicing without taking up an extra parameter).
@returns an array of HTF values.
@function f_HTF_Highest(string _HTF="", float _source, int _arrayLength, bool _useLiveDataOnChartTF=true, int _rangeIn)
Returns the highest value within a range consisting of a given number of bars back from the most recent bar.
@param string _HTF is the string that represents the higher timeframe. It must be in a format that the request.security() function recognises. The input timeframe cannot be lower than the chart timeframe or an error is thrown.
@param float _source is the source value that you want to sample, e.g. close, open, etc., or you can use any floating-point number.
@param int _arrayLength is the number of HTF bars you want to store and must be greater than zero. You can't have a range greater than this number.
@param bool _useLiveDataOnChartTF uses live data on the chart timeframe.
If the higher timeframe is the same as the chart timeframe, store the live value (i.e., from this very bar). For all truly higher timeframes, store the fixed value (i.e., from the previous bar).
The default is to use live data for the chart timeframe, so that this function works intuitively, that is, it does not fix data unless it has to (i.e., because the data is from a higher timeframe).
This means that on default settings, on the chart timeframe, it matches raw source values from security().
You can override this behaviour by passing _useLiveDataOnChartTF as false. Then it will fix all data for all timeframes.
@param _rangeIn is the number of bars to include in the range of bars from which we want to find the highest value. It is NOT the historical operator of the last bar in the range. The range always starts at the current bar. A value of 1 doesn't make much sense but the function will generously return the only value it can anyway. A value less than 1 doesn't make sense and will return an error. A value that is higher than the number of stored values will be corrected to equal the number of stored values.
@returns a floating-point number representing the highest value in the range.
@function f_HTF_Lowest(string _HTF="", float _source, int _arrayLength, bool _useLiveDataOnChartTF=true, int _rangeIn)
Returns the lowest value within a range consisting of a given number of bars back from the most recent bar.
@param string _HTF is the string that represents the higher timeframe. It must be in a format that the request.security() function recognises. The input timeframe cannot be lower than the chart timeframe or an error is thrown.
@param float _source is the source value that you want to sample, e.g. close, open, etc., or you can use any floating-point number.
@param int _arrayLength is the number of HTF bars you want to store and must be greater than zero. You can't go back further in history than this number of bars (minus one, because the current/most recent available bar is also stored).
@param bool _useLiveDataOnChartTF uses live data on the chart timeframe.
If the higher timeframe is the same as the chart timeframe, store the live value (i.e., from this very bar). For all truly higher timeframes, store the fixed value (i.e., from the previous bar).
The default is to use live data for the chart timeframe, so that this function works intuitively, that is, it does not fix data unless it has to (i.e., because the data is from a higher timeframe).
This means that on default settings, on the chart timeframe, it matches raw source values from security().
You can override this behaviour by passing _useLiveDataOnChartTF as false. Then it will fix all data for all timeframes.
@param _rangeIn is the number of bars to include in the range of bars from which we want to find the highest value. It is NOT the historical operator of the last bar in the range. The range always starts at the current bar. A value of 1 doesn't make much sense but the function will generously return the only value it can anyway. A value less than 1 doesn't make sense and will return an error. A value that is higher than the number of stored values will be corrected to equal the number of stored values.
@returns a floating-point number representing the lowest value in the range.
Library CommonLibrary "LibraryCommon"
A collection of custom tools & utility functions commonly used with my scripts
@description TODO: add library description here
getDecimals() Calculates how many decimals are on the quote price of the current market
Returns: The current decimal places on the market quote price
truncate(float, float) Truncates (cuts) excess decimal places
Parameters:
float : number The number to truncate
float : decimalPlaces (default=2) The number of decimal places to truncate to
Returns: The given number truncated to the given decimalPlaces
toWhole(float) Converts pips into whole numbers
Parameters:
float : number The pip number to convert into a whole number
Returns: The converted number
toPips(float) Converts whole numbers back into pips
Parameters:
float : number The whole number to convert into pips
Returns: The converted number
getPctChange(float, float, int) Gets the percentage change between 2 float values over a given lookback period
Parameters:
float : value1 The first value to reference
float : value2 The second value to reference
int : lookback The lookback period to analyze
av_getPositionSize(float, float, float, float) Calculates OANDA forex position size for AutoView based on the given parameters
Parameters:
float : balance The account balance to use
float : risk The risk percentage amount (as a whole number - eg. 1 = 1% risk)
float : stopPoints The stop loss distance in POINTS (not pips)
float : conversionRate The conversion rate of our account balance currency
Returns: The calculated position size (in units - only compatible with OANDA)
bullFib(priceLow, priceHigh, fibRatio) Calculates a bullish fibonacci value
Parameters:
priceLow : The lowest price point
priceHigh : The highest price point
fibRatio : The fibonacci % ratio to calculate
Returns: The fibonacci value of the given ratio between the two price points
bearFib(priceLow, priceHigh, fibRatio) Calculates a bearish fibonacci value
Parameters:
priceLow : The lowest price point
priceHigh : The highest price point
fibRatio : The fibonacci % ratio to calculate
Returns: The fibonacci value of the given ratio between the two price points
getMA(int, string) Gets a Moving Average based on type (MUST BE CALLED ON EVERY CALCULATION)
Parameters:
int : length The MA period
string : maType The type of MA
Returns: A moving average with the given parameters
getEAP(float) Performs EAP stop loss size calculation (eg. ATR >= 20.0 and ATR < 30, returns 20)
Parameters:
float : atr The given ATR to base the EAP SL calculation on
Returns: The EAP SL converted ATR size
getEAP2(float) Performs secondary EAP stop loss size calculation (eg. ATR < 40, add 5 pips, ATR between 40-50, add 10 pips etc)
Parameters:
float : atr The given ATR to base the EAP SL calculation on
Returns: The EAP SL converted ATR size
barsAboveMA(int, float) Counts how many candles are above the MA
Parameters:
int : lookback The lookback period to look back over
float : ma The moving average to check
Returns: The bar count of how many recent bars are above the MA
barsBelowMA(int, float) Counts how many candles are below the MA
Parameters:
int : lookback The lookback period to look back over
float : ma The moving average to reference
Returns: The bar count of how many recent bars are below the EMA
barsCrossedMA(int, float) Counts how many times the EMA was crossed recently
Parameters:
int : lookback The lookback period to look back over
float : ma The moving average to reference
Returns: The bar count of how many times price recently crossed the EMA
getPullbackBarCount(int, int) Counts how many green & red bars have printed recently (ie. pullback count)
Parameters:
int : lookback The lookback period to look back over
int : direction The color of the bar to count (1 = Green, -1 = Red)
Returns: The bar count of how many candles have retraced over the given lookback & direction
getBodySize() Gets the current candle's body size (in POINTS, divide by 10 to get pips)
Returns: The current candle's body size in POINTS
getTopWickSize() Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's top wick size in POINTS
getBottomWickSize() Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's bottom wick size in POINTS
getBodyPercent() Gets the current candle's body size as a percentage of its entire size including its wicks
Returns: The current candle's body size percentage
isHammer(float, bool) Checks if the current bar is a hammer candle based on the given parameters
Parameters:
float : fib (default=0.382) The fib to base candle body on
bool : colorMatch (default=false) Does the candle need to be green? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a hammer candle
isStar(float, bool) Checks if the current bar is a shooting star candle based on the given parameters
Parameters:
float : fib (default=0.382) The fib to base candle body on
bool : colorMatch (default=false) Does the candle need to be red? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a shooting star candle
isDoji(float, bool) Checks if the current bar is a doji candle based on the given parameters
Parameters:
float : wickSize (default=2) The maximum top wick size compared to the bottom (and vice versa)
bool : bodySize (default=0.05) The maximum body size as a percentage compared to the entire candle size
Returns: A boolean - true if the current bar matches the requirements of a doji candle
isBullishEC(float, float, bool) Checks if the current bar is a bullish engulfing candle
Parameters:
float : allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)
float : rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage
bool : engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?
Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle
isBearishEC(float, float, bool) Checks if the current bar is a bearish engulfing candle
Parameters:
float : allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)
float : rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage
bool : engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?
Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle
isInsideBar() Detects inside bars
Returns: Returns true if the current bar is an inside bar
isOutsideBar() Detects outside bars
Returns: Returns true if the current bar is an outside bar
barInSession(string, bool) Determines if the current price bar falls inside the specified session
Parameters:
string : sess The session to check
bool : useFilter (default=true) Whether or not to actually use this filter
Returns: A boolean - true if the current bar falls within the given time session
barOutSession(string, bool) Determines if the current price bar falls outside the specified session
Parameters:
string : sess The session to check
bool : useFilter (default=true) Whether or not to actually use this filter
Returns: A boolean - true if the current bar falls outside the given time session
dateFilter(int, int) Determines if this bar's time falls within date filter range
Parameters:
int : startTime The UNIX date timestamp to begin searching from
int : endTime the UNIX date timestamp to stop searching from
Returns: A boolean - true if the current bar falls within the given dates
dayFilter(bool, bool, bool, bool, bool, bool, bool) Checks if the current bar's day is in the list of given days to analyze
Parameters:
bool : monday Should the script analyze this day? (true/false)
bool : tuesday Should the script analyze this day? (true/false)
bool : wednesday Should the script analyze this day? (true/false)
bool : thursday Should the script analyze this day? (true/false)
bool : friday Should the script analyze this day? (true/false)
bool : saturday Should the script analyze this day? (true/false)
bool : sunday Should the script analyze this day? (true/false)
Returns: A boolean - true if the current bar's day is one of the given days
atrFilter()
fillCell()
Pinescript - Common Label & Line Array Functions Library by RRBPinescript - Common Label & Line Array Functions Library by RagingRocketBull 2021
Version 1.0
This script provides a library of common array functions for arrays of label and line objects with live testing of all functions.
Using this library you can easily create, update, delete, join label/line object arrays, and get/set properties of individual label/line object array items.
You can find the full list of supported label/line array functions below.
There are several libraries:
- Common String Functions Library
- Standard Array Functions Library
- Common Fixed Type Array Functions Library
- Common Label & Line Array Functions Library
- Common Variable Type Array Functions Library
Features:
- 30 array functions in categories create/update/delete/join/get/set with support for both label/line objects (45+ including all implementations)
- Create, Update label/line object arrays from list/array params
- GET/SET properties of individual label/line array items by index
- Join label/line objects/arrays into a single string for output
- Supports User Input of x,y coords of 5 different types: abs/rel/rel%/inc/inc% list/array, auto transforms x,y input into list/array based on type, base and xloc, translates rel into abs bar indexes
- Supports User Input of lists with shortened names of string properties, auto expands all standard string properties to their full names for use in functions
- Live Output for all/selected functions based on User Input. Test any function for possible errors you may encounter before using in script.
- Output filters: hide all excluded and show only allowed functions using a list of function names
- Output Panel customization options: set custom style, color, text size, and line spacing
Usage:
- select create function - create label/line arrays from lists or arrays (optional). Doesn't affect the update functions. The only change in output should be function name regardless of the selected implementation.
- specify num_objects for both label/line arrays (default is 7)
- specify common anchor point settings x,y base/type for both label/line arrays and GET/SET items in Common Settings
- fill lists with items to use as inputs for create label/line array functions in Create Label/Line Arrays section
- specify label/line array item index and properties to SET in corresponding sections
- select label/line SET function to see the changes applied live
Code Structure:
- translate x,y depending on x,y type, base and xloc as specified in UI (required for all functions)
- expand all shortened standard property names to full names (required for create/update* from arrays and set* functions, not needed for create/update* from lists) to prevent errors in label.new and line.new
- create param arrays from string lists (required for create/update* from arrays and set* functions, not needed for create/update* from lists)
- create label/line array from string lists (property names are auto expanded) or param arrays (requires already expanded properties)
- update entire label/line array or
- get/set label/line array item properties by index
Transforming/Expanding Input values:
- for this script to work on any chart regardless of price/scale, all x*,y* are specified as % increase relative to x0,y0 base levels by default, but user can enter abs x,price values specific for that chart if necessary.
- all lists can be empty, contain 1 or several items, have the same/different lengths. Array Length = min(min(len(list*)), mum_objects) is used to create label/line objects. Missing list items are replaced with default property values.
- when a list contains only 1 item it is duplicated (label name/tooltip is also auto incremented) to match the calculated Array Length
- since this script processes user input, all x,y values must be translated to abs bar indexes before passing them to functions. Your script may provide all data internally and doesn't require this step.
- at first int x, float y arrays are created from user string lists, transformed as described below and returned as x,y arrays.
- translated x,y arrays can then be passed to create from arrays function or can be converted back to x,y string lists for the create from lists function if necessary.
- all translation logic is separated from create/update/set functions for the following reasons:
- to avoid redundant code/dependency on ext functions/reduce local scopes and to be able to translate everything only once in one place - should be faster
- to simplify internal logic of all functions
- because your script may provide all data internally without user input and won't need the translation step
- there are 5 types available for both x,y: abs, rel, rel%, inc, inc%. In addition to that, x can be: bar index or time, y is always price.
- abs - absolute bar index/time from start bar0 (x) or price (y) from 0, is >= 0
- rel - relative bar index/time from cur bar n (x) or price from y0 base level, is >= 0
- rel% - relative % increase of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0
- inc - relative increment (step) for each new level of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0
- inc% - relative % increment (% step) for each new level of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0
- x base level >= 0
- y base level can be 0 (empty) or open, close, high, low of cur bar
- single item x1_list = "50" translates into:
- for x type abs: "50, 50, 50 ..." num_objects times regardless of xloc => x = 50
- for x type rel: "50, 50, 50 ... " num_objects times => x = x_base + 50
- for x type rel%: "50%, 50%, 50% ... " num_objects times => x_base * (1 + 0.5)
- for x type inc: "0, 50, 100 ... " num_objects times => x_base + 50 * i
- for x type inc%: "0%, 50%, 100% ... " num_objects times => x_base * (1 + 0.5 * i)
- when xloc = xloc.bar_index each rel*/inc* value in the above list is then subtracted from n: n - x to convert rel to abs bar index, values of abs type are not affected
- x1_list = "0, 50, 100, ..." of type rel is the same as "50" of type inc
- x1_list = "50, 50, 50, ..." of type abs/rel/rel% produces a sequence of the same values and can be shortened to just "50"
- single item y1_list = "2" translates into (ragardless of yloc):
- for y type abs: "2, 2, 2 ..." num_objects times => y = 2
- for y type rel: "2, 2, 2 ... " num_objects times => y = y_base + 2
- for y type rel%: "2%, 2%, 2% ... " num_objects times => y = y_base * (1 + 0.02)
- for y type inc: "0, 2, 4 ... " num_objects times => y = y_base + 2 * i
- for y type inc%: "0%, 2%, 4% ... " num_objects times => y = y_base * (1 + 0.02 * i)
- when yloc != yloc.price all calculated values above are simply ignored
- y1_list = "0, 2, 4" of type rel% is the same as "2" with type inc%
- y1_list = "2, 2, 2" of type abs/rel/rel% produces a sequence of the same values and can be shortened to just "2"
- you can enter shortened property names in lists. To lookup supported shortened names use corresponding dropdowns in Set Label/Line Array Item Properties sections
- all shortened standard property names must be expanded to full names (required for create/update* from arrays and set* functions, not needed for create/update* from lists) to prevent errors in label.new and line.new
- examples of shortened property names that can be used in lists: bar_index, large, solid, label_right, white, left, left, price
- expanded to their corresponding full names: xloc.bar_index, size.large, line.style_solid, label.style_label_right, color.white, text.align_left, extend.left, yloc.price
- all expanding logic is separated from create/update* from arrays and set* functions for the same reasons as above, and because param arrays already have different types, implying the use of final values.
- all expanding logic is included in the create/update* from lists functions because it seemed more natural to process string lists from user input directly inside the function, since they are already strings.
Creating Label/Line Objects:
- use study max_lines_count and max_labels_count params to increase the max number of label/line objects to 500 (+3) if necessary. Default number of label/line objects is 50 (+3)
- all functions use standard param sequence from methods in reference, except style always comes before colors.
- standard label/line.get* functions only return a few properties, you can't read style, color, width etc.
- label.new(na, na, "") will still create a label with x = n-301, y = NaN, text = "" because max default scope for a var is 300 bars back.
- there are 2 types of color na, label color requires color(na) instead of color_na to prevent error. text_color and line_color can be color_na
- for line to be visible both x1, x2 ends must be visible on screen, also when y1 == y2 => abs(x1 - x2) >= 2 bars => line is visible
- xloc.bar_index line uses abs x1, x2 indexes and can only be within 0 and n ends, where n <= 5000 bars (free accounts) or 10000 bars (paid accounts) limit, can't be plotted into the future
- xloc.bar_time line uses abs x1, x2 times, can't go past bar0 time but can continue past cur bar time into the future, doesn't have a length limit in bars.
- xloc.bar_time line with length = exact number of bars can be plotted only within bar0 and cur bar, can't be plotted into the future reliably because of future gaps due to sessions on some charts
- xloc.bar_index line can't be created on bar 0 with fixed length value because there's only 1 bar of horiz length
- it can be created on cur bar using fixed length x < n <= 5000 or
- created on bar0 using na and then assigned final x* values on cur bar using set_x*
- created on bar0 using n - fixed_length x and then updated on cur bar using set_x*, where n <= 5000
- default orientation of lines (for style_arrow* and extend) is from left to right (from bar 50 to bar 0), it reverses when x1 and x2 are swapped
- price is a function, not a line object property
Variable Type Arrays:
- you can't create an if/function that returns var type value/array - compiler uses strict types and doesn't allow that
- however you can assign array of any type to another array of any type creating an arr pointer of invalid type that must be reassigned to a matching array type before used in any expression to prevent error
- create_any_array2 uses this loophole to return an int_arr pointer of a var type array
- this works for all array types defined with/without var keyword and doesn't work for string arrays defined with var keyword for some reason
- you can't do this with var type vars, only var type arrays because arrays are pointers passed by reference, while vars are actual values passed by value.
- you can only pass a var type value/array param to a function if all functions inside support every type - otherwise error
- alternatively values of every type must be passed simultaneously and processed separately by corresponding if branches/functions supporting these particular types returning a common single type result
- get_var_types solves this problem by generating a list of dummy values of every possible type including the source type, tricking the compiler into allowing a single valid branch to execute without error, while ignoring all dummy results
Notes:
- uses Pinescript v3 Compatibility Framework
- uses Common String Functions Library, Common Fixed Type Array Functions Library, Common Variable Type Array Functions Library
- has to be a separate script to reduce the number of local scopes/compiled file size, can't be merged with another library.
- lets you live test all label/line array functions for errors. If you see an error - change params in UI
- if you see "Loop too long" error - hide/unhide or reattach the script
- if you see "Chart references too many candles" error - change x type or value between abs/rel*. This can happen on charts with 5000+ bars when a rel bar index x is passed to label.new or line.new instead of abs bar index n - x
- create/update_label/line_array* use string lists, while create/update_label/line_array_from_arrays* use array params to create label/line arrays. "from_lists" is dropped to shorten the names of the most commonly used functions.
- create_label/line_array2,4 are preferable, 5,6 are listed for pure demonstration purposes only - don't use them, they don't improve anything but dramatically increase local scopes/compiled file size
- for this reason you would mainly be using create/update_label/line_array2,4 for list params or create/update_label/line_array_from_arrays2 for array params
- all update functions are executed after each create as proof of work and can be disabled. Only create functions are required. Use update functions when necessary - when list/array params are changed by your script.
- both lists and array item properties use the same x,y_type, x,y_base from common settings
- doesn't use pagination, a single str contains all output
- why is this so complicated? What are all these functions for?
- this script merges standard label/line object methods with standard array functions to create a powerful set of label/line object array functions to simplify manipulation of these arrays.
- this library also extends the functionality of Common Variable Type Array Functions Library providing support for label/line types in var type array functions (any_to_str6, join_any_array5)
- creating arrays from either lists or arrays adds a level of flexibility that comes with complexity. It's very likely that in your script you'd have to deal with both string lists as input, and arrays internally, once everything is converted.
- processing user input, allowing customization and targeting for any chart adds a whole new layer of complexity, all inputs must be translated and expanded before used in functions.
- different function implementations can increase/reduce local scopes and compiled file size. Select a version that best suits your needs. Creating complex scripts often requires rewriting your code multiple times to fit the limits, every line matters.
P.S. Don't rely too much on labels, for too often they are fables.
List of functions*:
* - functions from other libraries are not listed
1. Join Functions
Labels
- join_label_object(label_, d1, d2)
- join_label_array(arr, d1, d2)
- join_label_array2(arr, d1, d2, d3)
Lines
- join_line_object(line_, d1, d2)
- join_line_array(arr, d1, d2)
- join_line_array2(arr, d1, d2, d3)
Any Type
- any_to_str6(arr, index, type)
- join_any_array4(arr, d1, d2, type)
- join_any_array5(arr, d, type)
2. GET/SET Functions
Labels
- label_array_get_text(arr, index)
- label_array_get_xy(arr, index)
- label_array_get_fields(arr, index)
- label_array_set_text(arr, index, str)
- label_array_set_xy(arr, index, x, y)
- label_array_set_fields(arr, index, x, y, str)
- label_array_set_all_fields(arr, index, x, y, str, xloc, yloc, label_style, label_color, text_color, text_size, text_align, tooltip)
- label_array_set_all_fields2(arr, index, x, y, str, xloc, yloc, label_style, label_color, text_color, text_size, text_align, tooltip)
Lines
- line_array_get_price(arr, index, bar)
- line_array_get_xy(arr, index)
- line_array_get_fields(arr, index)
- line_array_set_text(arr, index, width)
- line_array_set_xy(arr, index, x1, y1, x2, y2)
- line_array_set_fields(arr, index, x1, y1, x2, y2, width)
- line_array_set_all_fields(arr, index, x1, y1, x2, y2, xloc, extend, line_style, line_color, width)
- line_array_set_all_fields2(arr, index, x1, y1, x2, y2, xloc, extend, line_style, line_color, width)
3. Create/Update/Delete Functions
Labels
- delete_label_array(label_arr)
- create_label_array(list1, list2, list3, list4, list5, d)
- create_label_array2(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array3(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array4(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array5(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array6(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- update_label_array2(label_arr, x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- update_label_array4(label_arr, x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array_from_arrays2(x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d)
- create_label_array_from_arrays4(x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d)
- update_label_array_from_arrays2(label_arr, x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d)
Lines
- delete_line_array(line_arr)
- create_line_array(list1, list2, list3, list4, list5, list6, d)
- create_line_array2(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array3(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array4(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array5(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array6(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- update_line_array2(line_arr, x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- update_line_array4(line_arr, x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array_from_arrays2(x1_arr, y1_arr, x2_arr, y2_arr, xloc_arr, extend_arr, style_arr, color_arr, width_arr, d)
- update_line_array_from_arrays2(line_arr, x1_arr, y1_arr, x2_arr, y2_arr, xloc_arr, extend_arr, style_arr, color_arr, width_arr, d)
Using `varip` variables [PineCoders]█ OVERVIEW
The new varip keyword in Pine can be used to declare variables that escape the rollback process, which is explained in the Pine User Manual's page on the execution model . This publication explains how Pine coders can use variables declared with varip to implement logic that was impossible to code in Pine before, such as timing events during the realtime bar, or keeping track of sequences of events that occur during successive realtime updates. We present code that allows you to calculate for how much time a given condition is true during a realtime bar, and show how this can be used to generate alerts.
█ WARNINGS
1. varip is an advanced feature which should only be used by coders already familiar with Pine's execution model and bar states .
2. Because varip only affects the behavior of your code in the realtime bar, it follows that backtest results on strategies built using logic based on varip will be meaningless,
as varip behavior cannot be simulated on historical bars. This also entails that plots on historical bars will not be able to reproduce the script's behavior in realtime.
3. Authors publishing scripts that behave differently in realtime and on historical bars should imperatively explain this to traders.
█ CONCEPTS
Escaping the rollback process
Whereas scripts only execute once at the close of historical bars, when a script is running in realtime, it executes every time the chart's feed detects a price or volume update. At every realtime update, Pine's runtime normally resets the values of a script's variables to their last committed value, i.e., the value they held when the previous bar closed. This is generally handy, as each realtime script execution starts from a known state, which simplifies script logic.
Sometimes, however, script logic requires code to be able to save states between different executions in the realtime bar. Declaring variables with varip now makes that possible. The "ip" in varip stands for "intrabar persist".
Let's look at the following code, which does not use varip :
//@version=4
study("")
int updateNo = na
if barstate.isnew
updateNo := 1
else
updateNo := updateNo + 1
plot(updateNo, style = plot.style_circles)
On historical bars, barstate.isnew is always true, so the plot shows a value of "1". On realtime bars, barstate.isnew is only true when the script first executes on the bar's opening. The plot will then briefly display "1" until subsequent executions occur. On the next executions during the realtime bar, the second branch of the if statement is executed because barstate.isnew is no longer true. Since `updateNo` is initialized to `na` at each execution, the `updateNo + 1` expression yields `na`, so nothing is plotted on further realtime executions of the script.
If we now use varip to declare the `updateNo` variable, the script behaves very differently:
//@version=4
study("")
varip int updateNo = na
if barstate.isnew
updateNo := 1
else
updateNo := updateNo + 1
plot(updateNo, style = plot.style_circles)
The difference now is that `updateNo` tracks the number of realtime updates that occur on each realtime bar. This can happen because the varip declaration allows the value of `updateNo` to be preserved between realtime updates; it is no longer rolled back at each realtime execution of the script. The test on barstate.isnew allows us to reset the update count when a new realtime bar comes in.
█ OUR SCRIPT
Let's move on to our script. It has three parts:
— Part 1 demonstrates how to generate alerts on timed conditions.
— Part 2 calculates the average of realtime update prices using a varip array.
— Part 3 presents a function to calculate the up/down/neutral volume by looking at price and volume variations between realtime bar updates.
Something we could not do in Pine before varip was to time the duration for which a condition is continuously true in the realtime bar. This was not possible because we could not save the beginning time of the first occurrence of the true condition.
One use case for this is a strategy where the system modeler wants to exit before the end of the realtime bar, but only if the exit condition occurs for a specific amount of time. One can thus design a strategy running on a 1H timeframe but able to exit if the exit condition persists for 15 minutes, for example. REMINDER: Using such logic in strategies will make backtesting their complete logic impossible, and backtest results useless, as historical behavior will not match the strategy's behavior in realtime, just as using `calc_on_every_tick = true` will do. Using `calc_on_every_tick = true` is necessary, by the way, when using varip in a strategy, as you want the strategy to run like a study in realtime, i.e., executing on each price or volume update.
Our script presents an `f_secondsSince(_cond, _resetCond)` function to calculate the time for which a condition is continuously true during, or even across multiple realtime bars. It only works in realtime. The abundant comments in the script hopefully provide enough information to understand the details of what it's doing. If you have questions, feel free to ask in the Comments section.
Features
The script's inputs allow you to:
• Specify the number of seconds the tested conditions must last before an alert is triggered (the default is 20 seconds).
• Determine if you want the duration to reset on new realtime bars.
• Require the direction of alerts (up or down) to alternate, which minimizes the number of alerts the script generates.
The inputs showcase the new `tooltip` parameter, which allows additional information to be displayed for each input by hovering over the "i" icon next to it.
The script only displays useful information on realtime bars. This information includes:
• The MA against which the current price is compared to determine the bull or bear conditions.
• A dash which prints on the chart when the bull or bear condition is true.
• An up or down triangle that prints when an alert is generated. The triangle will only appear on the update where the alert is triggered,
and unless that happens to be on the last execution of the realtime bar, it will not persist on the chart.
• The log of all triggered alerts to the right of the realtime bar.
• A gray square on top of the elapsed realtime bars where one or more alerts were generated. The square's tooltip displays the alert log for that bar.
• A yellow dot corresponding to the average price of all realtime bar updates, which is calculated using a varip array in "Part 2" of the script.
• Various key values in the Data Window for each parts of the script.
Note that the directional volume information calculated in Part 3 of the script is not plotted on the chart—only in the Data Window.
Using the script
You can try running the script on an open market with a 30sec timeframe. Because the default settings reset the duration on new realtime bars and require a 20 second delay, a reasonable amount of alerts will trigger.
Creating an alert on the script
You can create a script alert on the script. Keep in mind that when you create an alert from this script, the duration calculated by the instance of the script running the alert will not necessarily match that of the instance running on your chart, as both started their calculations at different times. Note that we use alert.freq_all in our alert() calls, so that alerts will trigger on all instances where the associated condition is met. If your alert is being paused because it reaches the maximum of 15 triggers in 3 minutes, you can configure the script's inputs so that up/down alerts must alternate. Also keep in mind that alerts run a distinct instance of your script on different servers, so discrepancies between the behavior of scripts running on charts and alerts can occur, especially if they trigger very often.
Challenges
Events detected in realtime using variables declared with varip can be transient and not leave visible traces at the close of the realtime bar, as is the case with our script, which can trigger multiple alerts during the same realtime bar, when the script's inputs allow for this. In such cases, elapsed realtime bars will be of no use in detecting past realtime bar events unless dedicated code is used to save traces of events, as we do with our alert log in this script, which we display as a tooltip on elapsed realtime bars.
█ NOTES
Realtime updates
We have no control over when realtime updates occur. A realtime bar can open, and then no realtime updates can occur until the open of the next realtime bar. The time between updates can vary considerably.
Past values
There is no mechanism to refer to past values of a varip variable across realtime executions in the same bar. Using the history-referencing operator will, as usual, return the variable's committed value on previous bars. If you want to preserve past values of a varip variable, they must be saved in other variables or in an array .
Resetting variables
Because varip variables not only preserve their values across realtime updates, but also across bars, you will typically need to plan conditions that will at some point reset their values to a known state. Testing on barstate.isnew , as we do, is a good way to achieve that.
Repainting
The fact that a script uses varip does not make it necessarily repainting. A script could conceivably use varip to calculate values saved when the realtime bar closes, and then use confirmed values of those calculations from the previous bar to trigger alerts or display plots, avoiding repaint.
timenow resolution
Although the variable is expressed in milliseconds it has an actual resolution of seconds, so it only increments in multiples of 1000 milliseconds.
Warn script users
When using varip to implement logic that cannot be replicated on historical bars, it's really important to explain this to traders in published script descriptions, even if you publish open-source. Remember that most TradingViewers do not know Pine.
New Pine features used in this script
This script uses three new Pine features:
• varip
• The `tooltip` parameter in input() .
• The new += assignment operator. See these also: -= , *= , /= and %= .
Example scripts
These are other scripts by PineCoders that use varip :
• Tick Delta Volume , by RicadoSantos .
• Tick Chart and Volume Info from Lower Time Frames by LonesomeTheBlue .
Thanks
Thanks to the PineCoders who helped improve this publication—especially to bmistiaen .
Look first. Then leap.
VPA ANALYSIS VPA Analysis provide the indications for various conditions as per the Volume Spread Analysis concept. The various legends are provided below
LEGEND DETAILS
UT1 - Upthrust Bar: This will be widespread Bar on high Volume closing on the low. This normally happens after an up move. Here the smart money move the price to the High and then quickly brings to the Low trapping many retail trader who rushed into in order not to miss the bullish move. This is a bearish Signal
UT2 -Upthrust Bar Confirmation: A widespread Down Bar following a Upthrust Bar. This confirms the weakness of the Upthrust Bar. Expect the stock to move down
Confirms . This is a Bearish Signal
PUT - Pseudo Upthrust: An Upthrust Bar in bar action but the volume remains average. This still indicates weakness. Indicate Possible Bearishness
PUC -Pseudo Upthrust Confirmation: widespread Bar after a pseudo–Upthrust Bar confirms the weakness of the Pseudo Upthrust Bar
Confirms Bearishness
BC - Buying Climax: A very wide Spread bar on ultra-High Volume closing at the top. Such a Bar indicates the climatic move in an uptrend. This Bar traps many retailers as the uptrend ends and reverses quickly. Confirms Bearishness
TC - Trend Change: This Indicates a possible Trend Change in an uptrend. Indicates Weakness
SEC- Sell Condition: This bar indicates confluence of some bearish signals. Possible end of Uptrend and start of Downtrend soon. Bearish Signal
UT - Upthrust Condition: When multiple bearish signals occur, the legend is printed in two lines. The Legend “UT” indicates that an upthrust condition is present. Bearish Signal
ND - No demand in uptrend: This bar indicates that there is no demand. In an uptrend this indicates weakness. Bearish Signal
ND - No Demand: This bar indicates that there is no demand. This can occur in any part of the Trend. In all place other than in an uptrend this just indicates just weakness
ED - Effort to Move Down: Widespread Bar closing down on High volume or above average volume . The smart money is pushing the prices down. Bearish Signal
EDF - Effort to Move Down Failed: Widespread / above average spread Bar closing up on High volume or above average volume appearing after ‘Effort to move down” bar.
This indicates that the Effort to move the pries down has failed. Bullish signal
SV - Stopping Volume: A high volume medium to widespread Bar closing in the upper middle part in a down trend indicates that smart money is buying. This is an indication that the down trend is likely to end soon. Indicates strength
ST1 - Strength Returning 1: Strength seen returning after a down trend. High volume adds to strength. Indicates Strength
ST2 - Strength Returning 2: Strength seen returning after a down trend. High volume adds to strength.
BYC - Buy Condition: This bar indicates confluence of some bullish signals Possible end of downtrend and start of uptrend soon. Indicates Strength
EU - Effort to Move Up: Widespread Bar closing up on High volume or above average volume . The smart money is pushing the prices up. Bullish Signal
EUF - Effort to Move Up Failed: Widespread / above average spread Bar closing down on High volume or above average volume appearing after ‘Effort to move up” bar.
This indicates that the Effort to move the pries up has failed. Bearish Signal
LVT- Low Volume Test: A low volume bar dipping into previous supply area and closing in the upper part of the Bar. A successful test is a positive sign. Indicates Strength
ST(after a LVT ) - Strength after Successful Low Volume Test: An up Bar closing near High after a Test confirms strength. Bullish Signal
RUT - Reverse Upthrust Bar: This will be a widespread Bar on high Volume closing on the high is a Down Trend. Here the buyers have become active and move the prices from the low to High. The down Move is likely to end and up trend likely to start soon. indicates Strength
NS - No supply Bar: This bar indicates that there is no supply. This is a sign of strength especially in a down trend. Indicates strength
ST - Strength Returns: When multiple bullish signals occur, the legend is printed in two lines. The Legend “ST” indicates that an condition of strength other than the condition mentioned in the second line is present. Bullish Signals
BAR COLORS
Green- Bullish / Strength
Red - Bearish / weakness
Blue / White - Sentiment Changing from bullish to Bearish and Vice Versa
Larry Williams Qualified Trend Break Signals [tradeviZion]Larry Williams Qualified Trend Break Signals - Description
📖 Introduction
Welcome to the Larry Williams Qualified Trend Break Signals indicator. This description explains how the indicator works, its settings, and how to use it.
This indicator demonstrates Larry Williams' Qualified Trend Line Break technique - his preferred method for timing precise entries on daily charts when you already have a confirmed market setup.
---
🎯 About This Script
This indicator implements the Qualified Trend Line Break system - an entry technique that qualifies trend line breaks for better timing.
Important: This is NOT a signal generator. It's an entry timing tool for traders who already have a market setup and confirmation. Use it only after establishing weekly bias and daily confirmation.
Why We Made This Indicator:
This indicator demonstrates Larry Williams' favorite entry technique for daily timeframe trading. It's designed to be used as part of his complete methodology:
How To Use It Properly:
First, establish your setup: Check weekly chart for overall market bias (bullish/bearish)
Then confirm on daily: Look for confirmation signals on daily timeframe
Finally, use trend breaks: Enter trades only when trend breaks align with your setup direction
Important Warning: This is NOT a standalone buy/sell signal indicator. Using trend breaks without proper setup and confirmation will likely produce poor results. It's a timing tool for entries, not a signal generator.
---
About The Qualification Rules
The system improves on qualification methodology with these key changes:
For BUY signals (breaking above downtrend lines):
Break is usually bad if previous bar closed higher
But can still be good if:
Previous bar was inside the prior bar AND that prior bar closed lower
Price gaps above trend line and moves up at least one tick
Previous bar closed below its own opening price
For SELL signals (breaking below uptrend lines):
Break is usually bad if previous bar closed lower
But can still be good if:
Previous bar was inside the prior bar AND that prior bar closed higher
Price gaps below trend line and moves down at least one tick
Previous bar closed above its own opening price
---
📐 How The Qualification System Works
The trend break system is based on qualification methodology as developed by Larry Williams . It solves the problem where trend line breaks often fail and price goes back.
Trend Line Setup:
For BUY signals: Connect the two most recent declining swing highs to make a downtrend line
For SELL signals: Connect the two most recent rising swing lows to make an uptrend line
Inside Bar Rule:
A key principle: Trend breaks that occur on inside bars are completely ignored. The system only evaluates breaks that occur on regular bars, making signals more reliable.
How It Works In The Code
The indicator follows these steps:
Finds swing points: Identifies highs and lows in the price action
Draws trend lines: Connects 2 recent swing points to make trend lines
Checks inside bars: Ignores breaks that happen on inside bars
Qualifies signals: Uses the rules to check if breaks are good or bad
Shows signals: Only displays qualified BUY/SELL signals
Optional feature: Can show disqualified signals
⚙️ Settings
The indicator has 3 groups of settings to customize how it works.
---
📊 Signal Settings
Show Signals
Default: ON
ON: Displays green/red labels when trend breaks qualify for entry
OFF: Hides entry labels (trend lines still show for analysis)
Remember: These are entry TIMING signals, not standalone buy/sell signals
Signal Selection
Default: Both | Options: Buy Only, Sell Only, Both
Buy Only: Shows only BUY signals
Sell Only: Shows only SELL signals
Both: Shows both BUY and SELL signals
Break Validation
Default: Close | Options: Break Level, Close
Break Level: Signal when price touches the trend line (more signals)
Close: Signal when bar closes beyond trend line (fewer signals)
Tip: Try "Close" first for better signals
Show Disqualified
Default: OFF | Options: ON/OFF
What it does: Shows bad breaks
ON: Shows gray ❌ labels with explanations
OFF: Hides bad signals
👁️ Display Settings
Show Trend Lines
Default: ON
What it does: Shows trend lines on the chart
Looks like: Dashed blue lines connecting swing points
Goes to: Extends into future bars
Why: Shows where breakouts are expected
Show Swing Points
Default: ON
What it does: Marks highs/lows used for trend lines
Looks like: Shape markers at swing locations
Shows: How trend lines are constructed
Marker Style
Default: Circle | Options: Circle, Triangle, Square, Diamond, Cross
What it does: Choose shape for swing markers
Options: Circle, Triangle, Square, Diamond, Cross
Best choice: Circle is clear without being busy
Marker Size
Default: 3 | Range: 1-10
What it does: Controls marker size
Range: 1 (tiny) to 10 (large)
Show Inside Bars
Default: ON
What it does: Highlights inside bars
Looks like: Light orange background on inside bars
Note: These bars are ignored for break qualification
Important: Inside bars are ignored for break qualification
🎨 Colors
Signal Colors
Buy Signal (Default: Green) - Color for good BUY signals
Sell Signal (Default: Red) - Color for good SELL signals
Disqualified (Default: Gray) - Color for bad signals
Display Colors
Trend Line (Default: Blue) - Color for trend lines and markers
Inside Bar (Default: Light Orange) - Background for inside bars
💡 How To Use It In Larry Williams Methodology
Step 1 - Weekly Setup: Identify market bias on weekly chart (clear bullish/bearish trend)
Step 2 - Daily Confirmation: Find confirmation signals on daily timeframe
Step 3 - Trend Break Entry: Use qualified trend breaks only in setup direction
Important: Never enter based on trend breaks alone - always require setup + confirmation first
⚠️ Important Notice
This indicator implements Larry Williams' trend break entry technique. It should NOT be used as standalone buy/sell signals. Only use trend breaks for entry timing after you have established a proper market setup and confirmation. Poor results will occur if using signals without the complete Larry Williams methodology.
Credits: Based on Larry Williams' trading approach and qualification methodology. Swing detection logic adapted from "Larry Williams: Market Structure" by Smollet.
Smart Trader, Episode 03, by Ata Sabanci, Candles and TradelinesA volume-based multi-block analysis system designed for educational purposes. This indicator helps traders understand their current market situation through aggregated block analysis, volumetric calculations, trend detection, and an AI-style narrative engine.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
DESIGN PHILOSOPHY: CLEAN CHART, RICH DASHBOARD
Traditional indicators often clutter charts with dozens of support/resistance lines, making it difficult to see price action clearly. This indicator takes a different approach:
The Chart:
Displays only the most meaningful, nearest levels (1 up, 1 down) that have not been consumed by price. This keeps your chart clean and focused on what matters right now.
The Dashboard:
Contains all detailed metrics, calculations, and analysis. Instead of drawing 20 lines on your chart, you get comprehensive data in an organized table format.
Why this approach?
• A clean chart allows you to see price action without visual noise
• Fewer but more meaningful levels help focus attention on immediate reference points
• The dashboard provides depth without sacrificing chart clarity
• Beginners can learn chart reading with an uncluttered view while accessing detailed analysis when needed
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. BLOCK SEGMENTATION
What it does:
Divides the analysis window into fixed-size blocks. Each block contains multiple bars that are analyzed as a single unit.
Why:
Individual bars contain noise. A single red candle in an uptrend might cause unnecessary concern, but when you view 5-10 bars as one block, the overall direction becomes clear. Block segmentation filters out bar-to-bar noise and reveals the underlying structure.
Benefit:
• Clearer view of market structure at a higher aggregation level
• Enables comparison between time periods (Block 1 vs Block 2 vs Block 3)
• Creates the foundation for composite candles and trend detection
• Reduces emotional reaction to single-bar movements
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
2. COMPOSITE CANDLES (FRACTAL CONCEPT)
What it does:
Each block generates a "ghost candle" representing aggregated OHLC:
• Open: First bar's open in the block
• High: Highest high across all bars in the block
• Low: Lowest low across all bars in the block
• Close: Last bar's close in the block
Why:
This is essentially a FRACTAL view of the market. The same candlestick patterns that appear on a daily chart also appear on hourly charts, and on 5-minute charts. By aggregating bars into composite candles, you create a synthetic higher timeframe view without changing your actual timeframe.
Benefit:
• See higher timeframe patterns while staying on your preferred timeframe
• Identify block-level candlestick patterns (Doji, Hammer, Marubozu, Engulfing, etc.)
• Compare composite candle relationships: Does Block 1 engulf Block 2? Is Block 1 an inside bar relative to Block 2?
• Recognize patterns that individual bars obscure due to noise
Fractal Nature:
A hammer pattern means the same thing whether it appears on a 1-minute chart or a weekly chart: price tested lower levels and was rejected. Composite candles let you see these patterns at your chosen aggregation level, providing a multi-scale view of market behavior.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
3. VOLUME ENGINE
What it does:
This indicator is 100% VOLUME-BASED. It separates total volume into buying volume and selling volume using two methods:
Method 1 - Geometric (Approximation):
• Buy Volume = Total Volume × ((Close - Low) / Range)
• Sell Volume = Total Volume × ((High - Close) / Range)
Method 2 - Intrabar LTF (Precise):
Uses actual tick-level or lower timeframe data to determine real buy/sell distribution.
Why:
Raw volume tells you HOW MUCH was traded, but not WHO was aggressive. A large volume bar could mean heavy buying, heavy selling, or both. By separating buy and sell volume, you can identify which side is driving the market.
Benefit:
• Identify whether buyers or sellers are more aggressive
• Detect when volume contradicts price direction (divergence)
• Measure accumulation (buying into weakness) vs distribution (selling into strength)
• Quantify the delta (buy minus sell) to see net pressure
Why Delta Matters:
If price is rising but delta is negative, sellers are actually more aggressive despite the price increase. This divergence often precedes reversals because the price movement lacks volume confirmation.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
4. PIN ANALYSIS (WICK MEASUREMENT)
What it does:
Calculates average upper pin (wick) and lower pin sizes for each block, then tracks how these change across consecutive blocks.
Why:
Upper pins represent price levels that were tested but rejected by sellers. Lower pins represent price levels that were tested but rejected by buyers. The size and direction of pins reveal rejection strength at specific price zones.
Benefit:
• Large upper pins = strong selling pressure at higher levels
• Large lower pins = strong buying support at lower levels
• Increasing upper pins across blocks = intensifying selling pressure
• Decreasing lower pins across blocks = weakening buying support
Why Track Pin Changes:
Pin behavior often changes before price direction changes. If lower pins are shrinking while price is still rising, the buying support that was defending dips is weakening. This is observable data, not prediction.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
5. TREND CHANNEL DETECTION
What it does:
Identifies trend direction using block-level price structure:
• UPTREND: Block highs are higher than previous block highs, AND block lows are higher than previous block lows (HH/HL pattern)
• DOWNTREND: Block highs are lower than previous block highs, AND block lows are lower than previous block lows (LH/LL pattern)
• RANGE: No consistent directional pattern
Once detected, the system draws upper and lower channel boundaries by connecting extreme points within each trend segment.
Why:
HH/HL and LH/LL are the classical definitions of trend. By applying this logic to composite candles (blocks) rather than individual bars, the trend detection becomes more stable and less prone to whipsaws from single-bar noise.
Benefit:
• Clear visual boundaries showing the current trend channel
• Upper channel line = dynamic resistance based on actual price structure
• Lower channel line = dynamic support based on actual price structure
• Channel angle indicates trend strength (steeper = stronger)
• Channel width indicates volatility
Why Lock Trend States:
Once a block's trend classification is determined, it locks and does not change on subsequent recalculations. Without locking, the same block could flip between UP and DOWN repeatedly, creating inconsistent analysis. Locking ensures stability.
Why Project Lines Forward:
Channel lines can be projected into the future to show where support/resistance would be if the current trend continues at the same angle. This is not a prediction; it is a visual reference showing the trend's trajectory.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
6. CORE LEVELS: POC, MAX BUY, MAX SELL
What it does:
Identifies key price levels within each block based on volume data:
POC (Point of Control):
The price level where the highest total volume occurred within the block.
MAX BUY Level:
The bar with the highest buying volume. The HIGH of this bar marks the level.
MAX SELL Level:
The bar with the highest selling volume. The LOW of this bar marks the level.
MIN BUY/SELL Levels:
Optional levels showing where minimum buy/sell volume occurred.
Why:
High volume at a specific price means many participants entered positions there. These participants have a vested interest in that price level. If price returns to that area, those same participants may act to defend their positions.
Benefit:
• POC acts as a volume-based magnet; price tends to revisit high-volume areas
• MAX BUY level shows where buyers committed most aggressively
• MAX SELL level shows where sellers committed most aggressively
• These levels are based on actual transaction data, not arbitrary calculations
Why Consumed Levels Disappear:
When price crosses through a level, that level has been "tested." Keeping consumed levels on the chart creates visual clutter and suggests they are still relevant when they may no longer be. Removing them keeps focus on levels that have not yet been tested.
Why Show Only Nearest Levels:
If you have 20 blocks, you could have 60+ potential levels (POC, MAX BUY, MAX SELL for each). Displaying all of them makes the chart unreadable. Showing only the nearest untested level above and below current price keeps the chart clean while providing immediate reference points.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
7. QUALITY SCORE AND TREND INTELLIGENCE
What it does:
Calculates a quality score (0-100) for the current trend based on multiple factors:
• Angle steepness (stronger trends have steeper angles)
• Delta consistency (does volume support the trend direction?)
• Volume momentum (is participation increasing or decreasing?)
• Body expansion (are candle bodies growing or shrinking?)
• Pin alignment (do pins support the trend direction?)
• Contradiction count (how many factors disagree?)
Why:
Not all trends are equal. A trend with consistent volume support, expanding bodies, and aligned pins is healthier than a trend with contradicting signals. The quality score quantifies this.
Benefit:
• HIGH quality (80+): Multiple factors confirm the trend
• MEDIUM quality (60-79): Some factors confirm, some neutral
• LOW quality (below 60): Multiple contradictions exist
• Strength rating based on channel angle: VERY STRONG, STRONG, MODERATE, WEAK
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
8. NARRATIVE ENGINE
What it does:
Generates a text-based market analysis by synthesizing all calculated data into readable sentences.
How it works:
1. Analyzes current candle: pattern type (Doji, Hammer, Marubozu, etc.), body/wick ratios, range vs ATR
2. Analyzes composite candle: Block 1 pattern and relationship to Block 2 (Engulfing, Inside, Outside)
3. Evaluates trend context: direction, duration, quality, transitions
4. Examines volume data: delta, dominance, momentum direction
5. Checks proximity to key levels: channel boundaries, POC, core levels
6. Identifies divergences: when price and volume directions contradict
7. Produces a coherent narrative describing the current situation
Why:
Numbers and charts require interpretation. The narrative engine translates calculated data into plain language, helping traders understand what the data means in context. This is especially valuable for beginners learning to read charts.
Benefit:
• Synthesizes multiple data points into a coherent story
• Explicitly flags divergences and contradictions
• Describes the current situation without making predictions
• Educational: shows how different factors relate to each other
What the Narrative Does NOT Do:
The narrative describes what IS, not what WILL BE. It does not predict future price movement. It reports the current candle pattern, the current trend state, the current volume situation, and the current proximity to levels.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
9. SMART DASHBOARD
What it does:
Displays all metrics in an organized table with multiple sections.
Sections:
• Volume Engine: Calculation method, data availability, current candle buy/sell/delta
• Trend Volumetrics: Aggregated buy/sell/delta across the current trend, trend type
• Pressure and Momentum: Average pins, pin change percentages, body expansion status
• Trend Channel Boundaries: Upper/lower levels with exact prices, distances, percentages
• Trend Intelligence: Quality score, confidence level, strength rating, volume momentum
Why:
All the detailed calculations need to live somewhere without cluttering the chart. The dashboard provides comprehensive data in a structured format.
Benefit:
• All metrics in one place
• Organized by category for easy reference
• Hover over any label to see a tooltip explaining that metric
• No need to draw dozens of lines on the chart
TIP: Hover over dashboard headers and labels to see tooltips explaining each metric.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
10. LANGUAGE SUPPORT
The indicator supports three languages:
• English
• Türkçe (Turkish)
• हिन्दी (Hindi)
Why only three languages?
Each additional language requires duplicate strings throughout the code, increasing memory usage and compilation time. To keep the script optimized and responsive, language options are limited to these three.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
11. DATA ACCURACY AND LIMITATIONS
This indicator is 100% VOLUME-BASED and requires Lower Timeframe (LTF) intrabar data for accurate calculations.
DATA ACCURACY LEVELS:
• 1T (Tick): Most accurate, real volume distribution per tick
• 1S (1 Second): Reasonably accurate approximation
• 15S (15 Seconds): Good approximation, longer historical data available
• 1M (1 Minute): Rough approximation, maximum historical data range
BACKTEST AND REPLAY LIMITATIONS:
• Replay mode results may differ from live trading due to data availability
• For longer backtest periods, use higher LTF settings (15S or 1M)
• Not all symbols/exchanges support tick-level data
• Crypto and Forex typically have better LTF data availability than stocks
A NOTE ON DATA ACCESS:
Higher TradingView plans provide access to more historical intrabar data, which directly impacts the accuracy of volume-based calculations. More precise volume data leads to more reliable calculations.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
12. SETTINGS OVERVIEW
Main Settings:
• Window Bars: Total bars to analyze
• Group Count: Number of blocks to create
• Calculation Basis: Current bar (live updates) or Closed bar (stable, no repaint)
Block Analytics:
• Show Composite Candle: Toggle ghost candles on/off
• Composite Candle Transparency: Adjust visibility
• Dim Original Candles: Fade original candles when composites are shown
Volume Engine:
• Calculation Method: Geometric (approx) or Intrabar (precise)
• Lower Timeframe: Select LTF for intrabar calculations
Multi-Segment Trend:
• Enable Trend Detection: Toggle trend channels on/off
• Range Angle Threshold: Angle below which trend is classified as RANGE
• Line colors, width, and style
• Project to Future: Extend trend lines forward
Core Calculation:
• Enable Core Calculation: Toggle POC and core levels
• Show POC Nearest Up/Down: Display nearest untested POC levels
• Include MAX/MIN Buy/Sell Levels: Toggle extremes display
• Nearest Only: Show only the closest level above and below price
Market Narrative:
• Enable Market Narrative: Toggle narrative text
• Language selection
• Show Educational Disclaimer: Toggle disclaimer in dashboard
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
EDUCATIONAL PURPOSE
This indicator is designed to help traders:
1. Understand their current market situation at a glance
2. Learn chart reading through block analysis and composite candles
3. See how volume relates to price movement
4. Recognize when technical factors align or contradict
5. Focus on meaningful levels without chart clutter
Whether you are a beginner learning to read charts or an experienced trader seeking a cleaner analytical view, this tool provides structured data to support your analysis.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMPORTANT DISCLAIMER
This indicator is for EDUCATIONAL PURPOSES ONLY and does not constitute investment advice. Always conduct your own research and consult with a qualified financial advisor before making investment decisions.
This disclaimer is also displayed within the indicator itself. If you prefer a cleaner chart, you can disable it in Settings under Market Narrative by unchecking Show Educational Disclaimer.
Scalp Precision Matrix [BullByte]SCALP PRECISION MATRIX (SPM)
OVERVIEW
Scalp Precision Matrix (SPM) is a comprehensive decision-support framework designed specifically for scalpers and short-term traders. This indicator synthesizes five distinct analytical layers into a unified system that helps identify high-quality setups while avoiding common pitfalls that trap traders.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
THE CORE PROBLEM THIS INDICATOR ADDRESSES
Scalping demands rapid decision-making while simultaneously processing multiple data points. Traders constantly ask themselves: Is momentum still alive? Am I entering near a potential reversal zone? Is this the right session to trade? What is my actual risk-to-reward? Most traders either overwhelm themselves with too many separate indicators (creating analysis paralysis) or use too few (missing crucial context).
SPM was developed to consolidate these essential checks into one cohesive framework. Rather than overlaying disconnected indicators, each component in SPM directly informs and adjusts the others, creating an integrated analytical system.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
WHY THESE SPECIFIC COMPONENTS AND HOW THEY WORK TOGETHER
The five analytical layers in SPM are not arbitrarily combined. Each addresses a specific question in the scalping decision process, and together they form a logical workflow:
LAYER 1: MOMENTUM FUEL GAUGE
This answers the question: "Does the current move still have energy?"
After any impulse move (a significant directional price movement), momentum naturally decays over time. The Fuel Gauge estimates remaining momentum by analyzing four factors:
Body Strength (30% weight): Compares recent candle body sizes against the historical average. Strong momentum produces candles with large bodies relative to their wicks. The calculation takes the 3-bar average body size divided by the 20-bar average body size, then scales it to a 0-100 range.
Wick Rejection (25% weight): Measures the wick-to-body ratio. When wicks are large relative to bodies, it suggests rejection and weakening momentum. A ratio of 2.0 or higher (wicks twice the body size) scores low; smaller ratios score higher.
Volume Consistency (20% weight): Compares recent 3-bar average volume against the lookback period average. Sustained moves require consistent volume support. Volume dropping off suggests the move may be losing participation.
Time Decay (25% weight): Tracks how many bars have passed since the last detected impulse. Momentum naturally fades over time. The typical impulse duration is adjusted based on the current volatility regime.
These components are weighted and combined, then smoothed with a 3-period EMA to reduce noise. The result is a 0-100% gauge where:
- Above 70% = Strong momentum (green)
- 40-70% = Moderate momentum (amber)
- Below 40% = Weak momentum (red)
- Below 20% = Exhausted (triggers EXIT warning)
The Fuel Gauge also estimates how many bars of momentum remain based on the current burn rate.
IMPORTANT DISCLAIMER : The Fuel Gauge is NOT order flow, volume profile, or depth of market data. It is a technical proxy calculated entirely from standard OHLCV (Open, High, Low, Close, Volume) data. The term "Fuel" is used metaphorically to represent estimated remaining momentum energy.
LAYER 2: TRAP ZONE DETECTION
This answers the question: "Am I walking into a potential reversal area?"
Price tends to reverse at levels where it has reversed before. SPM identifies these zones by detecting clusters of historical swing points:
How it works:
1. The indicator detects swing highs and swing lows using the Swing Detection Length setting (default 5 bars on each side required to confirm a pivot).
2. Recent swing points are stored (up to 10 of each type).
3. For each potential zone, the algorithm counts how many swing points cluster within a tolerance of 0.5 ATR.
4. Zones with 2 or more clustered swing points, positioned between 0.3 and 4.0 ATR from current price, are marked as Trap Zones.
5. A Confluence Score is calculated based on cluster density and proximity to current price.
The percentage displayed (e.g., "TRAP 85%") is a CONFLUENCE SCORE, not a probability. Higher percentages mean more swing points cluster at that level and price is closer to it. This indicates stronger historical significance, not a prediction of future reversal.
CRITICAL DISCLAIMER : Trap Zones are NOT institutional order flow, liquidity pools, smart money footprints, or any proprietary data feed. They are calculated purely from historical swing point clustering using standard technical analysis. The term "trap" describes how price action has historically reversed at these levels, potentially trapping traders who enter prematurely. This is pattern recognition, not market structure data.
LAYER 3: VELOCITY ANALYSIS
This answers the question: "Is price moving favorably right now?"
Velocity measures how fast price is currently moving compared to its recent average:
Calculation:
- Current velocity = Absolute price change from previous bar divided by ATR
- Average velocity = Simple moving average of velocity over the lookback period
- Velocity ratio = Current velocity divided by average velocity
Classification:
- FAST (ratio above 1.5 ): Price is moving significantly faster than normal. Good for momentum continuation plays.
- NORMAL (ratio 0.5 to 1.5) : Typical price movement speed.
- SLOW (ratio below 0.5 ): Price is moving sluggishly. Often indicates ranging or choppy conditions where scalping becomes difficult.
The velocity score contributes 18% to the overall quality score calculation.
LAYER 4: SESSION AWARENESS
This answers the question: "Is this a good time to trade?"
Different trading sessions have different characteristics. SPM automatically detects which major session is active and adjusts its quality assessment:
Session Times (all in UTC):
- A sia Session : 00:00 - 08:00 UTC
- London Session : 08:00 - 16:00 UTC
- New York Session : 13:00 - 21:00 UTC
- London/NY Overlap : 13:00 - 16:00 UTC
- Off-Peak : Outside major sessions
Session Quality Weighting:
- Overlap : 100 points (highest liquidity, best movement)
- London : 85 points
- New York : 80 points
- Asia : 50 points (tends to range more)
- Off-Peak : 30 points (lower liquidity, more false signals)
The session score contributes 17% to the overall quality calculation. Signals are also filtered to prevent firing during off-peak hours.
Note : These are fixed UTC times and may not perfectly match your broker's session boundaries. Use them as general guidance rather than precise timing.
LAYER 5: VOLATILITY REGIME ADAPTATION
This answers the question: "How should I adjust for current market conditions?"
SPM compares current volatility (14-period ATR) against historical volatility (50-period ATR) to categorize the market:
HIGH Volatility (ratio above 1.3): Current ATR is 30%+ above normal. SPM widens thresholds to filter noise and extends target projections.
NORMAL Volatility (ratio 0.7 to 1.3): Typical conditions. Standard parameters apply.
LOW Volatility (ratio below 0.7): Current ATR is 30%+ below normal. SPM tightens thresholds for sensitivity and reduces target expectations. The market state may show AVOID during prolonged low volatility.
This adaptation prevents false signals during erratic markets and missed signals during quiet markets.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
THE SYNERGY: WHY THIS COMBINATION MATTERS
These five layers are not independent indicators placed on one chart. They form an interconnected system:
- A signal only fires when momentum exists (Fuel above 40%), price is away from danger zones (Trap Zones factored into quality score), movement is favorable (Velocity contributes to score), timing is appropriate (Session is not off-peak), and volatility is accounted for (thresholds adapt to regime).
- The Trap Zones directly influence Entry Zone placement. Entry zones are positioned beyond trap zones to avoid getting caught in reversals.
- Target projections automatically adjust to avoid placing take-profit levels inside detected trap zones.
- The Fuel Gauge affects which signal tier fires. Insufficient fuel prevents all signals.
- Session quality is weighted into the overall score, reducing signal quality during less favorable trading hours.
This integration is the core originality of SPM. Each component makes the others more useful than they would be in isolation.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
HOW THE QUALITY SCORE IS CALCULATED
The Quality Score (0-100) synthesizes all layers into a single number for each direction (long and short):
For Long Quality Score:
- Fuel Component (28% weight) : Full fuel value if impulse direction is bullish; 60% of fuel value otherwise
- Trap Avoidance (22% weight) : 75 points if no trap zone below; otherwise 100 minus the trap confluence score (minimum 20)
- Velocity Component (18% weight) : Direct velocity score
- Session Component (17% weight) : Current session quality score
- Trend Alignment (15% bonus) : Adds 12 points if price is above the 20-period SMA
For Short Quality Score:
- Same structure but reversed (bearish impulse direction, trap zone above, price below SMA)
The direction with the higher score becomes the current Bias. A 12-point difference is required to switch bias, preventing flip-flopping in neutral conditions.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SIGNAL TYPES AND WHAT THEY MEAN
SPM generates four types of signals, each with specific visual representation:
PRIME SIGNALS (Cyan Diamond)
These represent the highest quality confluence. Requirements:
- Quality score crosses above the Prime threshold (default 80)
- Bias aligns with signal direction
- Fuel is sufficient (above 40%)
- Session is active (not off-peak)
- Cooldown period has passed
Prime signals appear as cyan-colored diamond shapes. Long signals appear below the bar; short signals appear above.
STANDARD SIGNALS (Green Triangle Up / Red Triangle Down)
These represent good quality setups. Requirements:
- Quality score crosses above the Standard threshold (default 75) but below Prime
- Same bias, fuel, and cooldown requirements as Prime
Standard signals appear as small triangles in green (long) or red (short).
CAUTION SIGNALS (Small Faded Circle)
These represent minimum threshold setups. Requirements:
- Quality score crosses above the Caution threshold (default 65) but below Standard
- Same additional requirements
Caution signals appear as small, faded circles. These suggest the setup exists but with weaker confluence. Consider these only when broader market context supports them, or skip them entirely during uncertain conditions.
EXHAUSTION SIGNAL (Purple X with "EXIT" text)
This warning appears when the Fuel Gauge drops below 20% from above, indicating momentum has depleted. This is not a trade signal but a warning to:
- Consider exiting existing positions
- Avoid entering new trades in the current direction
- Wait for new momentum to develop
All signals use CONFIRMED bar data only (referencing the previous closed bar) to prevent repainting. Once a signal appears, it will never disappear or change position on historical bars.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
READING THE CHART ELEMENTS
TRAP ZONES (Red Dashed Box with "TRAP XX%" Label)
These mark price levels where multiple historical swing points cluster. The red dashed box shows the zone boundaries. The percentage is the confluence score indicating cluster strength and proximity.
How to use: When price approaches a trap zone, be cautious about entering in that direction. If your bias is LONG and there's a strong trap zone above, consider taking partial profits before price reaches it or adjusting your target below it.
ENTRY ZONES (Green Solid Box with "ENTRY" Label)
These show suggested entry areas based on the current bias direction. For LONG bias, the entry zone appears below the trap zone (buying the dip beyond support). For SHORT bias, it appears above the trap zone (selling the rally beyond resistance).
How to use: Rather than entering at current price, consider placing limit orders within the entry zone. This positions you beyond where typical trap reversals occur.
TARGET ZONES (Blue Dotted Box with "TARGET" Label)
These project potential take-profit areas based on ATR multiples, adjusted for:
- Current volatility regime (wider in high volatility, tighter in low)
- Impulse direction (larger targets when aligned with impulse)
- Nearby trap zones (targets adjust to avoid placing TP inside trap zones)
How to use: These are suggestions, not guarantees. Consider taking partial profits before the target or using trailing stops once price moves favorably.
STOP LEVEL (Orange Dashed Line with "STOP" Label)
This shows suggested stop-loss placement, calculated as 0.8 ATR beyond the trap zone (or 2.0 ATR from current price if no trap zone exists).
How to use: This provides a reference for risk calculation. The dashboard R:R ratio is calculated using this stop level.
Chart Example: Scalp Precision Matrix displays real-time market analysis through dynamic zones and quality scores. ENTRY/TARGET/STOP zones show potential price levels based on current market structure - they appear continuously as reference points, NOT as trade instructions. Actual trade signals (diamonds, triangles, circles) fire only when multiple conditions align: quality score thresholds are crossed, fuel gauge is sufficient, session is active, and cooldown period has passed. The zones help you understand market context; the signals tell you when to act.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
UNDERSTANDING THE DASHBOARD (Top Right Panel)
The main dashboard provides comprehensive market context:
Row 1 - Header:
- "SPM " : Indicator name
- Market State : Current overall condition
Market States Explained:
- PRIME : Excellent conditions. Quality score meets prime threshold, session is active. Best opportunities.
- READY : Good conditions. Quality score meets standard threshold. Solid setups available.
- WAIT : Mixed conditions. Some factors favorable, others not. Patience recommended.
- AVOID : Poor conditions. Off-peak session or very low volatility. High risk of false signals.
- EXIT : Fuel exhausted. Momentum depleted. Consider closing positions or waiting.
Row 2-3 - Quality Bars:
- " UP ########## " : Visual meter for long quality (each # = 10 points, . = empty)
- " DN ########## " : Visual meter for short quality
- The number on the right shows the exact quality score
Row 4 - Bias:
- Shows current directional lean: LONG, SHORT, or NEUTRAL
- Color-coded: Green for long, red for short, gray for neutral
Rows 5-7 (Full Mode Only) - Trade Levels:
- Entry : Suggested entry price for current bias direction
- Stop : Suggested stop-loss price
- Target : Projected take-profit price
Row 8 - Risk:Reward Ratio:
- Format : "1:X.X" where X.X is the reward multiple
- Color-coded : Green if 2:1 or better, amber if 1.5:1 to 2:1, red if below 1.5:1
Row 9 - Fuel:
- Shows percentage and estimated bars remaining in parentheses
- Example : "72% (8)" means 72% fuel with approximately 8 bars remaining
- Color-coded : Green above 70%, amber 40-70%, red below 40%
Row 10-11 (Full Mode Only) - Market Conditions:
- Vol : Current volatility regime (HIGH/NORMAL/LOW)
- Speed : Current velocity zone (FAST/NORMAL/SLOW)
Row 12 - Session:
- Shows active trading session
- Color-coded by session type
Row 13 (Full Mode Only) - Remaining:
- Time remaining in current session (hours and minutes)
Row 14 (Conditional) - Trap Warning:
- Appears when a significant trap zone exists in your bias direction
- Shows direction (ABOVE/BELOW) and confluence percentage
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
UNDERSTANDING THE QUICK PANEL (Bottom Left)
The Quick Panel provides essential information at a glance without looking away from price action:
Row 1: Current Bias and Quality Score (large text for quick reading)
Row 2: Market State
Row 3: Fuel Percentage
Row 4: Estimated Bars Remaining
Row 5: Risk:Reward Ratio
Row 6: Current Session
Both panels can be repositioned using the settings, and each can be toggled on/off independently.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SETTINGS EXPLAINED
CORE SETTINGS:
Analysis Lookback (Default: 20)
Number of bars used for statistical calculations including average volume and average body size. Higher values create smoother but slower-reacting analysis. Lower values are more responsive but may include more noise.
Swing Detection Length (Default: 5)
Bars required on each side to confirm a swing high or low. A setting of 5 means a swing high must have 5 lower highs on each side. Lower values detect more swings (more trap zones, more sensitivity). Higher values find only major pivots (fewer but more significant zones).
Impulse Sensitivity (Default: 1.5)
Multiplier for ATR when detecting impulse moves. Lower values (like 1.0) detect smaller price movements as impulses, refreshing the fuel gauge more frequently. Higher values (like 2.5) require larger moves, making impulse detection less frequent but more significant.
SIGNAL SETTINGS:
Prime/Standard/Caution Thresholds (Defaults: 80/75/65)
These control the quality score required for each signal tier. You can adjust these based on your preference:
- More conservative : Raise thresholds (e.g., 85/80/70) for fewer but higher-quality signals
- More aggressive : Lower thresholds (e.g., 75/70/60) for more signals with slightly lower quality
Signal Cooldown (Default: 8 bars)
Minimum bars between signals to prevent signal spam. After any signal fires, no new signals can appear until this many bars pass. Increase for fewer signals in choppy markets; decrease if you want faster signal refresh.
Show Prime/Standard/Caution/Exhaustion Signals
Toggle each signal type on or off based on your preference.
ZONE DISPLAY:
Show Trap Zones / Entry Zones / Target Zones / Stop Levels
Toggle each zone type on or off. Turning off zones you don't use reduces chart clutter.
Zone Transparency (Default: 88)
Controls how transparent zone boxes appear. Higher values (closer to 95) make zones barely visible; lower values (closer to 75) make them more prominent.
Zone History (Default: 25 bars)
How far back zone boxes extend on the chart. Purely visual preference.
BACKGROUND:
Background Mode (Options: Off, Subtle, Normal)
Controls whether and how intensely the chart background is colored. Subtle is barely noticeable; Normal is more visible; Off disables background coloring entirely.
Background Type (Options: Bias, Fuel)
- Bias : Colors background based on current directional lean (green for long, red for short)
- Fuel : Colors background based on momentum level (green for high fuel, amber for moderate, red for low)
DASHBOARD / QUICK PANEL:
Show Dashboard / Show Quick Panel
Toggle each panel on or off.
Compact Mode
When enabled, the main dashboard shows only essential rows (quality bars, bias, R:R, fuel, session) without entry/stop/target levels, volatility, velocity, or time remaining.
Position Settings
Choose where each panel appears on your chart from six options: Top Right, Top Left, Bottom Right, Bottom Left, Middle Right, Middle Left.
ALERTS:
Alert Prime Signals / Standard Signals / Fuel Exhaustion
Enable or disable TradingView alerts for each condition. When enabled, you can set up alerts in TradingView that will notify you when these conditions occur.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
RECOMMENDED TIMEFRAMES AND USAGE
OPTIMAL TIMEFRAMES:
- 1-minute to 5-minute : Best for active scalping with quick entries and exits
- 5-minute to 15-minute : Balanced scalping with slightly more confirmation
- 15-minute to 1-hour : Short-term swing entries, fewer but more significant signals
Zone visualizations only appear on intraday timeframes to prevent chart clutter on higher timeframes.
BEST PRACTICES:
1. Trade primarily during LONDON, NEW YORK, or OVERLAP sessions. The indicator weights these sessions higher for good reason - liquidity and movement are typically better.
2. Prioritize PRIME signals. These represent the highest confluence and have proven most reliable. Use STANDARD signals as secondary opportunities. Treat CAUTION signals with extra scrutiny.
3. Respect the Fuel Gauge. Avoid entering new positions when fuel is below 40%. When the EXIT signal appears, seriously consider closing or reducing positions.
4. Pay attention to TRAP warnings. When the dashboard shows a trap zone in your bias direction, be cautious about holding through that level.
5. Verify R:R before entry. The dashboard shows the risk-to-reward ratio. Ensure it meets your minimum requirements (many traders require at least 1.5:1 or 2:1).
6. When state shows AVOID or EXIT, step back. These conditions typically produce poor results.
7. Combine with your own analysis. SPM is a decision-support tool, not a standalone system. Use it alongside your understanding of market structure, news events, and overall context.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PRACTICAL EXAMPLE
Scenario : You're watching a 5-minute chart during London session. A cyan diamond (Prime Long signal) appears below the bar.
Before entering, you check the dashboard:
- State shows "PRIME" - conditions are favorable
- Fuel shows "72% (8)" - plenty of momentum remaining (approximately 8 bars)
- R:R shows "1:2.3" - acceptable risk-to-reward ratio
- Session shows "LONDON" - active session with good liquidity
- No TRAP warning in dashboard - no immediate resistance cluster in your way
- Entry zone visible on chart at a lower price level
- Stop and Target zones clearly marked
With this confluence of factors, you have context for a more informed decision. The signal indicates quality, the fuel suggests momentum remains, the R:R is favorable, and no immediate trap threatens your trade.
However, you also notice the target zone sits just below where a trap zone would be if there were one. This is by design - SPM adjusts targets to avoid placing them inside reversal zones.
This multi-factor confirmation delivered in a single glance is what SPM provides.
Chart Example :This chart demonstrates how the Scalp Precision Matrix identifies key market transitions. After a strong bullish impulse (cyan PRIME signal at ~08:30), price reached a historical reversal cluster (TRAP ZONE at 92,300). The indicator detected momentum exhaustion (purple EXIT signal) as fuel dropped below 20%, warning traders to exit longs. Now showing a SHORT bias with entry/stop/target zones clearly marked. The 92% trap zone confluence indicates a strong cluster of previous swing highs where price historically reversed.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
DATA WINDOW VALUES
For detailed analysis and strategy development, SPM exports the following values to TradingView's Data Window (visible when you hover over the chart with the indicator selected):
- Long Quality Score (0-100)
- Short Quality Score (0-100)
- Fuel Gauge (0-100%)
- Risk:Reward Ratio
These values can be useful for understanding how the indicator behaves over time and for developing your own insights about when it works best for your trading style.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
NON-REPAINTING CONFIRMATION
All signals in SPM are generated using CONFIRMED bar data only. The signal logic references the previous closed bar's values ( and in Pine Script terms). This means:
- Signals appear at the OPEN of the new bar (after the previous bar closes)
- Signals will NEVER disappear once they appear
- Signals will NEVER change position on historical bars
- What you see in backtesting is what you would have seen in real-time
The dashboard and zones update in real-time to provide current market context, but the trading signals themselves are non-repainting.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMPORTANT DISCLAIMERS
TERMINOLOGY CLARIFICATION:
This indicator uses terms that might imply access to data it does not have. To be completely transparent:
- "Trap Zones" are calculated from historical swing point clustering. They are NOT institutional liquidity pools, order blocks, smart money footprints, or any form of order flow data. The term "trap" is metaphorical, describing how price has historically reversed at these levels.
- "Fuel Gauge" is a technical momentum proxy. It is NOT order flow, volume profile, depth of market, or bid/ask data. It estimates momentum remaining based entirely on standard OHLCV price and volume data.
- "Quality Scores" are weighted combinations of the technical factors described above. A high score indicates multiple conditions align favorably according to the indicator's logic. It does NOT predict or guarantee trade success.
- The percentages shown on trap zones are CONFLUENCE SCORES measuring cluster density and proximity. They are NOT probability predictions of reversal.
TRADING RISK WARNING:
Trading involves substantial risk of loss and is not suitable for all investors. This indicator is a technical analysis tool designed to assist with decision-making. It does not constitute financial advice, trading advice, or any other sort of advice. Past performance of any signal or pattern does not guarantee future results. Markets are inherently unpredictable.
Always use proper risk management. Define your risk before entering any trade. Never risk more than you can afford to lose. Consider consulting with a licensed financial advisor before making trading decisions.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ORIGINALITY STATEMENT - NOT A MASHUP
Scalp Precision Matrix is an original work that combines several analytical concepts into a purpose-built scalping framework. While individual components like ATR calculations, pivot detection, session timing, and trend alignment exist in various forms elsewhere, the specific implementation here represents original synthesis:
- The Fuel Gauge decay model with its four-component weighted calculation
- The Trap Zone cluster detection with confluence scoring
- The multi-factor quality scoring system that integrates all layers
- The trap-aware entry and target zone placement logic
- The volatility regime adaptation across all components
- The session weighting is integrated into the quality assessment
The indicator does not simply overlay separate indicators on one chart. It creates interconnected layers where each component informs and adjusts the others. This integration is the core originality of SPM.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
For best results, combine SPM with your own market understanding and always practice proper risk management.
-BullByte
Cumulative Volume Delta (CVD) Suite [QuantAlgo]🟢 Overview
The Cumulative Volume Delta (CVD) Suite is a comprehensive toolkit that tracks the net difference between buying and selling pressure over time, helping traders identify significant accumulation/distribution patterns, spot divergences with price action, and confirm trend strength. By visualizing the running balance of volume flow, this indicator reveals underlying market sentiment that often precedes significant price movements.
🟢 How It Works
The indicator begins by determining the optimal timeframe for delta calculation. When auto-select is enabled, it automatically chooses a lower timeframe based on your chart period, e.g., using 1-second bars for minute charts, 5-second bars for 5-minute charts, and progressively larger intervals for higher timeframes. This granular approach captures volume flow dynamics that might be missed at the chart level.
Once the timeframe is established, the indicator calculates volume delta for each bar using directional classification:
getDelta() =>
close > open ? volume : close < open ? -volume : 0
When a bar closes higher than it opens (bullish candle), the entire volume is counted as positive delta representing buying pressure. Conversely, when a bar closes lower than its open (bearish candle), volume becomes negative delta representing selling pressure. This classification is applied to every bar in the selected lower timeframe, then aggregated upward to construct the delta for each chart bar:
array deltaValues = request.security_lower_tf(syminfo.tickerid, lowerTimeframe, getDelta())
float barDelta = 0.0
if array.size(deltaValues) > 0
for i = 0 to array.size(deltaValues) - 1
barDelta := barDelta + array.get(deltaValues, i)
This aggregation process sums all the individual delta values from the lower timeframe bars that comprise each chart bar, capturing the complete volume flow activity within that period. The resulting bar delta then feeds into the various display calculations:
rawCVD = ta.cum(barDelta) // Cumulative sum from chart start
smoothCVD = ta.sma(rawCVD, smoothingLength) // Smoothed for noise reduction
rollingCVD = math.sum(barDelta, rollingLength) // Rolling window calculation
Note: This directional bar approach differs from exchange-level orderflow CVD, which uses tick data to separate aggressive buy orders (executed at the ask price) from aggressive sell orders (executed at the bid price). While this method provides a volume flow approximation rather than pure tape-reading precision, it offers a practical and accessible way to analyze buying and selling dynamics across all timeframes and instruments without requiring specialized data feeds on TradingView.
🟢 Key Features
The indicator offers five distinct visualization modes, each designed to reveal different aspects of volume flow dynamics and cater to various trading strategies and market conditions.
1. Oscillator (Raw): Displays the true cumulative volume delta from the beginning of chart history, accompanied by an EMA signal line that helps identify trend direction and momentum shifts. When CVD crosses above the signal line, it indicates strengthening buying pressure; crosses below suggest increasing selling pressure. This mode is particularly valuable for spotting long-term accumulation/distribution phases and identifying divergences where CVD makes new highs/lows while price fails to confirm, often signaling potential reversals.
2. Oscillator (Smooth): Applies a simple moving average to the raw CVD to filter out noise while preserving the underlying trend structure, creating smoother signal line crossovers. Use this when trading trending instruments where you need confirmation of genuine volume-backed moves versus temporary volatility spikes.
3. Oscillator (Rolling): Calculates cumulative delta over only the most recent N bars (configurable window length), effectively resetting the baseline and removing the influence of distant historical data. This approach focuses exclusively on current market dynamics, making it highly responsive to recent shifts in volume pressure and particularly useful in markets that have undergone regime changes or structural shifts. This mode can be beneficial for traders when they want to analyze "what's happening now" without legacy bias from months or years of prior data affecting the readings.
4. Histogram: Renders the per-bar volume delta as individual histogram bars rather than cumulative values, showing the immediate buying or selling pressure that occurred during each specific candle. Positive (green) bars indicate that bar closed higher than it opened with buying volume, while negative (red) bars show selling volume dominance. This mode excels at identifying sudden volume surges, exhaustion points where large delta bars fail to move price, and bar-by-bar absorption patterns where one side is aggressively consuming the other's volume.
5. Candles: Transforms CVD data into OHLC candlestick format, where each candle's open represents the CVD at the start of the bar and subsequent intra-bar delta changes create the high, low, and close values. This visualization reveals the internal volume flow dynamics within each time period, showing whether buying or selling pressure dominated throughout the bar's formation and exposing intra-bar reversals or sustained directional pressure. Use candle wicks and bodies to identify volume acceptance/rejection at specific CVD levels, similar to how price candles show acceptance/rejection at price levels.
▶ Built-in Alert System: Comprehensive alerts for all display modes including bullish/bearish momentum shifts (CVD crossing signal line), buying/selling pressure detection (histogram mode), and bullish/bearish CVD candle formations. Fully customizable with exchange and timeframe placeholders.
▶ Visual Customization: Choose from 5 color presets (Classic, Aqua, Cosmic, Ember, Neon) or create your own custom color schemes. Optional price bar coloring feature overlays CVD trend colors directly onto your main chart candles, providing instant visual confirmation of volume flow and making divergences immediately apparent. Optional info label with configurable position and size displays current CVD values, data source timeframe, and mode at a glance.
Intrabar Volume Flow IntelligenceIntrabar Volume Flow Intelligence: A Comprehensive Analysis:
The Intrabar Volume Flow Intelligence indicator represents a sophisticated approach to understanding market dynamics through the lens of volume analysis at a granular, intrabar level. This Pine Script version 5 indicator transcends traditional volume analysis by dissecting price action within individual bars to reveal the true nature of buying and selling pressure that often remains hidden when examining only the external characteristics of completed candlesticks. At its core, this indicator operates on the principle that volume is the fuel that drives price movement, and by understanding where volume is being applied within each bar—whether at higher prices indicating buying pressure or at lower prices indicating selling pressure—traders can gain a significant edge in anticipating future price movements before they become obvious to the broader market.
The foundational innovation of this indicator lies in its use of lower timeframe data to analyze what happens inside each bar on your chart timeframe. While most traders see only the open, high, low, and close of a five-minute candle, for example, this indicator requests data from a one-minute timeframe by default to see all the individual one-minute candles that comprise that five-minute bar. This intrabar analysis allows the indicator to calculate a weighted intensity score based on where the price closed within each sub-bar's range. If the close is near the high, that volume is attributed more heavily to buying pressure; if near the low, to selling pressure. This methodology is far more nuanced than simple tick volume analysis or even traditional volume delta calculations because it accounts for the actual price behavior and distribution of volume throughout the formation of each bar, providing a three-dimensional view of market participation.
The intensity calculation itself demonstrates the coding sophistication embedded in this indicator. For each intrabar segment, the indicator calculates a base intensity using the formula of close minus low divided by the range between high and low. This gives a value between zero and one, where values approaching one indicate closes near the high and values approaching zero indicate closes near the low. However, the indicator doesn't stop there—it applies an open adjustment factor that considers the relationship between the close and open positions within the overall range, adding up to twenty percent additional weighting based on directional movement. This adjustment ensures that strongly directional intrabar movement receives appropriate emphasis in the final volume allocation. The adjusted intensity is then bounded between zero and one to prevent extreme outliers from distorting the analysis, demonstrating careful consideration of edge cases and data integrity.
The volume flow calculation multiplies this intensity by the actual volume transacted in each intrabar segment, creating buy volume and sell volume figures that represent not just quantity but quality of market participation. These figures are accumulated across all intrabar segments within the parent bar, and simultaneously, a volume-weighted average price is calculated for the entire bar using the typical price of each segment multiplied by its volume. This intrabar VWAP becomes a critical reference point for understanding whether the overall bar is trading above or below its fair value as determined by actual transaction levels. The deviation from this intrabar VWAP is then used as a weighting mechanism—when the close is significantly above the intrabar VWAP, buying volume receives additional weight; when below, selling volume is emphasized. This creates a feedback loop where volume that moves price away from equilibrium is recognized as more significant than volume that keeps price near balance.
The imbalance filter represents another layer of analytical sophistication that separates meaningful volume flows from normal market noise. The indicator calculates the absolute difference between buy and sell volume as a percentage of total volume, and this imbalance must exceed a user-defined threshold—defaulted to twenty-five percent but adjustable from five to eighty percent—before the volume flow is considered significant enough to register on the indicator. This filtering mechanism ensures that only bars with clear directional conviction contribute to the cumulative flow measurements, while bars with balanced buying and selling are essentially ignored. This is crucial because markets spend considerable time in equilibrium states where volume is simply facilitating position exchanges without directional intent. By filtering out these neutral periods, the indicator focuses trader attention exclusively on moments when one side of the market is demonstrating clear dominance.
The decay factor implementation showcases advanced state management in Pine Script coding. Rather than allowing imbalanced volume to simply disappear after one bar, the indicator maintains decayed values using variable state that persists across bars. When a new significant imbalance occurs, it replaces the decayed value; when no significant imbalance is present, the previous value is multiplied by the decay factor, which defaults to zero point eight-five. This means that a large volume imbalance continues to influence the indicator for several bars afterward, gradually diminishing in impact unless reinforced by new imbalances. This decay mechanism creates persistence in the flow measurements, acknowledging that large institutional volume accumulation or distribution campaigns don't execute in single bars but rather unfold across multiple bars. The cumulative flow calculation then sums these decayed values over a lookback period, creating a running total that represents sustained directional pressure rather than momentary spikes.
The dual moving average crossover system applied to these volume flows creates actionable trading signals from the underlying data. The indicator calculates both a fast exponential moving average and a slower simple moving average of the buy flow, sell flow, and net flow values. The use of EMA for the fast line provides responsiveness to recent changes while the SMA for the slow line provides a more stable baseline, and the divergence or convergence between these averages signals shifts in volume flow momentum. When the buy flow EMA crosses above its SMA while volume is elevated, this indicates that buying pressure is not only present but accelerating, which is the foundation for the strong buy signal generation. The same logic applies inversely for selling pressure, creating a symmetrical approach to detecting both upside and downside momentum shifts based on volume characteristics rather than price characteristics.
The volume threshold filtering ensures that signals only generate during periods of statistically significant market participation. The indicator calculates a simple moving average of total volume over a user-defined period, defaulted to twenty bars, and then requires that current volume exceed this average by a multiplier, defaulted to one point two times. This ensures that signals occur during periods when the market is actively engaged rather than during quiet periods when a few large orders can create misleading volume patterns. The indicator even distinguishes between high volume—exceeding the threshold—and very high volume—exceeding one point five times the threshold—with the latter triggering background color changes to alert traders to exceptional participation levels. This tiered volume classification allows traders to calibrate their position sizing and conviction levels based on the strength of market participation supporting the signal.
The flow momentum calculation adds a velocity dimension to the volume analysis. By calculating the rate of change of the net flow EMA over a user-defined momentum length—defaulted to five bars—the indicator measures not just the direction of volume flow but the acceleration or deceleration of that flow. A positive and increasing flow momentum indicates that buying pressure is not only dominant but intensifying, which typically precedes significant upward price movements. Conversely, negative and decreasing flow momentum suggests selling pressure is building upon itself, often preceding breakdowns. The indicator even calculates a second derivative—the momentum of momentum, termed flow acceleration—which can identify very early turning points when the rate of change itself begins to shift, providing the most forward-looking signal available from this methodology.
The divergence detection system represents one of the most powerful features for identifying potential trend reversals and continuations. The indicator maintains separate tracking of price extremes and flow extremes over a lookback period defaulted to fourteen bars. A bearish divergence is identified when price makes a new high or equals the recent high, but the net flow EMA is significantly below its recent high—specifically less than eighty percent of that high—and is declining compared to its value at the divergence lookback distance. This pattern indicates that while price is pushing higher, the volume support for that movement is deteriorating, which frequently precedes reversals. Bullish divergences work inversely, identifying situations where price makes new lows without corresponding weakness in volume flow, suggesting that selling pressure is exhausted and a reversal higher is probable. These divergence signals are plotted as distinct diamond shapes on the indicator, making them visually prominent for trader attention.
The accumulation and distribution zone detection provides a longer-term context for understanding institutional positioning. The indicator uses the bars-since function to track consecutive periods where the net flow EMA has remained positive or negative. When buying pressure has persisted for at least five consecutive bars, average intensity exceeds zero point six indicating strong closes within bar ranges, and volume is elevated above the threshold, the indicator identifies an accumulation zone. These zones suggest that smart money is systematically building long positions across multiple bars despite potentially choppy or sideways price action. Distribution zones are identified through the inverse criteria, revealing periods when institutions are systematically exiting or building short positions. These zones are visualized through colored fills on the indicator pane, creating a backdrop that helps traders understand the broader volume flow context beyond individual bar signals.
The signal strength scoring system provides a quantitative measure of conviction for each buy or sell signal. Rather than treating all signals as equal, the indicator assigns point values to different signal components: twenty-five points for the buy flow EMA-SMA crossover, twenty-five points for the net flow EMA-SMA crossover, twenty points for high volume presence, fifteen points for positive flow momentum, and fifteen points for bullish divergence presence. These points are summed to create a buy score that can range from zero to one hundred percent, with higher scores indicating that multiple independent confirmation factors are aligned. The same methodology creates a sell score, and these scores are displayed in the information table, allowing traders to quickly assess whether a signal represents a tentative suggestion or a high-conviction setup. This scoring approach transforms the indicator from a binary signal generator into a nuanced probability assessment tool.
The visual presentation of the indicator demonstrates exceptional attention to user experience and information density. The primary display shows the net flow EMA as a thick colored line that transitions between green when above zero and above its SMA, indicating strong buying, to a lighter green when above zero but below the SMA, indicating weakening buying, to red when below zero and below the SMA, indicating strong selling, to a lighter red when below zero but above the SMA, indicating weakening selling. This color gradient provides immediate visual feedback about both direction and momentum of volume flows. The net flow SMA is overlaid in orange as a reference line, and a zero line is drawn to clearly delineate positive from negative territory. Behind these lines, a histogram representation of the raw net flow—scaled down by thirty percent for visibility—shows bar-by-bar flow with color intensity reflecting whether flow is strengthening or weakening compared to the previous bar. This layered visualization allows traders to simultaneously see the raw data, the smoothed trend, and the trend of the trend, accommodating both short-term and longer-term trading perspectives.
The cumulative delta line adds a macro perspective by maintaining a running sum of all volume deltas divided by one million for scale, plotted in purple as a separate series. This cumulative measure acts similar to an on-balance volume calculation but with the sophisticated volume attribution methodology of this indicator, creating a long-term sentiment gauge that can reveal whether an asset is under sustained accumulation or distribution across days, weeks, or months. Divergences between this cumulative delta and price can identify major trend exhaustion or reversal points that might not be visible in the shorter-term flow measurements.
The signal plotting uses shape-based markers rather than background colors or arrows to maximize clarity while preserving chart space. Strong buy signals—meeting multiple criteria including EMA-SMA crossover, high volume, and positive momentum—appear as full-size green triangle-up shapes at the bottom of the indicator pane. Strong sell signals appear as full-size red triangle-down shapes at the top. Regular buy and sell signals that meet fewer criteria appear as smaller, semi-transparent circles, indicating they warrant attention but lack the full confirmation of strong signals. Divergence-based signals appear as distinct diamond shapes in cyan for bullish divergences and orange for bearish divergences, ensuring these critical reversal indicators are immediately recognizable and don't get confused with momentum-based signals. This multi-tiered signal hierarchy helps traders prioritize their analysis and avoid signal overload.
The information table in the top-right corner of the indicator pane provides real-time quantitative feedback on all major calculation components. It displays the current bar's buy volume and sell volume in millions with appropriate color coding, the imbalance percentage with color indicating whether it exceeds the threshold, the average intensity score showing whether closes are generally near highs or lows, the flow momentum value, and the current buy and sell scores. This table transforms the indicator from a purely graphical tool into a quantitative dashboard, allowing discretionary traders to incorporate specific numerical thresholds into their decision frameworks. For example, a trader might require that buy score exceed seventy percent and intensity exceed zero point six-five before taking a long position, creating objective entry criteria from subjective chart reading.
The background shading that occurs during very high volume periods provides an ambient alert system that doesn't require focused attention on the indicator pane. When volume spikes to one point five times the threshold and net flow EMA is positive, a very light green background appears across the entire indicator pane; when volume spikes with negative net flow, a light red background appears. These backgrounds create a subliminal awareness of exceptional market participation moments, ensuring traders notice when the market is making important decisions even if they're focused on price action or other indicators at that moment.
The alert system built into the indicator allows traders to receive notifications for strong buy signals, strong sell signals, bullish divergences, bearish divergences, and very high volume events. These alerts can be configured in TradingView to send push notifications to mobile devices, emails, or webhook calls to automated trading systems. This functionality transforms the indicator from a passive analysis tool into an active monitoring system that can watch markets continuously and notify the trader only when significant volume flow developments occur. For traders monitoring multiple instruments, this alert capability is invaluable for efficient time allocation, allowing them to analyze other opportunities while being instantly notified when this indicator identifies high-probability setups on their watch list.
The coding implementation demonstrates advanced Pine Script techniques including the use of request.security_lower_tf to access intrabar data, array manipulation to process variable-length intrabar arrays, proper variable scoping with var keyword for persistent state management across bars, and efficient conditional logic that prevents unnecessary calculations. The code structure with clearly delineated sections for inputs, calculations, signal generation, plotting, and alerts makes it maintainable and educational for those studying Pine Script development. The use of input groups with custom headers creates an organized settings panel that doesn't overwhelm users with dozens of ungrouped parameters, while still providing substantial customization capability for advanced users who want to optimize the indicator for specific instruments or timeframes.
For practical trading application, this indicator excels in several specific use cases. Scalpers and day traders can use the intrabar analysis to identify accumulation or distribution happening within the bars of their entry timeframe, providing early entry signals before momentum indicators or price patterns complete. Swing traders can use the cumulative delta and accumulation-distribution zones to understand whether short-term pullbacks in an uptrend are being bought or sold, helping distinguish between healthy retracements and trend reversals. Position traders can use the divergence detection to identify major turning points where price extremes are not supported by volume, providing low-risk entry points for counter-trend positions or warnings to exit with-trend positions before significant reversals.
The indicator is particularly valuable in ranging markets where price-based indicators produce numerous false breakout signals. By requiring that breakouts be accompanied by volume flow imbalances, the indicator filters out failed breakouts driven by low participation. When price breaks a range boundary accompanied by a strong buy or sell signal with high buy or sell score and very high volume, the probability of successful breakout follow-through increases dramatically. Conversely, when price breaks a range but the indicator shows low imbalance, opposing flow direction, or low volume, traders can fade the breakout or at minimum avoid chasing it.
During trending markets, the indicator helps traders identify the healthiest entry points by revealing where pullbacks are being accumulated by smart money. A trending market will show the cumulative delta continuing in the trend direction even as price pulls back, and accumulation zones will form during these pullbacks. When price resumes the trend, the indicator will generate strong buy or sell signals with high scores, providing objective entry points with clear invalidation levels. The flow momentum component helps traders stay with trends longer by distinguishing between healthy momentum pauses—where momentum goes to zero but doesn't reverse—and actual momentum reversals where opposing pressure is building.
The VWAP deviation weighting adds particular value for traders of liquid instruments like major forex pairs, stock indices, and high-volume stocks where VWAP is widely watched by institutional participants. When price deviates significantly from the intrabar VWAP and volume flows in the direction of that deviation with elevated weighting, it indicates that the move away from fair value is being driven by conviction rather than mechanical order flow. This suggests the deviation will likely extend further, creating continuation trading opportunities. Conversely, when price deviates from intrabar VWAP but volume flow shows reduced intensity or opposing direction despite the weighting, it suggests the deviation will revert to VWAP, creating mean reversion opportunities.
The ATR normalization option makes the indicator values comparable across different volatility regimes and different instruments. Without normalization, a one-million share buy-sell imbalance might be significant for a low-volatility stock but trivial for a high-volatility cryptocurrency. By normalizing the delta by ATR, the indicator accounts for the typical price movement capacity of the instrument, making signal thresholds and comparison values meaningful across different trading contexts. This is particularly valuable for traders running the indicator on multiple instruments who want consistent signal quality regardless of the underlying instrument characteristics.
The configurable decay factor allows traders to adjust how persistent they want volume flows to remain influential. For very short-term scalping, a lower decay factor like zero point five will cause volume imbalances to dissipate quickly, keeping the indicator focused only on very recent flows. For longer-term position trading, a higher decay factor like zero point nine-five will allow significant volume events to influence the indicator for many bars, revealing longer-term accumulation and distribution patterns. This flexibility makes the single indicator adaptable to trading styles ranging from one-minute scalping to daily chart position trading simply by adjusting the decay parameter and the lookback bars.
The minimum imbalance percentage setting provides crucial noise filtering that can be optimized per instrument. Highly liquid instruments with tight spreads might show numerous small imbalances that are meaningless, requiring a higher threshold like thirty-five or forty percent to filter noise effectively. Thinly traded instruments might rarely show extreme imbalances, requiring a lower threshold like fifteen or twenty percent to generate adequate signals. By making this threshold user-configurable with a wide range, the indicator accommodates the full spectrum of market microstructure characteristics across different instruments and timeframes.
In conclusion, the Intrabar Volume Flow Intelligence indicator represents a comprehensive volume analysis system that combines intrabar data access, sophisticated volume attribution algorithms, multi-timeframe smoothing, statistical filtering, divergence detection, zone identification, and intelligent signal scoring into a cohesive analytical framework. It provides traders with visibility into market dynamics that are invisible to price-only analysis and even to conventional volume analysis, revealing the true intentions of market participants through their actual transaction behavior within each bar. The indicator's strength lies not in any single feature but in the integration of multiple analytical layers that confirm and validate each other, creating high-probability signal generation that can form the foundation of complete trading systems or provide powerful confirmation for discretionary analysis. For traders willing to invest time in understanding its components and optimizing its parameters for their specific instruments and timeframes, this indicator offers a significant informational advantage in increasingly competitive markets where edge is derived from seeing what others miss and acting on that information before it becomes consensus.
CVD Zones & Divergence [Pro]# CVD Zones & Divergence
**Complete CVD order flow toolkit** - Divergences, POC, Profile, and Supply/Demand zones all in one professional indicator.
## 🎯 What It Does
Combines **four powerful order flow tools** into a single, cohesive indicator:
1. **CVD Divergences** - Early warnings + confirmed signals
2. **Point of Control (POC)** - Fair value equilibrium line
3. **CVD Profile** - Visual distribution histogram
4. **Supply/Demand Zones** - Real absorption-based S/R levels
All based on **Cumulative Volume Delta (CVD)** - actual buying/selling pressure, not approximations.
## ✨ Key Features
### 🔄 CVD Divergences (Dual Mode)
**Confirmed Divergences** (High Accuracy)
- Solid lines (customizable colors)
- 🔻 Bear / 🔺 Bull labels
- Win rate: ~70-80%
- Best for swing traders
**Early Warning Mode** ⚡ (Fast Signals)
- Dashed lines (default purple)
- ⚠️ Early Bear / ⚠️ Early Bull labels
- Fires 6+ bars earlier
- Win rate: ~55-65%
- Best for scalpers/day traders
### 🎯 Point of Control (POC)
- **Independent lookback** (300 bars default)
- Yellow line showing fair value
- Where most CVD activity occurred
- Acts as dynamic support/resistance
- Resets and recalculates continuously
### 📊 CVD Profile Histogram
- **Visual CVD distribution** over lookback period
- **Split buy/sell** (blue/orange bars)
- **Value Area** (70% CVD zone highlighted)
- Position: Right/Left/Current (your choice)
- Shows where actual order flow happened
### 📦 Supply/Demand Zones
- **Absorption-based** detection (not guesses!)
- Green = Demand (buyers absorbed 2:1+)
- Red = Supply (sellers absorbed 2:1+)
- Shows **real** institutional levels
- Auto-sorted by strength
- Displays top 8 zones
## 📊 What You See on Chart
```
Your Chart:
├─ 🔴 Red lines (bearish divergences)
├─ 🟢 Green lines (bullish divergences)
├─ 🟣 Purple dashed (early warnings)
├─ 🟡 Yellow POC line (fair value)
├─ 📊 Blue/Orange profile (right side)
├─ 🟢 Green boxes (demand zones)
└─ 🔴 Red boxes (supply zones)
```
## ⚙️ Recommended Settings
### 15m Day Trading (Most Popular)
```
📊 Profile:
- Lookback: 150 bars
- Profile Rows: 24
- Position: Right
🎯 POC:
- POC Lookback: 300 bars
- Show POC: ON
📦 Zones:
- Min Absorption Ratio: 2.0
- HVN Threshold: 1.5
- Max Zones: 8
🔄 Divergences:
- Pivot L/R: 9
- Early Warning: ON
- Early Right Bars: 3
- Min Bars Between: 40
- Min CVD Diff: 5%
```
### 5m Scalping
```
Profile Lookback: 100
POC Lookback: 200
Pivot L/R: 7
Early Warning Right: 2
Min Bars Between: 60
```
### 1H Swing Trading
```
Profile Lookback: 200
POC Lookback: 400-500
Pivot L/R: 12-14
Early Warning Right: 4-5
Min Bars Between: 30
Min CVD Diff: 8%
```
## 💡 How to Trade
### Setup 1: Divergence at Zone ⭐ (BEST - 75%+ win rate)
**Entry:**
- Price hits demand/supply zone
- Divergence appears (early or confirmed)
- Double confluence = high probability
**Example (Long):**
```
1. Price drops into green demand zone
2. ⚠️ Early bullish divergence fires
3. Enter long with tight stop below zone
4. Target: POC or next supply zone
```
**Risk/Reward:** 1:3 to 1:5
---
### Setup 2: POC Bounce/Rejection
**Entry:**
- Price approaches POC line
- Wait for reaction (bounce or rejection)
- Enter in direction of reaction
**Long Setup:**
```
1. Price pulls back to POC from above
2. POC acts as support
3. Bullish divergence appears (confirmation)
4. Enter long, stop below POC
```
**Short Setup:**
```
1. Price rallies to POC from below
2. POC acts as resistance
3. Bearish divergence appears
4. Enter short, stop above POC
```
**Risk/Reward:** 1:2 to 1:4
---
### Setup 3: Zone + Profile Confluence
**Entry:**
- Supply/demand zone aligns with thick profile bar
- Shows high CVD activity at that level
- Triple confluence = very high probability
**Example:**
```
1. Supply zone at 26,100
2. Profile shows heavy selling at 26,100
3. Price rallies to 26,100
4. Bearish divergence appears
5. Enter short
```
**Risk/Reward:** 1:4 to 1:6
---
### Setup 4: Early Warning Scalp ⚡
**Entry (Aggressive):**
- ⚠️ Early warning fires
- Price at zone or POC
- Enter immediately
- Tight stop (1-2 ATR)
**Management:**
```
- Take 50% profit at 1:1
- Move stop to breakeven
- 🔻 Confirmed signal → Trail stop
- Exit rest at target
```
**Risk/Reward:** 1:1.5 to 1:2
**Trades/day:** 3-8
---
### Setup 5: Multi-Timeframe (Advanced)
**Confirmation Required:**
```
Higher TF (1H):
- Confirmed divergence
- At major POC or zone
Lower TF (15m):
- Early warning triggers
- Entry with better timing
```
**Benefits:**
- HTF gives direction
- LTF gives entry
- Best of both worlds
**Risk/Reward:** 1:3 to 1:5
---
## 📊 Component Details
### CVD Profile
**What the colors mean:**
- **Blue bars** = Buying CVD (demand)
- **Orange bars** = Selling CVD (supply)
- **Lighter shade** = Value Area (70% CVD)
- **Thicker bar** = More volume at that price
**How to use:**
- Thick bars = Support/Resistance
- Profile shape shows market structure
- Balanced profile = range
- Skewed profile = trend
---
### Supply/Demand Zones
**How they're detected:**
1. High Volume Node (1.5x average)
2. CVD buy/sell ratio calculated
3. Ratio ≥ 2.0 → Zone created
4. Sorted by strength (top 8 shown)
**Zone labels show:**
- Type: "Demand" or "Supply"
- Ratio: "2.8:1" = strength
**Not like other indicators:**
- ❌ Other tools use price action alone
- ✅ This uses actual CVD absorption
- Shows WHERE limit orders defended levels
---
### Point of Control (POC)
**What it shows:**
- Price with highest CVD activity
- Market's "fair value"
- Dynamic S/R level
**How to use:**
- Price above POC = bullish bias
- Price below POC = bearish bias
- POC retest = trading opportunity
- POC cross = trend change signal
**Independent lookback:**
- Profile: 150 bars (short-term)
- POC: 300 bars (longer-term context)
- Gives stable, relevant POC
---
## 🔧 Settings Explained
### 📊 Profile Settings
**Lookback Bars** (150 default)
- How many bars for profile calculation
- Lower = more recent, reactive
- Higher = more historical, stable
**Profile Rows** (24 default)
- Granularity of distribution
- Lower = coarser (faster)
- Higher = finer detail (slower)
**Profile Position**
- Right: After current price
- Left: Before lookback period
- Current: At lookback start
**Value Area** (70% default)
- Highlights main CVD concentration
- 70% is standard
- Higher % = wider zone
---
### 🎯 POC Settings
**POC Lookback** (300 default)
- Independent from profile
- Longer = more stable POC
- Shorter = more reactive POC
**Show POC Line/Label**
- Toggle visibility
- Customize color/width
---
### 📦 Zone Settings
**Min Absorption Ratio** (2.0 default)
- Buy/Sell threshold for zones
- 2.0 = 2:1 ratio minimum
- Higher = fewer, stronger zones
**HVN Threshold** (1.5 default)
- Volume must be 1.5x average
- Higher = stricter filtering
- Lower = more zones
**Max Zones** (8 default)
- Limits display clutter
- Shows strongest N zones only
---
### 🔄 Divergence Settings
**Pivot Left/Right** (9/9 default)
- Bars to confirm pivot
- Higher = slower, more confirmed
- Lower = faster, less confirmed
**Early Warning**
- ON = Show early signals
- Early Right Bars (3 default)
- 3 = 6 bars faster than confirmed
**Filters:**
- Min Bars Between (40): Prevents spam
- Min CVD Diff % (5): Filters weak signals
**Visual:**
- Line styles: Solid/Dashed/Dotted
- Colors: Customize all 4 types
- Labels: Toggle ON/OFF
---
## 🎨 Color Customization
**Divergences:**
- Bullish Confirmed: Green (default)
- Bearish Confirmed: Red (default)
- Early Bullish: Purple (default)
- Early Bearish: Purple (default)
**Zones & Profile:**
- Bull/Demand: Green
- Bear/Supply: Red
- Buy CVD Profile: Blue
- Sell CVD Profile: Orange
- Value Area Up/Down: Lighter blue/orange
**POC:**
- POC Color: Yellow (default)
All customizable to your preference!
---
## 🔔 Alerts Available
**6 Alert Types:**
1. 🔻 Bearish Divergence (confirmed)
2. 🔺 Bullish Divergence (confirmed)
3. ⚠️ Early Bearish Warning
4. ⚠️ Early Bullish Warning
5. (Manual: POC cross)
6. (Manual: Zone touch)
**Setup:**
1. Click Alert (⏰)
2. Choose "CVD Zones & Divergence"
3. Select alert type
4. Configure notification
5. Create!
---
## 💎 Pro Tips
### From Experienced Traders:
**"Use zones with divergences for best setups"**
- Zone alone: 60% win rate
- Divergence alone: 65% win rate
- Both together: 75%+ win rate
**"POC is your friend"**
- Price tends to revert to POC
- Great target for counter-trend trades
- POC cross = potential trend change
**"Profile tells the story"**
- Thick bars = institutional levels
- Balanced profile = range-bound
- Skewed high = distribution (top)
- Skewed low = accumulation (bottom)
**"Early warnings for entries, confirmed for confidence"**
- Early = better entry price
- Confirmed = validation
- Use both in scale-in strategy
**"Filter by timeframe"**
- 1m-5m: Very fast, many signals
- 15m: Sweet spot for most traders
- 1H-4H: High quality, fewer signals
---
## 🔧 Tuning Guide
### Too Cluttered?
**Simplify:**
```
✅ Show Divergences: ON
✅ Show POC: ON
❌ Show Zones: OFF (or reduce to 4-5)
❌ Show Value Area: OFF
❌ Divergence Labels: OFF
→ Clean chart with just lines + POC
```
### Missing Opportunities?
**More Signals:**
```
↓ Pivot Right: 6-7
↓ Early Warning Right: 2
↓ Min Bars Between: 25-30
↓ Min CVD Diff: 2-3%
↓ Min Absorption Ratio: 1.8
```
### Too Many False Signals?
**Stricter Filters:**
```
↑ Pivot Right: 12-15
↑ Min Bars Between: 60
↑ Min CVD Diff: 8-10%
↑ Min Absorption Ratio: 2.5
↓ Max Zones: 4-5
```
### POC Not Making Sense?
**Adjust POC Lookback:**
```
If too high: Increase to 400-500
If too low: Increase to 400-500
If jumping around: Increase to 500+
→ Longer lookback = more stable POC
```
---
## ❓ FAQ
**Q: Difference from CVD Divergence (standalone)?**
A: This is the **complete package**:
- Divergence tool = divergences only
- This = divergences + POC + profile + zones
- Use divergence tool for clean charts
- Use this for full analysis
**Q: Too slow/laggy?**
A: Reduce computational load:
```
Profile Rows: 18 (from 24)
Lookback: 100 (from 150)
Max Zones: 5 (from 8)
```
**Q: No volume data error?**
A: Symbol has no volume
- Works: Futures, stocks, crypto
- Maybe: Forex (broker-dependent)
- Doesn't work: Some forex pairs
**Q: Can I use just some features?**
A: Absolutely! Toggle what you want:
```
Zones only: Turn off divergences + POC
POC only: Turn off zones + divergences
Divergences only: Turn off zones + POC + profile
Mix and match as needed!
```
**Q: Best timeframe?**
A:
- **1m-5m**: Scalping (busy, many signals)
- **15m**: Day trading ⭐ (recommended)
- **1H-4H**: Swing trading (quality signals)
- **Daily**: Position trading (very selective)
**Q: Works on crypto/forex/stocks?**
A:
- ✅ Futures: Excellent
- ✅ Stocks: Excellent
- ✅ Crypto: Very good (major pairs)
- ⚠️ Forex: Depends on broker volume
---
## 📈 Performance Expectations
### Realistic Win Rates
| Strategy | Win Rate | Avg R/R | Trades/Week |
|----------|----------|---------|-------------|
| Early warnings only | 55-65% | 1:1.5 | 15-30 |
| Confirmed only | 70-80% | 1:2 | 8-15 |
| Divergence + Zone | 75-85% | 1:3 | 5-12 |
| Full confluence (all 4) | 80-90% | 1:4+ | 3-8 |
**Keys to success:**
- Don't trade every signal
- Wait for confluence
- Proper risk management
- Trade what you see, not what you think
---
## 🚀 Quick Start
**New User (5 minutes):**
1. ✅ Add to 15m chart
2. ✅ Default settings work well
3. ✅ Watch for 1 week (don't trade yet!)
4. ✅ Note which setups work best
5. ✅ Backtest on 50+ signals
6. ✅ Start with small size
7. ✅ Scale up slowly
**First Trade Checklist:**
- Divergence + Zone/POC = confluence
- Clear S/R level nearby
- Risk/reward minimum 1:2
- Position size = 1% risk max
- Stop loss placed
- Target identified
- Journal entry ready
---
## 📊 What Makes This Special?
**Most indicators:**
- Use RSI/MACD divergences (lagging)
- Guess at S/R zones (subjective)
- Don't show actual order flow
**This indicator:**
- Uses real CVD (actual volume delta)
- Absorption-based zones (real orders)
- Profile shows distribution (real activity)
- POC shows equilibrium (real fair value)
- All from one data source (coherent)
**Result:**
- Everything aligns
- No conflicting signals
- True order flow analysis
- Professional-grade toolkit
---
## 🎯 Trading Philosophy
**Remember:**
- Indicator shows you WHERE to look
- YOU decide whether to trade
- Quality over quantity always
- Risk management is #1
- Patience beats aggression
**Best trades have:**
- ✅ Multiple confluences
- ✅ Clear risk/reward
- ✅ Obvious invalidation point
- ✅ Aligned with trend/context
**Worst trades have:**
- ❌ Single signal only
- ❌ Poor location (middle of nowhere)
- ❌ Unclear stop placement
- ❌ Counter to all context
---
## ⚠️ Risk Disclaimer
**Important:**
- Past performance ≠ future results
- All trading involves risk
- Only risk what you can afford to lose
- This is a tool, not financial advice
- Use proper position sizing
- Keep a trading journal
- Consider professional advice
**Your responsibility:**
- Which setups to trade
- Position size
- Entry/exit timing
- Risk management
- Emotional control
**Success = Tool + Strategy + Discipline + Risk Management**
---
## 📝 Version History
**v1.0** - Current Release
- CVD divergences (confirmed + early warning)
- Point of Control (independent lookback)
- CVD profile histogram
- Supply/demand absorption zones
- Value area visualization
- 6 alert types
- Full customization
---
## 💬 Community
**Questions?** Drop a comment below
**Success story?** Share with the community
**Feature request?** Let me know
**Bug report?** Provide details in comments
---
**Happy Trading! 🚀📊**
*Professional order flow analysis in one indicator.*
**Like this?** ⭐ Follow for more quality tools!
Simple Candle Strategy# Candle Pattern Strategy - Pine Script V6
## Overview
A TradingView trading strategy script (Pine Script V6) that identifies candlestick patterns over a configurable lookback period and generates trading signals based on pattern recognition rules.
## Strategy Logic
The strategy analyzes the most recent N candlesticks (default: 5) and classifies their patterns into three categories, then generates buy/sell signals based on specific pattern combinations.
### Candlestick Pattern Classification
Each candlestick is classified as one of three types:
| Pattern | Definition | Formula |
|---------|-----------|---------|
| **Close at High** | Close price near the highest price of the candle | `(high - close) / (high - low) ≤ (1 - threshold)` |
| **Close at Low** | Close price near the lowest price of the candle | `(close - low) / (high - low) ≤ (1 - threshold)` |
| **Doji** | Opening and closing prices very close; long upper/lower wicks | `abs(close - open) / (high - low) ≤ threshold` |
### Trading Rules
| Condition | Action | Signal |
|-----------|--------|--------|
| Number of Doji candles ≥ 3 | **SKIP** - Market is too chaotic | No trade |
| "Close at High" count ≥ 2 + Last candle closes at high | **LONG** - Bullish confirmation | Buy Signal |
| "Close at Low" count ≥ 2 + Last candle closes at low | **SHORT** - Bearish confirmation | Sell Signal |
## Configuration Parameters
All parameters are adjustable in TradingView's "Settings/Inputs" tab:
| Parameter | Default | Range | Description |
|-----------|---------|-------|-------------|
| **K-line Lookback Period** | 5 | 3-20 | Number of candlesticks to analyze |
| **Doji Threshold** | 0.1 | 0.0-1.0 | Body size / Total range ratio for doji identification |
| **Doji Count Limit** | 3 | 1-10 | Number of dojis that triggers skip signal |
| **Close at High Proximity** | 0.9 | 0.5-1.0 | Required proximity to highest price (0.9 = 90%) |
| **Close at Low Proximity** | 0.9 | 0.5-1.0 | Required proximity to lowest price (0.9 = 90%) |
### Parameter Tuning Guide
#### Proximity Thresholds (Close at High/Low)
- **0.95 or higher**: Stricter - only very strong candles qualify
- **0.90 (default)**: Balanced - good for most market conditions
- **0.80 or lower**: Looser - catches more patterns, higher false signals
#### Doji Threshold
- **0.05-0.10**: Strict doji identification
- **0.10-0.15**: Standard doji detection
- **0.15+**: Includes near-doji patterns
#### Lookback Period
- **3-5 bars**: Fast, sensitive to recent patterns
- **5-10 bars**: Balanced approach
- **10-20 bars**: Slower, filters out noise
## Visual Indicators
### Chart Markers
- **Green Up Arrow** ▲: Long entry signal triggered
- **Red Down Arrow** ▼: Short entry signal triggered
- **Gray X**: Skip signal (too many dojis detected)
### Statistics Table
Located at top-right corner, displays real-time pattern counts:
- **Close at High**: Count of candles closing near the high
- **Close at Low**: Count of candles closing near the low
- **Doji**: Count of doji/near-doji patterns
### Signal Labels
- Green label: "✓ Long condition met" - below entry bar
- Red label: "✓ Short condition met" - above entry bar
- Gray label: "⊠ Too many dojis, skip" - trade skipped
## Risk Management
### Exit Strategy
The strategy includes built-in exit rules based on ATR (Average True Range):
- **Stop Loss**: ATR × 2
- **Take Profit**: ATR × 3
Example: If ATR is $10, stop loss is at -$20 and take profit is at +$30
### Position Sizing
Default: 100% of equity per trade (adjustable in strategy properties)
**Recommendation**: Reduce to 10-25% of equity for safer capital allocation
## How to Use
### 1. Copy the Script
1. Open TradingView
2. Go to Pine Script Editor
3. Create a new indicator
4. Copy the entire `candle_pattern_strategy.pine` content
5. Click "Add to Chart"
### 2. Apply to Chart
- Select your preferred timeframe (1m, 5m, 15m, 1h, 4h, 1d)
- Choose a trading symbol (stocks, forex, crypto, etc.)
- The strategy will generate signals on all historical bars and in real-time
### 3. Configure Parameters
1. Right-click the strategy on chart → "Settings"
2. Adjust parameters in the "Inputs" tab
3. Strategy will recalculate automatically
4. Backtest results appear in the Strategy Tester panel
### 4. Backtesting
1. Click "Strategy Tester" (bottom panel)
2. Set date range for historical testing
3. Review performance metrics:
- Win rate
- Profit factor
- Drawdown
- Total returns
## Key Features
✅ **Execution Model Compliant** - Follows official Pine Script V6 standards
✅ **Global Scope** - All historical references in global scope for consistency
✅ **Adjustable Sensitivity** - Fine-tune all pattern detection thresholds
✅ **Real-time Updates** - Works on both historical and real-time bars
✅ **Visual Feedback** - Clear signals with labels and statistics table
✅ **Risk Management** - Built-in ATR-based stop loss and take profit
✅ **No Repainting** - Signals remain consistent after bar closes
## Important Notes
### Before Trading Live
1. **Backtest thoroughly**: Test on at least 6-12 months of historical data
2. **Paper trading first**: Practice with simulated trades
3. **Optimize parameters**: Find the best settings for your trading instrument
4. **Manage risk**: Never risk more than 1-2% per trade
5. **Monitor performance**: Review trades regularly and adjust as needed
### Market Conditions
The strategy works best in:
- Trending markets with clear directional bias
- Range-bound markets with defined support/resistance
- Markets with moderate volatility
The strategy may underperform in:
- Highly choppy/noisy markets (many false signals)
- Markets with gaps or overnight gaps
- Low liquidity periods
### Limitations
- Works on chart timeframes only (not intrabar analysis)
- Requires at least 5 bars of history (configurable)
- Fixed exit rules may not suit all trading styles
- No trend filtering (will trade both directions)
## Technical Details
### Historical Buffer Management
The strategy declares maximum bars back to ensure enough historical data:
```pine
max_bars_back(close, 20)
max_bars_back(open, 20)
max_bars_back(high, 20)
max_bars_back(low, 20)
```
This prevents runtime errors when accessing historical candlestick data.
### Pattern Detection Algorithm
```
For each bar in lookback period:
1. Calculate (high - close) / (high - low) → close_to_high_ratio
2. If close_to_high_ratio ≤ (1 - threshold) → count as "Close at High"
3. Calculate (close - low) / (high - low) → close_to_low_ratio
4. If close_to_low_ratio ≤ (1 - threshold) → count as "Close at Low"
5. Calculate abs(close - open) / (high - low) → body_ratio
6. If body_ratio ≤ doji_threshold → count as "Doji"
Signal Generation:
7. If doji_count ≥ cross_count_limit → SKIP_SIGNAL
8. If close_at_high_count ≥ 2 AND last_close_at_high → LONG_SIGNAL
9. If close_at_low_count ≥ 2 AND last_close_at_low → SHORT_SIGNAL
```
## Example Scenarios
### Scenario 1: Bullish Signal
```
Last 5 bars pattern:
Bar 1: Closes at high (95%) ✓
Bar 2: Closes at high (92%) ✓
Bar 3: Closes at mid (50%)
Bar 4: Closes at low (10%)
Bar 5: Closes at high (96%) ✓ (last bar)
Result:
- Close at high count: 3 (≥ 2) ✓
- Last closes at high: ✓
- Doji count: 0 (< 3) ✓
→ LONG SIGNAL ✓
```
### Scenario 2: Skip Signal
```
Last 5 bars pattern:
Bar 1: Doji pattern ✓
Bar 2: Doji pattern ✓
Bar 3: Closes at mid
Bar 4: Doji pattern ✓
Bar 5: Closes at high
Result:
- Doji count: 3 (≥ 3)
→ SKIP SIGNAL - Market too chaotic
```
## Performance Optimization
### Tips for Better Results
1. **Use Higher Timeframes**: 15m or higher reduces false signals
2. **Combine with Indicators**: Add volume or trend filters
3. **Seasonal Adjustment**: Different parameters for different seasons
4. **Instrument Selection**: Test on liquid, high-volume instruments
5. **Regular Rebalancing**: Adjust parameters quarterly based on performance
## Troubleshooting
### No Signals Generated
- Check if lookback period is too large
- Verify proximity thresholds aren't too strict (try 0.85 instead of 0.95)
- Ensure doji limit allows for trading (try 4-5 instead of 3)
### Too Many False Signals
- Increase proximity thresholds to 0.95+
- Reduce lookback period to 3-4 bars
- Increase doji limit to 3-4
- Test on higher timeframes
### Strategy Tester Shows Losses
- Review individual trades to identify patterns
- Adjust stop loss and take profit ratios
- Change lookback period and thresholds
- Test on different market conditions
## References
- (www.tradingview.com)
- (www.tradingview.com)
- (www.investopedia.com)
- (www.investopedia.com)
## Disclaimer
**This strategy is provided for educational and research purposes only.**
- Not financial advice
- Past performance does not guarantee future results
- Always conduct thorough backtesting before live trading
- Trading involves significant risk of loss
- Use proper risk management and position sizing
## License
Created: December 15, 2025
Version: 1.0
---
**For updates and modifications, refer to the accompanying documentation files.**
PoC Migration Map [BackQuant]PoC Migration Map
A volume structure tool that builds a side volume profile, extracts rolling Points of Control (PoCs), and maps how those PoCs migrate through time so you can see where value is moving, how volume clusters shift, and how that aligns with trend regime.
What this is
This indicator combines a classic volume profile with a segmented PoC trail. It looks back over a configurable window, splits that window into bins by price, and shows you where volume has concentrated. On top of that, it slices the lookback into fixed bar segments, finds the local PoC in each segment, and plots those PoCs as a chain of nodes across the chart.
The result is a "migration map" of value:
A side volume profile that shows how volume is distributed over the recent price range.
A sequence of PoC nodes that show where local value has been accepted over time.
Lines that connect those PoCs to reveal the path of value migration.
Optional trend coloring based on EMA 12 and EMA 21, so each PoC also encodes trend regime.
Used together, this gives you a structural read on where the market has actually traded size, how "value" is moving, and whether that movement is aligned or fighting the current trend.
Core components
Lookback volume profile - a side histogram built from all closes and volumes in the chosen lookback window.
Segmented PoC trail - rolling PoCs computed over fixed bar segments, plotted as nodes in time.
Trend heatmap - optional color mapping of PoC nodes using EMA 12 versus EMA 21.
PoC labels - optional labels on every Nth PoC for easier reading and referencing.
How it works
1) Global lookback and binning
You choose:
Lookback Bars - how far back to collect data.
Number of Bins - how finely to split the price range.
The script:
Finds the highest high and lowest low in the lookback.
Computes the total price range and divides it into equal binCount slices.
Assigns each bar's close and volume into the appropriate price bin.
This creates a discretized volume distribution across the entire lookback.
2) Side volume profile
If "Show Side Profile" is enabled, a right-hand volume profile is drawn:
Each bin becomes a horizontal bar anchored at a configurable "Right Offset" from the current bar.
The horizontal width of each bar is proportional to that bin's volume relative to the maximum volume bin.
Optionally, volume values and percentages are printed inside the profile bars.
Color and transparency are controlled by:
Base Profile Color and its transparency.
A gradient that uses relative volume to modulate opacity between lower volume and higher volume bins.
Profile Width (%) - how wide the maximum bin can extend in bars.
This gives you an at-a-glance view of the volume landscape for the chosen lookback window.
3) Segmenting for PoC migration
To build the PoC trail, the lookback is divided into segments:
Bars per Segment - bars in each local cluster.
Number of Segments - how many segments you want to see back in time.
For each segment:
The script uses the same price bins and accumulates volume only from bars in that segment.
It finds the bin with the highest volume in that segment, which is the local PoC for that segment.
It sets the PoC price to the center of that bin.
It finds the "mid bar" of the segment and places the PoC node at that time on the chart.
This is repeated for each segment from older to newer, so you get a chain of PoCs that shows how local value has migrated over time.
4) Trend regime and color coding
The indicator precomputes:
EMA 12 (Fast).
EMA 21 (Slow).
For each PoC:
It samples EMA 12 and EMA 21 at the mid bar of that segment.
It computes a simple trend score as fast EMA minus slow EMA.
If trend heatmap is enabled, PoC nodes (and the lines between them) are colored by:
Trend Up Color if EMA 12 is above EMA 21.
Trend Down Color if EMA 12 is below EMA 21.
Trend Flat Color if they are roughly equal.
If the trend heatmap is disabled, PoC color is instead based on PoC migration:
If the current PoC is above the previous PoC, use the Up PoC Color.
If the current PoC is below the previous PoC, use the Down PoC Color.
If unchanged, use the Flat PoC Color.
5) Connecting PoCs and labels
Once PoC prices and times are known:
Each PoC is connected to the previous one with a dotted line, using the PoC's color.
Optional labels are placed next to every Nth PoC:
Label text uses a simple "PoC N" scheme.
Label background uses a configurable label background color.
Label border is colored by the PoC's own color for visual consistency.
This turns the PoCs into a visual path that can be read like a "value trajectory" across the chart.
What it plots
When fully enabled, you will see:
A right-sided volume profile for the chosen lookback window, built from volume by price.
Colored horizontal bars representing each price bin's relative volume.
Optional volume text showing each bin's volume and its percentage of the profile maximum.
A series of PoC nodes spaced across the chart at the mid point of each segment.
Dotted lines connecting those PoCs to show the migration path of value.
Optional PoC labels at each Nth node for easier reference.
Color-coding of PoCs and lines either by EMA 12 / 21 trend regime or by up/down PoC drift.
Reading PoC migration and market pressure
Side profile as a pressure map
The side profile shows where trading has been most active:
Thick, opaque bars represent high volume zones and possible high interest or acceptance areas.
Thin, faint bars represent low volume zones, potential rejection or transition areas.
When price trades near a high volume bin, the market is sitting on an area of prior acceptance and size.
When price moves quickly through low volume bins, it often does so with less friction.
This gives you a static map of where the market has been willing to do business within your lookback.
PoC trail as a value migration map
The PoC chain represents "where value has lived" over time:
An upward sloping PoC trail indicates value migrating higher. Buyers have been willing to transact at increasingly higher prices.
A downward sloping trail indicates value migrating lower and sellers pushing the center of mass down.
A flat or oscillating trail indicates balance or rotational behaviour, with no clear directional acceptance.
Taken together, you can interpret:
Side profile as "where the volume mass sits", a static pressure field.
PoC trail as "how that mass has moved", the dynamic path of value.
Trend heatmap as a regime overlay
When PoCs are colored by the EMA 12 / 21 spread:
Green PoCs mark segments where the faster EMA is above the slower EMA, that is, a local uptrend regime.
Red PoCs mark segments where the faster EMA is below the slower EMA, that is, a local downtrend regime.
Gray PoCs mark flat or ambiguous trend segments.
This lets you answer questions like:
"Is value migrating higher while the trend regime is also up?" (trend confirming value).
"Is value migrating higher but most PoCs are red?" (value against the prevailing trend).
"Has value started to roll over just as PoCs flip from green to red?" (early regime transition).
Key settings
General Settings
Lookback Bars - how many bars back to use for both the global volume profile and segment profiles.
Number of Bins - how many price bins to split the high to low range into.
Profile Settings
Show Side Profile - toggle the right-hand volume profile on or off.
Profile Width (%) - how wide the largest volume bar is allowed to be in terms of bars.
Base Profile Color - the starting color for profile bars, with transparency.
Show Volume Values - if enabled, print volume and percent for each non-zero bin.
Profile Text Color - color for volume text inside the profile.
PoC Migration Settings
Show PoC Migration - toggle the PoC trail plotting.
Bars per Segment - the number of bars contained in each segment.
Number of Segments - how many segments to build backwards from the current bar.
Horizontal Spacing (bars) - spacing between PoC nodes when drawn. (Used to separate PoCs horizontally.)
Label Every Nth PoC - draw labels at every Nth PoC (0 or 1 to suppress labels).
Right Offset (bars) - horizontal offset to anchor the side profile on the right.
Up PoC Color - color used when a PoC is higher than the previous one, if trend heatmap is off.
Down PoC Color - color used when a PoC is lower than the previous one, if trend heatmap is off.
Flat PoC Color - color used when the PoC is unchanged, if trend heatmap is off.
PoC Label Background - background color for PoC labels.
Trend Heatmap Settings
Color PoCs By Trend (EMA 12 / 21) - when enabled, overrides simple up/down coloring and uses EMA-based trend colors.
Fast EMA - length for the fast EMA.
Slow EMA - length for the slow EMA.
Trend Up Color - color for PoCs in a bullish EMA regime.
Trend Down Color - color for PoCs in a bearish EMA regime.
Trend Flat Color - color for neutral or flat EMA regimes.
Trading applications
1) Value migration and trend confirmation
Use the PoC path to see if value is following price or lagging it:
In a healthy uptrend, price, PoCs, and trend regime should all lean higher.
In a weakening trend, price may still move up, but PoCs flatten or start drifting lower, suggesting fewer participants are accepting the new highs.
In a downtrend, persistent downward PoC migration confirms that sellers are winning the value battle.
2) Identifying acceptance and rejection zones
Combine the side profile with PoC locations:
High volume bins near clustered PoCs mark strong acceptance zones, good areas to watch for re-tests and decision points.
PoCs that quickly jump across low volume areas can indicate rejection and fast repricing between value zones.
High volume zones with mixed PoC colors may signal balance or prolonged negotiation.
3) Structuring entries and exits
Use the map to refine trade location:
Fade trades against value migration are higher risk unless you see clear signs of exhaustion or regime change.
Pullbacks into prior PoC zones in the direction of the current PoC slope can offer higher quality entries.
Stops placed beyond major accepted zones (clusters of PoCs and high volume bins) are less likely to be hit by random noise.
4) Regime transitions
Watch how PoCs behave as the EMA regime changes:
A flip in EMA 12 versus EMA 21, coupled with a turn in PoC slope, is a strong signal that value is beginning to move with the new trend.
If EMAs flip but PoC migration does not follow, the trend signal may be early or false.
A weakening PoC path (lower highs in PoCs) while trend colors are still green can warn of a late-stage trend.
Best practices
Start with a moderate lookback such as 200 to 300 bars and a moderate bin count such as 20 to 40. Too many bins can make the profile overly granular and sparse.
Align "Bars per Segment" with your trading horizon. For example, 5 to 10 bars for intraday, 10 to 20 bars for swing.
Use the profile and PoC trail as structural context rather than as a direct buy or sell signal. Combine with your existing setups for timing.
Pay attention to clusters of PoCs at similar prices. Those are areas where the market has repeatedly accepted value, and they often matter on future tests.
Notes
This is a structural volume tool, not a complete trading system. It does not manage execution, position sizing or risk management. Use it to understand:
Where the bulk of trading has occurred in your chosen window.
How the center of volume has migrated over time.
Whether that migration is aligned with or fighting the current trend regime.
By turning PoC evolution into a visible path and adding a trend-aware heatmap, the PoC Migration Map makes it easier to see how value has been moving, where the market is likely to feel "heavy" or "light", and how that structure fits into your trading decisions.
SP500 Session Gap Fade StrategySummary in one paragraph
SPX Session Gap Fade is an intraday gap fade strategy for index futures, designed around regular cash sessions on five minute charts. It helps you participate only when there is a full overnight or pre session gap and a valid intraday session window, instead of trading every open. The original part is the gap distance engine which anchors both stop and optional target to the previous session reference close at a configurable flat time, so every trade’s risk scales with the actual gap size rather than a fixed tick stop.
Scope and intent
• Markets. Primarily index futures such as ES, NQ, YM, and liquid index CFDs that exhibit overnight gaps and regular cash hours.
• Timeframes. Intraday timeframes from one minute to fifteen minutes. Default usage is five minute bars.
• Default demo used in the publication. Symbol CME:ES1! on a five minute chart.
• Purpose. Provide a simple, transparent way to trade opening gaps with a session anchored risk model and forced flat exit so you are not holding into the last part of the session.
• Limits. This is a strategy. Orders are simulated on standard candles only.
Originality and usefulness
• Unique concept or fusion. The core novelty is the combination of a strict “full gap” entry condition with a session anchored reference close and a gap distance based TP and SL engine. The stop and optional target are symmetric multiples of the actual gap distance from the previous session’s flat close, rather than fixed ticks.
• Failure mode it addresses. Fixed sized stops do not scale when gaps are unusually small or unusually large, which can either under risk or over risk the account. The session flat logic also reduces the chance of holding residual positions into late session liquidity and news.
• Testability. All key pieces are explicit in the Inputs: session window, minutes before session end, whether to use gap exits, whether TP or SL are active, and whether to allow candle based closes and forced flat. You can toggle each component and see how it changes entries and exits.
• Portable yardstick. The main unit is the absolute price gap between the entry bar open and the previous session reference close. tp_mult and sl_mult are multiples of that gap, which makes the risk model portable across contracts and volatility regimes.
Method overview in plain language
The strategy first defines a trading session using exchange time, for example 08:30 to 15:30 for ES day hours. It also defines a “flat” time a fixed number of minutes before session end. At the flat bar, any open position is closed and the bar’s close price is stored as the reference close for the next session. Inside the session, the strategy looks for a full gap bar relative to the prior bar: a gap down where today’s high is below yesterday’s low, or a gap up where today’s low is above yesterday’s high. A full gap down generates a long entry; a full gap up generates a short entry. If the gap risk engine is enabled and a valid reference close exists, the strategy measures the distance between the entry bar open and that reference close. It then sets a stop and optional target as configurable multiples of that gap distance and manages them with strategy.exit. Additional exits can be triggered by a candle color flip or by the forced flat time.
Base measures
• Range basis. The main unit is the absolute difference between the current entry bar open and the stored reference close from the previous session flat bar. That value is used as a “gap unit” and scaled by tp_mult and sl_mult to build the target and stop.
Components
• Component one: Gap Direction. Detects full gap up or full gap down by comparing the current high and low to the previous bar’s high and low. Gap down signals a long fade, gap up signals a short fade. There is no smoothing; it is a strict structural condition.
• Component two: Session Window. Only allows entries when the current time is within the configured session window. It also defines a flat time before the session end where positions are forced flat and the reference close is updated.
• Component three: Gap Distance Risk Engine. Computes the absolute distance between the entry open and the stored reference close. The stop and optional target are placed as entry ± gap_distance × multiplier so that risk scales with gap size.
• Optional component: Candle Exit. If enabled, a bullish bar closes short positions and a bearish bar closes long positions, which can shorten holding time when price reverses quickly inside the session.
• Session windows. Session logic uses the exchange time of the chart symbol. When changing symbols or venues, verify that the session time string still matches the new instrument’s cash hours.
Fusion rule
All gates are hard conditions rather than weighted scores. A trade can only open if the session window is active and the full gap condition is true. The gap distance engine only activates if a valid reference close exists and use_gap_risk is on. TP and SL are controlled by separate booleans so you can use SL only, TP only, or both. Long and short are symmetric by construction: long trades fade full gap downs, short trades fade full gap ups with mirrored TP and SL logic.
Signal rule
• Long entry. Inside the active session, when the current bar shows a full gap down relative to the previous bar (current high below prior low), the strategy opens a long position. If the gap risk engine is active, it places a gap based stop below the entry and an optional target above it.
• Short entry. Inside the active session, when the current bar shows a full gap up relative to the previous bar (current low above prior high), the strategy opens a short position. If the gap risk engine is active, it places a gap based stop above the entry and an optional target below it.
• Forced flat. At the configured flat time before session end, any open position is closed and the close price of that bar becomes the new reference close for the following session.
• Candle based exit. If enabled, a bearish bar closes longs, and a bullish bar closes shorts, regardless of where TP or SL sit, as long as a position is open.
What you will see on the chart
• Markers on entry bars. Standard strategy entry markers labeled “long” and “short” on the gap bars where trades open.
• Exit markers. Standard exit markers on bars where either the gap stop or target are hit, or where a candle exit or forced flat close occurs. Exit IDs “long_gap” and “short_gap” label gap based exits.
• Reference levels. Horizontal lines for the current long TP, long SL, short TP, and short SL while a position is open and the gap engine is enabled. They update when a new trade opens and disappear when flat.
• Session background. This version does not add background shading for the session; session logic runs internally based on time.
• No on chart table. All decisions are visible through orders and exit levels. Use the Strategy Tester for performance metrics.
Inputs with guidance
Session Settings
• Trading session (sess). Session window in exchange time. Typical value uses the regular cash session for each contract, for example “0830-1530” for ES. Adjust if your broker or symbol uses different hours.
• Minutes before session end to force exit (flat_before_min). Minutes before the session end where positions are forced flat and the reference close is stored. Typical range is 15 to 120. Raising it closes trades earlier in the day; lowering it allows trades later in the session.
Gap Risk
• Enable gap based TP/SL (use_gap_risk). Master switch for the gap distance exit engine. Turning it off keeps entries and forced flat logic but removes automatic TP and SL placement.
• Use TP limit from gap (use_gap_tp). Enables gap based profit targets. Typical values are true for structured exits or false if you want to manage exits manually and only keep a stop.
• Use SL stop from gap (use_gap_sl). Enables gap based stop losses. This should normally remain true so that each trade has a defined initial risk in ticks.
• TP multiplier of gap distance (tp_mult). Multiplier applied to the gap distance for the target. Typical range is 0.5 to 2.0. Raising it places the target further away and reduces hit frequency.
• SL multiplier of gap distance (sl_mult). Multiplier applied to the gap distance for the stop. Typical range is 0.5 to 2.0. Raising it widens the stop and increases risk per trade; lowering it tightens the stop and may increase the number of small losses.
Exit Controls
• Exit with candle logic (use_candle_exit). If true, closes shorts on bullish candles and longs on bearish candles. Useful when you want to react to intraday reversal bars even if TP or SL have not been reached.
• Force flat before session end (use_forced_flat). If true, guarantees you are flat by the configured flat time and updates the reference close. Turn this off only if you understand the impact on overnight risk.
Filters
There is no separate trend or volatility filter in this version. All trades depend on the presence of a full gap bar inside the session. If you need extra filtering such as ATR, volume, or higher timeframe bias, they should be added explicitly and documented in your own fork.
Usage recipes
Intraday conservative gap fade
• Timeframe. Five minute chart on ES regular session.
• Gap risk. use_gap_risk = true, use_gap_tp = true, use_gap_sl = true.
• Multipliers. tp_mult around 0.7 to 1.0 and sl_mult around 1.0.
• Exits. use_candle_exit = false, use_forced_flat = true. Focus on the structured TP and SL around the gap.
Intraday aggressive gap fade
• Timeframe. Five minute chart.
• Gap risk. use_gap_risk = true, use_gap_tp = false, use_gap_sl = true.
• Multipliers. sl_mult around 0.7 to 1.0.
• Exits. use_candle_exit = true, use_forced_flat = true. Entries fade full gaps, stops are tight, and candle color flips flatten trades early.
Higher timeframe gap tests
• Timeframe. Fifteen minute or sixty minute charts on instruments with regular gaps.
• Gap risk. Keep use_gap_risk = true. Consider slightly higher sl_mult if gaps are structurally wider on the higher timeframe.
• Note. Expect fewer trades and be careful with sample size; multi year data is recommended.
Properties visible in this publication
• On average our risk for each position over the last 200 trades is 0.4% with a max intraday loss of 1.5% of the total equity in this case of 100k $ with 1 contract ES. For other assets, recalculations and customizations has to be applied.
• Initial capital. 100 000.
• Base currency. USD.
• Default order size method. Fixed with size 1 contract.
• Pyramiding. 0.
• Commission. Flat 2 USD per order in the Strategy Tester Properties. (2$ buying + 2$selling)
• Slippage. One tick in the Strategy Tester Properties.
• Process orders on close. ON.
Realism and responsible publication
• No performance claims are made. Past results do not guarantee future outcomes.
• Costs use a realistic flat commission and one tick of slippage per trade for ES class futures.
• Default sizing with one contract on a 100 000 reference account targets modest per trade risk. In practice, extreme slippage or gap through events can exceed this, so treat the one and a half percent risk target as a design goal, not a guarantee.
• All orders are simulated on standard candles. Shapes can move while a bar is forming and settle on bar close.
Honest limitations and failure modes
• Economic releases, thin liquidity, and limit conditions can break the assumptions behind the simple gap model and lead to slippage or skipped fills.
• Symbols with very frequent or very large gaps may require adjusted multipliers or alternative risk handling, especially in high volatility regimes.
• Very quiet periods without clean gaps will produce few or no trades. This is expected behavior, not a bug.
• Session windows follow the exchange time of the chart. Always confirm that the configured session matches the symbol.
• When both the stop and target lie inside the same bar’s range, the TradingView engine decides which is hit first based on its internal intrabar assumptions. Without bar magnifier, tie handling is approximate.
Legal
Education and research only. This strategy is not investment advice. You remain responsible for all trading decisions. Always test on historical data and in simulation with realistic costs before considering any live use.
Sigma Trinity ModelAbstract
Sigma Trinity Model is an educational framework that studies how three layers of market behavior interact within the same trend: (1) structural momentum (Rasta), (2) internal strength (RSI), and (3) continuation/compounding structure (Pyramid). The model deliberately combines bar-close momentum logic with intrabar, wick-aware strength checks to help users see how reversals form, confirm, and extend. It is not a signal service or automation tool; it is a transparent learning instrument for chart study and backtesting.
Why this is not “just a mashup”
Many scripts merge indicators without explaining the purpose. Sigma Trinity is a coordinated, three-engine study designed for a specific learning goal:
Rasta (structure): defines when momentum actually flips using a dual-line EMA vs smoothed EMA. It gives the entry/exit framework on bar close for clean historical study.
RSI (energy): measures internal strength with wick-aware triggers. It uses RSI of LOW (for bottom touches/reclaims) and RSI of HIGH (for top touches/exhaustion) so users can see intrabar strength/weakness that the close can hide.
Pyramid (progression): demonstrates how continuation behaves once momentum and strength align. It shows the logic of adds (compounding) as a didactic layer, also on bar close to keep historical alignment consistent.
These three roles are complementary, not redundant: structure → strength → progression.
Architecture Overview
Execution model
Rasta & Pyramid: bar close only by default (historically stable, easy to audit).
RSI: per tick (realtime) with bar-close backup by default, using RSI of LOW for entries and RSI of HIGH for exits. This makes the module sensitive to intra-bar wicks while still giving a close-based safety net for backtests.
Stops (optional in strategy builds): wick-accurate: trail arms/ratchets on HIGH; stop hit checks with LOW (or Close if selected) with a small undershoot buffer to avoid micro-noise hits.
Visual model
Dual lines (EMA vs smoothed EMA) for Rasta + color fog to see direction and compression/expansion.
Rungs (small vertical lines) drawn between the two Rasta lines to visualize wave spacing and rhythm.
Clean labels for Entry/Exit/Pyramid Add/RSI events. Everything is state-locked to avoid spamming.
Module 1 — Rasta (Structural Momentum Layer)
Goal: Identify structural momentum reversals and maintain a consistent, replayable backbone for study.
Method:
Compute an EMA of a chosen price source (default Close), and a smoothed version (SMA/EMA/RMA/WMA/None selectable).
Flip points occur when the EMA line crosses the smoothed line.
Optional EMA 8/21 trend filter can gate entries (long-bias when EMA8 > EMA21). A small “adaptive on flip” option lets an entry fire when the filter itself flips to ON and the EMA is already above the smoothed line—useful for trend resumption.
Why bar close only?
Bar-close Rasta gives a stable, auditable timeline for the structure of the trend. It teaches users to separate “structure” (close-resolved) from “energy” (intrabar, via RSI).
Visuals:
Fog between the lines (green/red) to show regime.
Rungs between lines to show spread (compression vs expansion).
Optional plotting of EMA8/EMA21 so users can see the gating effect.
Module 2 — RSI (Internal Strength / Energy Layer)
Goal: Reveal the intrabar strength/weakness that often precedes or confirms structural flips.
Method:
Standard RSI with adjustable length and signal smoothing for the panel view.
Logic uses wick-aware sources:
Entry trigger: RSI of LOW (same RSI length) touching or below a lower band (default 15). Think of it as intraband reactivation from the bottom, using the candle’s deepest excursion.
Exit trigger: RSI of HIGH touching or above an upper band (default 85). Think of it as exhaustion at the top, using the candle’s highest excursion.
Realtime + Close Backup: fires intrabar on tick, but if the realtime event was missed, the close backup will note it at bar end.
Cooldown control: optional bars-between-signals to avoid rapid re-triggers on choppy sequences.
Why wick-aware RSI?
A close-only RSI can miss the true micro-extremes that cause reversals. Using LOW/HIGH for triggers captures the behavior that traders actually react to during the bar, while the bar-close backup preserves historical reproducibility.
Module 3 — Pyramid (Continuation / Compounding Layer)
Goal: Teach how continuation behaves once a trend is underway, and how adds can be structured.
Method:
Same dual-line logic as Rasta (EMA vs smoothed EMA), but only fires when already in a position (or after prior entry conditions).
Supports the same EMA 8/21 filter and optional adaptive-on-flip behavior.
Bar close only to maintain historical cohesion.
What it teaches:
Adds tend to cluster when momentum persists.
Students can experiment with add spacing and compare “one-shot entries” vs “laddered adds” during strong regimes.
How the Pieces Work Together
Rasta establishes the structural frame (when the wave flip is real enough to record at close).
RSI validates or challenges that structure by tracking intrabar energy at the extremes (low/high touches).
Pyramid shows what sustained continuation looks like once (1) and (2) align.
This produces a layered view: Structure → Energy → Progression. Users can see when all three line up (strongest phases) and when they diverge (riskier phases or transitions).
How to Use It (Step-by-Step)
Quick Start
Apply script to any symbol/timeframe.
In Strategy/Indicator Properties:
Enable On every tick (recommended).
If available, enable Using bar magnifier and choose a lower resolution (e.g., 1m) to simulate intrabar fills more realistically.
Keep On bar close unchecked if you want to observe realtime logic in live charts (strategies still place orders on close by platform design).
Default behavior: Rasta & Pyramid = bar close; RSI = per tick with close backup.
Reading the Chart
Watch for Rasta Entry/Exit labels: they define clean structural turns on close.
Watch RSI Entry (LOW touch at/below lower band) and RSI Exit (HIGH touch at/above upper band) to gauge internal energy extremes.
Pyramid Add labels reveal continuation phases once a move is already in progress.
Tuning
Rasta smoothing: choose SMA/EMA/RMA/WMA or None. Higher smoothing → later but cleaner flips; lower smoothing → earlier but choppier.
RSI bands: a common educational setting is 15/85 for strong extremes; 20/80 is a bit looser.
Cooldown: increase if you see too many RSI re-fires in chop.
EMA 8/21 filter: toggle ON to study “trend-gated” entries, OFF to study raw momentum flips.
Backtesting Notes (for Strategy Builds)
Stops (optional): trail is armed when price advances by a trigger (default D–F₀), ratchets only upward from HIGH, and hits from LOW (or Close if chosen) with a tiny undershoot buffer to avoid micro-wicks.
Order sequencing per bar (mirrors the script’s code comments):
Trail ratchet via HIGH
Intrabar stop hit via LOW/CLOSE → immediate close
If still in position at bar close: process exits (Rasta/RSI)
If still in position at bar close: process Pyramid Add
If flat at bar close: process entries (Rasta/RSI)
Platform reality: strategies place orders at bar close in historical testing; the intrabar logic improves realism for stops and event marking but final order timestamps are still close-resolved.
Inputs Reference (common)
Modules: enable/disable RSI and Pyramid learning layers.
Rasta: EMA length, smoothing type/length, EMA8/21 filter & adaptive flip, fog opacity, rungs on/off & limit.
RSI: RSI length, signal MA length (panel), Entry band (LOW), Exit band (HIGH), cooldown bars, labels.
Pyramid: EMA length, smoothing, EMA8/21 filter & adaptive adds.
Execution: toggle Bar Close Only for Rasta/Pyramid; toggle Realtime + Close Backup for RSI.
Stops (strategy): Fixed Stop % (first), Fixed Stop % (add), Trail Distance %, Trigger rule (auto D–F₀ or custom), undershoot buffer %, and hit source (LOW/CLOSE).
What to Study With It
Convergence: how often RSI-LOW entry touches precede the next Rasta flip.
Divergence: cases where RSI screams exhaustion (HIGH >= upper band) but Rasta hasn’t flipped yet—often transition zones.
Continuation: how Pyramid adds cluster in strong moves; how spacing changes with smoothing/filter choices.
Regime changes: use EMA8/21 filter toggles to see what happens at macro turns vs chop.
Limitations & Scope
This is a learning tool, not a trade copier. It does not provide financial advice or automated execution.
Intrabar results depend on data granularity; bar magnifier (when available) can help simulate lower-resolution ticks, but true tick-by-tick fills are a platform-level feature and not guaranteed across all symbols.
Suggested Publication Settings (Strategy)
Initial capital: 100
Order size: 100 USD (cash)
Pyramiding: 10
Commission: 0.25%
Slippage: 3 ticks
Recalculate: ✓ On every tick
Fill orders: ✓ Using bar magnifier (choose 1m or similar); leave On bar close unchecked for live viewing.
Educational License
Released under the Michael Culpepper Gratitude License (2025).
Use and modify freely for education and research with attribution. No resale. No promises of profitability. Purpose is understanding, not signals.
LibWghtLibrary "LibWght"
This is a library of mathematical and statistical functions
designed for quantitative analysis in Pine Script. Its core
principle is the integration of a custom weighting series
(e.g., volume) into a wide array of standard technical
analysis calculations.
Key Capabilities:
1. **Universal Weighting:** All exported functions accept a `weight`
parameter. This allows standard calculations (like moving
averages, RSI, and standard deviation) to be influenced by an
external data series, such as volume or tick count.
2. **Weighted Averages and Indicators:** Includes a comprehensive
collection of weighted functions:
- **Moving Averages:** `wSma`, `wEma`, `wWma`, `wRma` (Wilder's),
`wHma` (Hull), and `wLSma` (Least Squares / Linear Regression).
- **Oscillators & Ranges:** `wRsi`, `wAtr` (Average True Range),
`wTr` (True Range), and `wR` (High-Low Range).
3. **Volatility Decomposition:** Provides functions to decompose
total variance into distinct components for market analysis.
- **Two-Way Decomposition (`wTotVar`):** Separates variance into
**between-bar** (directional) and **within-bar** (noise)
components.
- **Three-Way Decomposition (`wLRTotVar`):** Decomposes variance
relative to a linear regression into **Trend** (explained by
the LR slope), **Residual** (mean-reversion around the
LR line), and **Within-Bar** (noise) components.
- **Local Volatility (`wLRLocTotStdDev`):** Measures the total
"noise" (within-bar + residual) around the trend line.
4. **Weighted Statistics and Regression:** Provides a robust
function for Weighted Linear Regression (`wLinReg`) and a
full suite of related statistical measures:
- **Between-Bar Stats:** `wBtwVar`, `wBtwStdDev`, `wBtwStdErr`.
- **Residual Stats:** `wResVar`, `wResStdDev`, `wResStdErr`.
5. **Fallback Mechanism:** All functions are designed for reliability.
If the total weight over the lookback period is zero (e.g., in
a no-volume period), the algorithms automatically fall back to
their unweighted, uniform-weight equivalents (e.g., `wSma`
becomes a standard `ta.sma`), preventing errors and ensuring
continuous calculation.
---
**DISCLAIMER**
This library is provided "AS IS" and for informational and
educational purposes only. It does not constitute financial,
investment, or trading advice.
The author assumes no liability for any errors, inaccuracies,
or omissions in the code. Using this library to build
trading indicators or strategies is entirely at your own risk.
As a developer using this library, you are solely responsible
for the rigorous testing, validation, and performance of any
scripts you create based on these functions. The author shall
not be held liable for any financial losses incurred directly
or indirectly from the use of this library or any scripts
derived from it.
wSma(source, weight, length)
Weighted Simple Moving Average (linear kernel).
Parameters:
source (float) : series float Data to average.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 1.
Returns: series float Linear-kernel weighted mean; falls back to
the arithmetic mean if Σweight = 0.
wEma(source, weight, length)
Weighted EMA (exponential kernel).
Parameters:
source (float) : series float Data to average.
weight (float) : series float Weight series.
length (simple int) : simple int Look-back length ≥ 1.
Returns: series float Exponential-kernel weighted mean; falls
back to classic EMA if Σweight = 0.
wWma(source, weight, length)
Weighted WMA (linear kernel).
Parameters:
source (float) : series float Data to average.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 1.
Returns: series float Linear-kernel weighted mean; falls back to
classic WMA if Σweight = 0.
wRma(source, weight, length)
Weighted RMA (Wilder kernel, α = 1/len).
Parameters:
source (float) : series float Data to average.
weight (float) : series float Weight series.
length (simple int) : simple int Look-back length ≥ 1.
Returns: series float Wilder-kernel weighted mean; falls back to
classic RMA if Σweight = 0.
wHma(source, weight, length)
Weighted HMA (linear kernel).
Parameters:
source (float) : series float Data to average.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 1.
Returns: series float Linear-kernel weighted mean; falls back to
classic HMA if Σweight = 0.
wRsi(source, weight, length)
Weighted Relative Strength Index.
Parameters:
source (float) : series float Price series.
weight (float) : series float Weight series.
length (simple int) : simple int Look-back length ≥ 1.
Returns: series float Weighted RSI; uniform if Σw = 0.
wAtr(tr, weight, length)
Weighted ATR (Average True Range).
Implemented as WRMA on *true range*.
Parameters:
tr (float) : series float True Range series.
weight (float) : series float Weight series.
length (simple int) : simple int Look-back length ≥ 1.
Returns: series float Weighted ATR; uniform weights if Σw = 0.
wTr(tr, weight, length)
Weighted True Range over a window.
Parameters:
tr (float) : series float True Range series.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 1.
Returns: series float Weighted mean of TR; uniform if Σw = 0.
wR(r, weight, length)
Weighted High-Low Range over a window.
Parameters:
r (float) : series float High-Low per bar.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 1.
Returns: series float Weighted mean of range; uniform if Σw = 0.
wBtwVar(source, weight, length, biased)
Weighted Between Variance (biased/unbiased).
Parameters:
source (float) : series float Data series.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population (biased); false → sample.
Returns:
variance series float The calculated between-bar variance (σ²btw), either biased or unbiased.
sumW series float The sum of weights over the lookback period (Σw).
sumW2 series float The sum of squared weights over the lookback period (Σw²).
wBtwStdDev(source, weight, length, biased)
Weighted Between Standard Deviation.
Parameters:
source (float) : series float Data series.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population (biased); false → sample.
Returns: series float σbtw uniform if Σw = 0.
wBtwStdErr(source, weight, length, biased)
Weighted Between Standard Error.
Parameters:
source (float) : series float Data series.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population (biased); false → sample.
Returns: series float √(σ²btw / N_eff) uniform if Σw = 0.
wTotVar(mu, sigma, weight, length, biased)
Weighted Total Variance (= between-group + within-group).
Useful when each bar represents an aggregate with its own
mean* and pre-estimated σ (e.g., second-level ranges inside a
1-minute bar). Assumes the *weight* series applies to both the
group means and their σ estimates.
Parameters:
mu (float) : series float Group means (e.g., HL2 of 1-second bars).
sigma (float) : series float Pre-estimated σ of each group (same basis).
weight (float) : series float Weight series (volume, ticks, …).
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population (biased); false → sample.
Returns:
varBtw series float The between-bar variance component (σ²btw).
varWtn series float The within-bar variance component (σ²wtn).
sumW series float The sum of weights over the lookback period (Σw).
sumW2 series float The sum of squared weights over the lookback period (Σw²).
wTotStdDev(mu, sigma, weight, length, biased)
Weighted Total Standard Deviation.
Parameters:
mu (float) : series float Group means (e.g., HL2 of 1-second bars).
sigma (float) : series float Pre-estimated σ of each group (same basis).
weight (float) : series float Weight series (volume, ticks, …).
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population (biased); false → sample.
Returns: series float σtot.
wTotStdErr(mu, sigma, weight, length, biased)
Weighted Total Standard Error.
SE = √( total variance / N_eff ) with the same effective sample
size logic as `wster()`.
Parameters:
mu (float) : series float Group means (e.g., HL2 of 1-second bars).
sigma (float) : series float Pre-estimated σ of each group (same basis).
weight (float) : series float Weight series (volume, ticks, …).
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population (biased); false → sample.
Returns: series float √(σ²tot / N_eff).
wLinReg(source, weight, length)
Weighted Linear Regression.
Parameters:
source (float) : series float Data series.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 2.
Returns:
mid series float The estimated value of the regression line at the most recent bar.
slope series float The slope of the regression line.
intercept series float The intercept of the regression line.
wResVar(source, weight, midLine, slope, length, biased)
Weighted Residual Variance.
linear regression – optionally biased (population) or
unbiased (sample).
Parameters:
source (float) : series float Data series.
weight (float) : series float Weighting series (volume, etc.).
midLine (float) : series float Regression value at the last bar.
slope (float) : series float Slope per bar.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population variance (σ²_P), denominator ≈ N_eff.
false → sample variance (σ²_S), denominator ≈ N_eff - 2.
(Adjusts for 2 degrees of freedom lost to the regression).
Returns:
variance series float The calculated residual variance (σ²res), either biased or unbiased.
sumW series float The sum of weights over the lookback period (Σw).
sumW2 series float The sum of squared weights over the lookback period (Σw²).
wResStdDev(source, weight, midLine, slope, length, biased)
Weighted Residual Standard Deviation.
Parameters:
source (float) : series float Data series.
weight (float) : series float Weight series.
midLine (float) : series float Regression value at the last bar.
slope (float) : series float Slope per bar.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population (biased); false → sample.
Returns: series float σres; uniform if Σw = 0.
wResStdErr(source, weight, midLine, slope, length, biased)
Weighted Residual Standard Error.
Parameters:
source (float) : series float Data series.
weight (float) : series float Weight series.
midLine (float) : series float Regression value at the last bar.
slope (float) : series float Slope per bar.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population (biased); false → sample.
Returns: series float √(σ²res / N_eff); uniform if Σw = 0.
wLRTotVar(mu, sigma, weight, midLine, slope, length, biased)
Weighted Linear-Regression Total Variance **around the
window’s weighted mean μ**.
σ²_tot = E_w ⟶ *within-group variance*
+ Var_w ⟶ *residual variance*
+ Var_w ⟶ *trend variance*
where each bar i in the look-back window contributes
m_i = *mean* (e.g. 1-sec HL2)
σ_i = *sigma* (pre-estimated intrabar σ)
w_i = *weight* (volume, ticks, …)
ŷ_i = b₀ + b₁·x (value of the weighted LR line)
r_i = m_i − ŷ_i (orthogonal residual)
Parameters:
mu (float) : series float Per-bar mean m_i.
sigma (float) : series float Pre-estimated σ_i of each bar.
weight (float) : series float Weight series w_i (≥ 0).
midLine (float) : series float Regression value at the latest bar (ŷₙ₋₁).
slope (float) : series float Slope b₁ of the regression line.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population; false → sample.
Returns:
varRes series float The residual variance component (σ²res).
varWtn series float The within-bar variance component (σ²wtn).
varTrd series float The trend variance component (σ²trd), explained by the linear regression.
sumW series float The sum of weights over the lookback period (Σw).
sumW2 series float The sum of squared weights over the lookback period (Σw²).
wLRTotStdDev(mu, sigma, weight, midLine, slope, length, biased)
Weighted Linear-Regression Total Standard Deviation.
Parameters:
mu (float) : series float Per-bar mean m_i.
sigma (float) : series float Pre-estimated σ_i of each bar.
weight (float) : series float Weight series w_i (≥ 0).
midLine (float) : series float Regression value at the latest bar (ŷₙ₋₁).
slope (float) : series float Slope b₁ of the regression line.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population; false → sample.
Returns: series float √(σ²tot).
wLRTotStdErr(mu, sigma, weight, midLine, slope, length, biased)
Weighted Linear-Regression Total Standard Error.
SE = √( σ²_tot / N_eff ) with N_eff = Σw² / Σw² (like in wster()).
Parameters:
mu (float) : series float Per-bar mean m_i.
sigma (float) : series float Pre-estimated σ_i of each bar.
weight (float) : series float Weight series w_i (≥ 0).
midLine (float) : series float Regression value at the latest bar (ŷₙ₋₁).
slope (float) : series float Slope b₁ of the regression line.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population; false → sample.
Returns: series float √((σ²res, σ²wtn, σ²trd) / N_eff).
wLRLocTotStdDev(mu, sigma, weight, midLine, slope, length, biased)
Weighted Linear-Regression Local Total Standard Deviation.
Measures the total "noise" (within-bar + residual) around the trend.
Parameters:
mu (float) : series float Per-bar mean m_i.
sigma (float) : series float Pre-estimated σ_i of each bar.
weight (float) : series float Weight series w_i (≥ 0).
midLine (float) : series float Regression value at the latest bar (ŷₙ₋₁).
slope (float) : series float Slope b₁ of the regression line.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population; false → sample.
Returns: series float √(σ²wtn + σ²res).
wLRLocTotStdErr(mu, sigma, weight, midLine, slope, length, biased)
Weighted Linear-Regression Local Total Standard Error.
Parameters:
mu (float) : series float Per-bar mean m_i.
sigma (float) : series float Pre-estimated σ_i of each bar.
weight (float) : series float Weight series w_i (≥ 0).
midLine (float) : series float Regression value at the latest bar (ŷₙ₋₁).
slope (float) : series float Slope b₁ of the regression line.
length (int) : series int Look-back length ≥ 2.
biased (bool) : series bool true → population; false → sample.
Returns: series float √((σ²wtn + σ²res) / N_eff).
wLSma(source, weight, length)
Weighted Least Square Moving Average.
Parameters:
source (float) : series float Data series.
weight (float) : series float Weight series.
length (int) : series int Look-back length ≥ 2.
Returns: series float Least square weighted mean. Falls back
to unweighted regression if Σw = 0.
