Inizia

DATA

Footprint Data Test [Zofesu]Overview Verify your Data Integrity with Institutional Precision. This diagnostic tool is a professional-grade utility designed to verify if your current broker and symbol provide real-time Footprint Data (Intrabar Volume). In the world of high-stakes trading, especially when scalping Nasdaq or BTC, your strategies are only as good as the data feeding them. This script ensures your "data fuel" is active before you rely on complex Order Flow or Delta-based indicators. Why this is Original and Useful TradingView's Public Library is filled with Order Flow indicators, but many traders fail to realize that their broker might not even provide the necessary tick-level data for these tools to function. This script is unique because: Direct Engine Access: It utilizes the latest Pine Script™ v6 request.footprint method to probe the exchange’s database directly. Diagnostic Transparency: Instead of guessing why an indicator isn't plotting, this tool provides a clear "Green Light" status. Educational Value: It bridges the gap between retail charting and institutional data requirements, helping traders understand the difference between simulated volume and real footprint distribution. How it Works The script attempts to request footprint data for the last 10 bars. In Pine Script™ v6, if the broker (e.g., certain CFD providers) does not support this data, the method returns na. The tool captures this state and translates it into a simplified UI. Core Components Status Table: A clean, non-intrusive UI element at the bottom center of your chart for instant diagnostics. Data Active ✅: Confirms your broker provides real-time footprint/tick data. You can safely proceed with Order Flow and Volume Profile strategies. No Data / Not Supported: Indicates the symbol or broker lacks the necessary granularity. Footprint-based indicators will not function correctly in this environment. Next to the indicator, at the top left, you will see a red exclamation point. Strategic Application Broker Verification: Compare data quality between different providers (e.g., IC Markets vs. Binance vs. CME). Symbol Compatibility: Essential for testing Nasdaq (NQ), S&P 500 (ES), or Crypto pairs before deploying capital. Data Subscriptions: If you see a red status on Indices, it often confirms the need for a "Real-Time Data Subscription" from the exchange. Switch time frames to see where the real data is.
Indicatore Pine Script®
di Zofesu
StO Price Action - Panel US Economy DataShort Summary - Displays selected us economic data as a time series graph - Economic indicator name shown in the upper-right corner - Designed as a lightweight fundamental context overlay Full Description Overview - Plots economic macro data as a continuous graph - Combines visual trend context with clear textual identification Supported Economic Data - CPI – Consumer Price Index - CIR – Core Inflation Rate (YoY) - IRYY – Inflation Rate (YoY) - IJC – Initial Jobless Claims - JC4W – Jobless Claims (4-Week Average) - NFP – Nonfarm Payrolls - UR – Unemployment Rate Graph Behavior - Selected economic series is rendered as a line graph - Graph color is user-configurable Label Display - Full descriptive name of the selected indicator - Fixed position in the upper-right corner Usage - Helps identify macro trends alongside price action - Useful for bias alignment on higher timeframes - Works well with Trend-following Systems or higher-timeframe structure analysis Notes - Economic data is informational and non-predictive - Not a signal or timing tool - Best used as contextual background not standalone input
Indicatore Pine Script®
di sto_svc
Bar Index & TimeLibrary to convert a bar index to a timestamp and vice versa. Utilizes runtime memory to store the 𝚝𝚒𝚖𝚎 and 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 values of every bar on the chart (and optional future bars), with the ability of storing additional custom values for every chart bar. █  PREFACE This library aims to tackle some problems that pine coders (from beginners to advanced) often come across, such as: I'm trying to draw an object with a 𝚋𝚊𝚛_𝚒𝚗𝚍𝚎𝚡 that is more than 10,000 bars into the past, but this causes my script to fail. How can I convert the 𝚋𝚊𝚛_𝚒𝚗𝚍𝚎𝚡 to a UNIX time so that I can draw visuals using xloc.bar_time ? I have a diagonal line drawing and I want to get the "y" value at a specific time, but line.get_price() only accepts a bar index value. How can I convert the timestamp into a bar index value so that I can still use this function? I want to get a previous 𝚘𝚙𝚎𝚗 value that occurred at a specific timestamp. How can I convert the timestamp into a historical offset so that I can use 𝚘𝚙𝚎𝚗 ? I want to reference a very old value for a variable. How can I access a previous value that is older than the maximum historical buffer size of 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎 ? This library can solve the above problems (and many more) with the addition of a few lines of code, rather than requiring the coder to refactor their script to accommodate the limitations. █  OVERVIEW The core functionality provided is conversion between xloc.bar_index and xloc.bar_time values. The main component of the library is the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object, created via the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function which basically stores the 𝚝𝚒𝚖𝚎 and 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 of every bar on the chart, and there are 3 more overloads to this function that allow collecting and storing additional data. Once a 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object is created, use any of the exported methods: Methods to convert a UNIX timestamp into a bar index or bar offset: 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚐𝚎𝚝𝙽𝚞𝚖𝚋𝚎𝚛𝙾𝚏𝙱𝚊𝚛𝚜𝙱𝚊𝚌𝚔() Methods to retrieve the stored data for a bar index: 𝚝𝚒𝚖𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚝𝚒𝚖𝚎𝙲𝚕𝚘𝚜𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚟𝚊𝚕𝚞𝚎𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(), 𝚐𝚎𝚝𝙰𝚕𝚕𝚅𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜𝙰𝚝𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡() Methods to retrieve the stored data at a number of bars back (i.e., historical offset): 𝚝𝚒𝚖𝚎(), 𝚝𝚒𝚖𝚎𝙲𝚕𝚘𝚜𝚎(), 𝚟𝚊𝚕𝚞𝚎() Methods to retrieve all the data points from the earliest bar (or latest bar) stored in memory, which can be useful for debugging purposes: 𝚐𝚎𝚝𝙴𝚊𝚛𝚕𝚒𝚎𝚜𝚝𝚂𝚝𝚘𝚛𝚎𝚍𝙳𝚊𝚝𝚊(), 𝚐𝚎𝚝𝙻𝚊𝚝𝚎𝚜𝚝𝚂𝚝𝚘𝚛𝚎𝚍𝙳𝚊𝚝𝚊() Note: the library's strong suit is referencing data from very old bars in the past, which is especially useful for scripts that perform its necessary calculations only on the last bar. █  USAGE Step 1 Import the library. Replace with the latest available version number for this library. //@version=6 indicator("Usage") import n00btraders/ChartData/ Step 2 Create a 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object to collect data on every bar. Do not declare as `var` or `varip`. chartData = ChartData.collectChartData() // call on every bar to accumulate the necessary data Step 3 Call any method(s) on the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object. Do not modify its fields directly. if barstate.islast int firstBarTime = chartData.timeAtBarIndex(0) int lastBarTime = chartData.time(0) log.info("First `time`: " + str.format_time(firstBarTime) + ", Last `time`: " + str.format_time(lastBarTime)) █  EXAMPLES • Collect Future Times The overloaded 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() functions that accept a 𝚋𝚊𝚛𝚜𝙵𝚘𝚛𝚠𝚊𝚛𝚍 argument can additionally store time values for up to 500 bars into the future. //@version=6 indicator("Example `collectChartData(barsForward)`") import n00btraders/ChartData/1 chartData = ChartData.collectChartData(barsForward = 500) var rectangle = box.new(na, na, na, na, xloc = xloc.bar_time, force_overlay = true) if barstate.islast int futureTime = chartData.timeAtBarIndex(bar_index + 100) int lastBarTime = time box.set_lefttop(rectangle, lastBarTime, open) box.set_rightbottom(rectangle, futureTime, close) box.set_text(rectangle, "Extending box 100 bars to the right. Time: " + str.format_time(futureTime)) • Collect Custom Data The overloaded 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() functions that accept a 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜 argument can additionally store custom user-specified values for every bar on the chart. //@version=6 indicator("Example `collectChartData(variables)`") import n00btraders/ChartData/1 var map variables = map.new() variables.put("open", open) variables.put("close", close) variables.put("open-close midpoint", (open + close) / 2) variables.put("boolean", open > close ? 1 : 0) chartData = ChartData.collectChartData(variables = variables) var fgColor = chart.fg_color var table1 = table.new(position.top_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true) var table2 = table.new(position.bottom_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true) if barstate.isfirst table.cell(table1, 0, 0, "ChartData.value()", text_color = fgColor) table.cell(table2, 0, 0, "open ", text_color = fgColor) table.merge_cells(table1, 0, 0, 1, 0) table.merge_cells(table2, 0, 0, 1, 0) for i = 1 to 8 table.cell(table1, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace) table.cell(table2, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace) table.cell(table1, 1, i, text_color = fgColor) table.cell(table2, 1, i, text_color = fgColor) if barstate.islast for i = 1 to 8 float open1 = chartData.value("open", 5000 * i) float open2 = i < 3 ? open : -1 table.cell_set_text(table1, 0, i, "chartData.value(\"open\", " + str.tostring(5000 * i) + "): ") table.cell_set_text(table2, 0, i, "open : ") table.cell_set_text(table1, 1, i, str.tostring(open1)) table.cell_set_text(table2, 1, i, open2 >= 0 ? str.tostring(open2) : "Error") • xloc.bar_index → xloc.bar_time The 𝚝𝚒𝚖𝚎 value (or 𝚝𝚒𝚖𝚎_𝚌𝚕𝚘𝚜𝚎 value) can be retrieved for any bar index that is stored in memory by the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object. //@version=6 indicator("Example `timeAtBarIndex()`") import n00btraders/ChartData/1 chartData = ChartData.collectChartData() if barstate.islast int start = bar_index - 15000 int end = bar_index - 100 // line.new(start, close, end, close) // !ERROR - `start` value is too far from current bar index start := chartData.timeAtBarIndex(start) end := chartData.timeAtBarIndex(end) line.new(start, close, end, close, xloc.bar_time, width = 10) • xloc.bar_time → xloc.bar_index Use 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡() to find the bar that a timestamp belongs to. If the timestamp falls in between the close of one bar and the open of the next bar, the 𝚜𝚗𝚊𝚙 parameter can be used to determine which bar to choose: 𝚂𝚗𝚊𝚙.𝙻𝙴𝙵𝚃 - prefer to choose the leftmost bar (typically used for closing times) 𝚂𝚗𝚊𝚙.𝚁𝙸𝙶𝙷𝚃 - prefer to choose the rightmost bar (typically used for opening times) 𝚂𝚗𝚊𝚙.𝙳𝙴𝙵𝙰𝚄𝙻𝚃 (or 𝚗𝚊) - copies the same behavior as xloc.bar_time uses for drawing objects //@version=6 indicator("Example `timestampToBarIndex()`") import n00btraders/ChartData/1 startTimeInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Session Start Time") endTimeInput = input.time(timestamp("01 Aug 2025 15:15 -0500"), "Session End Time") chartData = ChartData.collectChartData() if barstate.islastconfirmedhistory int startBarIndex = chartData.timestampToBarIndex(startTimeInput, ChartData.Snap.RIGHT) int endBarIndex = chartData.timestampToBarIndex(endTimeInput, ChartData.Snap.LEFT) line1 = line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true) line2 = line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true) linefill.new(line1, line2, color.new(color.green, 90)) // using Snap.DEFAULT to show that it is equivalent to drawing lines using `xloc.bar_time` (i.e., it aligns to the same bars) startBarIndex := chartData.timestampToBarIndex(startTimeInput) endBarIndex := chartData.timestampToBarIndex(endTimeInput) line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.yellow, width = 3) line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.yellow, width = 3) line.new(startTimeInput, 0, startTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11) line.new(endTimeInput, 0, endTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11) • Get Price of Line at Timestamp The pine script built-in function line.get_price() requires working with bar index values. To get the price of a line in terms of a timestamp, convert the timestamp into a bar index or offset. //@version=6 indicator("Example `line.get_price()` at timestamp") import n00btraders/ChartData/1 lineStartInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Line Start") chartData = ChartData.collectChartData() var diagonal = line.new(na, na, na, na, force_overlay = true) if time <= lineStartInput line.set_xy1(diagonal, bar_index, open) if barstate.islastconfirmedhistory line.set_xy2(diagonal, bar_index, close) if barstate.islast int timeOneWeekAgo = timenow - (7 * timeframe.in_seconds("1D") * 1000) // Note: could also use `timetampToBarIndex(timeOneWeekAgo, Snap.DEFAULT)` and pass the value directly to `line.get_price()` int barsOneWeekAgo = chartData.getNumberOfBarsBack(timeOneWeekAgo) float price = line.get_price(diagonal, bar_index - barsOneWeekAgo) string formatString = "Time 1 week ago: {0,number,#} - Equivalent to {1} bars ago 𝚕𝚒𝚗𝚎.𝚐𝚎𝚝_𝚙𝚛𝚒𝚌𝚎(): {2,number,#.##}" string labelText = str.format(formatString, timeOneWeekAgo, barsOneWeekAgo, price) label.new(timeOneWeekAgo, price, labelText, xloc.bar_time, style = label.style_label_lower_right, size = 16, textalign = text.align_left, force_overlay = true) █  RUNTIME ERROR MESSAGES This library's functions will generate a custom runtime error message in the following cases: 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() is not called consecutively, or is called more than once on a single bar Invalid 𝚋𝚊𝚛𝚜𝙵𝚘𝚛𝚠𝚊𝚛𝚍 argument in the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function Invalid 𝚟𝚊𝚛𝚒𝚊𝚋𝚕𝚎𝚜 argument in the 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊() function Invalid 𝚕𝚎𝚗𝚐𝚝𝚑 argument in any of the functions that accept a number of bars back Note: there is no runtime error generated for an invalid 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙 or 𝚋𝚊𝚛𝙸𝚗𝚍𝚎𝚡 argument in any of the functions. Instead, the functions will assign 𝚗𝚊 to the returned values. Any other runtime errors are due to incorrect usage of the library. █  NOTES • Function Descriptions The library source code uses Markdown for the exported functions. Hover over a function/method call in the Pine Editor to display formatted, detailed information about the function/method. //@version=6 indicator("Demo Function Tooltip") import n00btraders/ChartData/1 chartData = ChartData.collectChartData() int barIndex = chartData.timestampToBarIndex(timenow) log.info(str.tostring(barIndex)) • Historical vs. Realtime Behavior Under the hood, the data collector for this library is declared as `var`. Because of this, the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object will always reflect the latest available data on realtime updates. Any data that is recorded for historical bars will remain unchanged throughout the execution of a script. //@version=6 indicator("Demo Realtime Behavior") import n00btraders/ChartData/1 var map variables = map.new() variables.put("open", open) variables.put("close", close) chartData = ChartData.collectChartData(variables) if barstate.isrealtime varip float initialOpen = open varip float initialClose = close varip int updateCount = 0 updateCount += 1 float latestOpen = open float latestClose = close float recordedOpen = chartData.valueAtBarIndex("open", bar_index) float recordedClose = chartData.valueAtBarIndex("close", bar_index) string formatString = "# of updates: {0} 𝚘𝚙𝚎𝚗 at update #1: {1,number,#.##} 𝚌𝚕𝚘𝚜𝚎 at update #1: {2,number,#.##} " + "𝚘𝚙𝚎𝚗 at update #{0}: {3,number,#.##} 𝚌𝚕𝚘𝚜𝚎 at update #{0}: {4,number,#.##} " + "𝚘𝚙𝚎𝚗 stored in memory: {5,number,#.##} 𝚌𝚕𝚘𝚜𝚎 stored in memory: {6,number,#.##}" string labelText = str.format(formatString, updateCount, initialOpen, initialClose, latestOpen, latestClose, recordedOpen, recordedClose) label.new(bar_index, close, labelText, style = label.style_label_left, force_overlay = true) • Collecting Chart Data for Other Contexts If your use case requires collecting chart data from another context, avoid directly retrieving the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 object as this may exceed memory limits . //@version=6 indicator("Demo Return Calculated Results") import n00btraders/ChartData/1 timeInput = input.time(timestamp("01 Sep 2025 08:30 -0500"), "Time") var int oneMinuteBarsAgo = na // !ERROR - Memory Limits Exceeded // chartDataArray = request.security_lower_tf(syminfo.tickerid, "1", ChartData.collectChartData()) // oneMinuteBarsAgo := chartDataArray.last().getNumberOfBarsBack(timeInput) // function that returns calculated results (a single integer value instead of an entire `ChartData` object) getNumberOfBarsBack() => chartData = ChartData.collectChartData() chartData.getNumberOfBarsBack(timeInput) calculatedResultsArray = request.security_lower_tf(syminfo.tickerid, "1", getNumberOfBarsBack()) oneMinuteBarsAgo := calculatedResultsArray.size() > 0 ? calculatedResultsArray.last() : na if barstate.islast string labelText = str.format("The selected timestamp occurs 1-minute bars ago", oneMinuteBarsAgo) label.new(bar_index, hl2, labelText, style = label.style_label_left, size = 16, force_overlay = true) • Memory Usage The library's convenience and ease of use comes at the cost of increased usage of computational resources. For simple scripts, using this library will likely not cause any issues with exceeding memory limits. But for large and complex scripts, you can reduce memory issues by specifying a lower 𝚌𝚊𝚕𝚌_𝚋𝚊𝚛𝚜_𝚌𝚘𝚞𝚗𝚝 amount in the indicator() or strategy() declaration statement. //@version=6 // !ERROR - Memory Limits Exceeded using the default number of bars available (~20,000 bars for Premium plans) //indicator("Demo `calc_bars_count` parameter") // Reduce number of bars using `calc_bars_count` parameter indicator("Demo `calc_bars_count` parameter", calc_bars_count = 15000) import n00btraders/ChartData/1 map variables = map.new() variables.put("open", open) variables.put("close", close) variables.put("weekofyear", weekofyear) variables.put("dayofmonth", dayofmonth) variables.put("hour", hour) variables.put("minute", minute) variables.put("second", second) // simulate large memory usage chartData0 = ChartData.collectChartData(variables) chartData1 = ChartData.collectChartData(variables) chartData2 = ChartData.collectChartData(variables) chartData3 = ChartData.collectChartData(variables) chartData4 = ChartData.collectChartData(variables) chartData5 = ChartData.collectChartData(variables) chartData6 = ChartData.collectChartData(variables) chartData7 = ChartData.collectChartData(variables) chartData8 = ChartData.collectChartData(variables) chartData9 = ChartData.collectChartData(variables) log.info(str.tostring(chartData0.time(0))) log.info(str.tostring(chartData1.time(0))) log.info(str.tostring(chartData2.time(0))) log.info(str.tostring(chartData3.time(0))) log.info(str.tostring(chartData4.time(0))) log.info(str.tostring(chartData5.time(0))) log.info(str.tostring(chartData6.time(0))) log.info(str.tostring(chartData7.time(0))) log.info(str.tostring(chartData8.time(0))) log.info(str.tostring(chartData9.time(0))) if barstate.islast result = table.new(position.middle_right, 1, 1, force_overlay = true) table.cell(result, 0, 0, "Script Execution Successful ✅", text_size = 40) █  EXPORTED ENUMS Snap   Behavior for determining the bar that a timestamp belongs to.   Fields:      LEFT : Snap to the leftmost bar.      RIGHT : Snap to the rightmost bar.      DEFAULT : Default `xloc.bar_time` behavior. Note: this enum is used for the 𝚜𝚗𝚊𝚙 parameter of 𝚝𝚒𝚖𝚎𝚜𝚝𝚊𝚖𝚙𝚃𝚘𝙱𝚊𝚛𝙸𝚗𝚍𝚎𝚡(). █  EXPORTED TYPES Note: users of the library do not need to worry about directly accessing the fields of these types; all computations are done through method calls on an object of the 𝙲𝚑𝚊𝚛𝚝𝙳𝚊𝚝𝚊 type. Variable   Represents a user-specified variable that can be tracked on every chart bar.   Fields:      name (series string) : Unique identifier for the variable.      values (array) : The array of stored values (one value per chart bar). ChartData   Represents data for all bars on a chart.   Fields:      bars (series int) : Current number of bars on the chart.      timeValues (array) : The `time` values of all chart (and future) bars.      timeCloseValues (array) : The `time_close` values of all chart (and future) bars.      variables (array) : Additional custom values to track on all chart bars. █  EXPORTED FUNCTIONS collectChartData()   Collects and tracks the `time` and `time_close` value of every bar on the chart.   Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`. collectChartData(barsForward)   Collects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars.   Parameters:      barsForward (simple int) : Number of future bars to collect data for.   Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`. collectChartData(variables)   Collects and tracks the `time` and `time_close` value of every bar on the chart. Additionally, tracks a custom set of variables for every chart bar.   Parameters:      variables (simple map) : Custom values to collect on every chart bar.   Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`. collectChartData(barsForward, variables)   Collects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars. Additionally, tracks a custom set of variables for every chart bar.   Parameters:      barsForward (simple int) : Number of future bars to collect data for.      variables (simple map) : Custom values to collect on every chart bar.   Returns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`. █  EXPORTED METHODS method timestampToBarIndex(chartData, timestamp, snap)   Converts a UNIX timestamp to a bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      timestamp (series int) : A UNIX time.      snap (series Snap) : A `Snap` enum value.   Returns: A bar index, or `na` if unable to find the appropriate bar index. method getNumberOfBarsBack(chartData, timestamp)   Converts a UNIX timestamp to a history-referencing length (i.e., number of bars back).   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      timestamp (series int) : A UNIX time.   Returns: A bar offset, or `na` if unable to find a valid number of bars back. method timeAtBarIndex(chartData, barIndex)   Retrieves the `time` value for the specified bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      barIndex (int) : The bar index.   Returns: The `time` value, or `na` if there is no `time` stored for the bar index. method time(chartData, length)   Retrieves the `time` value of the bar that is `length` bars back relative to the latest bar.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      length (series int) : Number of bars back.   Returns: The `time` value `length` bars ago, or `na` if there is no `time` stored for that bar. method timeCloseAtBarIndex(chartData, barIndex)   Retrieves the `time_close` value for the specified bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      barIndex (series int) : The bar index.   Returns: The `time_close` value, or `na` if there is no `time_close` stored for the bar index. method timeClose(chartData, length)   Retrieves the `time_close` value of the bar that is `length` bars back from the latest bar.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      length (series int) : Number of bars back.   Returns: The `time_close` value `length` bars ago, or `na` if there is none stored. method valueAtBarIndex(chartData, name, barIndex)   Retrieves the value of a custom variable for the specified bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      name (series string) : The variable name.      barIndex (series int) : The bar index.   Returns: The value of the variable, or `na` if that variable is not stored for the bar index. method value(chartData, name, length)   Retrieves a variable value of the bar that is `length` bars back relative to the latest bar.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      name (series string) : The variable name.      length (series int) : Number of bars back.   Returns: The value `length` bars ago, or `na` if that variable is not stored for the bar index. method getAllVariablesAtBarIndex(chartData, barIndex)   Retrieves all custom variables for the specified bar index.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      barIndex (series int) : The bar index.   Returns: Map of all custom variables that are stored for the specified bar index. method getEarliestStoredData(chartData)   Gets all values from the earliest bar data that is currently stored in memory.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.   Returns: A tuple: method getLatestStoredData(chartData, futureData)   Gets all values from the latest bar data that is currently stored in memory.   Namespace types: ChartData   Parameters:      chartData (series ChartData) : The `ChartData` object.      futureData (series bool) : Whether to include the future data that is stored in memory.   Returns: A tuple:
Libreria Pine Script®
di n00btraders
6
Correlation Heatmap Matrix [TradingFinder] 20 Assets Variable🔵 Introduction Correlation is one of the most important statistical and analytical metrics in financial markets, data mining, and data science. It measures the strength and direction of the relationship between two variables. The correlation coefficient always ranges between +1 and -1 : a perfect positive correlation (+1) means that two assets or currency pairs move together in the same direction and at a constant ratio, a correlation of zero (0) indicates no clear linear relationship, and a perfect negative correlation (-1) means they move in exactly opposite directions. While the Pearson Correlation Coefficient is the most common method for calculation, other statistical methods like Spearman and Kendall are also used depending on the context. In financial market analysis, correlation is a key tool for Forex, the Stock Market, and the Cryptocurrency Market because it allows traders to assess the price relationship between currency pairs, stocks, or coins. For example, in Forex, EUR/USD and GBP/USD often have a high positive correlation; in stocks, companies from the same sector such as Apple and Microsoft tend to move similarly; and in crypto, most altcoins show a strong positive correlation with Bitcoin. Using a Correlation Heatmap in these markets visually displays the strength and direction of these relationships, helping traders make more accurate decisions for risk management and strategy optimization. 🟣 Correlation in Financial Markets In finance, correlation refers to measuring how closely two assets move together over time. These assets can be stocks, currency pairs, commodities, indices, or cryptocurrencies. The main goal of correlation analysis in trading is to understand these movement patterns and use them for risk management, trend forecasting, and developing trading strategies. 🟣 Correlation Heatmap A correlation heatmap is a visual tool that presents the correlation between multiple assets in a color-coded table. Each cell shows the correlation coefficient between two assets, with colors indicating its strength and direction. Warm colors (such as red or orange) represent strong negative correlation, cool colors (such as blue or cyan) represent strong positive correlation, and mid-range tones (such as yellow or green) indicate correlations that are close to neutral. 🟣 Practical Applications in Markets Forex : Identify currency pairs that move together or in opposite directions, avoid overexposure to similar trades, and spot unusual divergences. Crypto : Examine the dependency of altcoins on Bitcoin and find independent movers for portfolio diversification. Stocks : Detect relationships between stocks in the same industry or find outliers that move differently from their sector. 🟣 Key Uses of Correlation in Trading Risk management and diversification: Select assets with low or negative correlation to reduce portfolio volatility. Avoiding overexposure: Prevent opening multiple positions on highly correlated assets. Pairs trading: Exploit temporary deviations between historically correlated assets for arbitrage opportunities. Intermarket analysis: Study the relationships between different markets like stocks, currencies, commodities, and bonds. Divergence detection: Spot when two typically correlated assets move apart as a possible trend change signal. Market forecasting: Use correlated asset movements to anticipate others’ behavior. Event reaction analysis: Evaluate how groups of assets respond to economic or political events. ❗ Important Note It’s important to note that correlation does not imply causation — it only reflects co-movement between assets. Correlation is also dynamic and can change over time, which is why analyzing it across multiple timeframes provides a more accurate picture. Combining correlation heatmaps with other analytical tools can significantly improve the precision of trading decisions. 🔵 How to Use The Correlation Heatmap Matrix indicator is designed to analyze and manage the relationships between multiple assets at once. After adding the tool to your chart, start by selecting the assets you want to compare (up to 20). Then, choose the Correlation Period that fits your trading strategy. Shorter periods (e.g., 20 bars) are more sensitive to recent price movements, making them suitable for short-term trading, while longer periods (e.g., 100 or 200 bars) provide a broader view of correlation trends over time. The indicator outputs a color-coded matrix where each cell represents the correlation between two assets. Warm colors like red and orange signal strong negative correlation, while cool colors like blue and cyan indicate strong positive correlation. Mid-range tones such as yellow or green suggest correlations that are close to neutral. This visual representation makes it easy to spot market patterns at a glance. One of the most valuable uses of this tool is in portfolio risk management. Portfolios with highly correlated assets are more vulnerable to market swings. By using the heatmap, traders can find assets with low or negative correlation to reduce overall risk. Another key benefit is preventing overexposure. For example, if EUR/USD and GBP/USD have a high positive correlation, opening trades on both is almost like doubling the position size on one asset, increasing risk unnecessarily. The heatmap makes such relationships clear, helping you avoid them. The indicator is also useful for pairs trading, where a trader identifies assets that are usually correlated but have temporarily diverged — a potential arbitrage or mean-reversion opportunity. Additionally, the tool supports intermarket analysis, allowing traders to see how movements in one market (e.g., crude oil) may impact others (e.g., the Canadian dollar). Divergence detection is another advantage: if two typically aligned assets suddenly move in opposite directions, it could signal a major trend shift or a news-driven move. Overall, the Correlation Heatmap Matrix is not just an analytical indicator but also a fast, visual alert system for monitoring multiple markets at once. This is particularly valuable for traders in fast-moving environments like Forex and crypto. 🔵 Settings 🟣 Logic Correlation Period : Number of bars used to calculate correlation between assets. 🟣 Display Table on Chart : Enable/disable displaying the heatmap directly on the chart. Table Size : Choose the table size (from very small to very large). Table Position : Set the table location on the chart (top, middle, or bottom in various alignments). 🟣 Symbol Custom Select Market : Choose the market type (Forex, Stocks, Crypto, or Custom). Symbol 1 to Symbol 20: In custom mode, you can define up to 20 assets for correlation calculation. 🔵 Conclusion The Correlation Heatmap Matrix is a powerful tool for analyzing correlations across multiple assets in Forex, crypto, and stock markets. By displaying a color-coded table, it visually conveys both the strength and direction of correlations — warm colors for strong negative correlation, cool colors for strong positive correlation, and mid-range tones such as yellow or green for near-zero or neutral correlation. This helps traders select assets with low or negative correlation for diversification, avoid overexposure to similar trades, identify arbitrage and pairs trading opportunities, and detect unusual divergences between typically aligned assets. With support for custom mode and up to 20 symbols, it offers high flexibility for different trading strategies, making it a valuable complement to technical analysis and risk management.
Indicatore Pine Script®
di TFlab
5
Correlation HeatMap Matrix Data [TradingFinder]🔵 Introduction Correlation is a statistical measure that shows the degree and direction of a linear relationship between two assets. Its value ranges from -1 to +1 : +1 means perfect positive correlation, 0 means no linear relationship, and -1 means perfect negative correlation. In financial markets, correlation is used for portfolio diversification, risk management, pairs trading, intermarket analysis, and identifying divergences. Correlation HeatMap Matrix Data TradingFinder is a Pine Script v6 library that calculates and returns raw correlation matrix data between up to 20 symbols. It only provides the data – it does not draw or render the heatmap – making it ideal for use in other scripts that handle visualization or further analysis. The library uses ta.correlation for fast and accurate calculations. It also includes two helper functions for visual styling : CorrelationColor(corr) : takes the correlation value as input and generates a smooth gradient color, ranging from strong negative to strong positive correlation. CorrelationTextColor(corr) : takes the correlation value as input and returns a text color that ensures optimal contrast over the background color. Library "Correlation_HeatMap_Matrix_Data_TradingFinder" CorrelationColor(corr)   Parameters:      corr (float) CorrelationTextColor(corr)   Parameters:      corr (float) Data_Matrix(Corr_Period, Sym_1, Sym_2, Sym_3, Sym_4, Sym_5, Sym_6, Sym_7, Sym_8, Sym_9, Sym_10, Sym_11, Sym_12, Sym_13, Sym_14, Sym_15, Sym_16, Sym_17, Sym_18, Sym_19, Sym_20)   Parameters:      Corr_Period (int)      Sym_1 (string)      Sym_2 (string)      Sym_3 (string)      Sym_4 (string)      Sym_5 (string)      Sym_6 (string)      Sym_7 (string)      Sym_8 (string)      Sym_9 (string)      Sym_10 (string)      Sym_11 (string)      Sym_12 (string)      Sym_13 (string)      Sym_14 (string)      Sym_15 (string)      Sym_16 (string)      Sym_17 (string)      Sym_18 (string)      Sym_19 (string)      Sym_20 (string) 🔵 How to use Import the library into your Pine Script using the import keyword and its full namespace. Decide how many symbols you want to include in your correlation matrix (up to 20). Each symbol must be provided as a string, for example FX:EURUSD . Choose the correlation period (Corr\_Period) in bars. This is the lookback window used for the calculation, such as 20, 50, or 100 bars. Call Data_Matrix(Corr_Period, Sym_1, ..., Sym_20) with your selected parameters. The function will return an array containing the correlation values for every symbol pair (upper triangle of the matrix plus diagonal). For example : var string Sym_1 = '' , var string Sym_2 = '' , var string Sym_3 = '' , var string Sym_4 = '' , var string Sym_5 = '' , var string Sym_6 = '' , var string Sym_7 = '' , var string Sym_8 = '' , var string Sym_9 = '' , var string Sym_10 = '' var string Sym_11 = '', var string Sym_12 = '', var string Sym_13 = '', var string Sym_14 = '', var string Sym_15 = '', var string Sym_16 = '', var string Sym_17 = '', var string Sym_18 = '', var string Sym_19 = '', var string Sym_20 = '' switch Market 'Forex' => Sym_1 := 'EURUSD' , Sym_2 := 'GBPUSD' , Sym_3 := 'USDJPY' , Sym_4 := 'USDCHF' , Sym_5 := 'USDCAD' , Sym_6 := 'AUDUSD' , Sym_7 := 'NZDUSD' , Sym_8 := 'EURJPY' , Sym_9 := 'EURGBP' , Sym_10 := 'GBPJPY' ,Sym_11 := 'AUDJPY', Sym_12 := 'EURCHF', Sym_13 := 'EURCAD', Sym_14 := 'GBPCAD', Sym_15 := 'CADJPY', Sym_16 := 'CHFJPY', Sym_17 := 'NZDJPY', Sym_18 := 'AUDNZD', Sym_19 := 'USDSEK' , Sym_20 := 'USDNOK' 'Stock' => Sym_1 := 'NVDA' , Sym_2 := 'AAPL' , Sym_3 := 'GOOGL' , Sym_4 := 'GOOG' , Sym_5 := 'META' , Sym_6 := 'MSFT' , Sym_7 := 'AMZN' , Sym_8 := 'AVGO' , Sym_9 := 'TSLA' , Sym_10 := 'BRK.B' ,Sym_11 := 'UNH' , Sym_12 := 'V' , Sym_13 := 'JPM' , Sym_14 := 'WMT' , Sym_15 := 'LLY' , Sym_16 := 'ORCL', Sym_17 := 'HD' , Sym_18 := 'JNJ' , Sym_19 := 'MA' , Sym_20 := 'COST' 'Crypto' => Sym_1 := 'BTCUSD' , Sym_2 := 'ETHUSD' , Sym_3 := 'BNBUSD' , Sym_4 := 'XRPUSD' , Sym_5 := 'SOLUSD' , Sym_6 := 'ADAUSD' , Sym_7 := 'DOGEUSD' , Sym_8 := 'AVAXUSD' , Sym_9 := 'DOTUSD' , Sym_10 := 'TRXUSD' ,Sym_11 := 'LTCUSD' , Sym_12 := 'LINKUSD', Sym_13 := 'UNIUSD', Sym_14 := 'ATOMUSD', Sym_15 := 'ICPUSD', Sym_16 := 'ARBUSD', Sym_17 := 'APTUSD', Sym_18 := 'FILUSD', Sym_19 := 'OPUSD' , Sym_20 := 'USDT.D' 'Custom' => Sym_1 := Sym_1_C , Sym_2 := Sym_2_C , Sym_3 := Sym_3_C , Sym_4 := Sym_4_C , Sym_5 := Sym_5_C , Sym_6 := Sym_6_C , Sym_7 := Sym_7_C , Sym_8 := Sym_8_C , Sym_9 := Sym_9_C , Sym_10 := Sym_10_C ,Sym_11 := Sym_11_C, Sym_12 := Sym_12_C, Sym_13 := Sym_13_C, Sym_14 := Sym_14_C, Sym_15 := Sym_15_C, Sym_16 := Sym_16_C, Sym_17 := Sym_17_C, Sym_18 := Sym_18_C, Sym_19 := Sym_19_C , Sym_20 := Sym_20_C = Corr.Data_Matrix(Corr_period, Sym_1 ,Sym_2 ,Sym_3 ,Sym_4 ,Sym_5 ,Sym_6 ,Sym_7 ,Sym_8 ,Sym_9 ,Sym_10,Sym_11,Sym_12,Sym_13,Sym_14,Sym_15,Sym_16,Sym_17,Sym_18,Sym_19,Sym_20) Loop through or index into this array to retrieve each correlation value for your custom layout or logic. Pass each correlation value to CorrelationColor() to get the corresponding gradient background color, which reflects the correlation’s strength and direction (negative to positive). For example : Corr.CorrelationColor(SYM_3_10) Pass the same correlation value to CorrelationTextColor() to get the correct text color for readability against that background. For example : Corr.CorrelationTextColor(SYM_1_1) Use these colors in a table or label to render your own heatmap or any other visualization you need.
Libreria Pine Script®
di TFlab
1
Correlation HeatMap [TradingFinder] Sessions Data Science Stats🔵 Introduction n financial markets, correlation describes the statistical relationship between the price movements of two assets and how they interact over time. It plays a key role in both trading and investing by helping analyze asset behavior, manage portfolio risk, and understand intermarket dynamics. The Correlation Heatmap is a visual tool that shows how the correlation between multiple assets and a central reference asset (the Main Symbol) changes over time. It supports four market types forex, stocks, crypto, and a custom mode making it adaptable to different trading environments. The heatmap uses a color-coded grid where warmer tones represent stronger negative correlations and cooler tones indicate stronger positive ones. This intuitive color system allows traders to quickly identify when assets move together or diverge, offering real-time insights that go beyond traditional correlation tables. 🟣 How to Interpret the Heatmap Visually ? Each cell represents the correlation between the main symbol and one compared asset at a specific time. Warm colors (e.g. red, orange) suggest strong negative correlation as one asset rises, the other tends to fall. Cool colors (e.g. blue, green) suggest strong positive correlation both assets tend to move in the same direction. Lighter shades indicate weaker correlations, while darker shades indicate stronger correlations. The heatmap updates over time, allowing users to detect changes in correlation during market events or trading sessions. One of the standout features of this indicator is its ability to overlay global market sessions such as Tokyo, London, New York, or major equity opens directly onto the heatmap timeline. This alignment lets traders observe how correlation structures respond to real-world session changes. For example, they can spot when assets shift from being inversely correlated to moving together as a new session opens, potentially signaling new momentum or macro flow. The customizable symbol setup (including up to 20 compared assets) makes it ideal not only for forex and crypto traders but also for multi-asset and sector-based stock analysis. 🟣 Use Cases and Advantages Analyze sector rotation in equities by tracking correlation to major indices like SPX or DJI. Monitor altcoin behavior relative to Bitcoin to find early entry opportunities in crypto markets. Detect changes in currency alignment with DXY across trading sessions in forex. Identify correlation breakdowns during market volatility, signaling possible new trends. Use correlation shifts as confirmation for trade setups or to hedge multi-asset exposure 🔵 How to Use Correlation is one of the core concepts in financial analysis and allows traders to understand how assets behave in relation to one another. The Correlation Heatmap extends this idea by going beyond a simple number or static matrix. Instead, it presents a dynamic visual map of how correlations shift over time. In this indicator, a Main Symbol is selected as the reference point for analysis. In standard modes such as forex, stocks, or crypto, the symbol currently shown on the main chart is automatically used as the main symbol. This allows users to begin correlation analysis right away without adjusting any settings. The horizontal axis of the heatmap shows time, while the vertical axis lists the selected assets. Each cell on the heatmap shows the correlation between that asset and the main symbol at a given moment. This approach is especially useful for intermarket analysis. In forex, for example, tracking how currency pairs like OANDA:EURUSD EURUSD, FX:GBPUSD GBPUSD, and PEPPERSTONE:AUDUSD AUDUSD correlate with TVC:DXY DXY can give insight into broader capital flow. If these pairs start showing increasing positive correlation with DXY say, shifting from blue to light green it could signal the start of a new phase or reversal. Conversely, if negative correlation fades gradually, it may suggest weakening relationships and more independent or volatile movement. In the crypto market, watching how altcoins correlate with Bitcoin can help identify ideal entry points in secondary assets. In the stock market, analyzing how companies within the same sector move in relation to a major index like SP:SPX SPX or DJ:DJI DJI is also a highly effective technique for both technical and fundamental analysts. This indicator not only visualizes correlation but also displays major market sessions. When enabled, this feature helps traders observe how correlation behavior changes at the start of each session, whether it's Tokyo, London, New York, or the opening of stock exchanges. Many key shifts, breakouts, or reversals tend to happen around these times, and the heatmap makes them easy to spot. Another important feature is the market selection mode. Users can switch between forex, crypto, stocks, or custom markets and see correlation behavior specific to each one. In custom mode, users can manually select any combination of symbols for more advanced or personalized analysis. This makes the heatmap valuable not only for forex traders but also for stock traders, crypto analysts, and multi-asset strategists. Finally, the heatmap's color-coded design helps users make sense of the data quickly. Warm colors such as red and orange reflect stronger negative correlations, while cool colors like blue and green represent stronger positive relationships. This simplicity and clarity make the tool accessible to both beginners and experienced traders. 🔵 Settings Correlation Period: Allows you to set how many historical bars are used for calculating correlation. A higher number means a smoother, slower-moving heatmap, while a lower number makes it more responsive to recent changes. Select Market: Lets you choose between Forex, Stock, Crypto, or Custom. In the first three options, the chart’s active symbol is automatically used as the Main Symbol. In Custom mode, you can manually define the Main Symbol and up to 20 Compared Symbols. Show Open Session: Enables the display of major trading sessions such as Tokyo, London, New York, or equity market opening hours directly on the timeline. This helps you connect correlation shifts with real-world market activity. Market Mode: Lets you select whether the displayed sessions relate to the forex or stock market. 🔵 Conclusion The Correlation Heatmap is a robust and flexible tool for analyzing the relationship between assets across different markets. By tracking how correlations change in real time, traders can better identify alignment or divergence between symbols and gain valuable insights into market structure. Support for multiple asset classes, session overlays, and intuitive visual cues make this one of the most effective tools for intermarket analysis. Whether you’re looking to manage portfolio risk, validate entry points, or simply understand capital flow across markets, this heatmap provides a clear and actionable perspective that you can rely on.
Indicatore Pine Script®
di TFlab
4
Stock Table aiTrendviewProfessional Stock Market Monitoring Table (Pine Script v5) This indicator is a real-time multi-asset monitoring table designed for professional traders, analysts, and portfolio managers using TradingView. Built with Pine Script v5, it enables users to track up to 10 instruments (stocks, indices, forex pairs, cryptocurrencies, or commodities) in a unified table embedded directly into the chart. It is intended to streamline portfolio monitoring, cross-market analysis, and rapid visual comparison of asset performance. The core logic of this script involves retrieving live price data through TradingView’s request.security() function for each of the selected symbols. It calculates both absolute price change and percentage price change relative to the previous bar close. This ensures users can see real-time movements in each asset’s price. These calculations are updated at the close of every bar to optimize performance and reduce processing load using the barstate.islast condition. The display structure is dynamically generated using table.new() and related functions. Internally, the script stores symbol and price data in arrays for efficient processing. Symbols are cleaned to remove exchange prefixes (e.g., "NASDAQ:", "BINANCE:") so only the ticker name is displayed. Based on the selected layout (1 to 5 columns), the table auto-adjusts its row structure to maintain clarity and symmetry. Each cell reflects the ticker symbol, current price, and changes, with conditional formatting applied to indicate price movement direction using green (positive), red (negative), or neutral colors. Users can customize many visual elements including text size, color themes, transparency, table position, and whether headers are shown. The script includes built-in fallbacks for invalid symbols or empty data, ensuring robustness and uninterrupted performance during live market hours. Use cases include: Intraday traders monitoring multiple instruments simultaneously. Swing traders assessing relative strength and correlation. Portfolio managers scanning asset performance without switching charts. Analysts preparing multi-asset presentations or watchlists. To use the tool: Paste the Pine Script into the Pine Editor. Add the script to the chart. Enter your desired symbols via the input fields. Customize table position, layout, size, and color to suit your workspace. This script does not provide trade signals or financial advice. It is purely a market visualization and data presentation tool. All calculations are based on live chart data and are synchronized with the chart’s timeframe. Disclaimer from aiTrendview: This script is a visual tool developed for market awareness and comparative observation. It does not constitute financial advice or guarantee trading results. aiTrendview and its affiliates are not responsible for any losses arising from decisions made based on this tool. All trading involves risk, and past performance is not indicative of future results. Always consult with a qualified financial advisor before making trading decisions.
Indicatore Pine Script®
di aiTrendview-Charting-System
Ticker DataThis script mostly for Pine coders but may be useful for regular users too. I often find myself needing quick access to certain information about a ticker — like its full ticker name, mintick, last bar index and so on. Usually, I write a few lines of code just to display this info and check it. Today I got tired of doing that manually, so I created a small script that shows the most essential data in one place. I also added a few extra fields that might be useful or interesting to regular users. Description for regular users (from Pine Script Reference Manual) tickerid - full ticker name description - description for the current symbol industry - the industry of the symbol. Example: "Internet Software/Services", "Packaged software", "Integrated Oil", "Motor Vehicles", etc. country - the two-letter code of the country where the symbol is traded sector - the sector of the symbol. Example: "Electronic Technology", "Technology services", "Energy Minerals", "Consumer Durables", etc. session - session type (regular or extended) timezone - timezone of the exchange of the chart type - the type of market the symbol belongs to. Example: "stock", "fund", "index", "forex", "futures", "spread", "economic", "fundamental", "crypto". volumetype - volume type of the current symbol. mincontract - the smallest amount of the current symbol that can be traded mintick - min tick value for the current symbol (the smallest increment between a symbol's price movements) pointvalue - point value for the current symbol pricescale - a whole number used to calculate mintick (usually (when minmove is 1), it shows the resolution — how many decimal places the price has. For example, a pricescale 100 means the price will have two decimal places - 1 / 100 = 0.01) bar index - last bar index (if add 1 (because indexes starts from 0) it will shows how many bars available to you on the chart) If you need some more information at table feel free to leave a comment.
Indicatore Pine Script®
di NoveltyTrade
Correlation Coefficient Master TableThe Correlation Coefficient Master Table is a comprehensive tool designed to calculate and visualize the correlation coefficient between a selected base asset and multiple other assets over various time periods. It provides traders and analysts with a clear understanding of the relationships between assets, enabling them to analyze trends, diversification opportunities, and market dynamics. You can define key parameters such as the base asset’s data source (e.g., close price), the assets to compare against (up to six symbols), and multiple lookback periods for granular analysis. The indicator calculates the covariance and normalizes it by the product of the standard deviations. The correlation coefficient ranges from -1 to +1, with +1 indicating a perfect positive relationship, -1 a perfect negative relationship, and 0 no relationship. You can specify the lookback periods (e.g., 15, 30, 90, or 120 bars) to tailor the calculation to their analysis needs. The results are visualized as both a line plot and a table. The line plot shows the correlation over the primary lookback period (the Chart Length), which can be used to inspect a certain length close up, or could be used in conjunction with the table to provide you with five lookback periods at once for the same base asset. The dynamically created table provides a detailed breakdown of correlation values for up to six target assets across the four user-defined lengths. The table’s cells are formatted with rounded values and color-coded for easy interpretation. This indicator is ideal for traders, portfolio managers, and market researchers who need an in-depth understanding of asset interdependencies. By providing both the numerical correlation coefficients and their visual representation, users can easily identify patterns, assess diversification strategies, and monitor correlations across multiple timeframes, making it a valuable tool for decision-making.
Indicatore Pine Script®
di DeVrizii
Dynamic Risk-Adjusted Performance Ratios with TableWith this indicator, you have everything you need to monitor and compare the Sharpe ratio, Sortino ratio, and Omega ratio across multiple assets—all in one place. This tool is designed to help save time and improve efficiency by letting you track up to 15 assets simultaneously in a fully customizable table. You can adjust the lookback period to fit your trading strategy and get a clearer picture of how your assets perform over time. Instead of switching between charts, this indicator puts all the critical information you need at your fingertips. Sharpe Ratio - Helps evaluate the overall efficiency of investments by comparing the average return to the total risk (measured by the standard deviation of all returns). Essentially, it tells you how much excess return you’re getting for each unit of risk you’re taking. A higher Sharpe ratio means you’re getting better risk-adjusted performance—something you’ll want to aim for in your portfolio. Sortino Ratio - Goes a step further by focusing only on downside risk—because let’s face it, no one worries about positive volatility. This ratio is calculated by dividing the average return by the standard deviation of only the negative returns. Perfect for those concerned about avoiding losses rather than chasing extreme gains. It gives you a sharper view of how well your assets are performing relative to the risks you’re trying to avoid. Omega Ratio - Offers a unique perspective by comparing the sum of positive returns to the absolute sum of negative returns. It’s a straightforward way to see if your wins outweigh your losses. A higher Omega ratio means your positive returns significantly exceed the downside, which is exactly what you want when building a strong, reliable portfolio. This indicator is perfect for traders who want to streamline their decision-making process and gain an edge. Bringing together these three critical ratios into a single user-defined table makes it easy to compare and rank assets at a glance. Whether optimizing a portfolio or looking for the best opportunities, this tool helps you stay ahead by focusing on risk-adjusted returns. The customizable lookback period lets you tailor the analysis to fit your unique trading approach, giving you insights that align with your goals. If you’re serious about making data-driven decisions and improving your trading outcomes, this indicator is a game-changer for your toolkit.
Indicatore Pine Script®
di DeVrizii
Market Cycles The Market Cycles indicator transforms market price data into a stochastic wave, offering a unique perspective on market cycles. The wave is bounded between positive and negative values, providing clear visual cues for potential bullish and bearish trends. When the wave turns green, it signals a bullish cycle, while red indicates a bearish cycle. Designed to show clarity and precision, this tool helps identify market momentum and cyclical behavior in an intuitive way. Ideal for fine-tuning entries or analyzing broader trends, this indicator aims to enhance the decision-making process with simplicity and elegance.
Indicatore Pine Script®
di Zoe-Yoshev-Bepisgat
1
Candlestick DataCandlestick Data Indicator The Candlestick Data indicator provides a comprehensive overview of key metrics for analyzing price action and volume in real-time. This overlay indicator displays essential candlestick data and calculations directly on your chart, offering an all-in-one toolkit for traders seeking in-depth insights. Key Features: Price Metrics: View the daily high, low, close, and percentage change. Volume Insights: Analyze volume, relative volume, and volume buzz for breakout or consolidation signals. Range Analysis: Includes closing range, distance from low of day (LoD), and percentage change in daily range expansion. Advanced Metrics: Calculate ADR% (Average Daily Range %), ATR (Average True Range), and % from 52-week high. Moving Averages: Supports up to four customizable moving averages (EMA or SMA) with distance from price. Market Context: Displays the sector and industry group for the asset. This indicator is fully customizable, allowing you to toggle on or off specific metrics to suit your trading style. Designed for active traders, it brings critical data to your fingertips, streamlining decision-making and enhancing analysis. Perfect for momentum, swing, and day traders looking to gain a data-driven edge!
Indicatore Pine Script®
di Ollie_AllCaps
17
Volume CalendarDescription: The indicator displays a calendar with Volume data for up to 6 last months. It is designed to work on any timeframe, but works best on Daily and below. It is also consistent in that it displays the same data even if you go to lower timeframes like 5 minutes (even though the data is used is Daily). Features: - displays volume data for last N months (volume, volume change, % of weekly, monthly and yearly volume) - display total volume for each month - display monthly sentiment - find dates with volume spikes Inputs: - Number of months -> how many last months of data to display (from 1 to 6) - Volume Type -> display only Bullish, only Bearish or all volume - Cell color is based on -> Volume - the brighter the cell the higher volume was on that day; Volume Change - the brighter the cell the higher was the volume change that day; Volume Spike - the brighter the cell the higher was volume spike that day (volume spike is based on volume being above its average over last N candles) - Cell color timeframe -> Weekly - the cell color is calculated comparing volume of that cell with weekly volume; Monthly - comparing volume with monthly volume - Use volume for sentiment -> take the volume into account when calculating monthly sentiment (otherwise calculate it based on number of Bullish and Bearish days in the month) - Spike Average Period -> period of the moving average used for spike calculation - Spike Threshold -> current volume must be this many times greater than the average for it to be considered a spike - Table Size -> size of the table - Theme -> colouring of the table
Indicatore Pine Script®
di sabricat
csv_series_libraryThe CSV Series Library is an innovative tool designed for Pine Script developers to efficiently parse and handle CSV data for series generation. This library seamlessly integrates with TradingView, enabling the storage and manipulation of large CSV datasets across multiple Pine Script libraries. It's optimized for performance and scalability, ensuring smooth operation even with extensive data. Features: Multi-library Support: Allows for distribution of large CSV datasets across several libraries, ensuring efficient data management and retrieval. Dynamic CSV Parsing: Provides robust Python scripts for reading, formatting, and partitioning CSV data, tailored specifically for Pine Script requirements. Extensive Data Handling: Supports parsing CSV strings into Pine Script-readable series, facilitating complex financial data analysis. Automated Function Generation: Automatically wraps CSV blocks into distinct Pine Script functions, streamlining the process of integrating CSV data into Pine Script logic. Usage: Ideal for traders and developers who require extensive data analysis capabilities within Pine Script, especially when dealing with large datasets that need to be partitioned into manageable blocks. The library includes a set of predefined functions for parsing CSV data into usable series, making it indispensable for advanced trading strategy development. Example Implementation: CSV data is transformed into Pine Script series using generated functions. Multiple CSV blocks can be managed and parsed, allowing for flexible data series creation. The library includes comprehensive examples demonstrating the conversion of standard CSV files into functional Pine Script code. To effectively utilize the CSV Series Library in Pine Script, it is imperative to initially generate the correct data format using the accompanying Python program. Here is a detailed explanation of the necessary steps: 1. Preparing the CSV Data: The Python script provided with the CSV Series Library is designed to handle CSV files that strictly contain no-space, comma-separated single values. It is crucial that your CSV file adheres to this format to ensure compatibility and correctness of the data processing. 2. Using the Python Program to Generate Data: Once your CSV file is prepared, you need to use the Python program to convert this file into a format that Pine Script can interpret. The Python script performs several key functions: Reads the CSV file, ensuring that it matches the required format of no-space, comma-separated values. Formats the data into blocks, where each block is a string of data that does not exceed a specified character limit (default is 4,000 characters). This helps manage large datasets by breaking them down into manageable chunks. Wraps these blocks into Pine Script functions, each block being encapsulated in its own function to maintain organization and ease of access. 3. Generating and Managing Multiple Libraries: If the data from your CSV file exceeds the Pine Script or platform limits (e.g., too many characters for a single script), the Python script can split this data into multiple blocks across several files. 4. Creating a Pine Script Library: After generating the formatted data blocks, you must create a Pine Script library where these blocks are integrated. Each block of data is contained within its function, like my_csv_0(), my_csv_1(), etc. The full_csv() function in Pine Script then dynamically loads and concatenates these blocks to reconstruct the full data series. 5. Exporting the full_csv() Function: Once your Pine Script library is set up with all the CSV data blocks and the full_csv() function, you export this function from the library. This exported function can then be used in your actual trading projects. It allows Pine Script to access and utilize the entire dataset as if it were a single, continuous series, despite potentially being segmented across multiple library files. 6. Reconstructing the Full Series Using vec : When your dataset is particularly large, necessitating division into multiple parts, the vec type is instrumental in managing this complexity. Here’s how you can effectively reconstruct and utilize your segmented data: Definition of vec Type: The vec type in Pine Script is specifically designed to hold a dataset as an array of floats, allowing you to manage chunks of CSV data efficiently. Creating an Array of vec Instances: Once you have your data split into multiple blocks and each block is wrapped into its own function within Pine Script libraries, you will need to construct an array of vec instances. Each instance corresponds to a segment of your complete dataset. Using array.from(): To create this array, you utilize the array.from() function in Pine Script. This function takes multiple arguments, each being a vec instance that encapsulates a data block. Here’s a generic example: vec series_vector = array.from(vec.new(data_block_1), vec.new(data_block_2), ..., vec.new(data_block_n)) In this example, data_block_1, data_block_2, ..., data_block_n represent the different segments of your dataset, each returned from their respective functions like my_csv_0(), my_csv_1(), etc. Accessing and Utilizing the Data: Once you have your vec array set up, you can access and manipulate the full series through Pine Script functions designed to handle such structures. You can traverse through each vec instance, processing or analyzing the data as required by your trading strategy. This approach allows Pine Script users to handle very large datasets that exceed single-script limits by segmenting them and then methodically reconstructing the dataset for comprehensive analysis. The vec structure ensures that even with segmentation, the data can be accessed and utilized as if it were contiguous, thus enabling powerful and flexible data manipulation within Pine Script. Library "csv_series_library" A library for parsing and handling CSV data to generate series in Pine Script. Generally you will store the csv strings generated from the python code in libraries. It is set up so you can have multiple libraries to store large chunks of data. Just export the full_csv() function for use with this library. method csv_parse(data)   Namespace types: array   Parameters:      data (array) method make_series(series_container, start_index)   Namespace types: array   Parameters:      series_container (array)      start_index (int)   Returns: A tuple containing the current value of the series and a boolean indicating if the data is valid. method make_series(series_vector, start_index)   Namespace types: array   Parameters:      series_vector (array)      start_index (int)   Returns: A tuple containing the current value of the series and a boolean indicating if the data is valid. vec   A type that holds a dataset as an array of float arrays.   Fields:      data_set (array) : A chunk of csv data. (A float array)
Libreria Pine Script®
di The_Peaceful_Lizard
ADR Study [TFO]This indicator is focused on the Average Daily Range (ADR), with the goal of collecting data to show how often price reaches/closes through these levels, as well as a look at historical moves that reached ADR and at similar times of day to study how price moved for the remainder of the session. The ADR here (blue line) is calculated using the difference between a day's highest and lowest points. If our ADR length is 5, then we are taking this difference from the last 5 days and averaging them together. At the following day's open, we take half of this average and plot it above and below the daily opening price to place theoretical limits on how far price may move according to the lookback period. The triangles indicate when price has reached ADR (either +ADR or -ADR), and alerts can be created for these events. The Scale Factor is an optional parameter to scale the ADR by a certain amount. If set to 2 for example, then the ADR would be 2x the average daily range. This value will be reflected in the statistics options so that users can see how different values affect the outcomes. Show Table will display data collected on how often price reaches these levels, and how often price closes through them, for each day of the week. By default, these are colored as blue and red, respectively. From the following chart of NQ1!, we can see for example that on Mondays, price reached +ADR 38% of the time and closed through it 23% of the time. Note that the statistics for closing through the ADR levels are derived from all instances, not just those that reached ADR. Show Sample Sizes will display how many instances were collected for all given sets of data. Referring to the same example of NQ1!, we can see that this particular chart has collected data from 109 Mondays. From those Mondays, 41 reached +ADR (38%, verifying our initial claim) and 25 closed through it (23%). This is important to understand the scope of the data that we're working with, as percentages can be misleading for smaller sample sizes. Show Histogram will plot the same exact data as the table, just in a histogram form to visually emphasize the differences on a day-by-day basis. On this chart of RTY1!, we can see for example from the top histogram that on Wednesdays, 40% reached +ADR and only 22% closed through it. Similarly if we look at the bottom histogram, we can see that Wednesdays reached -ADR 46% of the time and closed through it only 28% of the time. We can also use Show Sample Sizes to display the same information that would be in the table, showing how many instances were collected for each event. In this case we can see that we observed 175 Fridays, where 76 reached +ADR (43%) and 44 closed above it (25%). Show Historical Moves is an interesting feature of this script. When enabled, if price has reached +/- ADR in the current session, the indicator will plot the evolution of the close prices from all past sessions that reached +/- ADR to see how they traded for the remainder of the session. These calculations are made with respect to the ADR range at the time that price traded through these levels. Historical Proximity (Bars) allows the user to observe historical moves where price reached ADR within this many bars of the current session (assuming price has reached an ADR level in the current session). In the above chart, this is set to 1000 so that we can observe each and every instance where price reached an ADR level. However, we can refine this a bit more. By limiting the Historical Proximity to something like 20, we are only considering historical moves that reached ADR within 20 bars of todays +ADR reach (9:50 am EST, noted by the blue triangle up). We can enable Show Average Move to display the average move by the filtered dataset, and Match +/-ADR to only observe moves inline with the current day's price action (in this case, only moves that reached +ADR, since price has not reached -ADR). We can add one more filter to this data with the setting Only Show Days That: closed through ADR; closed within ADR; or either. The option either is what you see above, as we are considering both days that closed through ADR and days that closed within it (note that in this case, closing within ADR simply means that price reached +ADR and closed the day below it, and vice versa for -ADR; this does not mean that price must have closed in between +ADR and -ADR). If we set this to only show instances that closed within ADR, we see the following data. Alternatively, we can choose to Only Show Days That closed through ADR, where we would see the following data. In this case, the average move very much resembles the price action that occurred on this particular day. This is in no way guaranteed, but it makes an interesting case for how we could use this data in our analysis by observing similar, historical price action. Please note that this data will change over time on a rolling basis due to TradingView's bar lookback, and that for this same reason, lower timeframes will yield less data than larger timeframes.
Indicatore Pine Script®
di tradeforopp
Day/Week/Month Metrics (Zeiierman)█ Overview The Day/Week/Month Metrics (Zeiierman) indicator is a powerful tool for traders looking to incorporate historical performance into their trading strategy. It computes statistical metrics related to the performance of a trading instrument on different time scales: daily, weekly, and monthly. Breaking down the performance into daily, weekly, and monthly metrics provides a granular view of the instrument's behavior. The indicator requires the chart to be set on a daily timeframe. █ Key Statistics ⚪ Day in month The performance of financial markets can show variability across different days within a month. This phenomenon, often referred to as the "monthly effect" or "turn-of-the-month effect," suggests that certain days of the month, especially the first and last days, tend to exhibit higher than average returns in many stock markets around the world. This effect is attributed to various factors including payroll contributions, investment of monthly dividends, and psychological factors among traders and investors. ⚪ Edge The Edge calculation identifies days within a month that consistently outperform the average monthly trading performance. It provides a statistical advantage by quantifying how often trading on these specific days yields better returns than the overall monthly average. This insight helps traders understand not just when returns might be higher, but also how reliable these patterns are over time. By focusing on days with a higher "Edge," traders can potentially increase their chances of success by aligning their strategies with historically more profitable days. ⚪ Month Historically, the stock market has exhibited seasonal trends, with certain months showing distinct patterns of performance. One of the most well-documented patterns is the "Sell in May and go away" phenomenon, suggesting that the period from November to April has historically brought significantly stronger gains in many major stock indices compared to the period from May to October. This pattern highlights the potential impact of seasonal investor sentiment and activities on market performance. ⚪ Day in week Various studies have identified the "day-of-the-week effect," where certain days of the week, particularly Monday and Friday, show different average returns compared to other weekdays. Historically, Mondays have been associated with lower or negative average returns in many markets, a phenomenon often linked to the settlement of trades from the previous week and negative news accumulation over the weekend. Fridays, on the other hand, might exhibit positive bias as investors adjust positions ahead of the weekend. ⚪ Week in month The performance of markets can also vary within different weeks of the month, with some studies suggesting a "week of the month effect." Typically, the first and the last week of the month may show stronger performance compared to the middle weeks. This pattern can be influenced by factors such as the timing of economic reports, monthly investment flows, and options and futures expiration dates which tend to cluster around these periods, affecting investor behavior and market liquidity. █ How It Works ⚪ Day in Month For each day of the month (1-31), the script calculates the average percentage change between the opening and closing prices of a trading instrument. This metric helps identify which days have historically been more volatile or profitable. It uses arrays to store the sum of percentage changes for each day and the total occurrences of each day to calculate the average percentage change. ⚪ Month The script calculates the overall gain for each month (January-December) by comparing the closing price at the start of a month to the closing price at the end, expressed as a percentage. This metric offers insights into which months might offer better trading opportunities based on historical performance. Monthly gains are tracked using arrays that store the sum of these gains for each month and the count of occurrences to calculate the average monthly gain. ⚪ Day in Week Similar to the day in the month analysis, the script evaluates the average percentage change between the opening and closing prices for each day of the week (Monday-Sunday). This information can be used to assess which days of the week are typically more favorable for trading. The script uses arrays to accumulate percentage changes and occurrences for each weekday, allowing for the calculation of average changes per day of the week. ⚪ Week in Month The script assesses the performance of each week within a month, identifying the gain from the start to the end of each week, expressed as a percentage. This can help traders understand which weeks within a month may have historically presented better trading conditions. It employs arrays to track the weekly gains and the number of weeks, using a counter to identify which week of the month it is (1-4), allowing for the calculation of average weekly gains. █ How to Use Traders can use this indicator to identify patterns or trends in the instrument's performance. For example, if a particular day of the week consistently shows a higher percentage of bullish closes, a trader might consider this in their strategy. Similarly, if certain months show stronger performance historically, this information could influence trading decisions. Identifying High-Performance Days and Periods Day in Month & Day in Week Analysis: By examining the average percentage change for each day of the month and week, traders can identify specific days that historically have shown higher volatility or profitability. This allows for targeted trading strategies, focusing on these high-performance days to maximize potential gains. Month Analysis: Understanding which months have historically provided better returns enables traders to adjust their trading intensity or capital allocation in anticipation of seasonally stronger or weaker periods. Week in Month Analysis: Identifying which weeks within a month have historically been more profitable can help traders plan their trades around these periods, potentially increasing their chances of success. █ Settings Enable or disable the types of statistics you want to display in the table. Table Size: Users can select the size of the table displayed on the chart, ranging from "Tiny" to "Auto," which adjusts based on screen size. Table Position: Users can choose the location of the table on the chart ----------------- Disclaimer The information contained in my Scripts/Indicators/Ideas/Algos/Systems does not constitute financial advice or a solicitation to buy or sell any securities of any type. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from the use of or reliance on such information. All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, backtest, or individual's trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs. My Scripts/Indicators/Ideas/Algos/Systems are only for educational purposes!
Indicatore Pine Script®
di Zeiierman
7
multidataLibrary "multidata" A library for multi-dimensional data arrays. Full documentation: faiyaz7283.github.io This library is designed to enhance data storage capabilities in Pine Script, enabling users to work with two separate data structures: data2d (key -> main-value | alternate-value) and data3d (primary key -> data key-> main-value | alternate-value). These structures facilitate storing key-value pairs in a flexible and efficient manner, offering various methods for manipulation and retrieval of data. Please check out the full documentation at faiyaz7283.github.io .
Libreria Pine Script®
di faiyaz7283
3
How To Input And Offset CSV DataExample method of how to use an input text area to import, offset, and plot ‎CSV data using an array. Note that when using this method there is a limit of 4096 total characters per input. For working with data sets larger than 4096 total characters an alternative method of pasting CSV data directly within the script can be seen below : NOTICE: This is an example script and not meant to be used as an actual strategy. By using this script or any portion thereof, you acknowledge that you have read and understood that this is for research purposes only and I am not responsible for any financial losses you may incur by using this script!
Indicatore Pine Script®
di allanster
5
SmartVPSGTitle: Identifying Volume Spikes, Price Movements and Gap Ups: A TradingView Script Introduction: In the world of trading, identifying volume spikes and price movements can provide valuable insights into market trends and potential trading opportunities. In this article, we'll explore a TradingView script that helps traders visualize volume spikes, price up moves with volume spikes, and gap-up days on their charts. Detecting Price Up Moves: The script starts by calculating price up moves. It compares the current day's closing price with the previous day's closing price and checks if it has increased by 3% or more. This helps traders spot significant upward price movements. Detecting Volume Spurts: Next, the script focuses on detecting volume spikes, which are often associated with increased market activity and potential trading opportunities. It compares the current day's volume with the highest volume of the previous nine sessions. If the current volume exceeds all the volumes of the previous nine sessions, it is considered a volume spurt. Example: Let's consider a hypothetical scenario where we have the following volume data for a stock: Day 1: 100,000 Day 2: 80,000 Day 3: 120,000 Day 4: 150,000 Day 5: 200,000 Day 6: 90,000 Day 7: 110,000 Day 8: 130,000 Day 9: 140,000 Day 10: 250,000 (current day) To determine if there is a volume spurt on Day 10, the script compares the current day's volume (250,000) with the highest volume of the previous nine sessions. In this case, the highest volume among the previous nine sessions is 200,000 (on Day 5). Since the current day's volume (250,000) exceeds the highest volume of the previous nine sessions (200,000), it is considered a volume spurt. Identifying Gap-Up Days: Gap-up days occur when the market opens significantly higher than the previous day's close. To identify these days, the script compares the current day's low price with the previous day's high price. If the low price is greater than the previous day's high, it is marked as a gap-up day. Visualizing the Findings: To provide a clear visual representation of the identified patterns, the script uses different shapes and colors. First, it plots small red dots above the candles whenever a volume spurt is detected. These dots help traders quickly identify periods of increased volume activity. For price up moves with volume spikes, the script utilizes blue triangular shapes below the candles. This allows traders to pinpoint instances where both price and volume are showing positive signs, indicating potential bullish movements. Additionally, the script incorporates green candles to represent gap-up days. These candles help traders recognize days when the market opens with a significant upward gap, suggesting a potential shift in market sentiment. Conclusion: The TradingView script discussed in this article provides traders with a visual representation of volume spikes , price up moves with volume spikes , and gap-up days . By incorporating these visual cues into their analysis, traders can gain valuable insights into market trends and potential trading opportunities. Remember, this script should be used for educational and informational purposes only and does not serve as financial advice or recommendations. Traders are encouraged to customize and modify the script according to their specific trading strategies and risk tolerance. Share this script with other traders on TradingView to enhance their chart analysis and trading decisions. PS: This TradingView script is designed to work specifically on the daily timeframe (daily candles). It calculates and identifies volume spurts based on the volume data of the daily timeframe. Since it is designed for the daily timeframe, it may not produce accurate results or work as intended on other timeframes.
Indicatore Pine Script®
di Triyambak_CA
18
TooltipLibrary "Tooltip" This library helps creating and managing nice looking data (key/value) tooltips that you can use for labels. The tooltips data key/value will align automatically. It is optional to convert the data to a values only string too. method addSpacesToKey(this)   Calculates the amount of spaces needed after the key to make it the key least 4 characters wide.   Namespace types: Data   Parameters:      this (Data) : (Data) The Data. method addTabs(this, longestKeyLength)   Calculates the amount of tabs to be used.   Namespace types: Data   Parameters:      this (Data) : (Data) The Data.      longestKeyLength (int) method longestKeyLength(this)   Returns the length of the longest key string in the array.   Namespace types: Data   Parameters:      this (Data ) : (Tooltip) The object to work with. @return (int) The length of the key. method toString(tooltips, withKey)   Helper function for the tooltip.   Namespace types: Data   Parameters:      tooltips (Data )      withKey (bool) : (bool) Wether to create a string with keys in it. @return (string) The string new()   Creates a new array to store tooltip data in @return (Data) The data array. Data   Key/Value pair for tooltips   Fields:      key (series string)      value (series string)
Libreria Pine Script®
di niquedegraaff
Seasonal Performance for Stocks & CryptoThe Seasonal Performance indicator quickly allows you to see if you are in a bullish or bearish time of year for an underlying security and where the current performance stacks up compared to the same time of year historically. Table is fully customizable from colors to what data to see. Table Displays Average Performance Best Performance Worst Performance Last Performance Current Performance Note this indicator will only work with Stocks, ETF's, Index's or Crypto.
Indicatore Pine Script®
di Amphibiantrading
4
XAUXXXThis simple script is meant to get around the limitations some data providers have, in terms of the length of historical data they choose to provide traders. Inspired by OANDA's XAUCAD pair only having data as far back as 2005, whereas XAUUSD has data back to to the 19th century. By taking the OHLC data from XAUUSD and multiplying it by the price of USD in a desired currency you are able to see further back in time, the limitation now being the length of FX data available instead of the price of Precious metal / currency pair. As shown in the chart you can now see the price of Gold in CAD as far back as the late 1960s, a nearly half century of data uncovered for all to see!
Indicatore Pine Script®
di EsIstTurnt