Bắt đầu

Tìm kiếm tập lệnh với "bar"

Volume & Dollar BarsThis scriptlet is a part of an ongoing project and attempts at volume and dollar bar identification. The original idea is taken from excellent books 'Hands-On Machine Learning for Algorithmic Trading' (2019) by Stefan Jansen and 'Advances in Financial Machine Learning' (2018) by Marcos Lopez de Prado. Statement of Purpose I am an advocate of Open source and against those who publish their code with a lock icon. My code and ideas are aimed at people with critical thinking, who are able to take an informative and responsible decision when it comes to investing their funds. I do not guarantee that all of my ideas will perform well. As usual, they require a certain degree of your sound judgment. My final aim is to provide you with coding techniques that you could use in your own scripts and strategies.
Chỉ báo Pine Script®
của capissimo
2
Rob Hoffman's Inventory Retracement Bar - by UCSgearsClaims by Rob Hoffman Developed and used to win trading competitions around the world, the Hoffman Inventory Retracement Trade is quickly becoming one of the most popular ways to identify where short-term counter trend institutional inventory has subsided and when it’s time to re-enter into a trade’s original trend direction. I have not included the TREND condition. - Enjoy Rob Hoffman Inventory Retracement Bar - tradersonline-mag.com
Chỉ báo Pine Script®
của UDAY_C_Santhakumar
19
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.
Chỉ báo Pine Script®
của HPotter
8
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:
Thư viện Pine Script®
của n00btraders
6
Bar metrics / Flowly Indicators— 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):
Chỉ báo Pine Script®
của FlowlyIndicators
5
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.
Chỉ báo Pine Script®
của UnknownUnicorn56349756
bar count plot only for far lookbackPurpose: TradingView limits the number of text/label objects (≈500), which causes traditional bar-count indicators to stop showing numbers when you scroll far back in history. This plots-only version bypasses that limitation entirely, allowing you to view bar numbers anywhere on the chart, even thousands of bars back. How It Works: Displays each bar’s in-day sequence number (1–78 by default) under the candles. Counts restart automatically at the start of each trading day. Uses a dual-channel “digit plot” system (tens + ones) instead of labels—extremely light on performance and unlimited in lookback. The digits are drawn every N bars (default = 3) to keep the view uncluttered. Key Parameters: Show every Nth bar: Controls how often numbers appear (1 = every bar, 3 = every 3 bars, etc.). Notes: Digits are plotted directly via plotshape()—no labels—so they remain visible even 5 000 + bars back. Alignment may vary slightly depending on chart zoom; this version is intended mainly for deep historical review rather than precise near-term alignment.
Chỉ báo Pine Script®
của rinaldo3
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
Chỉ báo Pine Script®
của CR-JE
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.
Chỉ báo Pine Script®
của The_Peaceful_Lizard
9
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.
Chỉ báo Pine Script®
của N_SEN
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.
Chỉ báo Pine Script®
của iitiantradingsage
6
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
Chỉ báo Pine Script®
của The_Peaceful_Lizard
2
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.
Chỉ báo Pine Script®
của CR-JE
Bar Count & EMA & PatternsA clean and practical charting tool designed for intraday traders, inspired by Al Brooks' Price Action methodology. Key Features: 📊 Bar Count Displays only during RTH (08:30-15:00) Supports 3-minute and 5-minute charts Shows bar 1 and multiples of 3 (3, 6, 9, 12...) Key levels highlighted: 18, 48, 81 (red), multiples of 12 (sky blue), bar 6 (light green) Optimized for China Securities Index Futures — 3-minute chart displays all 81 bars within RTH 📈 EMA Default 20-period EMA Customizable length, source, and color 🔍 Pattern Recognition Auto-detects Inside Bar (i) and Outside Bar (o) Supports complex patterns: II, OO, IOI, OIO Consecutive patterns extend automatically (e.g., iii, ooo) Design Philosophy: Inspired by Al Brooks' Price Action concepts, this indicator reduces chart noise and displays only essential information to support clearer trading decisions.
Chỉ báo Pine Script®
của JimmC98
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
Chỉ báo Pine Script®
của ChartPrime
12