3-Bar-Reversal-Pattern Strategy This startegy based on 3-day pattern reversal described in "Are Three-Bar
Patterns Reliable For Stocks" article by Thomas Bulkowski, presented in
January,2000 issue of Stocks&Commodities magazine.
That pattern conforms to the following rules:
- It uses daily prices, not intraday or weekly prices;
- The middle day of the three-day pattern has the lowest low of the three days, with no ties allowed;
- The last day must have a close above the prior day's high, with no ties allowed;
- Each day must have a nonzero trading range.
Tìm kiếm tập lệnh với "bar"
Bar Index & TimeLibrary to convert a bar index to a timestamp and vice versa.
Utilizes runtime memory to store the 𝚝𝚒𝚖𝚎 and 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 values of every bar on the chart (and optional future bars), with the ability of storing additional custom values for every chart bar.
█ PREFACE
This library aims to tackle some problems that pine coders (from beginners to advanced) often come across, such as:
I'm trying to draw an object with a 𝚋𝚊𝚛_𝚒𝚗𝚍𝚎𝚡 that is more than 10,000 bars into the past, but this causes my script to fail. How can I convert the 𝚋𝚊𝚛_𝚒𝚗𝚍𝚎𝚡 to a UNIX time so that I can draw visuals using xloc.bar_time ?
I have a diagonal line drawing and I want to get the "y" value at a specific time, but line.get_price() only accepts a bar index value. How can I convert the timestamp into a bar index value so that I can still use this function?
I want to get a previous 𝚘𝚙𝚎𝚗 value that occurred at a specific timestamp. How can I convert the timestamp into a historical offset so that I can use 𝚘𝚙𝚎𝚗 ?
I want to reference a very old value for a variable. How can I access a previous value that is older than the maximum historical buffer size of 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎 ?
This library can solve the above problems (and many more) with the addition of a few lines of code, rather than requiring the coder to refactor their script to accommodate the limitations.
█ OVERVIEW
The core functionality provided is conversion between xloc.bar_index and xloc.bar_time values.
The main component of the library is the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object, created via the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function which basically stores the 𝚝𝚒𝚖𝚎 and 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 of every bar on the chart, and there are 3 more overloads to this function that allow collecting and storing additional data. Once a 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object is created, use any of the exported methods:
Methods to convert a UNIX timestamp into a bar index or bar offset:
𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚐𝚎𝚝𝙽𝚞𝚖𝚋𝚎𝚛𝙾𝚏𝙱𝚊𝚛𝚜𝙱𝚊𝚌𝚔()
Methods to retrieve the stored data for a bar index:
𝚝𝚒𝚖𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚝𝚒𝚖𝚎𝙲𝚕𝚘𝚜𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚟𝚊𝚕𝚞𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚐𝚎𝚝𝙰𝚕𝚕𝚅𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡()
Methods to retrieve the stored data at a number of bars back (i.e., historical offset):
𝚝𝚒𝚖𝚎(), 𝚝𝚒𝚖𝚎𝙲𝚕𝚘𝚜𝚎(), 𝚟𝚊𝚕𝚞𝚎()
Methods to retrieve all the data points from the earliest bar (or latest bar) stored in memory, which can be useful for debugging purposes:
𝚐𝚎𝚝𝙴𝚊𝚛𝚕𝚒𝚎𝚜𝚝𝚂𝚝𝚘𝚛𝚎𝚍𝙳𝚊𝚝𝚊(), 𝚐𝚎𝚝𝙻𝚊𝚝𝚎𝚜𝚝𝚂𝚝𝚘𝚛𝚎𝚍𝙳𝚊𝚝𝚊()
Note: the library's strong suit is referencing data from very old bars in the past, which is especially useful for scripts that perform its necessary calculations only on the last bar.
█ USAGE
Step 1
Import the library. Replace with the latest available version number for this library.
//@version=6
indicator("Usage")
import n00btraders/ChartData/
Step 2
Create a 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object to collect data on every bar. Do not declare as `var` or `varip`.
chartData = ChartData.collectChartData() // call on every bar to accumulate the necessary data
Step 3
Call any method(s) on the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object. Do not modify its fields directly.
if barstate.islast
int firstBarTime = chartData.timeAtBarIndex(0)
int lastBarTime = chartData.time(0)
log.info("First `time`: " + str.format_time(firstBarTime) + ", Last `time`: " + str.format_time(lastBarTime))
█ EXAMPLES
• Collect Future Times
The overloaded 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() functions that accept a 𝚋𝚊𝚛𝚜𝙵𝚘𝚛𝚠𝚊𝚛𝚍 argument can additionally store time values for up to 500 bars into the future.
//@version=6
indicator("Example `collectChartData(barsForward)`")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData(barsForward = 500)
var rectangle = box.new(na, na, na, na, xloc = xloc.bar_time, force_overlay = true)
if barstate.islast
int futureTime = chartData.timeAtBarIndex(bar_index + 100)
int lastBarTime = time
box.set_lefttop(rectangle, lastBarTime, open)
box.set_rightbottom(rectangle, futureTime, close)
box.set_text(rectangle, "Extending box 100 bars to the right. Time: " + str.format_time(futureTime))
• Collect Custom Data
The overloaded 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() functions that accept a 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜 argument can additionally store custom user-specified values for every bar on the chart.
//@version=6
indicator("Example `collectChartData(variables)`")
import n00btraders/ChartData/1
var map variables = map.new()
variables.put("open", open)
variables.put("close", close)
variables.put("open-close midpoint", (open + close) / 2)
variables.put("boolean", open > close ? 1 : 0)
chartData = ChartData.collectChartData(variables = variables)
var fgColor = chart.fg_color
var table1 = table.new(position.top_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true)
var table2 = table.new(position.bottom_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true)
if barstate.isfirst
table.cell(table1, 0, 0, "ChartData.value()", text_color = fgColor)
table.cell(table2, 0, 0, "open ", text_color = fgColor)
table.merge_cells(table1, 0, 0, 1, 0)
table.merge_cells(table2, 0, 0, 1, 0)
for i = 1 to 8
table.cell(table1, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace)
table.cell(table2, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace)
table.cell(table1, 1, i, text_color = fgColor)
table.cell(table2, 1, i, text_color = fgColor)
if barstate.islast
for i = 1 to 8
float open1 = chartData.value("open", 5000 * i)
float open2 = i < 3 ? open : -1
table.cell_set_text(table1, 0, i, "chartData.value(\"open\", " + str.tostring(5000 * i) + "): ")
table.cell_set_text(table2, 0, i, "open : ")
table.cell_set_text(table1, 1, i, str.tostring(open1))
table.cell_set_text(table2, 1, i, open2 >= 0 ? str.tostring(open2) : "Error")
• xloc.bar_index → xloc.bar_time
The 𝚝𝚒𝚖𝚎 value (or 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 value) can be retrieved for any bar index that is stored in memory by the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object.
//@version=6
indicator("Example `timeAtBarIndex()`")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData()
if barstate.islast
int start = bar_index - 15000
int end = bar_index - 100
// line.new(start, close, end, close) // !ERROR - `start` value is too far from current bar index
start := chartData.timeAtBarIndex(start)
end := chartData.timeAtBarIndex(end)
line.new(start, close, end, close, xloc.bar_time, width = 10)
• xloc.bar_time → xloc.bar_index
Use 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡() to find the bar that a timestamp belongs to.
If the timestamp falls in between the close of one bar and the open of the next bar,
the 𝚜𝚗𝚊𝚙 parameter can be used to determine which bar to choose:
𝚂𝚗𝚊𝚙.𝙻𝙴𝙵𝚃 - prefer to choose the leftmost bar (typically used for closing times)
𝚂𝚗𝚊𝚙.𝚁𝙸𝙶𝙷𝚃 - prefer to choose the rightmost bar (typically used for opening times)
𝚂𝚗𝚊𝚙.𝙳𝙴𝙵𝙰𝚄𝙻𝚃 (or 𝚗𝚊) - copies the same behavior as xloc.bar_time uses for drawing objects
//@version=6
indicator("Example `timestampToBarIndex()`")
import n00btraders/ChartData/1
startTimeInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Session Start Time")
endTimeInput = input.time(timestamp("01 Aug 2025 15:15 -0500"), "Session End Time")
chartData = ChartData.collectChartData()
if barstate.islastconfirmedhistory
int startBarIndex = chartData.timestampToBarIndex(startTimeInput, ChartData.Snap.RIGHT)
int endBarIndex = chartData.timestampToBarIndex(endTimeInput, ChartData.Snap.LEFT)
line1 = line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true)
line2 = line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true)
linefill.new(line1, line2, color.new(color.green, 90))
// using Snap.DEFAULT to show that it is equivalent to drawing lines using `xloc.bar_time` (i.e., it aligns to the same bars)
startBarIndex := chartData.timestampToBarIndex(startTimeInput)
endBarIndex := chartData.timestampToBarIndex(endTimeInput)
line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.yellow, width = 3)
line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.yellow, width = 3)
line.new(startTimeInput, 0, startTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11)
line.new(endTimeInput, 0, endTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11)
• Get Price of Line at Timestamp
The pine script built-in function line.get_price() requires working with bar index values. To get the price of a line in terms of a timestamp, convert the timestamp into a bar index or offset.
//@version=6
indicator("Example `line.get_price()` at timestamp")
import n00btraders/ChartData/1
lineStartInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Line Start")
chartData = ChartData.collectChartData()
var diagonal = line.new(na, na, na, na, force_overlay = true)
if time <= lineStartInput
line.set_xy1(diagonal, bar_index, open)
if barstate.islastconfirmedhistory
line.set_xy2(diagonal, bar_index, close)
if barstate.islast
int timeOneWeekAgo = timenow - (7 * timeframe.in_seconds("1D") * 1000)
// Note: could also use `timetampToBarIndex(timeOneWeekAgo, Snap.DEFAULT)` and pass the value directly to `line.get_price()`
int barsOneWeekAgo = chartData.getNumberOfBarsBack(timeOneWeekAgo)
float price = line.get_price(diagonal, bar_index - barsOneWeekAgo)
string formatString = "Time 1 week ago: {0,number,#}\n - Equivalent to {1} bars ago\n\n𝚕𝚒𝚗𝚎.𝚐𝚎𝚝_𝚙𝚛𝚒𝚌𝚎(): {2,number,#.##}"
string labelText = str.format(formatString, timeOneWeekAgo, barsOneWeekAgo, price)
label.new(timeOneWeekAgo, price, labelText, xloc.bar_time, style = label.style_label_lower_right, size = 16, textalign = text.align_left, force_overlay = true)
█ RUNTIME ERROR MESSAGES
This library's functions will generate a custom runtime error message in the following cases:
𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() is not called consecutively, or is called more than once on a single bar
Invalid 𝚋𝚊𝚛𝚜𝙵𝚘𝚛𝚠𝚊𝚛𝚍 argument in the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function
Invalid 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜 argument in the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function
Invalid 𝚕𝚎𝚗𝚐𝚝𝚑 argument in any of the functions that accept a number of bars back
Note: there is no runtime error generated for an invalid 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙 or 𝚋𝚊𝚛𝙸𝚗𝚍𝚎𝚡 argument in any of the functions. Instead, the functions will assign 𝚗𝚊 to the returned values.
Any other runtime errors are due to incorrect usage of the library.
█ NOTES
• Function Descriptions
The library source code uses Markdown for the exported functions. Hover over a function/method call in the Pine Editor to display formatted, detailed information about the function/method.
//@version=6
indicator("Demo Function Tooltip")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData()
int barIndex = chartData.timestampToBarIndex(timenow)
log.info(str.tostring(barIndex))
• Historical vs. Realtime Behavior
Under the hood, the data collector for this library is declared as `var`. Because of this, the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object will always reflect the latest available data on realtime updates. Any data that is recorded for historical bars will remain unchanged throughout the execution of a script.
//@version=6
indicator("Demo Realtime Behavior")
import n00btraders/ChartData/1
var map variables = map.new()
variables.put("open", open)
variables.put("close", close)
chartData = ChartData.collectChartData(variables)
if barstate.isrealtime
varip float initialOpen = open
varip float initialClose = close
varip int updateCount = 0
updateCount += 1
float latestOpen = open
float latestClose = close
float recordedOpen = chartData.valueAtBarIndex("open", bar_index)
float recordedClose = chartData.valueAtBarIndex("close", bar_index)
string formatString = "# of updates: {0}\n\n𝚘𝚙𝚎𝚗 at update #1: {1,number,#.##}\n𝚌𝚕𝚘𝚜𝚎 at update #1: {2,number,#.##}\n\n"
+ "𝚘𝚙𝚎𝚗 at update #{0}: {3,number,#.##}\n𝚌𝚕𝚘𝚜𝚎 at update #{0}: {4,number,#.##}\n\n"
+ "𝚘𝚙𝚎𝚗 stored in memory: {5,number,#.##}\n𝚌𝚕𝚘𝚜𝚎 stored in memory: {6,number,#.##}"
string labelText = str.format(formatString, updateCount, initialOpen, initialClose, latestOpen, latestClose, recordedOpen, recordedClose)
label.new(bar_index, close, labelText, style = label.style_label_left, force_overlay = true)
• Collecting Chart Data for Other Contexts
If your use case requires collecting chart data from another context, avoid directly retrieving the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object as this may exceed memory limits .
//@version=6
indicator("Demo Return Calculated Results")
import n00btraders/ChartData/1
timeInput = input.time(timestamp("01 Sep 2025 08:30 -0500"), "Time")
var int oneMinuteBarsAgo = na
// !ERROR - Memory Limits Exceeded
// chartDataArray = request.security_lower_tf(syminfo.tickerid, "1", ChartData.collectChartData())
// oneMinuteBarsAgo := chartDataArray.last().getNumberOfBarsBack(timeInput)
// function that returns calculated results (a single integer value instead of an entire `ChartData` object)
getNumberOfBarsBack() =>
chartData = ChartData.collectChartData()
chartData.getNumberOfBarsBack(timeInput)
calculatedResultsArray = request.security_lower_tf(syminfo.tickerid, "1", getNumberOfBarsBack())
oneMinuteBarsAgo := calculatedResultsArray.size() > 0 ? calculatedResultsArray.last() : na
if barstate.islast
string labelText = str.format("The selected timestamp occurs 1-minute bars ago", oneMinuteBarsAgo)
label.new(bar_index, hl2, labelText, style = label.style_label_left, size = 16, force_overlay = true)
• Memory Usage
The library's convenience and ease of use comes at the cost of increased usage of computational resources. For simple scripts, using this library will likely not cause any issues with exceeding memory limits. But for large and complex scripts, you can reduce memory issues by specifying a lower 𝚌𝚊𝚕𝚌_𝚋𝚊𝚛𝚜_𝚌𝚘𝚞𝚗𝚝 amount in the indicator() or strategy() declaration statement.
//@version=6
// !ERROR - Memory Limits Exceeded using the default number of bars available (~20,000 bars for Premium plans)
//indicator("Demo `calc_bars_count` parameter")
// Reduce number of bars using `calc_bars_count` parameter
indicator("Demo `calc_bars_count` parameter", calc_bars_count = 15000)
import n00btraders/ChartData/1
map variables = map.new()
variables.put("open", open)
variables.put("close", close)
variables.put("weekofyear", weekofyear)
variables.put("dayofmonth", dayofmonth)
variables.put("hour", hour)
variables.put("minute", minute)
variables.put("second", second)
// simulate large memory usage
chartData0 = ChartData.collectChartData(variables)
chartData1 = ChartData.collectChartData(variables)
chartData2 = ChartData.collectChartData(variables)
chartData3 = ChartData.collectChartData(variables)
chartData4 = ChartData.collectChartData(variables)
chartData5 = ChartData.collectChartData(variables)
chartData6 = ChartData.collectChartData(variables)
chartData7 = ChartData.collectChartData(variables)
chartData8 = ChartData.collectChartData(variables)
chartData9 = ChartData.collectChartData(variables)
log.info(str.tostring(chartData0.time(0)))
log.info(str.tostring(chartData1.time(0)))
log.info(str.tostring(chartData2.time(0)))
log.info(str.tostring(chartData3.time(0)))
log.info(str.tostring(chartData4.time(0)))
log.info(str.tostring(chartData5.time(0)))
log.info(str.tostring(chartData6.time(0)))
log.info(str.tostring(chartData7.time(0)))
log.info(str.tostring(chartData8.time(0)))
log.info(str.tostring(chartData9.time(0)))
if barstate.islast
result = table.new(position.middle_right, 1, 1, force_overlay = true)
table.cell(result, 0, 0, "Script Execution Successful ✅", text_size = 40)
█ EXPORTED ENUMS
Snap
Behavior for determining the bar that a timestamp belongs to.
Fields:
LEFT : Snap to the leftmost bar.
RIGHT : Snap to the rightmost bar.
DEFAULT : Default `xloc.bar_time` behavior.
Note: this enum is used for the 𝚜𝚗𝚊𝚙 parameter of 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡().
█ EXPORTED TYPES
Note: users of the library do not need to worry about directly accessing the fields of these types; all computations are done through method calls on an object of the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 type.
Variable
Represents a user-specified variable that can be tracked on every chart bar.
Fields:
name (series string) : Unique identifier for the variable.
values (array) : The array of stored values (one value per chart bar).
ChartData
Represents data for all bars on a chart.
Fields:
bars (series int) : Current number of bars on the chart.
timeValues (array) : The `time` values of all chart (and future) bars.
timeCloseValues (array) : The `time_close` values of all chart (and future) bars.
variables (array) : Additional custom values to track on all chart bars.
█ EXPORTED FUNCTIONS
collectChartData()
Collects and tracks the `time` and `time_close` value of every bar on the chart.
Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(barsForward)
Collects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars.
Parameters:
barsForward (simple int) : Number of future bars to collect data for.
Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(variables)
Collects and tracks the `time` and `time_close` value of every bar on the chart. Additionally, tracks a custom set of variables for every chart bar.
Parameters:
variables (simple map) : Custom values to collect on every chart bar.
Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(barsForward, variables)
Collects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars. Additionally, tracks a custom set of variables for every chart bar.
Parameters:
barsForward (simple int) : Number of future bars to collect data for.
variables (simple map) : Custom values to collect on every chart bar.
Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
█ EXPORTED METHODS
method timestampToBarIndex(chartData, timestamp, snap)
Converts a UNIX timestamp to a bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
timestamp (series int) : A UNIX time.
snap (series Snap) : A `Snap` enum value.
Returns: A bar index, or `na` if unable to find the appropriate bar index.
method getNumberOfBarsBack(chartData, timestamp)
Converts a UNIX timestamp to a history-referencing length (i.e., number of bars back).
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
timestamp (series int) : A UNIX time.
Returns: A bar offset, or `na` if unable to find a valid number of bars back.
method timeAtBarIndex(chartData, barIndex)
Retrieves the `time` value for the specified bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
barIndex (int) : The bar index.
Returns: The `time` value, or `na` if there is no `time` stored for the bar index.
method time(chartData, length)
Retrieves the `time` value of the bar that is `length` bars back relative to the latest bar.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
length (series int) : Number of bars back.
Returns: The `time` value `length` bars ago, or `na` if there is no `time` stored for that bar.
method timeCloseAtBarIndex(chartData, barIndex)
Retrieves the `time_close` value for the specified bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
barIndex (series int) : The bar index.
Returns: The `time_close` value, or `na` if there is no `time_close` stored for the bar index.
method timeClose(chartData, length)
Retrieves the `time_close` value of the bar that is `length` bars back from the latest bar.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
length (series int) : Number of bars back.
Returns: The `time_close` value `length` bars ago, or `na` if there is none stored.
method valueAtBarIndex(chartData, name, barIndex)
Retrieves the value of a custom variable for the specified bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
name (series string) : The variable name.
barIndex (series int) : The bar index.
Returns: The value of the variable, or `na` if that variable is not stored for the bar index.
method value(chartData, name, length)
Retrieves a variable value of the bar that is `length` bars back relative to the latest bar.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
name (series string) : The variable name.
length (series int) : Number of bars back.
Returns: The value `length` bars ago, or `na` if that variable is not stored for the bar index.
method getAllVariablesAtBarIndex(chartData, barIndex)
Retrieves all custom variables for the specified bar index.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
barIndex (series int) : The bar index.
Returns: Map of all custom variables that are stored for the specified bar index.
method getEarliestStoredData(chartData)
Gets all values from the earliest bar data that is currently stored in memory.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
Returns: A tuple:
method getLatestStoredData(chartData, futureData)
Gets all values from the latest bar data that is currently stored in memory.
Namespace types: ChartData
Parameters:
chartData (series ChartData) : The `ChartData` object.
futureData (series bool) : Whether to include the future data that is stored in memory.
Returns: A tuple:
Bar metrics / quantifytools— Overview
Rather than eyeball evaluating bullishness/bearishness in any given bar, bar metrics allow a quantified approach using three basic fundamental data points: relative close, relative volatility and relative volume. These data points are visualized in a discreet data dashboard form, next to all real-time bars. Each value also has a dot in front, representing color coded extremes in the values.
Relative close represents position of bar's close relative to high and low, high of bar being 100% and low of bar being 0%. Relative close indicates strength of bulls/bears in a given bar, the higher the better for bulls, the lower the better for bears. Relative volatility (bar range, high - low) and relative volume are presented in a form of a multiplier, relative to their respective moving averages (SMA 20). A value of 1x indicates volume/volatility being on par with moving average, 2x indicates volume/volatility being twice as much as moving average and so on. Relative volume and volatility can be used for measuring general market participant interest, the "weight of the bar" as it were.
— Features
Users can gauge past bar metrics using lookback via input menu. Past bars, especially recent ones, are helpful for giving context for current bar metrics. Lookback bars are highlighted on the chart using a yellow box and metrics presented on the data dashboard with lookback symbols:
To inspect bar metric data and its implications, users can highlight bars with specified bracket values for each metric:
When bar highlighter is toggled on and desired bar metric values set, alert for the specified combination can be toggled on via alert menu. Note that bar highlighter must be enabled in order for alerts to function.
— Visuals
Bar metric dots are gradient colored the following way:
Relative volatility & volume
0x -> 1x / Neutral (white) -> Light (yellow)
1x -> 1.7x / Light (yellow) -> Medium (orange)
1.7x -> 2.4x / Medium (orange) -> Heavy (red)
Relative close
0% -> 25% / Heavy bearish (red) -> Light bearish (dark red)
25% -> 45% / Light bearish (dark red) -> Neutral (white)
45% - 55% / Neutral (white)
55% -> 75% / Neutral (white) -> Light bullish (dark green)
75% -> 100% / Light bullish (dark green) -> Heavy bullish (green)
All colors can be adjusted via input menu. Label size, label distance from bar (offset) and text format (regular/stealth) can be adjusted via input menu as well:
— Practical guide
As interpretation of bar metrics is highly contextual, it is especially important to use other means in conjunction with the metrics. Levels, oscillators, moving averages, whatever you have found useful for your process. In short, relative close indicates directional bias and relative volume/volatility indicates "weight" of directional bias.
General interpretation
High relative close, low relative volume/volatility = mildly bullish, bias up/consolidation
High relative close, medium relative volume/volatility = bullish, bias up
High relative close, high relative volume/volatility = exuberantly bullish, bias up/down depending on context
Medium relative close, low relative volume/volatility = noise, no bias
Medium relative close, medium to high relative volume/volatility = indecision, further evidence needed to evaluate bias
Low relative close, low relative volume/volatility = mildly bearish, bias down/consolidation
Low relative close, medium relative volume/volatility = bearish, bias down
Low relative close, high relative volume/volatility = exuberantly bearish, bias down/up depending on context
Nuances & considerations
As to relative close, it's important to note that each bar is a trading range when viewed on a lower timeframe, ES 1W vs. ES 4H:
When relative close is high, bulls were able to push price to range high by the time of close. When relative close is low, bears were able to push price to range low by the time of close. In other words, bulls/bears were able to gain the upper hand over a given trading range, hinting strength for the side that made the final push. When relative close is around middle range (40-60%), it can be said neither side is clearly dominating the range, hinting neutral/indecision bias from a relative close perspective.
As to relative volume/volatility, low values (less than ~0.7x) imply bar has low market participant interest and therefore is likely insignificant, as it is "lacking weight". Values close to or above 1x imply meaningful market participant interest, whereas values well above 1x (greater than ~1.3x) imply exuberance. This exuberance can manifest as initiation (beginning of a trend) or as exhaustion (end of a trend):
Bar Dependent Moving AverageImagine using an exercising strategy from a gym coach who retired 10 years ago as there dozens of other trainers who constantly try to adapt and find a better approach. You would be missing out.
It's the same with using fixed periods, you just look back.
How about an exercising strategy from a gym coach who is simultaneously trying to adapt himself?
How could you figure out a strategy that adapts with the market as the market is indirectly finding a better approach to take you out?
Relative Moving Averages simply speaking count the total amount of bars and divide it by the period for which you want to use the moving average. Instead of looking at the last X bars, it divides the total amount of bars / X as the moving average period.
It takes all bars into account, the entire chart history essentially turning it into an adaptive moving average, in the example mentioned above into an adaptive exercising strategy.
The Bar Dependent Moving Average Periods are 2,3,5,8 etc., i.e. the entire fibonacci sequence up to 4181.
The white line is the relative fibonacci moving average, which is calculated by adding all Fibonacci Bar Dependent Moving Averages with one another / by the total amount of fibonacci numbers used i.e. 18.
The bar-dependent fibonacci moving average is upon further investigation (on shorter timeframes <30m) a useful support/resistance indicator since the price tends to wick/consolidate or fully break through the fibonoacci bar dependent moving average.
If there are more than 5000 bars of Candlestick data enable the lock in the settings menu to limit the maximum last X bars back to 5000 to make it possible for Tradingview to run the script since Tradingview does not allow it to look more than 5000 bars back.
Bar colour BreakoutIndicator that changes the colour of the bars depending on the breakout of the high or the low of the previous bar. A lime bar indicates a bar that has a higher high than the previous one. A fuchsia bar indicates a bar that has a lower low than the previous bar. A yellow bar indicates an outside bar (higher high and lower low than the previous one). A blue bar indicates an inside bar (lower high and higher low).
Bar Color Long / Short Indicator With Advised SL Rev 1This is the Revised Version of Bar Color Long / Short Indicator With Advised SL with some extra features
Overview
This script is a trading indicator named "Bar Color Long / Short Indicator With Advised SL" designed for the TradingView platform. The indicator's primary purpose is to provide entry signals for long and short positions, based on various technical analysis methods. Additionally, the indicator suggests stop-loss levels for both long and short positions.
User Inputs
The indicator has several user inputs, such as:
Length
Smoothing
Multiplier
Show bar colors (ON/OFF)
When the bar colors are turned off, the alert signals for long and short positions will be displayed instead.
Custom Risk Calculation
The script calculates a custom risk level based on a modified version of the RSI (Relative Strength Index) formula. The custom risk level is divided into three categories: low, medium, and high.
Sentiment Score Calculation
The indicator calculates a sentiment score based on a combination of methods resembling EMA (Exponential Moving Average), MACD (Moving Average Convergence Divergence), and ROC (Rate of Change). The sentiment score is used to determine if the sentiment is positive or negative.
Bollinger Bands Percent and Combined Signal
The Bollinger Bands Percent is calculated, and the custom risk, sentiment score, and Bollinger Bands Percent are combined to generate a new signal. This signal is used in conjunction with EMA10 to determine the bar colors and provide entry signals.
Bar Colors
Based on the combined signal and EMA10, the script determines the bar colors as follows:
Orange: Positive sentiment
Blue: Negative sentiment
Gray: Neutral
Entry Signals and Alerts
When the bar colors are turned off, the indicator displays large green arrow signals for long (buy) positions and red arrow signals for short (sell) positions based on the sentiment and EMA10 conditions. The script also includes alert conditions for long and short signals, which can be used to set up notifications when these signals are triggered in the TradingView platform.
Advised Stop-Loss Levels
The indicator plots stop-loss lines for both long and short positions at the last candle, accompanied by labels showing the advised stop-loss levels in numeric values
Rev 1
added / changed :
SMA50 slope check
EMA20 higher or lower than EMA10
color ON/OFF changed
Signal once Buy and Sell
Bar Move Probability Price Levels (BMPPL)Hello fellow traders! I am thrilled to present my latest creation, the Bar Move Probability Price Levels (BMPPL) indicator. This powerful tool offers a statistical edge in your trading by helping you understand the likelihood of price movements at multiple levels based on historical data. In this post, I'll provide an overview of the indicator, its features, and how it can enhance your trading experience. Let's dive in!
What is the Bar Move Probability Price Levels Indicator?
The Bar Move Probability Price Levels (BMPPL) indicator is a versatile tool that calculates the probability of a bar's price movement at multiple levels, either up or down, based on past occurrences of similar price movements. This comprehensive approach can provide valuable insights into the potential direction of the market, allowing you to make better-informed trading decisions.
One of the standout features of the BMPPL indicator is its flexibility. You can choose to see the probabilities of reaching various price levels, or you can focus on the highest probability move by adjusting the "Max Number of Elements" and "Step Size" settings. This flexibility ensures that the indicator caters to your specific trading style and requirements.
Max Number of Elements and Step Size: Fine-Tuning Your BMPPL Indicator
The BMPPL indicator allows you to customize its output to suit your trading style and requirements through two key settings: Max Number of Elements and Step Size.
Max Number of Elements: This setting determines the maximum number of price levels displayed by the indicator. By default, it is set to 1000, meaning the indicator will show probabilities for up to 1000 price levels. You can adjust this setting to limit the number of price levels displayed, depending on your preference and trading strategy.
Step Size: The Step Size setting determines the increment between displayed price levels. By default, it is set to 100, which means the indicator will display probabilities for every 100th price level. Adjusting the Step Size allows you to control the granularity of the displayed probabilities, enabling you to focus on specific price movements.
By adjusting the Max Number of Elements and Step Size settings, you can fine-tune the BMPPL indicator to focus on the most relevant price levels for your trading strategy. For example, if you want to concentrate on the highest probability move, you can set the Max Number of Elements to 1 and the Step Size to 1. This will cause the indicator to display only the price level with the highest probability, simplifying your trading decisions.
Probability Calculation: Understanding the Core Concept
The BMPPL indicator calculates the probability of a bar's price movement by analyzing historical price changes and comparing them to the current price change (in percentage). The indicator maintains separate arrays for green (bullish) and red (bearish) price movements and their corresponding counts.
When a new bar is formed, the indicator checks whether the price movement (in percentage) is already present in the respective array. If it is, the corresponding count is updated. Otherwise, a new entry is added to the array, with an initial count of 1.
Once the historical data has been analyzed, the BMPPL indicator calculates the probability of each price movement by dividing the count of each movement by the sum of all counts. These probabilities are then stored in separate arrays for green and red movements.
Utilizing BMPPL Indicator Settings Effectively
To make the most of the BMPPL indicator, it's essential to understand how to use the Max Number of Elements and Step Size settings effectively:
Identify your trading objectives: Before adjusting the settings, it's crucial to know what you want to achieve with your trades. Are you targeting specific price levels or focusing on high-probability moves? Identifying your objectives will help you determine the appropriate settings.
Start with the default settings: The default settings provide a broad overview of price movement probabilities. Start by analyzing these settings to gain a general understanding of the market behavior.
Adjust the settings according to your objectives: Once you have a clear understanding of your trading objectives, adjust the Max Number of Elements and Step Size settings accordingly. For example, if you want to focus on the highest probability move, set both settings to 1.
Experiment and refine: As you gain experience with the BMPPL indicator, continue to experiment with different combinations of Max Number of Elements and Step Size settings. This will help you find the optimal configuration that aligns with your trading strategy and risk tolerance. Remember to continually evaluate your trading results and refine your settings as needed.
Combine with other technical analysis tools: While the BMPPL indicator provides valuable insights on its own, combining it with other technical analysis tools can further enhance your trading strategy. Use additional indicators and chart patterns to confirm your analysis and improve the accuracy of your trades.
Monitor and adjust: Market conditions are constantly changing, and it's crucial to stay adaptive. Keep monitoring the market and adjust your BMPPL settings as necessary to ensure they remain relevant and effective in the current market environment.
By understanding and effectively utilizing the Max Number of Elements and Step Size settings in the BMPPL indicator, you can gain a deeper insight into the potential direction of the market, allowing you to make more informed trading decisions. Experimenting with different settings and combining the BMPPL indicator with other technical analysis tools will ultimately help you develop a robust trading strategy that maximizes your potential profits.
How Can the BMPPL Indicator Benefit Your Trading?
The primary benefit of the BMPPL indicator is its ability to provide you with a statistical edge in your trading by displaying probabilities for various price movements. By analyzing historical price data, the indicator helps you understand the likelihood of certain price movements occurring, allowing you to make more informed decisions about your trades.
The customizable nature of the BMPPL indicator makes it a valuable tool for traders with specific price targets or risk management strategies in mind. By understanding the probability of reaching your target price or the likelihood of encountering a significant price movement, you can better manage your risk and optimize your trading strategy.
Additionally, the BMPPL indicator can be used in conjunction with other technical analysis tools and indicators to further strengthen your trading strategy. For example, you can combine the BMPPL indicator with support and resistance levels, trend lines, and moving averages to better time your entries and exits.
Wrapping Up
In conclusion, the Bar Move Probability Price Levels (BMPPL) indicator is a powerful and customizable tool that can help you gain a statistical edge in your trading. By analyzing historical price data and displaying probabilities for various price movements, the BMPPL indicator allows you to make more informed decisions about your trades, ultimately leading to more successful outcomes.
The customizable settings of the BMPPL indicator make it an adaptable tool for traders with diverse trading styles and risk management preferences. With its ability to provide valuable insights into the potential direction of the market, the BMPPL indicator is an essential addition to any trader's toolbox.
Moreover, when combined with other technical analysis tools and indicators, the BMPPL indicator can further enhance your trading strategy, allowing you to better time your entries and exits and maximize your potential profits. So, if you're looking to gain an edge in your trading and improve your decision-making process, the Bar Move Probability Price Levels (BMPPL) indicator is definitely worth exploring.
Bar Color - Moving Average Convergence Divergence [nsen]The Pine Script you've provided creates a custom indicator that utilizes the MACD (Moving Average Convergence Divergence) and displays various outputs, such as bar color changes based on MACD signals, and a table of data from multiple timeframes. Here's a breakdown of how the script works:
1. Basic Settings (Input)
• The script defines several user-configurable parameters, such as the MACD values, bar colors, the length of the EMA (Exponential Moving Average) periods, and signal smoothing.
• Users can also choose timeframes to analyze the MACD values, like 5 minutes, 15 minutes, 1 hour, 4 hours, and 1 day.
2. MACD Calculation
• It uses the EMA of the close price to calculate the MACD value, with fast_length and slow_length representing the fast and slow periods. The signal_length is used to calculate the Signal Line.
• The MACD value is the difference between the fast and slow EMA, and the Signal Line is the EMA of the MACD.
• The Histogram is the difference between the MACD and the Signal Line.
3. Plotting the Histogram
• The Histogram values are plotted with colors that change based on the value. If the Histogram is positive (rising), it is colored differently than if it's negative (falling). The colors are determined by the user inputs, for example, green for bullish (positive) signals and red for bearish (negative) signals.
4. Bar Coloring
• The bar color changes based on the MACD's bullish or bearish signal. If the MACD is bullish (MACD > Signal), the bar color will change to the color defined for bullish signals, and if it's bearish (MACD < Signal), the bar color will change to the color defined for bearish signals.
5. Multi-Timeframe Data Table
• The script includes a table displaying the MACD trend for different timeframes (e.g., 5m, 15m, 1h, 4h, 1d).
• Each timeframe will show a colored indicator: green (🟩) for bullish and red (🟥) for bearish, with the background color changing based on the trend.
6. Alerts
• The script has alert conditions to notify the user when the MACD shows a bullish or bearish entry:
• Bullish Entry: When the MACD turns bullish (crosses above the Signal Line).
• Bearish Entry: When the MACD turns bearish (crosses below the Signal Line).
• Alerts are triggered with custom messages such as "🟩 MACD Bullish Entry" and "🟥 MACD Bearish Entry."
Key Features:
• Customizable Inputs: Users can adjust the MACD settings, histogram colors, and timeframe options.
• Visual Feedback: The color changes of the histogram and bars provide instant visual cues for bullish or bearish trends.
• Multi-Timeframe Analysis: The table shows the MACD trend across multiple timeframes, helping traders monitor trends in different timeframes.
• Alert Conditions: Alerts notify users when key MACD crossovers occur.
Bar composition in 1minute | True candlestick colorThe indicator shows the true color of a bar based on the internal composition on 1 minute timeframe and the final outcome. It uses following parameters of 1minute and current timeframe inputs
relative bar close, average volume vs current volume and finally the volume of internal candles.
It follows following steps:
First, it defines the arrays of high, low, close, volume in one minute timeframe
Second, it identifies the negative and positive volume based on the bar closing at one minute timeframe
Third , it adds all the volume and find whether the overall volume is positive or negative for overall bar in higher timeframe (current timeframe)
Fourth, it compare the volume in current timeframe to average of volume in in current timeframe
Fifth, if relative closing, relative volume (current timeframe) and the combined volume (in 1 minute timeframe) gives same outcome then color of the bar is decided whether the bar is bullish, bearish or inconclusive/contnuation.
Through this you get to check price action in 1minute timeframe and the ultimate outcome in current timeframe. this helps in understanding whether the bar is truly bullish or bearish or continuation of the trend
Feel free to connect for any query.
Bar Move Probability (BMP)Hello fellow traders! I am excited to share with you my latest creation, the Bar Move Probability (BMP) indicator. This powerful tool is designed to give you a statistical edge in your trading by helping you understand the likelihood of price movements based on historical data. In this blog post, I'll give you an overview of the indicator, its features, and how it can help you make more informed trading decisions. Let's dive in!
What is the Bar Move Probability Indicator?
The Bar Move Probability (BMP) indicator is a unique tool that calculates the probability of a bar's price movement, either up or down, based on past occurrences of similar price movements. This can give you valuable insights into the potential direction of the market, allowing you to make better-informed trading decisions.
One of the key features of the BMP indicator is that it allows you to choose the price you want to determine the probability of. By inputting your desired price, the indicator will analyze historical data and provide you with the likelihood of reaching that price, offering a more personalized approach to trading.
How Does the BMP Indicator Work?
The BMP indicator calculates the probability of a bar's price movement by comparing the current price change (in percentage) to historical price changes. It does this by maintaining separate arrays for green (bullish) and red (bearish) price movements, as well as corresponding arrays for the count of each movement.
Whenever a new bar is formed, the indicator checks whether the price movement (in percentage) is already present in the respective array. If it is, the corresponding count is updated. Otherwise, a new entry is added to the array, with an initial count of 1.
After analyzing the historical data, the BMP indicator calculates the probability of each price movement by dividing the count of each movement by the sum of all counts. These probabilities are then stored in separate arrays for green and red movements.
Finally, the indicator displays the probability of the current price movement as a label on the chart. The label is color-coded, with green indicating a bullish price movement and red indicating a bearish price movement.
How Can the BMP Indicator Benefit Your Trading?
The primary benefit of the BMP indicator is its ability to provide you with a statistical edge in your trading. By analyzing historical price data, the indicator helps you understand the likelihood of a certain price movement occurring, allowing you to make more informed decisions about your trades.
The customizable nature of the BMP indicator, allowing you to input your desired price, makes it a valuable tool for traders with specific price targets in mind. By understanding the probability of reaching your target price, you can better manage your risk and optimize your trading strategy.
For example, suppose the BMP indicator shows a high probability of a bullish price movement towards your target price. In that case, you may consider entering a long position or tightening your stop loss on an existing short position. Conversely, if the indicator displays a high probability of a bearish price movement away from your target price, you may consider entering a short position or taking profit on an existing long position.
The BMP indicator can be used in conjunction with other technical analysis tools and indicators to further strengthen your trading strategy. For example, you can combine the BMP indicator with support and resistance levels, trend lines, and moving averages to better time your entries and exits.
Wrapping Up
In conclusion, the Bar Move Probability (BMP) indicator is a powerful and customizable tool that can help you gain a statistical edge in your trading. By analyzing historical price data and allowing you to input your desired price, the indicator provides valuable insights into the likelihood of price movements, enabling you to make better-informed trading decisions.
I hope you find the BMP indicator useful
Bar Color Long / Short Indicator With Advised SLOverview
This script is a trading indicator named "Bar Color Long / Short Indicator With Advised SL" designed for the TradingView platform. The indicator's primary purpose is to provide entry signals for long and short positions, based on various technical analysis methods. Additionally, the indicator suggests stop-loss levels for both long and short positions.
User Inputs
The indicator has several user inputs, such as:
Length
Smoothing
Multiplier
Show bar colors (ON/OFF)
When the bar colors are turned off, the alert signals for long and short positions will be displayed instead.
Custom Risk Calculation
The script calculates a custom risk level based on a modified version of the RSI (Relative Strength Index) formula. The custom risk level is divided into three categories: low, medium, and high.
Sentiment Score Calculation
The indicator calculates a sentiment score based on a combination of methods resembling EMA (Exponential Moving Average), MACD (Moving Average Convergence Divergence), and ROC (Rate of Change). The sentiment score is used to determine if the sentiment is positive or negative.
Bollinger Bands Percent and Combined Signal
The Bollinger Bands Percent is calculated, and the custom risk, sentiment score, and Bollinger Bands Percent are combined to generate a new signal. This signal is used in conjunction with EMA10 to determine the bar colors and provide entry signals.
Bar Colors
Based on the combined signal and EMA10, the script determines the bar colors as follows:
Orange: Positive sentiment
Blue: Negative sentiment
Gray: Neutral
Entry Signals and Alerts
When the bar colors are turned off, the indicator displays large green arrow signals for long (buy) positions and red arrow signals for short (sell) positions based on the sentiment and EMA10 conditions. The script also includes alert conditions for long and short signals, which can be used to set up notifications when these signals are triggered in the TradingView platform.
Advised Stop-Loss Levels
The indicator plots stop-loss lines for both long and short positions at the last candle, accompanied by labels showing the advised stop-loss levels in numeric values.
Bar Magnified Volume Profile/Fixed Range [ChartPrime]This indicator draws a volume profile by utilizing data from the lower timeframe to get a more accurate representation of where volume occurred on a bar to bar basis. The indicator creates a price range, and then splits that price range into 100 grids by default. The indicator then drops down to the lower timeframe, approximately 16 times lower than the current timeframe being viewed on the chart, and then parses through all of the lower timeframe bars, and attributes the lower timeframe bar volume to all grids that it is touching. The volume is dispersed proportionally to the grids which it is touching by whatever percent of the candle is inside each grid. For example, if one of the lower timeframe bars is interacting with "2" of the grids in the profile, and 60% of the candle is inside of the top grid, 60% of the volume from said candle will be attributed to the grid.
To make all of this magic happen, this script utilizes a quadratic time complexity algorithm while parsing and attributing the volume to all of the grids. Due to this type of algorithm being used in the script, many of the user inputs have been limited to allow for simplicity, but also to prevent possible errors when executing loops. For the most part, all of the settings have been thoroughly tested and configured with the right amount of limitations to prevent these errors, but also still give the user a broad range of flexibility to adjust the script to their liking.
📗 SETTINGS
Lookback Period: The lookback period determines how many bars back the script will search for the "highest high" and the "lowest low" which will then be used to generate the grids in-between
Number Of Levels: This setting determines how many grids there will be within the volume profile/fixed range. This is personal preference, however it is capped at 100 to prevent time complexity issues
Profile Length: This setting allows you to stretch or thin the volume profile. A higher number will stretch it more, vise versa a smaller number will thin it further. This does not change the volume profiles results or values, only its visual appearance.
Profile Offset: This setting allows you to offset the profile to the left or right, in the event the user does not appreciate the positioning of the default location of the profile. A higher number will shift it to the right, vise versa a lower number will shift it to the left. This is personal preference and does not affect the results or values of the profile.
🧰 UTILITY
The volume profile/fixed range can be used in many ways. One of the most popular methods is to identify high volume areas on the chart to be used as trade entries or exits in the event of the price revisiting the high volume areas. Take this picture as an example. The image clearly demonstrates how the 2 highest areas of volume within this magnified volume profile also line up to great areas of support and resistance in the market.
Here are some other useful methods of using the volume profile/fixed range
Identify Key Support and Resistance Levels for Setups
Determine Logical Take Profits and Stop Losses
Calculate Initial R Multiplier
Identify Balanced vs Imbalanced Markets
Determine Strength of Trends
Bar MagnifierMany times while developing algos based on patterns and reversals, I come across issues which needs lower timeframe inspection. Loading multiple charts and comparing equivalent lower timeframe is slightly cumbersome at times. Hence, I thought of building this simple tool - which will instantly provide me lower timeframe candles for given candle. Since the candle selection happen via confirmed time input, we can use this as slider to move from one candle to other for inspection.
🎲 Usage
🎯Loading the script
When you load the script, a prompt appears which asks you to select a time by clicking on the chart.
Select the bar you want to magnify and study
🎯Components
Once loaded, you can see the marker which tells which bar is magnified. And you can also see all the lower timeframe candles before that point. Please note that due to pine restrictions, we can only show last 250 lower timeframe bars. You can change the lower timeframe via settings to cover if the chart timeframe is very high.
🎯Moving to different bars
Click on the middle of the marker, you will see slider which you can slide to move from one bar to other.
Example, after sliding, you will see the lower timeframe data of new candle.
🎯Settings
Settings has only two inputs.
Bar time - selects the bar which needs to be inspected.
Lower timeframe - Default is 1 min. And select a timeframe according to your chart timeframe. Less than 1 min is not supported by security.lower_tf function. Hence, will not work.
Bar Replay Fix - Smooth Candle Transition for TradingViewThe Bar Replay Fix indicator addresses a known issue in TradingView’s Bar Replay mode, where the last completed candle is incorrectly drawn when switching from a lower timeframe to a higher one. This issue can create confusion during analysis, especially when replaying historical price action.
Key Features:
Accurate Candle Rendering: Ensures that candles are displayed correctly in Bar Replay mode by referencing and plotting the previous candle data.
Customizable Appearance: Configure the candle body, wick, and border colors for bullish, bearish, and doji candles to match your chart theme.
Seamless Integration: Works invisibly in the background to provide a smoother and more reliable replay experience.
Use Cases:
Enhance your backtesting accuracy by eliminating incorrect candle rendering during Bar Replay.
Maintain consistency in candle visualization when transitioning between timeframes in Replay mode.
Disclaimer: This indicator is specifically designed to resolve a visual issue in Bar Replay mode and does not provide any trading signals or analysis recommendations.
Bars Since MA Cross Can Help Trend FollowingMoving average crosses are popular signals for trend followers. Like many conditions, they tend to reverse after a certain amount of time. Today’s script is designed to help traders visualize and interpret these turns.
Bars Since MA Cross counts how many bars have passed since a fast-moving average crossed a slower MA. Bullish readings, with the faster MA above the slow, are plotted with positive numbers. The opposite is true for bearish conditions. Users can choose between simple, exponential and weighed average types. They can also mix them, comparing a fast EMA for a slower SMA, for example.
By default, it uses the 8- and 21-day EMAs.
This approach can help in a couple of ways. First, it can show divergences as a move weakens. Microsoft, in the example above, had a shorter bullish phase as it made new highs last December. This was followed by even briefer periods in January before the bear market took hold.
Likewise in May and June, Bars Since MA Cross showed shorter bearish periods before July’s counter-trend rally.
The second potential application is to know the age of a move. In this case look at September 2020. MSFT’s 8-day EMA was above its 21-day EMA for 108 days. The chart shows this was unusually long by previous examples, giving traders a sense the rally was getting long in the tooth. (MSFT would go the rest of that year without a new high.)
In conclusion, Bars Since MA Cross judges a move by its age and not its intensity. It’s a different approach that can sometimes help more than viewing simple price action.
TradeStation has, for decades, advanced the trading industry, providing access to stocks, options, futures and cryptocurrencies. See our Overview for more.
Important Information
TradeStation Securities, Inc., TradeStation Crypto, Inc., and TradeStation Technologies, Inc. are each wholly owned subsidiaries of TradeStation Group, Inc., all operating, and providing products and services, under the TradeStation brand and trademark. You Can Trade, Inc. is also a wholly owned subsidiary of TradeStation Group, Inc., operating under its own brand and trademarks. TradeStation Crypto, Inc. offers to self-directed investors and traders cryptocurrency brokerage services. It is neither licensed with the SEC or the CFTC nor is it a Member of NFA. When applying for, or purchasing, accounts, subscriptions, products, and services, it is important that you know which company you will be dealing with. Please click here for further important information explaining what this means.
This content is for informational and educational purposes only. This is not a recommendation regarding any investment or investment strategy. Any opinions expressed herein are those of the author and do not represent the views or opinions of TradeStation or any of its affiliates.
Investing involves risks. Past performance, whether actual or indicated by historical tests of strategies, is no guarantee of future performance or success. There is a possibility that you may sustain a loss equal to or greater than your entire investment regardless of which asset class you trade (equities, options, futures, or digital assets); therefore, you should not invest or risk money that you cannot afford to lose. Before trading any asset class, first read the relevant risk disclosure statements on the Important Documents page, found here: www.tradestation.com .
Bar Overlap - Sort of inside barsCalculates the amount the current bar overlaps with the previous bar as a percentage. 1 = totally overlapping (inside bar) , 0 = no overlap at all
Bars Since Last EMA Touch
This indicator keeps track of how many bars since price touched any EMA last time. You can for example
set 200 EMA. Tell the script to send an alert if/when 400 bars has been reached away from the EMA 200.
- You can hide/show The EMA Line.
- You can hide/show bar Count.
- You can set X bars from EMA to get Alert.
- You can change color of The Badge and EMA line to fit your background colors.
Enjoy!
Another Indicator From The Hunter Trading Group
Bar ChartI decided to change the type of charts for myself. Liked this one. When you add this script, the chart may slow down on a long history. Since this is my first script, I don't know how to make it easier.
A dot indicates a close, bars are displayed from high to low.
Black - inside bar
Blue outer bar
Green - high and low higher than the previous one
Red - high and low below the previous one
Bar by BarCalculation of weakness or force of the market. The current bar at the closing price to the number of bars specified by number in settings. At the time of growth or falling of the price if the spread decreases it means weakness and a possible turn. I recommend to use on 1D with settings 3-5. Use this indicator according to volume.
Bar count with New day Markerbased on bar count, highlight the first Bar with special colour on every day.
Bar ReplayThis indicator mirrors TradingView's bar replay feature to a certain extent, offering traders a streamlined way to analyze past market movements. It's a practical tool for strategy testing, pattern recognition, and refining trading approaches.
While it may have some limitations, it offers a practical solution for strategy testing and refining trading approaches for free and gets the job done. After all, having a tool is better than having none.
This is just an experiment so don't take it that seriously. I hope you guys find it useful.
If you have some ideas for improvement or found any bugs, kindly let me know.
How to use it?
Step 1 : Add the indicator to the chart.
Step 2 : Select the candle .
Step 3 : Make the changes visible.
Step 4 : How to Navigate
Step 5 : Change the date easily
The blank screen issue.
Note : There are some limitations
The data is limited to the free plan.
It's not smooth as the real Bar replay feature.
I haven't checked the bugs so let me know if you found any.
Bar Retracement Do you love Fibonacci ratios/levels? Have you ever thought to apply them to individual bars? If you are not familiar with these ratios and their significance, you can read about them here: www.investopedia.com
This simple indicator applies Fibonacci levels on the previous bar. This enables the quick determination of how far the current bar retraced relative to the precious one. Key levels are highlighted in yellow, orange, and red. You can choose to set an alert for "Large Retracements". This can be very useful for ending trades and avoiding full price reversals. There are other insights that can be gleaned as well.
Happy trading...
Bar By Bar ATR [upslidedown]After seeing strategy after strategy refer to calculating ATR values using a "calculator" (how barbaric!), I thought I'd take a stab at one possible solution to the "problem" as an overlay indicator on the main chart that replaces traditional standard ATR bands. This indicator presents ATR within a channel with a slick trick: invisible hover-able tooltips for you to know the ATR value for your strategy from bar to bar. Just zoom in and hover over the high ATR range and you'll see take profit and stop loss values for whatever strategy you might be running. I defaulted the indicator to a 1:1.5 ATR standard setup because that is good for many strategies but this is as configurable as you'd like to make it. One notable improvement for this indicator over standard ATR bands is that many existing ATR bands only use integers and this one uses a float value, so you can endlessly customize based on whatever strategy you might be running.
Note: Because labels are limited by default, the best way to historically see ATR values is to use TV's replay feature. I did this on purpose to limit resource usage. One could certainly print more labels but I felt it unnecessary to go beyond the default number of labels.
