지금 시작

Formatting

FMatrixLibraryLibrary "FMatrixLibrary" f_family(code)   Parameters:      code (string) f_execMode(fam)   Parameters:      fam (int) f_structure(fam)   Parameters:      fam (int) f_tfStyle(tf)   Parameters:      tf (string) f_regimeCompat(stype, swingReg, dayReg, scalpReg, tfStyle)   Parameters:      stype (string)      swingReg (string)      dayReg (string)      scalpReg (string)      tfStyle (string) f_riskMin(style)   Parameters:      style (string) f_riskMax(style)   Parameters:      style (string) f_minRR(style)   Parameters:      style (string) f_ddState(ddR)   Parameters:      ddR (float) f_aTier(enabled, ddOk, regimeOk, sessOk, dayOk, quarterOk, yearOk, equityOk, biasOk)   Parameters:      enabled (bool)      ddOk (bool)      regimeOk (bool)      sessOk (bool)      dayOk (bool)      quarterOk (bool)      yearOk (bool)      equityOk (bool)      biasOk (bool) f_bTier(aTier, enabled, ddOk, regimeOk, equityOk)   Parameters:      aTier (bool)      enabled (bool)      ddOk (bool)      regimeOk (bool)      equityOk (bool) f_regColor(reg)   Parameters:      reg (string) f_tierColor(tier)   Parameters:      tier (string) f_ddColor(state)   Parameters:      state (string)
Pine Script® 라이브러리
Rafe-Promachos-LLP의
TO_JSONTO_JSON A lightweight Pine Script v6 library for converting TradingView series data into JSON-formatted alert payloads. `TO_JSON` is designed for users who want to export chart data to external systems through TradingView alerts. It helps transform rolling series such as OHLCV, indicator values, or text states into JSON-compatible arrays and wraps them into a structured message for webhooks, bots, dashboards, or automated workflows. What this library does This library provides helper functions to: - convert float series into JSON arrays - convert integer series into JSON arrays using a sentinel value as `null` - convert string series into JSON arrays with fallback filling and JSON-safe escaping - wrap custom payloads into a top-level JSON alert message with symbol, timeframe, timestamp, and token It is especially useful when you want to send the latest `N` bars of market data or indicator values to an external service. Features - Rolling array export for `float`, `int`, and `string` series - Chronological output from oldest to newest - `null` support for missing values - JSON-safe string escaping - Simple wrapper for alert message generation - Works well for webhook-based automation and downstream parsing Exported functions ### `series_to_array_float_null(series float src, int N)` Converts the latest `N` values of a float series into a JSON array string. Missing values are exported as `null`. `series_to_array_int_sentinel(series int src, int N, int sentinel)` Converts the latest `N` values of an integer series into a JSON array string. The specified sentinel value is exported as `null`. `series_to_array_str_fill(series string src, int N, string fill="")` Converts the latest `N` values of a string series into a JSON array string. Missing values are replaced with `fill`, and strings are escaped for JSON compatibility. `json(simple string token="1234567890", string info="", simple string symbol="AUTO")` Wraps a custom JSON payload into a top-level alert message including: - symbol - timeframe - current timestamp - human-readable time - info payload - token Typical use case A common use case is exporting the last bars of: - time - open - high - low - close - volume - moving averages - custom signals into one flat JSON object, then embedding it into the alert message. Example ```pine //@version=6 import veegee82/TO_JSON/1 as json indicator("TO_JSON Example", overlay=false) stO = open stH = high stL = low stC = close stV = volume ema_50 = ta.ema(close, 50) ema_100 = ta.ema(close, 100) ema_200 = ta.ema(close, 200) ema_500 = ta.ema(close, 500) ema_1000 = ta.ema(close, 1000) json_flat(int n=50) => s_name = '"name":"' + 'vision_' + timeframe.period + '"' s_tf = ',"timeframe":"' + timeframe.period + '"' s_ts = ',"ts":' + json.series_to_array_float_null(time, n) s_o = ',"open":' + json.series_to_array_float_null(stO, n) s_h = ',"high":' + json.series_to_array_float_null(stH, n) s_l = ',"low":' + json.series_to_array_float_null(stL, n) s_c = ',"close":' + json.series_to_array_float_null(stC, n) s_v = ',"volume":' + json.series_to_array_float_null(stV, n) s_ema_50 = ',"ema_50":' + json.series_to_array_float_null(ema_50, n) s_ema_100 = ',"ema_100":' + json.series_to_array_float_null(ema_100, n) s_ema_200 = ',"ema_200":' + json.series_to_array_float_null(ema_200, n) s_ema_500 = ',"ema_500":' + json.series_to_array_float_null(ema_500, n) s_ema_1000 = ',"ema_1000":' + json.series_to_array_float_null(ema_1000, n) "{" + s_name + s_tf + s_ts + s_o + s_h + s_l + s_c + s_v + s_ema_50 + s_ema_100 + s_ema_200 + s_ema_500 + s_ema_1000 + "}" info = json_flat(100) alert( message = json.json(token = "1234567890", info = info, symbol = "AUTO"), freq = alert.freq_once_per_bar_close )
Pine Script® 라이브러리
veegee82의
fsl_helpersLibrary "fsl_helpers" A library with function helpers for FSL script family, including functions for plotting, formatting, etc. @version=6 plot_width_get()   Returns the internal panel width used by the helper library.   Returns: int Width of the custom plot panel. plot_x_axis(x, inc, theme)   Draws a vertical tick and label on the custom X-axis of the panel.   Parameters:      x (int) : X-axis coordinate in panel space.      inc (float) : Label value displayed below the tick.      theme (Theme type from QuantNomad/fsl_theme/3) : Theme used for the chart plot_y_axis(yy, min, max, theme, plot_mult)   Draws a horizontal Y-axis guide line and corresponding price label. Converts the normalized panel coordinate to the actual price level.   Parameters:      yy (float) : Normalized Y coordinate in panel space.      min (float) : Minimum value of the plotted price range.      max (float) : Maximum value of the plotted price range.      theme (Theme type from QuantNomad/fsl_theme/3) : Theme used for the chart      plot_mult (int) : Horizontal spacing multiplier used by the panel.   Returns: void plot_scale(y, min, max)   Converts a price value into the normalized panel scale used by the forward-curve plotting area.   Parameters:      y (float) : Price value to scale.      min (float) : Minimum value of the plotted price range.      max (float) : Maximum value of the plotted price range.   Returns: float Normalized Y coordinate for plotting. plot_scatter(x, y, max, min, col, s, tiptool, theme, plot_mult)   Draws a scatter-point marker in the forward-curve panel. Optionally attaches a tooltip containing symbol, time, and price.   Parameters:      x (int) : X index position within the curve.      y (float) : Price value of the point.      max (float) : Maximum value of the plotted price range.      min (float) : Minimum value of the plotted price range.      col (color) : Marker color.      s (string) : Marker size.      tiptool (string) : Text shown in the tooltip.      theme (Theme type from QuantNomad/fsl_theme/3) : Theme used for the chart      plot_mult (int) : Horizontal spacing multiplier used by the panel.   Returns: void plot_line(x, y, max, min, x1, y1, col, w, sty, plot_mult)   Draws a line segment between two curve points in the panel. Used to connect consecutive futures contracts in the forward curve.   Parameters:      x (int) : X position of the ending point.      y (float) : Price value of the ending point.      max (float) : Maximum value of the plotted price range.      min (float) : Minimum value of the plotted price range.      x1 (int) : X position of the starting point.      y1 (float) : Price value of the starting point.      col (color) : Line color.      w (int) : Line width.      sty (string) : Line style.      plot_mult (int) : Horizontal spacing multiplier used by the panel.   Returns: void plot_legend(y, col, sty, txt, theme, plot_mult)   Draws a legend entry composed of a marker, line sample, and label.   Parameters:      y (float) : Y position of the legend row.      col (color) : Legend color.      sty (string) : Line style used for the sample segment.      txt (string) : Legend label text.      theme (Theme type from QuantNomad/fsl_theme/3) : Theme used for the chart      plot_mult (int) : Horizontal spacing multiplier used by the panel.   Returns: void plot_remove_all_boxes()   Deletes all boxes currently drawn by the script. Useful before redrawing the custom panel.   Returns: void plot_remove_all_labels()   Deletes all labels currently drawn by the script. Useful before redrawing the custom panel.   Returns: void plot_remove_all_lines()   Deletes all lines currently drawn by the script. Useful before redrawing the custom panel.   Returns: void plot_main_boxes(main_title, theme, plot_mult)   Draws the main panel boxes for the forward-curve display, including frame, title area, legend area, and timeframe header.   Parameters:      main_title (string) : Main title for the plot      theme (Theme type from QuantNomad/fsl_theme/3) : Theme used for the chart      plot_mult (int) : Horizontal spacing multiplier used by the panel.   Returns: void
Pine Script® 라이브러리
QuantNomad의
fsl_themeLibrary "fsl_theme" FSL Theme Library Provides reusable UI color themes used across FSL indicators and strategies. The library defines a Theme structure containing colors for table headers, data rows, and directional indicators. Scripts can retrieve a preset theme using `getTheme()` and apply consistent styling to tables and labels. getTheme(id)   Returns the Theme configuration corresponding to the selected preset.   Parameters:      id (series ThemeId) : ThemeId identifier of the theme preset.   Returns: Theme structure containing all UI color settings. Theme   Structure containing all UI color definitions used by FSL scripts. These colors are typically applied to tables, labels, and UI elements.   Fields:      header_bg (series color)      header_tx (series color)      data_bg (series color)      data_tx (series color)      data_bg_sec (series color)      dir_cont_bg (series color)      dir_cont_tx (series color)      dir_backw_bg (series color)      dir_backw_tx (series color)
Pine Script® 라이브러리
QuantNomad의
ToolsPriceLibrary "ToolsPrice" Library for generic tools for price related actions Enum: PriceSource   An enumeration of named values representing price source.   Fields:      open Represents the "Open" price.      high Represents the "High" price.      low Represents the "Low" price.      close Represents the "Close" price.      hl2 Represents the "(High + Low)/2" price.      hlc3 Represents the "(High + Low + Close)/3" price.      ohlc4 Represents the "(Open + High + Low + Close)/4" price.      hlcc4 Represents the "(High + Low + Close + Close)/4" price. Function: getPriceBySource(src)   Returns series float according to provided PriceSource enum   Parameters:      src (series PriceSource) : PriceSource enum   Returns: Series float
Pine Script® 라이브러리
aybarsm의
biasHelperbiasHelpers: Core Engine for Bias Analytics against a set of Benchmarks Overview The ` biasHelper ` library is a highly optimized backend engine designed specifically for evaluating, tracking, and aggregating bias analytics across timeframes. Built on strict Model-View-Controller (MVC) software architecture principles, this library encapsulates all complex mathematical processing, state caching, and string formatting. By offloading these responsibilities, it allows front-end indicators to remain exceptionally lightweight, mathematically pure, and dedicated entirely to UI visualization. This library features built-in anti-repainting guardrails, deterministic pseudo-random evaluations, and dynamic memory allocation through User-Defined Types (UDTs). --- Core Architecture & Design Philosophy This library operates using two primary User-Defined Types (UDTs) that track the lifecycle of a trading session: 1. ` SessionInfo `: The primary memory matrix. It tracks OHLC data, prevailing directional bias, Heikin-Ashi extensions, and cumulative hit/close counts. 2. ` SessionLines `: The visual array tracker. It orchestrates the projection of structural support/resistance levels and evaluates live price touches against them. By maintaining state inside these objects rather than utilizing global arrays, the library ensures O(1) time complexity during bar evaluation, resulting in lightning-fast execution even on dense chart histories. --- Exported Types (UDTs) `SessionInfo` The core data structure for tracking session metrics and bias execution. * **Price Tracking**: `prevHigh`, `prevLow`, `currentHigh`, `currentLow`, `currentOpen`. * **Heikin-Ashi Anchors**: `prevHaOpen`, `prevHaClose`. * **State Trackers**: `pushedUp` (bool), `currentBias` (int: 1 = Bullish, -1 = Bearish, 0 = Neutral). * **Metric Accumulators**: `bullishCount`, `bearishCount`, `hitHighCount`, `hitLowCount`, `closeHighCount`, `closeLowCount`. `SessionLines` The spatial data structure for tracking visual levels and live touches. * Lines : `highLine`, `lowLine`. * Touch Booleans : `hitHighLine`, `hitLowLine`. --- Data & State Management `updateData(infoObj, isNew, pClose, cOpen, cHigh, cLow)` The standard market structure logic handler. It evaluates historical structural breaks against the previous close to determine the prevailing directional bias without repainting. * Parameters : Evaluates state using standard OHLC inputs and strictly anchors to `close ` (`pClose`) to guarantee real-time parity with historical states. `updateBenchmarkData(infoObj, isNew, pClose, cOpen, cHigh, cLow, bType, tfSeconds)` A dynamic routing matrix for alternative bias benchmarks. * Supported `bType` Routing : * `"MOM"`: Pure Candlestick Momentum (Close vs. Open). * `"HA"`: Synthetic Heikin-Ashi Momentum evaluated securely within standard chart data. * `"ABULL"` / `"ABEAR"`: Static directional evaluations (Always Bullish / Always Bearish). * `"COIN"`: Deterministic pseudo-random generation. Generates a perfect 50/50 randomized output anchored mathematically to the timestamp and previous close, guaranteeing it never repaints or flickers on live ticks. * `"DTD"`: Day-to-Day alternating parity based on absolute time intervals. `processLines(linesObj, infoObj, isNew, tRight, lStyle, currHigh, currLow)` Draws historical support/resistance barriers and evaluates current price action (`currHigh`, `currLow`) to register touches and successful close-throughs. --- Math & Aggregation `calcTrueRate(biasCount, hitCount, closeCount)` Calculates the *True Close-Through Rate* (Success Rate × Close-Through Rate) while safely handling zero-division scenarios. Returns a standardized float coefficient. `getTotals(infoObj)` Extracts aggregated cross-directional totals for condensed dashboard views. * Returns : A tuple ` `. --- UI Formatting Utilities `getTablePos(pos)` & `getTableSize(size)` Translates string-based user inputs (e.g., `"Top Right"`, `"Normal"`) into native Pine Script structural variables (`position.top_right`, `size.normal`). `formatResult(hit, biasCount)` Converts raw integers into a cleanly formatted fractional percentage string (e.g., `"45.2%"`). `formatPercent(value)` Converts a raw floating-point coefficient into a polished percentage string. --- Implementation Example To utilize this library in your indicator, instantiate the UDTs and pass them through the update loops securely: import TRSTNGLRD/biasHelpers/4 as lib // 1. Initialize Objects var lib.SessionInfo sessionData = lib.SessionInfo.new() var lib.SessionLines sessionLines = lib.SessionLines.new() // 2. Evaluate State if isEligibleTimeframe sessionData.updateData(isNewSession, close , open, high, low) = sessionLines.processLines(sessionData, isNewSession, rightTime, lineStyle, high, low) // 3. Extract Formatted Data = sessionData.getTotals() string trueRate = lib.formatPercent(lib.calcTrueRate(tBias, tHit, tClose)) Note to Developers This library adheres strictly to TradingView's anti-repainting guidelines. When feeding inputs into `updateData` or `updateBenchmarkData`, always utilize the previous bar's close (`close `) for the `pClose` parameter. Live data (`high`, `low`) should exclusively be passed into the `processLines` method to allow real-time touch detection.
Pine Script® 라이브러리
TRSTNGLRD의
ScaleValidator🛡️ ScaleValidator Library - Input Validation for PineScript 📢 ABOUT ScaleValidator is a lightweight utility library that provides robust input validation for PineScript. It ensures your scripts receive valid arguments and throws helpful runtime errors when they don't. ✨ FEATURES 🛡️ Validation Methods Validate inputs and throw descriptive runtime errors if invalid: • isValidLocation() — Validate location strings • isValidPosition() — Validate position strings • isValidFormat() — Validate format strings • isValidPOV() — Validate point-of-view (extend) strings 🔍 Helper Methods Quick boolean checks without throwing errors: • isLocationAbove() / isLocationBelow() — Check vertical location • isPositionAbove() / isPositionCenter() / isPositionBelow() — Check position row • isPositionLeft() / isPositionRight() — Check position column 💡 USAGE EXAMPLE //@version=6 indicator("Validator Demo", overlay = true) import cryptolinx/ScaleValidator/1 as v // Validate inputs before using them userPosition = input.string(position.top_center, "Position") if v.isValidPosition(userPosition) // Safe to use the position label.new(bar_index, high, "Valid!", xloc = xloc.bar_index, style = label.style_label_down, textcolor = color.white) // Quick checks without throwing errors if v.isPositionAbove(userPosition) // Position is in top row plotchar(close, char = "▲", location = location.abovebar) 📊 VALID CONSTANTS REFERENCE Locations • location.top — Top of pane • location.bottom — Bottom of pane • location.abovebar — Above price bar • location.belowbar — Below price bar • location.absolute — Absolute position Positions (3x3 Grid) • Top Row: top_left, top_center, top_right • Middle Row: middle_left, middle_center, middle_right • Bottom Row: bottom_left, bottom_center, bottom_right Formats • format.inherit — Inherit from parent • format.percent — Percentage format Point of View (Extend) • extend.both — Extend in both directions • extend.left — Extend to the left • extend.right — Extend to the right 🔧 METHOD REFERENCE Validators (throw runtime error if invalid) • isValidLocation(string) → bool • isValidPosition(string) → bool • isValidFormat(string) → bool • isValidPOV(string) → bool Helpers (return bool, no errors) • isLocationAbove(string) → bool • isLocationBelow(string) → bool • isPositionAbove(string) → bool • isPositionCenter(string) → bool • isPositionBelow(string) → bool • isPositionLeft(string) → bool • isPositionRight(string) → bool 🚀 WHY USE THIS? • 🛡️ Defensive Programming — Catch invalid inputs early • 📖 Helpful Errors — Descriptive messages show valid options • ⚡ Lightweight — No dependencies, minimal overhead • 🔗 Companion to ScalesDEV — Used internally by the Scale library 📋 CHANGELOG ✅ Added method badges (helper/validator) ✅ Created reference tables for valid constants ✅ Improved parameter descriptions ✅ Formatted return types 🙏 RELATED LIBRARIES Check out Scales for building beautiful scale visualizations that use this validator! Battries included! 🔋Happy coding! 🚀 @cryptolinx for the TradingView community
Pine Script® 라이브러리
cryptolinx의
DafeVisLibDafeVisLib: The Intelligent Visualization & UI Engine This is not a library of colors and drawing functions. This is an AI-powered artist and data scientist that lives in your code. It automates the complex, time-consuming process of data analysis and visualization, allowing you to focus on what truly matters: your trading ideas. █ CHAPTER 1: THE PHILOSOPHY - BEYOND PLOTTING, INTO PERCEPTION For too long, the world of technical indicator development has been bifurcated. On one side, you have the quantitative analyst, obsessed with mathematical purity but often displaying their work in a crude, unintuitive manner. On the other, you have the visual designer, creating beautiful indicators that often lack analytical depth. The result for the end-user is a compromise: either a tool that is powerful but ugly and hard to interpret, or one that is beautiful but analytically shallow. The DafeVisLib was created to shatter this compromise. Its core philosophy is that great analysis and great visualization are not separate disciplines; they are two sides of the same coin . An indicator should not just present data; it should communicate intelligence. It should automatically understand the nature of the data it is given and render it in the most effective, intuitive, and aesthetically pleasing way possible. This library is an "Architect." You provide it with the raw materials—a simple data series like an RSI or a moving average—and it handles the entire complex process of analysis, configuration, and rendering. It is the ultimate accelerator for developers, saving hundreds of hours of boilerplate code, and the ultimate upgrade for traders, providing a level of clarity and visual intelligence previously unseen on this platform. █ CHAPTER 2: THE CORE INNOVATION - THE "ANALYZE, THEN RENDER" PARADIGM The DafeVisualsLib operates on a revolutionary two-stage pipeline that sets it apart from any other tool. This is not a passive collection of functions; it is an active, intelligent system. STAGE 1: The analyze() Function (The Data Scientist) This is the brain. Before a single line is drawn, this function performs a sophisticated statistical analysis on your raw data series to understand its fundamental character. It asks the critical questions that a human analyst would: What is the Data Type? It automatically detects if your data is a bounded "oscillator" like an RSI, a zero-centric "momentum" indicator like MACD, a "price"-based line like a moving average, or a "volume"-based metric. This is crucial, as an oscillator should be visualized differently than a volume histogram. What is the Market Regime? It analyzes the data's volatility (using the coefficient of variation) to classify the current environment as a low-volatility "squeeze," a moderate-volatility "trend," or a high-volatility "volatile" state. Where is the Data in its Cycle? It normalizes the data to a 0-100 scale and calculates its Z-Score to determine if it is currently at a statistical "extreme." The output of this stage is a MetricAnalysis object—a complete analytical report on the DNA of your data. STAGE 2: The auto_config() Function (The Artist & Physicist) This is where the magic happens. This function takes the analytical report from analyze() and uses it to make a series of intelligent, context-aware decisions about how the data should be visualized. Intelligent Color Logic: It doesn't just use one color. For an "oscillator," it will create a beautiful heatmap gradient. For a "momentum" indicator, it will use a binary bull/bear color scheme. Neon Physics: It separates the color into a solid c_core and a transparent c_glow. The opacity of the glow is not static; it is dynamically controlled by the detected market regime. In a "volatile" regime, the glow becomes bright and intense. In a "squeeze," it becomes dim and subtle. Adaptive Style & Width: It automatically adjusts the plot style and line width. A "momentum" indicator will be rendered as an area chart by default. A "volume" series will become columns. A "price" line will be thick and bold in a volatile market and thin and clean in a calm market. Smart Zones: If it detects that the data is an "oscillator," it will automatically recommend showing overbought/oversold zones and provide the standard 70/30 levels. The output of this stage is a PlotConfig object—a complete, ready-to-use set of plotting instructions, intelligently tailored to your specific data and the current market conditions. █ CHAPTER 3: A DEEP DIVE INTO THE DEVELOPER'S TOOLKIT This library is a gift to Pine Script developers. It is a suite of powerful, high-level functions designed to dramatically simplify your workflow and elevate the final product. The Theme Engine Forget hard-coding colors. The get_theme() function provides access to a library of professionally designed, high-contrast color themes ( Neon, Cyber, Matrix, Gold, Ice, Blood, DAFE Signature ). Each Theme object contains a complete, consistent palette for primary, secondary, accent, bull, bear, and neutral colors. This allows you to build indicators that are not only functional but also have a polished, professional aesthetic that is consistent across all your DAFE-powered creations. The Color Engine Go beyond simple colors with a powerful suite of advanced color functions. gradient_color() allows for smooth linear interpolation between any two colors. gradient_3() creates a three-point gradient, perfect for heatmaps. adaptive_alpha() calculates the optimal transparency for an element based on a confidence or strength score, making your visuals dynamically react to the data. Candle Diagnostics The diagnose_candle() function is a complete microstructure analysis tool in a single call. It returns a detailed breakdown of any candle, including its body vs. wick percentages, and flags for common patterns like Dojis, Hammers, Shooting Stars, and Marubozus. The companion candle_color() function uses this analysis to provide intelligent, health-based candle coloring. The UI & HUD Toolkit Building user interfaces with tables can be tedious and complex. This library provides a comprehensive suite of helper functions to make it effortless and beautiful. ASCII Art Generators: Functions like draw_bar(), draw_gauge(), draw_stars(), and the incredible draw_sparkline() allow you to create rich, data-dense, text-based visualizations directly within your dashboards. Dashboard Builders: A modular toolkit for creating professional dashboards. create_pane() initializes the table. fill_header(), fill_metric(), fill_status(), and fill_separator() provide a simple, high-level API for populating your dashboard with consistently styled and beautifully formatted information. Smart Formatting: Utilities like smart_text() (which auto-selects black or white text for optimal contrast) and format_compact() (which abbreviates large numbers to "1.23M" or "456K") handle the small details that create a polished user experience. █ CHAPTER 4: DEVELOPMENT PHILOSOPHY The DafeVisLib was born from a desire to democratize elite-level indicator design. For too long, the ability to create beautiful, context-aware, and intuitively designed indicators has been the domain of a select few developers with deep knowledge of both programming and graphic design. This library changes that. It is an open-source tool that encapsulates thousands of hours of research and development into a simple, powerful API. Our philosophy is that a developer's most valuable asset is their idea. They should be free to focus on inventing new, powerful analytical concepts, without getting bogged down in the tedious, repetitive work of building robust visualization and configuration systems from scratch. This library is our contribution to the Pine Script community—a tool for builders, designed to accelerate innovation and elevate the quality of indicators for everyone. This library embraces that philosophy. It handles immense complexity on the backend to deliver absolute simplicity and elegance on the frontend, both for the developer who uses it and the trader who benefits from it. █ DISCLAIMER & IMPORTANT NOTES THIS IS A LIBRARY FOR DEVELOPERS: This script does nothing on its own. It is a powerful engine that must be imported and used by other indicator developers in their own scripts. It is a tool for building, not a ready-made indicator. THE ANALYSIS IS A GUIDE: The analyze() function's classification of data and regimes is based on a robust set of heuristics, but it is a statistical interpretation. It provides a powerful baseline for visualization but is not a substitute for a trader's own judgment. "Simplicity is the ultimate sophistication." — Leonardo da Vinci Taking you to school. — Dskyz, Trade with insight. Trade with anticipation.
Pine Script® 라이브러리
DskyzInvestments의
SpatialIndexYou can start using this now by inserthing this at the top of your indicator/strategy/library. import ArunaReborn/SpatialIndex/1 as SI Overview SpatialIndex is a high-performance Pine Script library that implements price-bucketed spatial indexing for efficient proximity queries on large datasets. Instead of scanning through hundreds or thousands of items linearly (O(n)), this library provides O(k) bucket lookup where k is typically just a handful of buckets, dramatically improving performance for price-based filtering operations. This library works with any data type through index-based references, making it universally applicable for support/resistance levels, pivot points, order zones, pattern detection points, Fair Value Gaps, and any other price-based data that needs frequent proximity queries. Why This Library Exists The Problem When building advanced technical indicators that track large numbers of price levels (support/resistance zones, pivot points, order blocks, etc.), you often need to answer questions like: - *"Which levels are within 5% of the current price?"* - *"What zones overlap with this price range?"* - *"Are there any significant levels near my entry point?"* The naive approach is to loop through every single item and check its price. For 500 levels across multiple timeframes, this means 500 comparisons every bar . On instruments with thousands of historical bars, this quickly becomes a performance bottleneck that can cause scripts to time out or lag. The Solution SpatialIndex solves this by organizing items into price buckets —like filing cabinets organized by price range. When you query for items near $50,000, the library only looks in the relevant buckets (e.g., $49,000-$51,000 range), ignoring all other price regions entirely. Performance Example: - Linear scan: Check 500 items = 500 comparisons per query - Spatial index: Check 3-5 buckets with ~10 items each = 30-50 comparisons per query - Result: 10-16x faster queries Key Features Core Capabilities - ✅ Generic Design : Works with any data type via index references - ✅ Multiple Index Strategies : Fixed bucket size or ATR-based dynamic sizing - ✅ Range Support : Index items that span price ranges (zones, gaps, channels) - ✅ Efficient Queries : O(k) bucket lookup instead of O(n) linear scan - ✅ Multiple Query Types : Proximity percentage, fixed range, exact price with tolerance - ✅ Dynamic Updates : Add, remove, update items in O(1) time - ✅ Batch Operations : Efficient bulk removal and reindexing - ✅ Query Caching : Optional caching for repeated queries within same bar - ✅ Statistics & Debugging : Built-in stats and diagnostic functions ### Advanced Features - ATR-Based Bucketing : Automatically adjusts bucket sizes based on volatility - Multi-Bucket Spanning : Items that span ranges are indexed in all overlapping buckets - Reindexing Support : Handles array removals with automatic index shifting - Cache Management : Configurable query caching with automatic invalidation - Empty Bucket Cleanup : Automatically removes empty buckets to minimize memory How It Works The Bucketing Concept Think of price space as divided into discrete buckets, like a histogram: ``` Price Range: $98-$100 $100-$102 $102-$104 $104-$106 $106-$108 Bucket Key: 49 50 51 52 53 Items: ``` When you query for items near $103: 1. Calculate which buckets overlap the $101.50-$104.50 range (keys 50, 51, 52) 2. Return items from only those buckets: 3. Never check items in buckets 49 or 53 Bucket Size Selection Fixed Size Mode: ```pine var SI.SpatialBucket index = SI.newSpatialBucket(2.0) // $2 per bucket ``` - Good for: Instruments with stable price ranges - Example: For stocks trading at $100, 2.0 = 2% increments ATR-Based Mode: ```pine float atr = ta.atr(14) var SI.SpatialBucket index = SI.newSpatialBucketATR(1.0, atr) // 1x ATR per bucket SI.updateATR(index, atr) // Update each bar ``` - Good for: Instruments with varying volatility - Adapts automatically to market conditions - 1.0 multiplier = one bucket spans one ATR unit Optimal Bucket Size: The library includes a helper function to calculate optimal size: ```pine float optimalSize = SI.calculateOptimalBucketSize(close, 5.0) // For 5% proximity queries ``` This ensures queries span approximately 3 buckets for optimal performance. Index-Based Architecture The library doesn't store your actual data—it only stores indices that point to your external arrays: ```pine // Your data var array levels = array.new() var array types = array.new() var array ages = array.new() // Your index var SI.SpatialBucket index = SI.newSpatialBucket(2.0) // Add a level array.push(levels, 50000.0) array.push(types, "support") array.push(ages, 0) SI.add(index, array.size(levels) - 1, 50000.0) // Store index 0 // Query near current price SI.QueryResult result = SI.queryProximity(index, close, 5.0) for idx in result.indices float level = array.get(levels, idx) string type = array.get(types, idx) // Work with your actual data ``` This design means: - ✅ Works with any data structure you define - ✅ No data duplication - ✅ Minimal memory footprint - ✅ Full control over your data --- Usage Guide Basic Setup ```pine // Import library import username/SpatialIndex/1 as SI // Create index var SI.SpatialBucket index = SI.newSpatialBucket(2.0) // Your data arrays var array supportLevels = array.new() var array touchCounts = array.new() ``` Adding Items Single Price Point: ```pine // Add a support level at $50,000 array.push(supportLevels, 50000.0) array.push(touchCounts, 1) int levelIdx = array.size(supportLevels) - 1 SI.add(index, levelIdx, 50000.0) ``` Price Range (Zones/Gaps): ```pine // Add a resistance zone from $51,000 to $52,000 array.push(zoneBottoms, 51000.0) array.push(zoneTops, 52000.0) int zoneIdx = array.size(zoneBottoms) - 1 SI.addRange(index, zoneIdx, 51000.0, 52000.0) // Indexed in all overlapping buckets ``` Querying Items Proximity Query (Percentage): ```pine // Find all levels within 5% of current price SI.QueryResult result = SI.queryProximity(index, close, 5.0) if array.size(result.indices) > 0 for idx in result.indices float level = array.get(supportLevels, idx) // Process nearby level ``` Fixed Range Query: ```pine // Find all items between $49,000 and $51,000 SI.QueryResult result = SI.queryRange(index, 49000.0, 51000.0) ``` Exact Price with Tolerance: ```pine // Find items at exactly $50,000 +/- $100 SI.QueryResult result = SI.queryAt(index, 50000.0, 100.0) ``` Removing Items Safe Removal Pattern: ```pine SI.QueryResult result = SI.queryProximity(index, close, 5.0) if array.size(result.indices) > 0 // IMPORTANT: Sort descending to safely remove from arrays array sorted = SI.sortIndicesDescending(result) for idx in sorted // Remove from index SI.remove(index, idx) // Remove from your data arrays array.remove(supportLevels, idx) array.remove(touchCounts, idx) // Reindex to maintain consistency SI.reindexAfterRemoval(index, idx) ``` Batch Removal (More Efficient): ```pine // Collect indices to remove array toRemove = array.new() for i = 0 to array.size(supportLevels) - 1 if array.get(touchCounts, i) > 10 // Remove old levels array.push(toRemove, i) // Remove in descending order from data arrays array sorted = array.copy(toRemove) array.sort(sorted, order.descending) for idx in sorted SI.remove(index, idx) array.remove(supportLevels, idx) array.remove(touchCounts, idx) // Batch reindex (much faster than individual reindexing) SI.reindexAfterBatchRemoval(index, toRemove) ``` Updating Items ```pine // Update a level's price (e.g., after refinement) float newPrice = 50100.0 SI.update(index, levelIdx, newPrice) array.set(supportLevels, levelIdx, newPrice) // Update a zone's range SI.updateRange(index, zoneIdx, 51000.0, 52500.0) array.set(zoneBottoms, zoneIdx, 51000.0) array.set(zoneTops, zoneIdx, 52500.0) ``` Query Caching For repeated queries within the same bar: ```pine // Create cache (persistent) var SI.CachedQuery cache = SI.newCachedQuery() // Cached query (returns cached result if parameters match) SI.QueryResult result = SI.queryProximityCached( index, cache, close, 5.0, // proximity% 1 // cache duration in bars ) // Invalidate cache when index changes significantly if bigChangeDetected SI.invalidateCache(cache) ``` --- Practical Examples Example 1: Support/Resistance Finder ```pine //@version=6 indicator("S/R with Spatial Index", overlay=true) import username/SpatialIndex/1 as SI // Data storage var array levels = array.new() var array types = array.new() // "support" or "resistance" var array touches = array.new() var array ages = array.new() // Spatial index var SI.SpatialBucket index = SI.newSpatialBucket(close * 0.02) // 2% buckets // Detect pivots bool isPivotHigh = ta.pivothigh(high, 5, 5) bool isPivotLow = ta.pivotlow(low, 5, 5) // Add new levels if isPivotHigh array.push(levels, high ) array.push(types, "resistance") array.push(touches, 1) array.push(ages, 0) SI.add(index, array.size(levels) - 1, high ) if isPivotLow array.push(levels, low ) array.push(types, "support") array.push(touches, 1) array.push(ages, 0) SI.add(index, array.size(levels) - 1, low ) // Find nearby levels (fast!) SI.QueryResult nearby = SI.queryProximity(index, close, 3.0) // Within 3% // Process nearby levels for idx in nearby.indices float level = array.get(levels, idx) string type = array.get(types, idx) // Check for touch if type == "support" and low <= level and low > level array.set(touches, idx, array.get(touches, idx) + 1) else if type == "resistance" and high >= level and high < level array.set(touches, idx, array.get(touches, idx) + 1) // Age and cleanup old levels for i = array.size(ages) - 1 to 0 array.set(ages, i, array.get(ages, i) + 1) // Remove levels older than 500 bars or with 5+ touches if array.get(ages, i) > 500 or array.get(touches, i) >= 5 SI.remove(index, i) array.remove(levels, i) array.remove(types, i) array.remove(touches, i) array.remove(ages, i) SI.reindexAfterRemoval(index, i) // Visualization for idx in nearby.indices line.new(bar_index, array.get(levels, idx), bar_index + 10, array.get(levels, idx), color=array.get(types, idx) == "support" ? color.green : color.red) ``` Example 2: Multi-Timeframe Zone Detector ```pine //@version=6 indicator("MTF Zones", overlay=true) import username/SpatialIndex/1 as SI // Store zones from multiple timeframes var array zoneBottoms = array.new() var array zoneTops = array.new() var array zoneTimeframes = array.new() // ATR-based spatial index for adaptive bucketing var SI.SpatialBucket index = SI.newSpatialBucketATR(1.0, ta.atr(14)) SI.updateATR(index, ta.atr(14)) // Update bucket size with volatility // Request higher timeframe data = request.security(syminfo.tickerid, "240", ) // Detect HTF zones if not na(htf_high) and not na(htf_low) float zoneTop = htf_high float zoneBottom = htf_low * 0.995 // 0.5% zone thickness // Check if zone already exists nearby SI.QueryResult existing = SI.queryRange(index, zoneBottom, zoneTop) if array.size(existing.indices) == 0 // No overlapping zones // Add new zone array.push(zoneBottoms, zoneBottom) array.push(zoneTops, zoneTop) array.push(zoneTimeframes, "4H") int idx = array.size(zoneBottoms) - 1 SI.addRange(index, idx, zoneBottom, zoneTop) // Query zones near current price SI.QueryResult nearbyZones = SI.queryProximity(index, close, 2.0) // Within 2% // Highlight nearby zones for idx in nearbyZones.indices box.new(bar_index - 50, array.get(zoneBottoms, idx), bar_index, array.get(zoneTops, idx), bgcolor=color.new(color.blue, 90)) ``` ### Example 3: Performance Comparison ```pine //@version=6 indicator("Spatial Index Performance Test") import username/SpatialIndex/1 as SI // Generate 500 random levels var array levels = array.new() var SI.SpatialBucket index = SI.newSpatialBucket(close * 0.02) if bar_index == 0 for i = 0 to 499 float randomLevel = close * (0.9 + math.random() * 0.2) // +/- 10% array.push(levels, randomLevel) SI.add(index, i, randomLevel) // Method 1: Linear scan (naive approach) int linearCount = 0 float proximityPct = 5.0 float lowBand = close * (1 - proximityPct/100) float highBand = close * (1 + proximityPct/100) for i = 0 to array.size(levels) - 1 float level = array.get(levels, i) if level >= lowBand and level <= highBand linearCount += 1 // Method 2: Spatial index query SI.QueryResult result = SI.queryProximity(index, close, proximityPct) int spatialCount = array.size(result.indices) // Compare performance plot(result.queryCount, "Items Examined (Spatial)", color=color.green) plot(linearCount, "Items Examined (Linear)", color=color.red) plot(spatialCount, "Results Found", color=color.blue) // Spatial index typically examines 10-50 items vs 500 for linear scan! ``` API Reference Summary Initialization - `newSpatialBucket(bucketSize)` - Fixed bucket size - `newSpatialBucketATR(atrMultiplier, atrValue)` - ATR-based buckets - `updateATR(sb, newATR)` - Update ATR for dynamic sizing Adding Items - `add(sb, itemIndex, price)` - Add item at single price point - `addRange(sb, itemIndex, priceBottom, priceTop)` - Add item spanning range Querying - `queryProximity(sb, refPrice, proximityPercent)` - Query by percentage - `queryRange(sb, priceBottom, priceTop)` - Query fixed range - `queryAt(sb, price, tolerance)` - Query exact price with tolerance - `queryProximityCached(sb, cache, refPrice, pct, duration)` - Cached query Removing & Updating - `remove(sb, itemIndex)` - Remove item - `update(sb, itemIndex, newPrice)` - Update item price - `updateRange(sb, itemIndex, newBottom, newTop)` - Update item range - `reindexAfterRemoval(sb, removedIndex)` - Reindex after single removal - `reindexAfterBatchRemoval(sb, removedIndices)` - Batch reindex - `clear(sb)` - Remove all items Utilities - `size(sb)` - Get item count - `isEmpty(sb)` - Check if empty - `contains(sb, itemIndex)` - Check if item exists - `getStats(sb)` - Get debug statistics string - `calculateOptimalBucketSize(price, pct)` - Calculate optimal bucket size - `sortIndicesDescending(result)` - Sort for safe removal - `sortIndicesAscending(result)` - Sort ascending Performance Characteristics Time Complexity - Add : O(1) for single point, O(m) for range spanning m buckets - Remove : O(1) lookup + O(b) bucket cleanup where b = buckets item spans - Query : O(k) where k = buckets in range (typically 3-5) vs O(n) linear scan - Update : O(1) removal + O(1) addition = O(1) total Space Complexity - Memory per item : ~8 bytes for index reference + map overhead - Bucket overhead : Proportional to price range coverage - Typical usage : For 500 items with 50 active buckets ≈ 4-8KB total Scalability - ✅ 100 items : ~5-10x faster than linear scan - ✅ 500 items : ~10-15x faster - ✅ 1000+ items : ~15-20x faster - ⚠️ Performance degrades if bucket size is too small (too many buckets) - ⚠️ Performance degrades if bucket size is too large (too many items per bucket) Best Practices Bucket Size Selection 1. Start with 2-5% of asset price for percentage-based queries 2. Use ATR-based mode for volatile assets or multi-symbol scripts 3. Test bucket size using `calculateOptimalBucketSize()` function 4. Monitor with `getStats()` to ensure reasonable bucket count Memory Management 1. Clear old items regularly to prevent unbounded growth 2. Use age tracking to remove stale data 3. Set maximum item limits based on your needs 4. Batch removals are more efficient than individual removals Query Optimization 1. Use caching for repeated queries within same bar 2. Invalidate cache when index changes significantly 3. Sort results descending before removal iteration 4. Batch operations when possible (reindexing, removal) Data Consistency 1. Always reindex after removal to maintain index alignment 2. Remove from arrays in descending order to avoid index shifting issues 3. Use batch reindex for multiple simultaneous removals 4. Keep external arrays and index in sync at all times Limitations & Caveats Known Limitations - Not suitable for exact price matching : Use tolerance with `queryAt()` - Bucket size affects performance : Too small = many buckets, too large = many items per bucket - Memory usage : Scales with price range coverage and item count - Reindexing overhead : Removing items mid-array requires index shifting When NOT to Use - ❌ Datasets with < 50 items (linear scan is simpler) - ❌ Items that change price every bar (constant reindexing overhead) - ❌ When you need ALL items every time (no benefit over arrays) - ❌ Exact price level matching without tolerance (use maps instead) When TO Use - ✅ Large datasets (100+ items) with occasional queries - ✅ Proximity-based filtering (% of price, ATR-based ranges) - ✅ Multi-timeframe level tracking - ✅ Zone/range overlap detection - ✅ Price-based spatial filtering --- Technical Details Bucketing Algorithm Items are assigned to buckets using integer division: ``` bucketKey = floor((price - basePrice) / bucketSize) ``` For ATR-based mode: ``` effectiveBucketSize = atrValue × atrMultiplier bucketKey = floor((price - basePrice) / effectiveBucketSize) ``` Range Indexing Items spanning price ranges are indexed in all overlapping buckets to ensure accurate range queries. The midpoint bucket is designated as the "primary bucket" for removal operations. Index Consistency The library maintains two maps: 1. `buckets`: Maps bucket keys → IntArray wrappers containing item indices 2. `itemToBucket`: Maps item indices → primary bucket key (for O(1) removal) This dual-mapping ensures both fast queries and fast removal while maintaining consistency. Implementation Note: Pine Script doesn't allow nested collections (map containing arrays directly), so the library uses an `IntArray` wrapper type to hold arrays within the map structure. This is an internal implementation detail that doesn't affect usage. --- Version History Version 1.0 - Initial release Credits & License License : Mozilla Public License 2.0 (TradingView default) Library Type : Open-source educational resource This library is designed as a public domain utility for the Pine Script community. As per TradingView library rules, this code can be freely reused by other authors. If you use this library in your scripts, please provide appropriate credit as required by House Rules. Summary SpatialIndex is a specialized library that solves a specific problem: fast proximity queries on large price-based datasets . If you're building indicators that track hundreds of levels, zones, or price points and need to frequently filter by proximity to current price, this library can provide 10-20x performance improvements over naive linear scanning. The index-based architecture makes it universally applicable to any data type, and the ATR-based bucketing ensures it adapts to market conditions automatically. Combined with query caching and batch operations, it provides a complete solution for spatial data management in Pine Script. Use this library when speed matters and your dataset is large.
Pine Script® 라이브러리
ArunaReborn의
Dhan_libLibrary "Dhan_lib" Overview Dhan_lib is a Pine Script v6 library designed to help traders automate trading orders via TradingView alerts and webhook integration with the Dhan broker API. This library generates JSON-formatted alert messages for the following instruments. Equity (Intraday and Delivery) Options (CE and PE Buy and Sell) Futures (Buy and Sell) These alert strings can be directly used inside TradingView alerts to place live orders through an external webhook setup. 🔹 Supported Instruments Equity Intraday Buy and Sell Delivery Buy and Sell Options Call (CE) Buy and Sell Put (PE) Buy and Sell ATM, ITM, and OTM strike selection Intraday and Carry Forward Futures Buy and Sell Intraday and Carry Forward 🔹 Key Features ✅ Pine Script v6 compatible ✅ Clean and reusable library functions ✅ Automatic ATM, ITM, and OTM strike calculation ✅ Expiry date handled via string format YYYY-MM-DD ✅ Fully webhook-ready JSON alert structure ✅ Supports multi-leg order format ✅ Designed for TradingView to Dhan automation 🔹 How to Use Import the library in your strategy or indicator. import Shivam_Mandrai/Dhan_lib/1 Call the required function. order_msg = buy_CE_option("YOUR_SECRET_KEY", "NIFTY", 1) Use the returned string as the alert message. alert(order_msg, alert.freq_once_per_bar) Connect TradingView alerts to your Dhan webhook receiver. --- 🔹 Important Notes Strike prices are calculated dynamically based on the current chart price (close). Futures symbols use TradingView continuous contract format such as NIFTY1!. Quantity refers to the number of lots, not the lot size. Expiry date must be provided in YYYY-MM-DD format. ⚠️ DISCLAIMER (PLEASE READ CAREFULLY) This library is provided strictly for educational and automation purposes only. I am not a SEBI-registered advisor. I do not guarantee any profit or accuracy of orders. I am not responsible for any financial loss, missed trades, execution errors, or broker-side issues. Trading in stocks, options, and futures involves significant risk. Automated trading can fail due to internet issues, broker API downtime, incorrect webhook configuration, slippage, or market volatility. 👉 Use this library entirely at your own risk. 👉 Always test thoroughly using paper trading or simulation before deploying with real capital. If you want, I can also: * Shrink this further for TradingView character limits * Convert it into a single-paragraph version * Localize it for Indian retail traders buy_stock_intraday(secret_key, symbol, qty, exchange)   to buy the stock Intraday   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Stock symbol eg-> "TATASTEEL".      qty (int) : int quantity for the order eg-> 1.      exchange (string) : string Trading Exchange eg-> "NSE".   Returns: order string. sell_stock_intraday(secret_key, symbol, qty, exchange)   to sell the stock Intraday   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Stock symbol eg-> "TATASTEEL".      qty (int) : int quantity for the order eg-> 1.      exchange (string) : string Trading Exchange eg-> "NSE".   Returns: order string. buy_stock_delivery(secret_key, symbol, qty, exchange)   to buy the stock delivery   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Stock symbol eg-> "TATASTEEL".      qty (int) : int quantity for the order eg-> 1.      exchange (string) : string Trading Exchange eg-> "NSE".   Returns: order string. sell_stock_delivery(secret_key, symbol, qty, exchange)   to sell the stock delivery   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Stock symbol eg-> "TATASTEEL".      qty (int) : int quantity for the order eg-> 1.      exchange (string) : string Trading Exchange eg-> "NSE".   Returns: order string. buy_CE_option(secret_key, symbol, lots, expiry_date, intraday, strike_price_base, ITM_points, OTM_points, exchange)   to buy CE option   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Index / Stock symbol eg-> "NIFTY", "BANKNIFTY".      lots (int) : int Number of lots eg-> 1.      expiry_date (string) : string Option expiry date in YYYY-MM-DD format eg-> "2026-01-20".      intraday (bool) : bool Set true for intraday order, set false for delivery order eg-> true.      strike_price_base (float) : float Strike price step size eg-> 50, 100 (default is 100).      ITM_points (float) : float Points below CMP to select ITM strike eg-> 100 (default is 0).      OTM_points (float) : float Points above CMP to select OTM strike eg-> 100 (default is 0).      exchange (string) : string Trading Exchange eg-> "NSE" (default is NSE).   Returns: order string. buy_PE_option(secret_key, symbol, lots, expiry_date, intraday, strike_price_base, ITM_points, OTM_points, exchange)   to buy PE option   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Index / Stock symbol eg-> "NIFTY", "BANKNIFTY".      lots (int) : int Number of lots eg-> 1.      expiry_date (string) : string Option expiry date in YYYY-MM-DD format eg-> "2026-01-20".      intraday (bool) : bool Set true for intraday order, set false for delivery order eg-> true.      strike_price_base (float) : float Strike price step size eg-> 50, 100 (default is 100).      ITM_points (float) : float Points below CMP to select ITM strike eg-> 100 (default is 0).      OTM_points (float) : float Points above CMP to select OTM strike eg-> 100 (default is 0).      exchange (string) : string Trading Exchange eg-> "NSE" (default is NSE).   Returns: order string. sell_CE_option(secret_key, symbol, lots, expiry_date, intraday, strike_price_base, ITM_points, OTM_points, exchange)   to Sell CE option   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Index / Stock symbol eg-> "NIFTY", "BANKNIFTY".      lots (int) : int Number of lots eg-> 1.      expiry_date (string) : string Option expiry date in YYYY-MM-DD format eg-> "2026-01-20".      intraday (bool) : bool Set true for intraday order, set false for delivery order eg-> true.      strike_price_base (float) : float Strike price step size eg-> 50, 100 (default is 100).      ITM_points (float) : float Points below CMP to select ITM strike eg-> 100 (default is 0).      OTM_points (float) : float Points above CMP to select OTM strike eg-> 100 (default is 0).      exchange (string) : string Trading Exchange eg-> "NSE" (default is NSE).   Returns: order string. sell_PE_option(secret_key, symbol, lots, expiry_date, intraday, strike_price_base, ITM_points, OTM_points, exchange)   to sell PE option   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Index / Stock symbol eg-> "NIFTY", "BANKNIFTY".      lots (int) : int Number of lots eg-> 1.      expiry_date (string) : string Option expiry date in YYYY-MM-DD format eg-> "2026-01-20".      intraday (bool) : bool Set true for intraday order, set false for delivery order eg-> true.      strike_price_base (float) : float Strike price step size eg-> 50, 100 (default is 100).      ITM_points (float) : float Points below CMP to select ITM strike eg-> 100 (default is 0).      OTM_points (float) : float Points above CMP to select OTM strike eg-> 100 (default is 0).      exchange (string) : string Trading Exchange eg-> "NSE" (default is NSE).   Returns: order string. buy_future(secret_key, symbol, lot, intraday, exchange)   to buy the Future   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Stock symbol eg-> "NIFTY".      lot (int) : int quantity for the order eg-> 1.      intraday (bool) : bool Set true for intraday order, set false for delivery order eg-> true.      exchange (string) : string Trading Exchange eg-> "NSE".   Returns: order string. sell_future(secret_key, symbol, lot, intraday, exchange)   to sell the Future   Parameters:      secret_key (string) : string Secret Key of the Dhan Account eg-> "S1HgS".      symbol (string) : string Stock symbol eg-> "NIFTY".      lot (int) : int quantity for the order eg-> 1.      intraday (bool) : bool Set true for intraday order, set false for delivery order eg-> true.      exchange (string) : string Trading Exchange eg-> "NSE".   Returns: order string.
Pine Script® 라이브러리
Shivam_Mandrai의
9
PriceFormatLibrary for automatically converting price values to formatted strings matching the same format that TradingView uses to display open/high/low/close prices on the chart. █  OVERVIEW This library is intended for Pine Coders who are authors of scripts that display numbers onto a user's charts. Typically, 𝚜𝚝𝚛.𝚝𝚘𝚜𝚝𝚛𝚒𝚗𝚐() would be used to convert a number into a string which can be displayed in a label / box / table, but this only works well for values that are formatted as a simple decimal number. The purpose of this library is to provide an easy way to create a formatted string for values which use other types of formats besides the decimal format. The main functions exported by this library are: 𝚏𝚘𝚛𝚖𝚊𝚝𝙿𝚛𝚒𝚌𝚎() - creates a formatted string from a price value 𝚖𝚎𝚊𝚜𝚞𝚛𝚎𝙿𝚛𝚒𝚌𝚎𝙲𝚑𝚊𝚗𝚐𝚎() - creates a formatted string from the distance between two prices 𝚝𝚘𝚜𝚝𝚛𝚒𝚗𝚐() - an alternative to the built-in 𝚜𝚝𝚛.𝚝𝚘𝚜𝚝𝚛𝚒𝚗𝚐(𝚟𝚊𝚕𝚞𝚎, 𝚏𝚘𝚛𝚖𝚊𝚝) This library also exports some auxiliary functions which are used under the hood of the previously mentioned functions, but can also be useful to Pine Coders that need fine-tuned control for customized formatting of numeric values: Functions that determine information about the current chart: 𝚒𝚜𝙵𝚛𝚊𝚌𝚝𝚒𝚘𝚗𝚊𝚕𝙵𝚘𝚛𝚖𝚊𝚝(), 𝚒𝚜𝚅𝚘𝚕𝚞𝚖𝚎𝙵𝚘𝚛𝚖𝚊𝚝(), 𝚒𝚜𝙿𝚎𝚛𝚌𝚎𝚗𝚝𝚊𝚐𝚎𝙵𝚘𝚛𝚖𝚊𝚝(), 𝚒𝚜𝙳𝚎𝚌𝚒𝚖𝚊𝚕𝙵𝚘𝚛𝚖𝚊𝚝(), 𝚒𝚜𝙿𝚒𝚙𝚜𝙵𝚘𝚛𝚖𝚊𝚝() Functions that convert a 𝚏𝚕𝚘𝚊𝚝 value to a formatted string: 𝚊𝚜𝙳𝚎𝚌𝚒𝚖𝚊𝚕(), 𝚊𝚜𝙿𝚒𝚙𝚜(), 𝚊𝚜𝙵𝚛𝚊𝚌𝚝𝚒𝚘𝚗𝚊𝚕(), 𝚊𝚜𝚅𝚘𝚕𝚞𝚖𝚎() █  EXAMPLES • Simple Example This example shows the simplest way to utilize this library. //@version=6 indicator("Simple Example") import n00btraders/PriceFormat/1 var table t = table.new(position.middle_right, 2, 1, bgcolor = color.new(color.blue, 90), force_overlay = true) if barstate.isfirst table.cell(t, 0, 0, "Current Price: ", text_color = color.black, text_size = 40) table.cell(t, 1, 0, text_color = color.blue, text_size = 40) if barstate.islast string lastPrice = close.formatPrice() // Simple, easy way to format price table.cell_set_text(t, 1, 0, lastPrice) • Complex Example This example calls all of the main functions and uses their optional arguments. //@version=6 indicator("Complex Example") import n00btraders/PriceFormat/1 // Enum values that can be used as optional arguments precision = input.enum(PriceFormat.Precision.DEFAULT) language = input.enum(PriceFormat.Language.ENGLISH) // Main library functions used to create formatted strings string formattedOpen = open.formatPrice(precision, language, allowPips = true) string rawOpenPrice = PriceFormat.tostring(open, format.price) string formattedClose = close.formatPrice(precision, language, allowPips = true) string rawClosePrice = PriceFormat.tostring(close, format.price) = PriceFormat.measurePriceChange(open, close, precision, language, allowPips = true) // Labels to display formatted values on chart string prices = str.format("Open: {0} ({1}) Close: {2} ({3})", formattedOpen, rawOpenPrice, formattedClose, rawClosePrice) string change = str.format("Change (close - open): {0} / {1}", distance, ticks) label.new(chart.point.now(high), prices, yloc = yloc.abovebar, textalign = text.align_left, force_overlay = true) label.new(chart.point.now(low), change, yloc = yloc.belowbar, style = label.style_label_up, force_overlay = true) █  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. • Precision Settings The Precision option in the chart settings can change the format of how prices are displayed on the chart. Since the user's selected choice cannot be known through any Pine built-in variable, this library provides a 𝙿𝚛𝚎𝚌𝚒𝚜𝚒𝚘𝚗 enum that can be used as an optional script input for the user to specify their selected choice. • Language Settings The Language option in the user menu can change the decimal/grouping separators in the prices that are displayed on the chart. Since the user's selected choice cannot be known through any Pine built-in variable, this library provides a 𝙻𝚊𝚗𝚐𝚞𝚊𝚐𝚎 enum that can be used as an optional script input for the user to specify their selected choice. █  EXPORTED FUNCTIONS method formatPrice(price, precision, language, allowPips)   Formats a price value to match how it would be displayed on the user's current chart.   Namespace types: series float, simple float, input float, const float   Parameters:      price (float) : The value to format.      precision (series Precision) : A Precision.* enum value.      language (series Language) : A Language.* enum value.      allowPips (simple bool) : Whether to allow decimal numbers to display as pips.   Returns: Automatically formatted price string. measurePriceChange(startPrice, endPrice, precision, language, allowPips)   Measures a change in price in terms of both distance and ticks.   Parameters:      startPrice (float) : The starting price.      endPrice (float) : The ending price.      precision (series Precision) : A Precision.* enum value.      language (series Language) : A Language.* enum value.      allowPips (simple bool) : Whether to allow decimal numbers to display as pips.   Returns: A tuple of formatted strings: . method tostring(value, format)   Alternative to the Pine `str.tostring(value, format)` built-in function.   Namespace types: series float, simple float, input float, const float   Parameters:      value (float) : (series float) The value to format.      format (string) : (series string) The format string.   Returns: String in the specified format. isFractionalFormat()   Determines if the default behavior of the chart's price scale is to use a fractional format.   Returns: True if the chart can display prices in fractional format. isVolumeFormat()   Determines if the default behavior of the chart's price scale is to display prices as volume.   Returns: True if the chart can display prices as volume. isPercentageFormat()   Determines if the default behavior of the chart's price scale is to display percentages.   Returns: True if the chart can display prices as percentages. isDecimalFormat()   Determines if the default behavior of the chart's price scale is to use a decimal format.   Returns: True if the chart can display prices in decimal format. isPipsFormat()   Determines if the current symbol's prices can be displayed as pips.   Returns: True if the chart can display prices as pips. method asDecimal(value, precision, minTick, decimalSeparator, groupingSeparator, eNotation)   Converts a number to a string in decimal format.   Namespace types: series float, simple float, input float, const float   Parameters:      value (float) : The value to format.      precision (int) : Number of decimal places.      minTick (float) : Minimum tick size.      decimalSeparator (string) : The decimal separator.      groupingSeparator (string) : The thousands separator, aka digit group separator.      eNotation (bool) : Whether the result should use E notation.   Returns: String in decimal format. method asPips(value, priceScale, minMove, minMove2, decimalSeparator, groupingSeparator)   Converts a number to a string in decimal format with the last digit replaced by a superscript.   Namespace types: series float, simple float, input float, const float   Parameters:      value (float) : The value to format.      priceScale (int) : Price scale.      minMove (int) : Min move.      minMove2 (int) : Min move 2.      decimalSeparator (string) : The decimal separator.      groupingSeparator (string) : The thousands separator, aka digit group separator.   Returns: String in decimal format with an emphasis on the pip value. method asFractional(value, priceScale, minMove, minMove2, fractionalSeparator1, fractionalSeparator2)   Converts a number to a string in fractional format.   Namespace types: series float, simple float, input float, const float   Parameters:      value (float) : The value to format.      priceScale (int) : Price scale.      minMove (int) : Min move.      minMove2 (int) : Min move 2.      fractionalSeparator1 (string) : The primary fractional separator.      fractionalSeparator2 (string) : The secondary fractional separator.   Returns: String in fractional format. method asVolume(value, precision, minTick, decimalSeparator, groupingSeparator, spacing)   Converts a number to a string in volume format.   Namespace types: series float, simple float, input float, const float   Parameters:      value (float) : The value to format.      precision (int) : Maximum number of decimal places.      minTick (float) : Minimum tick size.      decimalSeparator (string) : The decimal separator.      groupingSeparator (string) : The thousands separator, aka digit group separator.      spacing (string) : The whitespace separator.   Returns: String in volume format.
Pine Script® 라이브러리
n00btraders의
2
jsonbuilderLibrary "jsonbuilder" JsonBuilder for easiest way to generate json string JSONBuilder(pairs)   Create JSONBuilder instance   Parameters:      pairs (array) : Pairs list, not required for users method addField(this, key, value, kind)   Add Json Object   Namespace types: _JSONBuilder   Parameters:      this (_JSONBuilder)      key (string) : Field key      value (string) : Field value      kind (series Kind) : Kind value method execute(this)   Create json string   Namespace types: _JSONBuilder   Parameters:      this (_JSONBuilder) method addArray(this, key, value)   Add Json Array   Namespace types: _JSONBuilder   Parameters:      this (_JSONBuilder)      key (string) : Field key      value (array<_JSONBuilder>) : Object value array method addObject(this, key, value)   Add Json Object   Namespace types: _JSONBuilder   Parameters:      this (_JSONBuilder)      key (string) : Field key      value (_JSONBuilder) : Object value _JSONBuilder   JSONBuilder type   Fields:      pairs (array) : Pairs data
Pine Script® 라이브러리
EmreKb의
2
Helper Lib by tristanlee85Library "helpers" This library offers various functions and types based on the algorithmic concepts as authored by ICT. kv(key, value)   Returns a string of the key/value set, suitable for debug logging   Parameters:      key (string)      value (string)   Returns: A string formatted as "{key}: {value}" kv(key, value)   Parameters:      key (string)      value (int) kv(key, value)   Parameters:      key (string)      value (float) kv(key, value)   Parameters:      key (string)      value (bool) method enable(this, enable)   Enable/Disable debug logging   Namespace types: Debugger   Parameters:      this (Debugger)      enable (bool) : Set to `true` by default. method group(this, label)   Creates a group label for nested debug() invocations   Namespace types: Debugger   Parameters:      this (Debugger)      label (string) method groupEnd(this, label)   Ends the specified debug group   Namespace types: Debugger   Parameters:      this (Debugger)      label (string) method log(this, s, arg1, arg2, arg3, arg4, arg5)   Logs the param values if debug mode is enabled   Namespace types: Debugger   Parameters:      this (Debugger)      s (string) : Title of the log message      arg1 (string)      arg2 (string)      arg3 (string)      arg4 (string)      arg5 (string) method logIf(this, expr, s, arg1, arg2, arg3, arg4, arg5)   Same behavior as debug() except will only log if the passed expression is true   Namespace types: Debugger   Parameters:      this (Debugger)      expr (bool) : Boolean expression to determine if debug logs should be logged      s (string) : Title of the log message      arg1 (string)      arg2 (string)      arg3 (string)      arg4 (string)      arg5 (string) style_getLineStyleFromType(opt)   Returns the corresponding line style constant for the given LineStyleType   Parameters:      opt (series LineStyleType) : The selected line style type   Returns: The Pine Script line style constant style_getTextSizeFromType(opt)   Returns the corresponding text size constant for the given TextSizeType   Parameters:      opt (series TextSizeType) : The selected text size type   Returns: The Pine Script text size constant style_getTextHAlignFromType(t)   Returns the corresponding horizontal text align constant for the given HAlignType   Parameters:      t (series HAlignType) : The selected text align type   Returns: The Pine Script text align constant style_getTextVAlignFromType(t)   Returns the corresponding vertical text align constant for the given VAlignType   Parameters:      t (series VAlignType) : The selected text align type   Returns: The Pine Script text align constant format_sentimentType(sentiment, pd)   Used to produce a string with the sentiment and PD array type (e.g., "+FVG")   Parameters:      sentiment (series SentimentType) : The sentiment value (e.g., SentimentType.BULLISH)      pd (series PDArrayType) : The price data array (e.g., PDArrayType.FVG)   Returns: A formatted string with the sentiment and PD array (e.g., "+FVG") format_timeToString(timestamp)   Formats a UNIX timestamp into a date and time string based on predefined formats   Parameters:      timestamp (int) : The UNIX timestamp to format   Returns: A formatted string as "MM-dd (E) - HH:mm" method init(this)   Initializes the session and validates the configuration. This MUST be called immediately after creating a new instance.   Namespace types: Session   Parameters:      this (Session) : The Session object reference   Returns: The Session object (chainable) or throws a runtime error if invalid method isActive(this, _time)   Determines if the session is active based on the current bar time   Namespace types: Session   Parameters:      this (Session) : The Session object reference      _time (int)   Returns: `true` if the session is currently active; `false` otherwise method draw(this)   Draws the line and optional label   Namespace types: LineLabel   Parameters:      this (LineLabel) : The LineLabel object reference   Returns: The LineLabel object (chainable) method extend(this, x)   Extends the line and label right to the specified bar index   Namespace types: LineLabel   Parameters:      this (LineLabel) : The LineLabel object reference      x (int) : The bar index to extend to   Returns: The LineLabel object (chainable) method destroy(this)   Removes the line and label from the chart   Namespace types: LineLabel   Parameters:      this (LineLabel) : The LineLabel object reference isFVG(includeVI, barIdx)   Checks if the previous bars form a Fair Value Gap (FVG)   Parameters:      includeVI (bool) : If true, includes Volume Imbalance in the FVG calculation      barIdx (int) : The index of the bar to check from (default is 0 for the current bar)   Returns: A Gap object if a FVG is detected; otherwise, `na` isVolumeImbalance(barIdx)   Checks if the previous bars form a Volume Imbalance (VI)   Parameters:      barIdx (int) : The index of the bar to check from (default is 0 for the current bar)   Returns: A Gap object if a VI is detected; otherwise, `na` isLiquidityVoid(barIdx)   Checks if the previous bars form a Liquidity Void (LV)   Parameters:      barIdx (int) : The index of the bar to check from (default is 0 for the current bar)   Returns: A Gap object if an LV is detected; otherwise, `na` isSwingPoint(barIdx)   Checks if the previous bars form a swing point   Parameters:      barIdx (int) : The index of the bar to check from (default is 0 for the current bar)   Returns: A SwingPoint object if a swing point is detected; otherwise, `na` Debugger   A debug logging utility with group support   Fields:      enabled (series bool)      _debugGroupStack (array) Session   Defines a trading session with a name and time range. When creating a new instance of this type, you MUST call init() immediately.   Fields:      name (series string) : A display-friendly name (e.g., "NY AM")      session (series string) : A string defining the session time range (e.g., "1300-1400")      enabled (series bool) : Optional flag for custom logic; defaults to false      start (series int) : UNIX time representing the session start (set via isActive())      end (series int) : UNIX time representing the session end (set via isActive())      _t (series int)      _start_HH (series float)      _start_mm (series float)      _end_HH (series float)      _end_mm (series float) Gap   Represents a price inefficiency (gap) with details on sentiment and price levels   Fields:      type (series SentimentType) : The sentiment of the gap (e.g., SentimentType.BULLISH)      name (series string) : A display-friendly name (e.g., "+FVG")      startTime (series int) : UNIX time value for the gap's start      endTime (series int) : UNIX time value for the gap's end      startIndex (series int) : Bar index where the gap starts      endIndex (series int) : Bar index where the gap ends      gapLow (series float) : The lowest price level of the gap      gapHigh (series float) : The highest price level of the gap      ce (series float) : The consequent encroachment level of the gap SwingPoint   Represents a swing point with details on type and price level   Fields:      type (series SwingPointType) : The type of swing point (e.g., SwingPointType.HIGH)      time (series int) : UNIX time value for the swing point      barIdx (series int) : Bar index where the swing point occurs      price (series float) : The price level of the swing point which is either the high or low of the middle bar LineLabel   Combines a line and box type to produce a line with a label that is properly aligned   Fields:      x (series int) : The X-axis starting point as a bar index      y (series float) : The Y-axis starting point as the price level      color (series color) : Both the line and text color      width (series int) : Thickness of the line      label (series string) : Text to display      showLabel (series bool) : Boolean to conditionally show/hide the label (default is false)      lineStyle (series LineStyleType) : The style of the line      textSize (series TextSizeType)      _b (series box)      _l (series line)
Pine Script® 라이브러리
tristanlee85의
TextLibrary "Text" library to format text in different fonts or cases plus a sort function. 🔸 Credits and Usage This library is inspired by the work of three authors (in chronological order of publication date): Unicode font function - JD - Duyck UnicodeReplacementFunction - wlhm font - kaigouthro 🔹 Fonts Besides extra added font options, the toFont(fromText, font) method uses a different technique. On the first runtime bar (whether it is barstate.isfirst , barstate.islast , or between) regular letters and numbers and mapped with the chosen font. After this, each character is replaced using the build-in key - value pair map function . Also an enum Efont is included. Note: Some fonts are not complete, for example there isn't a replacement for every character in Superscript/Subscript. Example of usage (besides the included table example): import fikira/Text/1 as t i_font = input.enum(t.Efont.Blocks) if barstate.islast sentence = "this sentence contains words" label.new(bar_index, 0, t.toFont(fromText = sentence, font = str.tostring(i_font)), style=label.style_label_lower_right) label.new(bar_index, 0, t.toFont(fromText = sentence, font = "Circled" ), style=label.style_label_lower_left ) label.new(bar_index, 0, t.toFont(fromText = sentence, font = "Wiggly" ), style=label.style_label_upper_right) label.new(bar_index, 0, t.toFont(fromText = sentence, font = "Upside Latin" ), style=label.style_label_upper_left ) 🔹 Cases The script includes a toCase(fromText, case) method to transform text into snake_case, UPPER SNAKE_CASE, kebab-case, camelCase or PascalCase, as well as an enum Ecase . Example of usage (besides the included table example): import fikira/Text/1 as t i_case = input.enum(t.Ecase.camel) if barstate.islast sentence = "this sentence contains words" label.new(bar_index, 0, t.toCase(fromText = sentence, case = str.tostring(i_case)), style=label.style_label_lower_right) label.new(bar_index, 0, t.toCase(fromText = sentence, case = "snake_case" ), style=label.style_label_lower_left ) label.new(bar_index, 0, t.toCase(fromText = sentence, case = "PascalCase" ), style=label.style_label_upper_right) label.new(bar_index, 0, t.toCase(fromText = sentence, case = "SNAKE_CASE" ), style=label.style_label_upper_left ) 🔹 Sort The sort(strings, order, sortByUnicodeDecimalNumbers) method returns a sorted array of strings. strings: array of strings, for example words = array.from("Aword", "beyond", "Space", "salt", "pepper", "swing", "someThing", "otherThing", "12345", "_firstWord") order: "asc" / "desc" (ascending / descending) sortByUnicodeDecimalNumbers: true/false; default = false _____ • sortByUnicodeDecimalNumbers: every Unicode character is linked to a Unicode Decimal number ( wikipedia.org/wiki/List_of_Unicode_characters ), for example: 1 49 2 50 3 51 ... A 65 B 66 ... S 83 ... _ 95 ` 96 a 97 b 98 ... o 111 p 112 q 113 r 114 s 115 ... This means, if we sort without adjusting ( sortByUnicodeDecimalNumbers = true ), in ascending order, the letter b (98 - small) would be after S (83 - Capital). By disabling sortByUnicodeDecimalNumbers , Capital letters are intermediate transformed to str.lower() after which the Unicode Decimal number is retrieved from the small number instead of the capital number. For example S (83) -> s (115), after which the number 115 is used to sort instead of 83. Example of usage (besides the included table example): import fikira/Text/1 as t if barstate.islast aWords = array.from("Aword", "beyond", "Space", "salt", "pepper", "swing", "someThing", "otherThing", "12345", "_firstWord") label.new(bar_index, 0, str.tostring(t.sort(strings= aWords, order = 'asc' , sortByUnicodeDecimalNumbers = false)), style=label.style_label_lower_right) label.new(bar_index, 0, str.tostring(t.sort(strings= aWords, order = 'desc', sortByUnicodeDecimalNumbers = false)), style=label.style_label_lower_left ) label.new(bar_index, 0, str.tostring(t.sort(strings= aWords, order = 'asc' , sortByUnicodeDecimalNumbers = true )), style=label.style_label_upper_right) label.new(bar_index, 0, str.tostring(t.sort(strings= aWords, order = 'desc', sortByUnicodeDecimalNumbers = true )), style=label.style_label_upper_left ) 🔸 Methods/functions method toFont(fromText, font)   toFont : Transforms text into the selected font   Namespace types: series string, simple string, input string, const string   Parameters:      fromText (string)      font (string)   Returns: `fromText` transformed to desired `font` method toCase(fromText, case)   toCase : formats text to snake_case, UPPER SNAKE_CASE, kebab-case, camelCase or PascalCase   Namespace types: series string, simple string, input string, const string   Parameters:      fromText (string)      case (string)   Returns: `fromText` formatted to desired `case` method sort(strings, order, sortByUnicodeDecimalNumbers)   sort : sorts an array of strings, ascending/descending and by Unicode Decimal numbers or not.   Namespace types: array   Parameters:      strings (array)      order (string)      sortByUnicodeDecimalNumbers (bool)   Returns: Sorted array of strings
Pine Script® 라이브러리
fikira의
2
TimezoneFormatIANAUTCLibrary "TimezoneFormatIANAUTC" Provides either the full IANA timezone identifier or the corresponding UTC offset for TradingView’s built-in variables and functions. tz(_tzname, _format)   Parameters:      _tzname (string) : "London", "New York", "Istanbul", "+1:00", "-03:00" etc.      _format (string) : "IANA" or "UTC"   Returns: "Europe/London", "America/New York", "UTC+1:00" Example Code import ARrowofTime/TimezoneFormatIANAUTC/1 as libtz sesTZInput = input.string(defval = "Singapore", title = "Timezone") example1 = libtz.tz("London", "IANA") // Return Europe/London example2 = libtz.tz("London", "UTC") // Return UTC+1:00 example3 = libtz.tz("UTC+5", "IANA") // Return UTC+5:00 example4 = libtz.tz("UTC+4:30", "UTC") // Return UTC+4:30 example5 = libtz.tz(sesTZInput, "IANA") // Return Asia/Singapore example6 = libtz.tz(sesTZInput, "UTC") // Return UTC+8:00 sesTime1 = time("","1300-1700", example1) // returns the UNIX time of the current bar in session time or na sesTime2 = time("","1300-1700", example2) // returns the UNIX time of the current bar in session time or na sesTime3 = time("","1300-1700", example3) // returns the UNIX time of the current bar in session time or na sesTime4 = time("","1300-1700", example4) // returns the UNIX time of the current bar in session time or na sesTime5 = time("","1300-1700", example5) // returns the UNIX time of the current bar in session time or na sesTime6 = time("","1300-1700", example6) // returns the UNIX time of the current bar in session time or na Parameter Format Guide This section explains how to properly format the parameters for the tz(_tzname, _format) function. _tzname (string) must be either; A valid timezone name exactly as it appears in the chart’s lower-right corner (e.g. New York, London). A valid UTC offset in ±H:MM or ±HH:MM format. Hours: 0–14 (zero-padded or not, e.g. +1:30, +01:30, -0:00). Minutes: Must be 00, 15, 30, or 45 examples; "New York" → ✅ Valid chart label "London" → ✅ Valid chart label "Berlin" → ✅ Valid chart label "America/New York" → ❌ Invalid chart label. (Use "New York" instead) "+1:30" → ✅ Valid offset with single-digit hour "+01:30" → ✅ Valid offset with zero-padded hour "-05:00" → ✅ Valid negative offset "-0:00" → ✅ Valid zero offset "+1:1" → ❌ Invalid (minute must be 00, 15, 30, or 45) "+2:50" → ❌ Invalid (minute must be 00, 15, 30, or 45) "+15:00" → ❌ Invalid (hour must be 14 or below) _tztype (string) must be either; "IANA" → returns full IANA timezone identifier (e.g. "Europe/London"). When a time function call uses an IANA time zone identifier for its timezone argument, its calculations adjust automatically for historical and future changes to the specified region’s observed time, such as daylight saving time (DST) and updates to time zone boundaries, instead of using a fixed offset from UTC. "UTC" → returns UTC offset string (e.g. "UTC+01:00")
Pine Script® 라이브러리
ARrowofTime의