เริ่มกันเลย

Strings

K21CommonLibrary "K21Common" minDollarMove()   Calculates the minimum dollar move per tick for the current symbol   Returns: (float) Dollar value per tick movement @description Uses syminfo.pointvalue (contract value per point) and syminfo.minmove (minimum tick movement) to calculate the dollar value of a single tick. This works across all futures contracts without manual configuration. replaceTradeTemplateTags(template, entry_num, description, entry_price, stop_price, tp_price, contracts, risk_dollars, reward_dollars, rr_ratio, max_risk)   Replaces trade related template tags with actual values   Parameters:      template (string) : (string) Template string with tags      entry_num (int) : (int) Entry number (1-5)      description (string) : (string) Entry description      entry_price (float) : (float) Entry price      stop_price (float) : (float) Stop price      tp_price (float) : (float) TP price      contracts (int) : (int) Number of contracts      risk_dollars (float) : (float) Risk in dollars      reward_dollars (float) : (float) Reward in dollars      rr_ratio (float) : (float) Risk:Reward ratio      max_risk (float) : (float) Maximum allowed risk   Returns: (string) Processed template string isLightColor(clr)   Checks if a color is light based on luminance calculation   Parameters:      clr (color) : (color) The color to check   Returns: (bool) True if the color is light isDarkColor(clr)   Checks if a color is dark based on luminance calculation   Parameters:      clr (color) : (color) The color to check   Returns: (bool) True if the color is dark isLightScheme()   Checks if the current chart color scheme is light   Returns: (bool) True if the chart uses a light color scheme isDarkScheme()   Checks if the current chart color scheme is dark   Returns: (bool) True if the chart uses a dark color scheme getBarIndexFromTime(target_time)   Finds the bar_index for a given timestamp by searching historical bars   Parameters:      target_time (int) : (int) The timestamp to find   Returns: (int) The bar_index where time matches or is closest to target_time
ไลบรารี Pine Script®
โดย Knighted21
VoltRouter Webhook BuilderBuild TradingView alert webhook payloads for VoltRouter — a signal routing service that executes your TradingView strategy alerts directly at your broker. $0.07/signal, pay-as-you-go, no subscription required . Supports: market, limit, stop, bracket (TP+SL), trailing stop, FLAT, and cancel-all. How to use: 1. Sign up at voltrouter.com and connect your broker 2. Import this library in your strategy 3. Paste the output into a TradingView alert → Webhook URL field Setup: voltrouter.com import VoltRouterWebhook as vr // In your strategy alert message field: vr.market("MNQM26", "buy", 1, "ibkr", "my_strategy") vr.bracket("MNQM26", "sell", 1, close + 10, close - 5) vr.flat("MNQM26")
ไลบรารี Pine Script®
โดย yuzername
lib_pickmytradeLibrary "lib_pickmytrade" a simple helper to create webhook messages for alert webhooks to pickmytrade alert_msg_exit(account_id, token)   generates a json formatted EXIT message string for an alert() call, simply closing any open trade   Parameters:      account_id (string) : the pickmytrade account id      token (string) : the pickmytrade token   Returns: a json formatted message string for the alert() call alert_msg_trail_sl(account_id, token, is_long, trail_sl)   generates a json formatted TRAIL STOP LOSS message string for an alert() call   Parameters:      account_id (string) : the pickmytrade account id      token (string) : the pickmytrade token      is_long (bool) : trade direction      trail_sl (float) : new stop loss level   Returns: a json formatted message string for the alert() call alert_msg_entry(account_id, token, is_long, tp1, qty1, tp2, qty2, tp3, qty3, sl, tp1_be_offset, limit_price, limit_cancel_time)   generates a json formatted ENTRY message string for an alert() call   Parameters:      account_id (string) : the pickmytrade account id      token (string) : the pickmytrade token      is_long (bool) : trade direction      tp1 (float) : tp1 target      qty1 (int) : tp1 quantity (optional)      tp2 (float) : tp2 target      qty2 (int) : tp2 quantity (optional)      tp3 (float) : tp3 target      qty3 (int) : tp3 quantity (optional)      sl (float) : sl stop      tp1_be_offset (float) : sl to be when hitting tp1, with this offset (optional, must be >= 0)      limit_price (float) : limit entry target (optional)      limit_cancel_time (int) : limit entry cancel time, if not filled (gtc) (optional)   Returns: a json formatted message string for the alert() call
ไลบรารี Pine Script®
โดย robbatt
DafeRCMLibRolling Confidence Matrix Library (RCM) A Structural Evidence Accumulation Engine for Pine Script Developers What This Library Does The Rolling Confidence Matrix (RCM) is a developer library that provides a stateful structural analysis engine for Pine Script indicators. It maintains rolling evidence buckets that accumulate and decay observations about market structure on every bar, then synthesizes those observations into confidence scores, a directional state classification, and a set of modulation outputs that downstream indicators can consume. The library is designed to be algorithm-agnostic. It does not generate signals, draw lines, or produce visual output. It computes structural context that other indicators use to make better decisions — whether that indicator is a Supertrend, a moving average crossover, a Bollinger Band system, or a machine learning model. The Problem This Solves Traditional indicators are structurally blind. A Supertrend calculates band width from ATR alone. A moving average crossover fires regardless of whether the cross happens during a structural breakout or inside exhaustion chop. A Bollinger Band squeeze looks identical mathematically whether it precedes a genuine expansion or a false breakout. These indicators lack the ability to evaluate what kind of price action is producing their signals. The RCM addresses this by maintaining a persistent, per-bar structural memory that any indicator can query. How It Works: The Five Evidence Buckets The RCM tracks five categories of structural evidence, accumulated separately for bull and bear sides (10 buckets total). Each bucket decays by a configurable rate every bar, accumulates when its specific conditions are detected, and is hard-capped to prevent runaway values. Impulse — Detects directional thrust bars. Criteria: body exceeds the 10-bar average body by 15%, close position is in the upper 30% (bull) or lower 30% (bear) of the bar's range, and the bar's range exceeds the 10-bar average range by 5%. Volume confirmation adds additional evidence when the volume ratio exceeds 1.2x the 20-bar average. Structure — Detects swing-level events. Criteria: price closes above the 5-bar highest high (swing break), price sweeps below a swing low and reclaims it on a bullish close (reclaim), or price wicks through a swing level but closes back inside (sweep absorption). Each event type contributes a different evidence weight, reflecting its structural significance. Exhaustion — Detects reversal pressure. Criteria: a bearish-body bar with a lower wick exceeding 45% of the total range on volume above 1.2x average contributes bull exhaustion evidence (potential buying absorption). The inverse applies for bear exhaustion. This bucket represents counter-trend pressure building within the current move. Continuation — Detects trend persistence. Criteria: the EMA(21) of HLC3 has a positive slope, price is above the anchor, and the current close exceeds the previous close. This bucket also has asymmetric decay: when price moves to the wrong side of the anchor, continuation evidence decays at 62% per bar instead of the standard rate. Anchor crosses trigger a 50% immediate reduction. Compression — Detects range contraction. Criteria: the current bar's range is below 80% of the 10-bar average range, and the ATR(14) to SMA(ATR,30) ratio is below 0.95. Compression evidence accumulates on the side of the anchor (bull compression above, bear compression below), representing potential energy buildup before expansion. Bucket Caps Each bucket has a defined maximum to prevent any single evidence type from dominating the confidence calculation: Impulse: 25 Structure: 30 Exhaustion: 20 Continuation: 20 Compression: 15 Confidence Computation Bull and bear confidence scores are computed as weighted sums of their respective five buckets: bullConf = bullImpulse × wImpulse + bullStructure × wStructure + bullExhaustion × wExhaustion + bullContinuation × wContinuation + bullCompression × wCompression Default weights are: Impulse 1.20, Structure 1.35, Exhaustion 1.15, Continuation 1.00, Compression 0.90. Structure carries the highest default weight because swing-level events are the most structurally significant observations. From these scores, the library derives: Net Confidence: bullConf − bearConf Activity: bullConf + bearConf (total evidence in the system) Dominance: netConf / activity (how one-sided the evidence is, range −1 to +1) Bull/Bear Pressure: each side's share of total activity (range 0 to 1) The Three-State Engine The state engine uses hysteresis to prevent flickering between states. Entering a state requires strong evidence; holding a state requires only moderate evidence. Entry Conditions (Transition → Bull/Bear): Net confidence exceeds the entry threshold (default: 12.0) AND dominance exceeds the dominance threshold (default: 0.18) Hold Conditions (Bull/Bear → Transition): A state is lost when ANY of: Net confidence drops below the hold threshold (default: 5.0) Opposing pressure exceeds the flip pressure threshold (default: 0.58) Erosion (peak confidence minus current) exceeds 35% of current confidence This hysteresis design means the engine requires conviction to enter a directional state but gives the trend room to breathe once established. Substates When the engine is in Transition (state = 0), it internally classifies the type of transition based on which evidence buckets are dominant: Early (substate 1): Within 3 bars of losing a directional state. Evidence is collapsing. Contested (substate 2): Both bull and bear confidence exceed 50% of the entry threshold. Both sides have material evidence. Rotational (substate 3): Exhaustion buckets represent more than 35% of total non-compression evidence. The market is churning. Compression (substate 4): Compression buckets exceed 35% of total evidence while impulse is below 15%. Energy is building. The external state remains 0 for all substates. Consumers who need granularity can query st.substate. Damage Detection When the engine is in a directional state, it evaluates structural compromise on every bar by accumulating a damage score from seven independent checks: For a Bull state, damage accumulates from: Price below the anchor (+1.5) Bear impulse condition detected (+1.0) Upper wick ratio exceeds 35% (+0.75) Anchor slope is negative (+1.0) Bear pressure exceeds 45% (+1.0) Close and high are both lower than previous bar (+0.75) Price crossed below the anchor this bar (+1.25) Maximum possible damage score per bar: 7.25. When the score exceeds the damage threshold (default: 4.0), the trend is flagged as damaged. Damage Response When damage is detected, the engine modifies the active side's evidence buckets: Continuation is reduced by (0.25 × damageDecayMult) — default removes ~44% Impulse is multiplied by damageImpulseCut — default retains 88% Structure is multiplied by 0.92 Opposing exhaustion receives +1.5 Opposing impulse receives +1.0 This creates a natural degradation cycle: damage weakens the active trend's evidence while strengthening the opposing side's, making a transition more likely without forcing it. Integrity Score The library computes a continuous structural integrity measure from 0.0 (broken) to 1.0 (fully intact), derived from four components: Erosion component (max −0.30): How far current confidence has fallen from its peak Damage component (max −0.30): Current damage score relative to threshold Opposing pressure (max −0.20): Counter-trend pressure magnitude Transition duration (max −0.15): How long the engine has been in transition state External evidence modifiers can also adjust integrity by ±0.1. Directional Permissions Rather than a simple pass/fail gate, the library outputs four permission values: allowLong (bool) : Structural permission to take long positions allowShort (bool): Structural permission to take short positions preferLong (float, 0−1): Strength of structural preference for longs preferShort (float, 0−1): Strength of structural preference for shorts In Bull state: longs are allowed, shorts are blocked unless the trend is damaged (allowing counter-trend fades). preferLong equals the confidence strength. In Bear state: the inverse. In Transition: both sides are allowed, preference leans toward whichever side has more evidence. External Evidence Sockets The library accepts additive evidence injection from external systems through the ExternalEvidence type. External evidence is applied after internal bucket computation but before state transitions, meaning it can influence confidence but cannot directly set state. ev = rcm.ExternalEvidence.new(bullEvidence=3.0, source="dreamer") st := rcm.inject(st, ev) External evidence is reset to zero after each update() call. This prevents stale external data from persisting. Modulation Outputs The library provides purpose-built modulation functions for different indicator types: Band Modulation (get_band_mod): Returns a float multiplier for band/envelope width. Bands tighten during high-confidence directional states and widen when damage is detected. Used by Supertrend, Bollinger Band, and PSAR-type indicators. Score Modulation (get_score_mod): Returns an additive modifier for directional scores. When a score's direction aligns with the RCM state, it receives a confidence-proportional boost. When it opposes, it receives a penalty. Used by signal-scoring systems. Signal Gate (get_gate): Returns a boolean indicating whether signals should be permitted. When transition blocking is enabled, all signals are suppressed during Transition state. Full Package (get_modulation): Returns all outputs in a single RCMModulation struct including band mod, score mod, gate, permissions, integrity, state color, and regime label. Configuration The library ships with three preset configurations: default_config(): Balanced settings suitable for 15m−1H timeframes scalp_config(): Faster decay (0.75), lower thresholds, higher impulse weight — optimized for 1m−5m swing_config(): Slower decay (0.88), higher thresholds, higher structure weight — optimized for 4H−Daily All 16 configuration parameters can also be set individually through the RCMConfig constructor. Developer Integration Guide Step 1: Import and Initialize import DskyzInvestments/DafeRCMLib/1 as rcm var rcm.RCMState st = rcm.RCMState.new() var rcm.RCMConfig cfg = rcm.default_config() Both objects must be declared with var for state persistence across bars. Step 2: Update Every Bar st := rcm.update(st, cfg) Call update() exactly once per bar. It handles all evidence detection, decay, confidence computation, damage detection, state transitions, substate classification, and integrity scoring. Step 3: Query Modulation Outputs For band-based indicators (Supertrend, BB, PSAR): band := band * rcm.get_band_mod(st, 0.45, 1.10) For score-based systems (signal scoring, ML models): fusedScore = rawScore + rcm.get_score_mod(st, rawScore, 0.25) For signal gating: buySignal := buySignal and rcm.get_gate(st, true) For directional permissions: rcm.RCMPermissions perms = rcm.get_permissions(st) if perms.allowLong and perms.preferLong > 0.3 // High structural preference for longs Step 4: Optional — Inject External Evidence if myDreamerScore > 2.0 ev = rcm.ExternalEvidence.new(bullEvidence=2.0, source="dreamer") st := rcm.inject(st, ev) // inject() must be called BEFORE update() Step 5: Optional — Use Dashboard Helpers rcm.conf_bar(st.bullConf, 130, 8) // Returns "████░░░░" rcm.state_text(st) // Returns "▲ BULL" rcm.damage_text(st) // Returns "Intact" rcm.integrity_text(st) // Returns "87.3%" rcm.state_color(st, bullCol, bearCol, transCol) Step 6: Optional — Narrative Text = rcm.narrative_regime(st, bullCol, bearCol, transCol, dimCol) = rcm.narrative_kinetics(st, accentCol, dimCol) = rcm.narrative_structure(st, bullCol, bearCol, transCol, dimCol) What This Library Does Not Do It does not generate buy/sell signals It does not draw on the chart It does not use request.security or access external timeframes It does not use request.footprint (consumers can inject footprint-derived evidence through the external socket) It does not persist data beyond the current chart's bar history It does not adapt its own parameters automatically The library computes structural context. What the consuming indicator does with that context is entirely the developer's decision. Companion Demo The DafeRCMLibDEMO indicator demonstrates every function and output of this library using a simple EMA crossover system as the base indicator. It includes: Modulated ATR bands showing get_band_mod() in action Trade signals gated by get_permissions() and get_gate() State shift and damage markers Substate classification labels Evidence bucket subplots for all 10 buckets Confidence, integrity, and modulation output subplots Full quantitative dashboard and narrative panel — Dskyz, Trade with insight. Trade with anticipation.
ไลบรารี Pine Script®
โดย DskyzInvestments
3
Vantage_News_HistoricalVantage News is a Pine Script library that provides pre-market economic event filtering defaults intended for strategies that trade on YM futures. It determines a default for whether trading should be blocked, delayed, or allowed on any given day. This Historical file contains prior years. Core Concept News events are pre-compiled into Pine Script data libraries organized by half-year (LO1_News2025H1, LO1_News2025H2, etc.), updated weekly on Sundays. There are no API calls — events are baked into arrays of dates, times, type IDs, and severities. Severity System Can be configured to define or override three default severity tiers: - Sev 3 (CPI, NFP, FOMC) — defaults to blocks the entire day or delays, depending on policy - Sev 2 (ISM PMI, claims) — defaults to delay trading until the event time + a configurable post-delay window - Sev 1 (secondary indicators) — defaults to no delays Blocking vs Delaying - Block: No trading for the full session. WillTradeToday() returns false. - Delay: Trading allowed after eventTime + delayMinutes. IsDelayed(currentTimeMs) returns true until the release time passes. Provides a per-event-type policy mechanism so overrides can force any event to block, delay, or be ignored regardless of its base severity. Next Trading Window Calculation FindNextTradingWindow() scans forward up to 14 days, skipping weekends and blocked days based on the provided configuration. If the next tradeable day has a delay, it returns the delayed start time — so an info panel can show e.g. "Mon 7:35 AM" to indicate the next trading opening Exception Mappings Each half-year library can ship per-event-type overrides (different severity, custom delay minutes, tags). When the applyLibExceptionMappings configuration is enabled, these override the base severity — allowing the data to carry date-specific adjustments. Special Handling CME early close days are encoded as a special event type. CheckCmeEarlyClose() returns a halt timestamp so a strategy can truncate the session. Caching Evaluation is lazy and memoized by date string — EvaluateForDate() only recomputes when the date changes. The event cache is built once at initialization via a day index for fast date lookups.
ไลบรารี Pine Script®
โดย Vantage-Stack
fsl_futuresLibrary "fsl_futures" Futures helpers for TradingView. Provides month code constants and utilities for determining allowed / major contract months per futures root (e.g., SI uses HKNUZ). allMonthCodes()   Returns the standard CME-style futures month codes as an array.   Returns: array of month codes in order: F,G,H,J,K,M,N,Q,U,V,X,Z allMonthCodesStr()   Returns all month codes as a single string for quick membership checks.   Returns: string "FGHJKMNQUVXZ" majorMonthsByRoot(product_root)   Returns the major month-code subset for a given futures root. If the root is not mapped, defaults to all months.   Parameters:      product_root (string) : Futures root symbol, e.g. "SI", "ES", "CL"   Returns: string of allowed month codes (e.g., "HKNUZ" for SI), otherwise "FGHJKMNQUVXZ" allowedMonthsByRoot(product_root)   Returns the allowed month-code subset for a given futures root. If the root is not mapped, defaults to all months.   Parameters:      product_root (string) : Futures root symbol, e.g. "SI", "ES", "CL"   Returns: string of allowed month codes (e.g., "HKNUZ" for SI), otherwise "FGHJKMNQUVXZ" isMajorMonth(product_root, month_code)   Checks whether a month code is major for a given futures root.   Parameters:      product_root (string) : Futures root symbol, e.g. "SI"      month_code (string) : Single-letter month code, e.g. "H"   Returns: bool true if month_code is included in the major set for that root isAllowedMonth(product_root, month_code)   Checks whether a month code is allowed for a given futures root.   Parameters:      product_root (string) : Futures root symbol, e.g. "SI"      month_code (string) : Single-letter month code, e.g. "H"   Returns: bool true if month_code is included in the allowed set for that root
ไลบรารี Pine Script®
โดย QuantNomad
SimpleTableA library for when you just want to get a table up with the least hassle. The function `f_drawTableFromColumns()`, is intended to be the simplest possible way to draw a table with the least code in the calling script. Just pass in between one and ten arrays that contain the strings you want to show. Each string array represents one column. That's it. You get a table back. If you want to style the table you can optionally pass colours, size, and whether the table has a header row that should be displayed differently. An example usage section demonstrates creating a three-column table. The function automatically sizes the table based on the number of non-na arrays and the maximum column length. Optional styling parameters cover table position, text size, text alignment, text colour, cell background, header background, header text, and border width. If you don't supply any of these arguments, the table uses some sensible default values. The table is created and updated on the last bar only, with caching to avoid unnecessary redraws. Column shrink detection clears the table only when required, preventing stale cell content. This is not a full-fledged table management library; there are already lots of those published. It is (I believe and hope) the easiest library to use. For example, you don't need to supply a matrix, or a user-defined type full of settings. The library wraps the input arrays into a map, and uses a user-defined type, but internally, so you don't need to worry about it. Just supply one or more arrays with some text. f_drawTableFromColumnArrays(_a_col1, _a_col2, _a_col3, _a_col4, _a_col5, _a_col6, _a_col7, _a_col8, _a_col9, _a_col10, _position, _textSize, _textAlign, _textColor, _cellBgColor, _headerBgColor, _headerTextColor, _hasHeaderRow, _borderWidth)   Renders a table using up to ten string arrays. The table size is derived from the number of non-na arrays and the maximum length across the supplied arrays.   Parameters:      _a_col1 (array) : (array) Column 1 values. Supply na to omit.      _a_col2 (array) : (array) Column 2 values. Supply na to omit.      _a_col3 (array) : (array) Column 3 values. Supply na to omit.      _a_col4 (array) : (array) Column 4 values. Supply na to omit.      _a_col5 (array) : (array) Column 5 values. Supply na to omit.      _a_col6 (array) : (array) Column 6 values. Supply na to omit.      _a_col7 (array) : (array) Column 7 values. Supply na to omit.      _a_col8 (array) : (array) Column 8 values. Supply na to omit.      _a_col9 (array) : (array) Column 9 values. Supply na to omit.      _a_col10 (array) : (array) Column 10 values. Supply na to omit.      _position (string) : (TablePosition) Table position on the chart. Default is top right.      _textSize (string) : (TableTextSize) Text size for all cells. Default is normal.      _textAlign (string) : (TableTextAlign) Horizontal alignment for all cells. Default is left.      _textColor (color) : (color) Text colour for all cells. Default is chart foreground color.      _cellBgColor (color) : (color) Background colour for all cells. Uses a default if na. Default is gray 90%.      _headerBgColor (color) : (color) Background colour for the header row. Uses a default if na. Default is gray 75%.      _headerTextColor (color) : (color) Text colour for the header row. Uses a default if na.      _hasHeaderRow (bool) : (bool) If true, row 0 is treated as a header. Default is true.      _borderWidth (int) : (int) Table border width. Must be non-negative. Default is 1.   Returns: The table object, so the caller can store the table ID if required.
ไลบรารี Pine Script®
โดย SimpleCryptoLife
AssetCorrelationUtils - Open source Library Used for Indicators that utilize correlation between assets for divergence calculations. It has no drawing elements. ASSET CORRELATION UTILS PineScript library for automatic detection of correlated asset pairs and triads for multi-asset analysis. WHAT IT DOES This library automatically identifies correlated assets based on the current chart symbol. It returns properly configured asset pairings for use in SMT divergence detection, inter-market analysis, and multi-asset comparison tools. HOW IT WORKS The library matches your chart symbol against known correlation groups: Index Futures: NQ/ES/YM/RTY triads (including micros) Metals: Gold/Silver/Copper triads (futures and CFD) Forex: EUR/GBP/DXY and USD/JPY/CHF triads Energy: Crude/Gasoline/Heating Oil triads Treasury: ZB/ZF/ZN bond triads Crypto: BTC/ETH/TOTAL3 and major altcoin pairings Inversion flags are automatically computed for assets that move inversely (e.g., DXY vs EUR pairs). HOW TO USE import fstarcapital/AssetCorrelationUtils/1 as acu // Simple: auto-detect from current chart config = acu.resolveCurrentChart() // Access resolved assets primary = config.primary secondary = config.secondary tertiary = config.tertiary EXPORTED FUNCTIONS resolveCurrentChart(): One-call auto-detection using chart syminfo resolveAssets(): Full detection with custom parameters resolveTriad() / resolveDyad(): Manual resolution with inversion logic detect*() functions: Category-specific detectors for custom workflows TYPES AssetPairing: Core structure for primary/secondary/tertiary tickers with inversion flags AssetConfig: Full resolution result with detection status and asset category DISCLAIMER This library is a utility for building multi-asset indicators. Asset correlations are not guaranteed and may change over time. Always validate pairings for your specific trading context. Full Default Function @type and @field descriptions below. Library "AssetCorrelationUtils" detectIndicesFutures(ticker)   Detects Index Futures (NQ/ES/YM/RTY + micro variants)   Parameters:      ticker (string) : The ticker string to check (typically syminfo.ticker)   Returns: AssetPairing with secondary and tertiary assets configured detectMetalsFutures(ticker)   Detects Metal Futures (GC/SI/HG + micro variants)   Parameters:      ticker (string) : The ticker string to check   Returns: AssetPairing with secondary and tertiary assets configured detectForexFutures(ticker)   Detects Forex Futures (6E/6B + micro variants)   Parameters:      ticker (string) : The ticker string to check   Returns: AssetPairing with secondary and tertiary assets configured detectEnergyFutures(ticker)   Detects Energy Futures (CL/RB/HO + micro variants)   Parameters:      ticker (string) : The ticker string to check   Returns: AssetPairing with secondary and tertiary assets configured detectTreasuryFutures(ticker)   Detects Treasury Futures (ZB/ZF/ZN)   Parameters:      ticker (string) : The ticker string to check   Returns: AssetPairing with secondary and tertiary assets configured detectCryptoFutures(ticker)   Detects CME Crypto Futures (BTC/ETH + micro variants)   Parameters:      ticker (string) : The ticker string to check   Returns: AssetPairing with secondary and tertiary assets configured detectCADFutures(ticker)   Detects CAD Forex Futures (6C + micro variants)   Parameters:      ticker (string) : The ticker string to check   Returns: AssetPairing with secondary and tertiary assets configured detectForexCFD(ticker, tickerId)   Detects Forex CFD pairs (EUR/GBP/DXY, USD/JPY/CHF triads)   Parameters:      ticker (string) : The ticker string to check      tickerId (string) : The full ticker ID (syminfo.tickerid) for primary asset   Returns: AssetPairing with secondary and tertiary assets configured detectCrypto(ticker, tickerId)   Detects major Crypto assets (BTC, ETH, SOL, XRP, alts)   Parameters:      ticker (string) : The ticker string to check      tickerId (string) : The full ticker ID for primary asset   Returns: AssetPairing with secondary and tertiary assets configured detectMetalsCFD(ticker, tickerId)   Detects Metals CFD (XAU/XAG/Copper)   Parameters:      ticker (string) : The ticker string to check      tickerId (string) : The full ticker ID for primary asset   Returns: AssetPairing with secondary and tertiary assets configured detectIndicesCFD(ticker, tickerId)   Detects Indices CFD (NAS100/SP500/DJ30)   Parameters:      ticker (string) : The ticker string to check      tickerId (string) : The full ticker ID for primary asset   Returns: AssetPairing with secondary and tertiary assets configured detectEUStocks(ticker, tickerId)   Detects EU Stock Indices (GER40/EU50) - Dyad only   Parameters:      ticker (string) : The ticker string to check      tickerId (string) : The full ticker ID for primary asset   Returns: AssetPairing with secondary asset configured (tertiary empty for dyad) getDefaultFallback(tickerId)   Returns default fallback assets (chart ticker only, no correlation)   Parameters:      tickerId (string) : The full ticker ID for primary asset   Returns: AssetPairing with chart ticker as primary, empty secondary/tertiary (no correlation) applySessionModifierWithBackadjust(tickerStr, sessionType)   Applies futures session modifier to ticker WITH back adjustment   Parameters:      tickerStr (string) : The ticker to modify      sessionType (string) : The session type (syminfo.session)   Returns: Modified ticker string with session and backadjustment.on applied applySessionModifierNoBackadjust(tickerStr, sessionType)   Applies futures session modifier to ticker WITHOUT back adjustment   Parameters:      tickerStr (string) : The ticker to modify      sessionType (string) : The session type (syminfo.session)   Returns: Modified ticker string with session and backadjustment.off applied isTriadMode(pairing)   Checks if a pairing represents a valid triad (3 assets)   Parameters:      pairing (AssetPairing) : The AssetPairing to check   Returns: True if tertiary is non-empty (triad mode), false for dyad getAssetTicker(tickerId)   Extracts clean ticker string from full ticker ID   Parameters:      tickerId (string) : The full ticker ID (e.g., "BITGET:BTCUSDT.P")   Returns: Clean ticker string (e.g., "BTCUSDT.P") resolveTriad(chartTickerId, pairing)   Resolves triad asset assignments with proper inversion flags   Parameters:      chartTickerId (string) : The current chart's ticker ID (syminfo.tickerid)      pairing (AssetPairing) : The detected AssetPairing   Returns: Tuple resolveDyad(chartTickerId, pairing)   Resolves dyad asset assignment with proper inversion flag   Parameters:      chartTickerId (string) : The current chart's ticker ID      pairing (AssetPairing) : The detected AssetPairing (dyad: tertiary is empty)   Returns: Tuple resolveAssets(ticker, tickerId, assetType, sessionType, useBackadjust)   Main auto-detection entry point. Detects asset category and returns fully resolved config.   Parameters:      ticker (string) : The ticker string to check (typically syminfo.ticker)      tickerId (string) : The full ticker ID (typically syminfo.tickerid)      assetType (string) : The asset type (typically syminfo.type)      sessionType (string) : The session type for futures (typically syminfo.session)      useBackadjust (bool) : Whether to apply back adjustment for futures session alignment   Returns: AssetConfig with fully resolved assets, inversion flags, and detection status resolveCurrentChart()   Simplified auto-detection using current chart's syminfo values   Returns: AssetConfig with fully resolved assets, inversion flags, and detection status AssetPairing   Core asset pairing structure for triad/dyad configurations   Fields:      primary (series string) : The primary (chart) asset ticker ID      secondary (series string) : The secondary correlated asset ticker ID      tertiary (series string) : The tertiary correlated asset ticker ID (empty for dyad)      invertSecondary (series bool) : Whether secondary asset should be inverted for divergence calc      invertTertiary (series bool) : Whether tertiary asset should be inverted for divergence calc AssetConfig   Full asset resolution result with mode detection and computed values   Fields:      detected (series bool) : Whether auto-detection succeeded      isTriadMode (series bool) : True if triad (3 assets), false if dyad (2 assets)      primary (series string) : The resolved primary asset ticker ID      secondary (series string) : The resolved secondary asset ticker ID      tertiary (series string) : The resolved tertiary asset ticker ID (empty for dyad)      invertSecondary (series bool) : Computed inversion flag for secondary asset      invertTertiary (series bool) : Computed inversion flag for tertiary asset      assetCategory (series string) : String describing the detected asset category
ไลบรารี Pine Script®
โดย fstarcapital
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
10
Count█  OVERVIEW A library of functions for counting the number of times (frequency) that elements occur in an array or matrix. █ USAGE Import the Count library. import joebaus/count/1 as c Create an array or matrix that is a `float`, `int`, `string`, or `bool` type to count elements from, then call the count function on the array or matrix. id = array.from(1.00, 1.50, 1.25, 1.00, 0.75, 1.25, 1.75, 1.25) countMap = id.count() // Alternatively: countMap = c.count(id) The "count map" will return a map with keys for each unique element in the array or matrix, and with respective values representing the number of times the unique element was counted. The keys will be the same type as the array or matrix counted. The values will always be an `int` type. array mapKeys = countMap.keys() // Returns unique keys array mapValues = countMap.values() // Returns counts If an array is in ascending or descending order, then the keys of the map will also generate in the same order. intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6) // Ascending order map countMap = intArray.count() // Creates a "count map" of all unique elements array mapKeys = countMap.keys() // Returns // Ascending order array mapValues = countMap.values() // Returns count Include a value to get the count of only that value in an array or matrix. floatMatrix = matrix.new(3, 3, 0.0) floatMatrix.set(0, 0, 1.0), floatMatrix.set(1, 0, 1.0), floatMatrix.set(2, 0, 1.0) floatMatrix.set(0, 1, 1.5), floatMatrix.set(1, 1, 2.0), floatMatrix.set(2, 1, 2.5) floatMatrix.set(0, 2, 1.0), floatMatrix.set(1, 2, 2.5), floatMatrix.set(2, 2, 1.5) int countFloatMatrix = floatMatrix.count(1.0) // Counts all 1.0 elements, returns 5 // Alternatively: int countFloatMatrix = c.count(floatMatrix, 1.0) The string method of count() can use strings or regular expressions like "bull*" to count all matching occurrences in a string array. stringArray = array.from('bullish', 'bull', 'bullish', 'bear', 'bull', 'bearish', 'bearish') int countString = stringArray.count('bullish') // Returns 2 int countStringRegex = stringArray.count('bull*') // Returns 4 To count multiple values, use an array of values instead of a single value. Returning a count map only of elements in the array. countArray = array.from(1.0, 2.5) map countMap = floatMatrix.count(countArray) array mapKeys = countMap.keys() // Returns keys array mapValues = countMap.values() // Returns counts Multiple regex patterns or strings can be counted as well. stringMatrix = matrix.new(3, 3, '') stringMatrix.set(0, 0, 'a'), stringMatrix.set(1, 0, 'a'), stringMatrix.set(2, 0, 'a') stringMatrix.set(0, 1, 'b'), stringMatrix.set(1, 1, 'c'), stringMatrix.set(2, 1, 'd') stringMatrix.set(0, 2, 'a'), stringMatrix.set(1, 2, 'd'), stringMatrix.set(2, 2, 'b') // Count the number of times the regex patterns `'^(a|c)$'` and `'^(b|d)$'` occur array regexes = array.from('^(a|c)$', '^(b|d)$') map countMap = stringMatrix.count(regexes) array mapKeys = countMap.keys() // Returns array mapValues = countMap.values() // Returns An optional comparison operator can be specified to count the number of times an equality was satisfied for `float`, `int`, and `bool` methods of `count()`. intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6) // Count the number of times an element is greater than 4 countInt = intArray.count(4, '>') // Returns 2 When passing an array of values to count and a comparison operator, the operator will apply to each value. intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6) values = array.from(3, 4) // Count the number of times and element is greater than 3 and 4 map countMap = intArray.count(values, '>') array mapKeys = countMap.keys() // Returns array mapValues = countMap.values() // Returns Multiple comparison operators can be applied when counting multiple values. intMatrix = matrix.new(3, 3, 0) intMatrix.set(0, 0, 2), intMatrix.set(1, 0, 3), intMatrix.set(2, 0, 5) intMatrix.set(0, 1, 2), intMatrix.set(1, 1, 4), intMatrix.set(2, 1, 2) intMatrix.set(0, 2, 5), intMatrix.set(1, 2, 2), intMatrix.set(2, 2, 3) values = array.from(3, 4) comparisons = array.from('<', '>') // Count the number of times an element is less than 3 and greater than 4 map countMap = intMatrix.count(values, comparisons) array mapKeys = countMap.keys() // Returns array mapValues = countMap.values() // Returns
ไลบรารี Pine Script®
โดย joebaus
4
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
TAUtilityLibLibrary "TAUtilityLib" Technical Analysis Utility Library - Collection of functions for market analysis, smoothing, scaling, and structure detection log_snapshot(label1, val1, label2, val2, label3, val3, label4, val4, label5, val5)   Creates formatted log snapshot with 5 labeled values   Parameters:      label1 (string)      val1 (float)      label2 (string)      val2 (float)      label3 (string)      val3 (float)      label4 (string)      val4 (float)      label5 (string)      val5 (float)   Returns: void (logs to console) f_get_next_tf(tf, steps)   Gets next higher timeframe(s) from current   Parameters:      tf (string) : Current timeframe string      steps (string) : "1 TF Higher" for next TF, any other value for 2 TFs higher   Returns: Next timeframe string or na if at maximum f_get_prev_tf(tf)   Gets previous lower timeframe from current   Parameters:      tf (string) : Current timeframe string   Returns: Previous timeframe string or na if at minimum supersmoother(_src, _length)   Ehler's SuperSmoother - low-lag smoothing filter   Parameters:      _src (float) : Source series to smooth      _length (simple int) : Smoothing period   Returns: Smoothed series butter_smooth(src, len)   Butterworth filter for ultra-smooth price filtering   Parameters:      src (float) : Source series      len (simple int) : Filter period   Returns: Butterworth smoothed series f_dynamic_ema(source, dynamic_length)   Dynamic EMA with variable length   Parameters:      source (float) : Source series      dynamic_length (float) : Dynamic period (can vary bar to bar)   Returns: Dynamically adjusted EMA dema(source, length)   Double Exponential Moving Average (DEMA)   Parameters:      source (float) : Source series      length (simple int) : Period for DEMA calculation   Returns: DEMA value f_scale_percentile(primary_line, secondary_line, x)   Scales secondary line to match primary line using percentile ranges   Parameters:      primary_line (float) : Reference series for target scale      secondary_line (float) : Series to be scaled      x (int) : Lookback bars for percentile calculation   Returns: Scaled version of secondary_line calculate_correlation_scaling(demamom_range, demamom_min, correlation_range, correlation_min)   Calculates scaling factors for correlation alignment   Parameters:      demamom_range (float) : Range of primary series      demamom_min (float) : Minimum of primary series      correlation_range (float) : Range of secondary series      correlation_min (float) : Minimum of secondary series   Returns: tuple for alignment getBB(src, length, mult, chartlevel)   Calculates Bollinger Bands with chart level offset   Parameters:      src (float) : Source series      length (simple int) : MA period      mult (simple float) : Standard deviation multiplier      chartlevel (simple float) : Vertical offset for plotting   Returns: tuple get_mrc(source, length, mult, mult2, gradsize)   Mean Reversion Channel with multiple bands and conditions   Parameters:      source (float) : Price source      length (simple int) : Channel period      mult (simple float) : First band multiplier      mult2 (simple float) : Second band multiplier      gradsize (simple float) : Gradient size for zone detection   Returns: analyzeMarketStructure(highFractalBars, highFractalPrices, lowFractalBars, lowFractalPrices, trendDirection)   Analyzes market structure for ChoCH and BOS patterns   Parameters:      highFractalBars (array) : Array of high fractal bar indices      highFractalPrices (array) : Array of high fractal prices      lowFractalBars (array) : Array of low fractal bar indices      lowFractalPrices (array) : Array of low fractal prices      trendDirection (int) : Current trend (1=up, -1=down, 0=neutral)   Returns: - change signals and new trend direction
ไลบรารี Pine Script®
โดย cybermediaboy
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
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
SIC_TICKER_DATAThe SIC Ticker Data is an advanced and efficient library for ticker-to-industry classification and sector analysis. Built with enterprise-grade performance optimizations, this library provides instant access to SIC codes, industry classifications, and peer company data for comprehensive market analysis. Perfect for: Sector rotation strategies, peer analysis, portfolio diversification, market screening, and financial research tools. The simple idea behind this library is to pull any data related to SIC number of any US stock market ticker provided by SEC in order to see the industry and also see the exact competitors of the ticker. The library stores 3 types of data: SIC number, Ticker, and Industry name. What makes it very useful is that you can pull any one of this data using the other. For example, if you would like to know which tickers are inside a certain SIC, or what's the SIC number of a specific ticker, or even which tickers are inside a certain industry, you can use this library to pull this data. The idea for data inside this library is to be accessible in any direction possible as long as they're related to each other. We've also published a simple indicator that uses this library in order to demonstrate the inner workings of this library. The library stores thousands of tickers and their relevant SIC code and industry for your use and is constantly updated with new data when available. This is a large library but it is optimized to run as fast as possible. The previous unpublished versions would take over 40 seconds to load any data but the final public version here loads the data in less than 5 seconds. 🔍 Primary Lookup Functions createDataStore() Initialize the library with all pre-loaded data. store = data.createDataStore() getSicByTicker(store, ticker) Get SIC code for any ticker symbol. sic = data.getSicByTicker(store, "AAPL") // Returns: "3571" getIndustryByTicker(store, ticker) Get industry classification for any ticker. industry = data.getIndustryByTicker(store, "AAPL") // Returns: "Computer Hardware" getTickersBySic(store, sic) Get all companies in a specific SIC code. software = data.getTickersBySic(store, "7372") // Returns: "MSFT,GOOGL,META,V,MA,CRM,ADBE,ORCL,NOW,INTU" getTickersByIndustry(store, industry) Get all companies in an industry. retail = data.getTickersByIndustry(store, "Retail") // Returns: "AMZN,HD,WMT,TGT,COST,LOW" 📊 Array & Analysis Functions getTickerArrayBySic(store, sic) Get tickers as array for processing. techArray = data.getTickerArrayBySic(store, "7372") for i = 0 to array.size(techArray) - 1 ticker = array.get(techArray, i) // Process each tech company getTickerCountBySic(store, sic) Count companies in a sector (ultra-fast). pinescripttechCount = data.getTickerCountBySic(store, "7372") // Returns: 10 🎯 Utility Functions tickerExists(store, ticker) Check if ticker exists in database. exists = data.tickerExists(store, "AAPL") // Returns: true tickerInSic(store, ticker, sic) Check if ticker belongs to specific sector. isInTech = data.tickerInSic(store, "AAPL", "3571") // Returns: true 💡 Usage Examples Example 1: Basic Ticker Lookup // @version=6 import EdgeTerminal/SIC_TICKER_DATA/1 as data indicator("Ticker Analysis", overlay=true) store = data.createDataStore() currentSic = data.getSicByTicker(store, syminfo.ticker) currentIndustry = data.getIndustryByTicker(store, syminfo.ticker) if barstate.islast and currentSic != "NOT_FOUND" label.new(bar_index, high, syminfo.ticker + " SIC: " + currentSic + " Industry: " + currentIndustry) Example 2: Sector Analysis // @version=6 import EdgeTerminal/SIC_TICKER_DATA/1 as data indicator("Sector Comparison", overlay=false) store = data.createDataStore() // Compare sector sizes techCount = data.getTickerCountBySic(store, "7372") // Software financeCount = data.getTickerCountBySic(store, "6199") // Finance healthCount = data.getTickerCountBySic(store, "2834") // Pharmaceutical plot(techCount, title="Tech Companies", color=color.blue) plot(financeCount, title="Finance Companies", color=color.green) plot(healthCount, title="Health Companies", color=color.red) Example 3: Peer Analysis // @version=6 import EdgeTerminal/SIC_TICKER_DATA/1 as data indicator("Find Competitors", overlay=true) store = data.createDataStore() currentSic = data.getSicByTicker(store, syminfo.ticker) if currentSic != "NOT_FOUND" competitors = data.getTickersBySic(store, currentSic) peerCount = data.getTickerCountBySic(store, currentSic) if barstate.islast label.new(bar_index, high, "Competitors (" + str.tostring(peerCount) + "): " + competitors) Example 4: Portfolio Sector Allocation // @version=6 import EdgeTerminal/SIC_TICKER_DATA/1 as data indicator("Portfolio Analysis", overlay=false) store = data.createDataStore() // Analyze your portfolio's sector distribution portfolioTickers = array.from("AAPL", "MSFT", "GOOGL", "JPM", "JNJ") sectorCount = map.new() for i = 0 to array.size(portfolioTickers) - 1 ticker = array.get(portfolioTickers, i) industry = data.getIndustryByTicker(store, ticker) if industry != "NOT_FOUND" currentCount = map.get(sectorCount, industry) newCount = na(currentCount) ? 1 : currentCount + 1 map.put(sectorCount, industry, newCount) 🔧 Advanced Feature You can also bulk load data for large data sets like this: // Pre-format your data as pipe-separated string bulkData = "AAPL:3571:Computer Hardware|MSFT:7372:Software|GOOGL:7372:Software" store = data.createDataStoreFromBulk(bulkData)
ไลบรารี Pine Script®
โดย EdgeTerminal
Color█ OVERVIEW This library is a Pine Script® programming tool for advanced color processing. It provides a comprehensive set of functions for specifying and analyzing colors in various color spaces, mixing and manipulating colors, calculating custom gradients and schemes, detecting contrast, and converting colors to or from hexadecimal strings. █ CONCEPTS Color Color refers to how we interpret light of different wavelengths in the visible spectrum . The colors we see from an object represent the light wavelengths that it reflects, emits, or transmits toward our eyes. Some colors, such as blue and red, correspond directly to parts of the spectrum. Others, such as magenta, arise from a combination of wavelengths to which our minds assign a single color. The human interpretation of color lends itself to many uses in our world. In the context of financial data analysis, the effective use of color helps transform raw data into insights that users can understand at a glance. For example, colors can categorize series, signal market conditions and sessions, and emphasize patterns or relationships in data. Color models and spaces A color model is a general mathematical framework that describes colors using sets of numbers. A color space is an implementation of a specific color model that defines an exact range (gamut) of reproducible colors based on a set of primary colors , a reference white point , and sometimes additional parameters such as viewing conditions. There are numerous different color spaces — each describing the characteristics of color in unique ways. Different spaces carry different advantages, depending on the application. Below, we provide a brief overview of the concepts underlying the color spaces supported by this library. RGB RGB is one of the most well-known color models. It represents color as an additive mixture of three primary colors — red, green, and blue lights — with various intensities. Each cone cell in the human eye responds more strongly to one of the three primaries, and the average person interprets the combination of these lights as a distinct color (e.g., pure red + pure green = yellow). The sRGB color space is the most common RGB implementation. Developed by HP and Microsoft in the 1990s, sRGB provided a standardized baseline for representing color across CRT monitors of the era, which produced brightness levels that did not increase linearly with the input signal. To match displays and optimize brightness encoding for human sensitivity, sRGB applied a nonlinear transformation to linear RGB signals, often referred to as gamma correction . The result produced more visually pleasing outputs while maintaining a simple encoding. As such, sRGB quickly became a standard for digital color representation across devices and the web. To this day, it remains the default color space for most web-based content. TradingView charts and Pine Script `color.*` built-ins process color data in sRGB. The red, green, and blue channels range from 0 to 255, where 0 represents no intensity, and 255 represents maximum intensity. Each combination of red, green, and blue values represents a distinct color, resulting in a total of 16,777,216 displayable colors. CIE XYZ and xyY The XYZ color space, developed by the International Commission on Illumination (CIE) in 1931, aims to describe all color sensations that a typical human can perceive. It is a cornerstone of color science, forming the basis for many color spaces used today. XYZ, and the derived xyY space, provide a universal representation of color that is not tethered to a particular display. Many widely used color spaces, including sRGB, are defined relative to XYZ or derived from it. The CIE built the color space based on a series of experiments in which people matched colors they perceived from mixtures of lights. From these experiments, the CIE developed color-matching functions to calculate three components — X, Y, and Z — which together aim to describe a standard observer's response to visible light. X represents a weighted response to light across the color spectrum, with the highest contribution from long wavelengths (e.g., red). Y represents a weighted response to medium wavelengths (e.g., green), and it corresponds to a color's relative luminance (i.e., brightness). Z represents a weighted response to short wavelengths (e.g., blue). From the XYZ space, the CIE developed the xyY chromaticity space, which separates a color's chromaticity (hue and colorfulness) from luminance. The CIE used this space to define the CIE 1931 chromaticity diagram , which represents the full range of visible colors at a given luminance. In color science and lighting design, xyY is a common means for specifying colors and visualizing the supported ranges of other color spaces. CIELAB and Oklab The CIELAB (L*a*b*) color space, derived from XYZ by the CIE in 1976, expresses colors based on opponent process theory. The L* component represents perceived lightness, and the a* and b* components represent the balance between opposing unique colors. The a* value specifies the balance between green and red , and the b* value specifies the balance between blue and yellow . The primary intention of CIELAB was to provide a perceptually uniform color space, where fixed-size steps through the space correspond to uniform perceived changes in color. Although relatively uniform, the color space has been found to exhibit some non-uniformities, particularly in the blue part of the color spectrum. Regardless, modern applications often use CIELAB to estimate perceived color differences and calculate smooth color gradients. In 2020, a new LAB-oriented color space, Oklab , was introduced by Björn Ottosson as an attempt to rectify the non-uniformities of other perceptual color spaces. Similar to CIELAB, the L value in Oklab represents perceived lightness, and the a and b values represent the balance between opposing unique colors. Oklab has gained widespread adoption as a perceptual space for color processing, with support in the latest CSS Color specifications and many software applications. Cylindrical models A cylindrical-coordinate model transforms an underlying color model, such as RGB or LAB, into an alternative expression of color information that is often more intuitive for the average person to use and understand. Instead of a mixture of primary colors or opponent pairs, these models represent color as a hue angle on a color wheel , with additional parameters that describe other qualities such as lightness and colorfulness (a general term for concepts like chroma and saturation). In cylindrical-coordinate spaces, users can select a color and modify its lightness or other qualities without altering the hue. The three most common RGB-based models are HSL (Hue, Saturation, Lightness), HSV (Hue, Saturation, Value), and HWB (Hue, Whiteness, Blackness). All three define hue angles in the same way, but they define colorfulness and lightness differently. Although they are not perceptually uniform, HSL and HSV are commonplace in color pickers and gradients. For CIELAB and Oklab, the cylindrical-coordinate versions are CIELCh and Oklch , which express color in terms of perceived lightness, chroma, and hue. They offer perceptually uniform alternatives to RGB-based models. These spaces create unique color wheels, and they have more strict definitions of lightness and colorfulness. Oklch is particularly well-suited for generating smooth, perceptual color gradients. Alpha and transparency Many color encoding schemes include an alpha channel, representing opacity . Alpha does not help define a color in a color space; it determines how a color interacts with other colors in the display. Opaque colors appear with full intensity on the screen, whereas translucent (semi-opaque) colors blend into the background. Colors with zero opacity are invisible. In Pine Script, there are two ways to specify a color's alpha:  • Using the `transp` parameter of the built-in `color.*()` functions. The specified value represents transparency (the opposite of opacity), which the functions translate into an alpha value.  • Using eight-digit hexadecimal color codes. The last two digits in the code represent alpha directly. A process called alpha compositing simulates translucent colors in a display. It creates a single displayed color by mixing the RGB channels of two colors (foreground and background) based on alpha values, giving the illusion of a semi-opaque color placed over another color. For example, a red color with 80% transparency on a black background produces a dark shade of red. Hexadecimal color codes A hexadecimal color code (hex code) is a compact representation of an RGB color. It encodes a color's red, green, and blue values into a sequence of hexadecimal ( base-16 ) digits. The digits are numerals ranging from `0` to `9` or letters from `a` (for 10) to `f` (for 15). Each set of two digits represents an RGB channel ranging from `00` (for 0) to `ff` (for 255). Pine scripts can natively define colors using hex codes in the format `#rrggbbaa`. The first set of two digits represents red, the second represents green, and the third represents blue. The fourth set represents alpha . If unspecified, the value is `ff` (fully opaque). For example, `#ff8b00` and `#ff8b00ff` represent an opaque orange color. The code `#ff8b0033` represents the same color with 80% transparency. Gradients A color gradient maps colors to numbers over a given range. Most color gradients represent a continuous path in a specific color space, where each number corresponds to a mix between a starting color and a stopping color. In Pine, coders often use gradients to visualize value intensities in plots and heatmaps, or to add visual depth to fills. The behavior of a color gradient depends on the mixing method and the chosen color space. Gradients in sRGB usually mix along a straight line between the red, green, and blue coordinates of two colors. In cylindrical spaces such as HSL, a gradient often rotates the hue angle through the color wheel, resulting in more pronounced color transitions. Color schemes A color scheme refers to a set of colors for use in aesthetic or functional design. A color scheme usually consists of just a few distinct colors. However, depending on the purpose, a scheme can include many colors. A user might choose palettes for a color scheme arbitrarily, or generate them algorithmically. There are many techniques for calculating color schemes. A few simple, practical methods are:  • Sampling a set of distinct colors from a color gradient.  • Generating monochromatic variants of a color (i.e., tints, tones, or shades with matching hues).  • Computing color harmonies — such as complements, analogous colors, triads, and tetrads — from a base color. This library includes functions for all three of these techniques. See below for details. █ CALCULATIONS AND USE Hex string conversion The `getHexString()` function returns a string containing the eight-digit hexadecimal code corresponding to a "color" value or set of sRGB and transparency values. For example, `getHexString(255, 0, 0)` returns the string `"#ff0000ff"`, and `getHexString(color.new(color.red, 80))` returns `"#f2364533"`. The `hexStringToColor()` function returns the "color" value represented by a string containing a six- or eight-digit hex code. The `hexStringToRGB()` function returns a tuple containing the sRGB and transparency values. For example, `hexStringToColor("#f23645")` returns the same value as color.red . Programmers can use these functions to parse colors from "string" inputs, perform string-based color calculations, and inspect color data in text outputs such as Pine Logs and tables. Color space conversion All other `get*()` functions convert a "color" value or set of sRGB channels into coordinates in a specific color space, with transparency information included. For example, the tuple returned by `getHSL()` includes the color's hue, saturation, lightness, and transparency values. To convert data from a color space back to colors or sRGB and transparency values, use the corresponding `*toColor()` or `*toRGB()` functions for that space (e.g., `hslToColor()` and `hslToRGB()`). Programmers can use these conversion functions to process inputs that define colors in different ways, perform advanced color manipulation, design custom gradients, and more. The color spaces this library supports are:  • sRGB  • Linear RGB (RGB without gamma correction)  • HSL, HSV, and HWB  • CIE XYZ and xyY  • CIELAB and CIELCh  • Oklab and Oklch Contrast-based calculations Contrast refers to the difference in luminance or color that makes one color visible against another. This library features two functions for calculating luminance-based contrast and detecting themes. The `contrastRatio()` function calculates the contrast between two "color" values based on their relative luminance (the Y value from CIE XYZ) using the formula from version 2 of the Web Content Accessibility Guidelines (WCAG) . This function is useful for identifying colors that provide a sufficient brightness difference for legibility. The `isLightTheme()` function determines whether a specified background color represents a light theme based on its contrast with black and white. Programmers can use this function to define conditional logic that responds differently to light and dark themes. Color manipulation and harmonies The `negative()` function calculates the negative (i.e., inverse) of a color by reversing the color's coordinates in either the sRGB or linear RGB color space. This function is useful for calculating high-contrast colors. The `grayscale()` function calculates a grayscale form of a specified color with the same relative luminance. The functions `complement()`, `splitComplements()`, `analogousColors()`, `triadicColors()`, `tetradicColors()`, `pentadicColors()`, and `hexadicColors()` calculate color harmonies from a specified source color within a given color space (HSL, CIELCh, or Oklch). The returned harmonious colors represent specific hue rotations around a color wheel formed by the chosen space, with the same defined lightness, saturation or chroma, and transparency. Color mixing and gradient creation The `add()` function simulates combining lights of two different colors by additively mixing their linear red, green, and blue components, ignoring transparency by default. Users can calculate a transparency-weighted mixture by setting the `transpWeight` argument to `true`. The `overlay()` function estimates the color displayed on a TradingView chart when a specific foreground color is over a background color. This function aids in simulating stacked colors and analyzing the effects of transparency. The `fromGradient()` and `fromMultiStepGradient()` functions calculate colors from gradients in any of the supported color spaces, providing flexible alternatives to the RGB-based color.from_gradient() function. The `fromGradient()` function calculates a color from a single gradient. The `fromMultiStepGradient()` function calculates a color from a piecewise gradient with multiple defined steps. Gradients are useful for heatmaps and for coloring plots or drawings based on value intensities. Scheme creation Three functions in this library calculate palettes for custom color schemes. Scripts can use these functions to create responsive color schemes that adjust to calculated values and user inputs. The `gradientPalette()` function creates an array of colors by sampling a specified number of colors along a gradient from a base color to a target color, in fixed-size steps. The `monoPalette()` function creates an array containing monochromatic variants (tints, tones, or shades) of a specified base color. Whether the function mixes the color toward white (for tints), a form of gray (for tones), or black (for shades) depends on the `grayLuminance` value. If unspecified, the function automatically chooses the mix behavior with the highest contrast. The `harmonyPalette()` function creates a matrix of colors. The first column contains the base color and specified harmonies, e.g., triadic colors. The columns that follow contain tints, tones, or shades of the harmonic colors for additional color choices, similar to `monoPalette()`. █ EXAMPLE CODE The example code at the end of the script generates and visualizes color schemes by processing user inputs. The code builds the scheme's palette based on the "Base color" input and the additional inputs in the "Settings/Inputs" tab:  • "Palette type" specifies whether the palette uses a custom gradient, monochromatic base color variants, or color harmonies with monochromatic variants.  • "Target color" sets the top color for the "Gradient" palette type.  • The "Gray luminance" inputs determine variation behavior for "Monochromatic" and "Harmony" palette types. If "Auto" is selected, the palette mixes the base color toward white or black based on its brightness. Otherwise, it mixes the color toward the grayscale color with the specified relative luminance (from 0 to 1).  • "Harmony type" specifies the color harmony used in the palette. Each row in the palette corresponds to one of the harmonious colors, starting with the base color. The code creates a table on the first bar to display the collection of calculated colors. Each cell in the table shows the color's `getHexString()` value in a tooltip for simple inspection. Look first. Then leap. █ EXPORTED FUNCTIONS Below is a complete list of the functions and overloads exported by this library. getRGB(source)   Retrieves the sRGB red, green, blue, and transparency components of a "color" value. getHexString(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channel values to a string representing the corresponding color's hexadecimal form. getHexString(source)   (Overload 2 of 2) Converts a "color" value to a string representing the sRGB color's hexadecimal form. hexStringToRGB(source)   Converts a string representing an sRGB color's hexadecimal form to a set of decimal channel values. hexStringToColor(source)   Converts a string representing an sRGB color's hexadecimal form to a "color" value. getLRGB(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channel values to a set of linear RGB values with specified transparency information. getLRGB(source)   (Overload 2 of 2) Retrieves linear RGB channel values and transparency information from a "color" value. lrgbToRGB(lr, lg, lb, t)   Converts a set of linear RGB channel values to a set of sRGB values with specified transparency information. lrgbToColor(lr, lg, lb, t)   Converts a set of linear RGB channel values and transparency information to a "color" value. getHSL(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of HSL values with specified transparency information. getHSL(source)   (Overload 2 of 2) Retrieves HSL channel values and transparency information from a "color" value. hslToRGB(h, s, l, t)   Converts a set of HSL channel values to a set of sRGB values with specified transparency information. hslToColor(h, s, l, t)   Converts a set of HSL channel values and transparency information to a "color" value. getHSV(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of HSV values with specified transparency information. getHSV(source)   (Overload 2 of 2) Retrieves HSV channel values and transparency information from a "color" value. hsvToRGB(h, s, v, t)   Converts a set of HSV channel values to a set of sRGB values with specified transparency information. hsvToColor(h, s, v, t)   Converts a set of HSV channel values and transparency information to a "color" value. getHWB(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of HWB values with specified transparency information. getHWB(source)   (Overload 2 of 2) Retrieves HWB channel values and transparency information from a "color" value. hwbToRGB(h, w, b, t)   Converts a set of HWB channel values to a set of sRGB values with specified transparency information. hwbToColor(h, w, b, t)   Converts a set of HWB channel values and transparency information to a "color" value. getXYZ(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of XYZ values with specified transparency information. getXYZ(source)   (Overload 2 of 2) Retrieves XYZ channel values and transparency information from a "color" value. xyzToRGB(x, y, z, t)   Converts a set of XYZ channel values to a set of sRGB values with specified transparency information xyzToColor(x, y, z, t)   Converts a set of XYZ channel values and transparency information to a "color" value. getXYY(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of xyY values with specified transparency information. getXYY(source)   (Overload 2 of 2) Retrieves xyY channel values and transparency information from a "color" value. xyyToRGB(xc, yc, y, t)   Converts a set of xyY channel values to a set of sRGB values with specified transparency information. xyyToColor(xc, yc, y, t)   Converts a set of xyY channel values and transparency information to a "color" value. getLAB(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of CIELAB values with specified transparency information. getLAB(source)   (Overload 2 of 2) Retrieves CIELAB channel values and transparency information from a "color" value. labToRGB(l, a, b, t)   Converts a set of CIELAB channel values to a set of sRGB values with specified transparency information. labToColor(l, a, b, t)   Converts a set of CIELAB channel values and transparency information to a "color" value. getOKLAB(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of Oklab values with specified transparency information. getOKLAB(source)   (Overload 2 of 2) Retrieves Oklab channel values and transparency information from a "color" value. oklabToRGB(l, a, b, t)   Converts a set of Oklab channel values to a set of sRGB values with specified transparency information. oklabToColor(l, a, b, t)   Converts a set of Oklab channel values and transparency information to a "color" value. getLCH(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of CIELCh values with specified transparency information. getLCH(source)   (Overload 2 of 2) Retrieves CIELCh channel values and transparency information from a "color" value. lchToRGB(l, c, h, t)   Converts a set of CIELCh channel values to a set of sRGB values with specified transparency information. lchToColor(l, c, h, t)   Converts a set of CIELCh channel values and transparency information to a "color" value. getOKLCH(r, g, b, t)   (Overload 1 of 2) Converts a set of sRGB channels to a set of Oklch values with specified transparency information. getOKLCH(source)   (Overload 2 of 2) Retrieves Oklch channel values and transparency information from a "color" value. oklchToRGB(l, c, h, t)   Converts a set of Oklch channel values to a set of sRGB values with specified transparency information. oklchToColor(l, c, h, t)   Converts a set of Oklch channel values and transparency information to a "color" value. contrastRatio(value1, value2)   Calculates the contrast ratio between two colors values based on the formula from version 2 of the Web Content Accessibility Guidelines (WCAG). isLightTheme(source)   Detects whether a background color represents a light theme or dark theme, based on the amount of contrast between the color and the white and black points. grayscale(source)   Calculates the grayscale version of a color with the same relative luminance (i.e., brightness). negative(source, colorSpace)   Calculates the negative (i.e., inverted) form of a specified color. complement(source, colorSpace)   Calculates the complementary color for a `source` color using a cylindrical color space. analogousColors(source, colorSpace)   Calculates the analogous colors for a `source` color using a cylindrical color space. splitComplements(source, colorSpace)   Calculates the split-complementary colors for a `source` color using a cylindrical color space. triadicColors(source, colorSpace)   Calculates the two triadic colors for a `source` color using a cylindrical color space. tetradicColors(source, colorSpace, square)   Calculates the three square or rectangular tetradic colors for a `source` color using a cylindrical color space. pentadicColors(source, colorSpace)   Calculates the four pentadic colors for a `source` color using a cylindrical color space. hexadicColors(source, colorSpace)   Calculates the five hexadic colors for a `source` color using a cylindrical color space. add(value1, value2, transpWeight)   Additively mixes two "color" values, with optional transparency weighting. overlay(fg, bg)   Estimates the resulting color that appears on the chart when placing one color over another. fromGradient(value, bottomValue, topValue, bottomColor, topColor, colorSpace)   Calculates the gradient color that corresponds to a specific value based on a defined value range and color space. fromMultiStepGradient(value, steps, colors, colorSpace)   Calculates a multi-step gradient color that corresponds to a specific value based on an array of step points, an array of corresponding colors, and a color space. gradientPalette(baseColor, stopColor, steps, strength, model)   Generates a palette from a gradient between two base colors. monoPalette(baseColor, grayLuminance, variations, strength, colorSpace)   Generates a monochromatic palette from a specified base color. harmonyPalette(baseColor, harmonyType, grayLuminance, variations, strength, colorSpace)   Generates a palette consisting of harmonious base colors and their monochromatic variants.
ไลบรารี Pine Script®
โดย TradingView
3
light_logLight Log - A Defensive Programming Library for Pine Script Overview The Light Log library transforms Pine Script development by introducing structured logging and defensive programming patterns typically found in enterprise languages like C#. This library addresses a fundamental challenge in Pine Script: the lack of sophisticated error handling and debugging tools that developers expect when building complex trading systems. At its core, Light Log provides three transformative capabilities that work together to create more reliable and maintainable code. First, it wraps all native Pine Script types in error-aware containers, allowing values to carry validation state alongside their data. Second, it offers a comprehensive logging system with severity levels and conditional rendering. Third, it includes defensive programming utilities that catch errors early and make code self-documenting. The Philosophy of Errors as Values Traditional Pine Script error handling relies on runtime errors that halt execution, making it difficult to build resilient systems that can gracefully handle edge cases. Light Log introduces a paradigm shift by treating errors as first-class values that flow through your program alongside regular data. When you wrap a value using Light Log's type system, you're not just storing data – you're creating a container that can carry both the value and its validation state. For example, when you call myNumber.INT() , you receive an INT object that contains both the integer value and a Log object that can describe any issues with that value. This approach, inspired by functional programming languages, allows errors to propagate through calculations without causing immediate failures. Consider how this changes error handling in practice. Instead of a calculation failing catastrophically when it encounters invalid input, it can produce a result object that contains both the computed value (which might be na) and a detailed log explaining what went wrong. Subsequent operations can check has_error() to decide whether to proceed or handle the error condition gracefully. The Typed Wrapper System Light Log provides typed wrappers for every native Pine Script type: INT, FLOAT, BOOL, STRING, COLOR, LINE, LABEL, BOX, TABLE, CHART_POINT, POLYLINE, and LINEFILL. These wrappers serve multiple purposes beyond simple value storage. Each wrapper type contains two fields: the value field v holds the actual data, while the error field e contains a Log object that tracks the value's validation state. This dual nature enables powerful programming patterns. You can perform operations on wrapped values and accumulate error information along the way, creating an audit trail of how values were processed. The wrapper system includes convenient methods for converting between wrapped and unwrapped values. The extension methods like INT() , FLOAT() , etc., make it easy to wrap existing values, while the from_INT() , from_FLOAT() methods extract the underlying values when needed. The has_error() method provides a consistent interface for checking whether any wrapped value has encountered issues during processing. The Log Object: Your Debugging Companion The Log object represents the heart of Light Log's debugging capabilities. Unlike simple string concatenation for error messages, the Log object provides a structured approach to building, modifying, and rendering diagnostic information. Each Log object carries three essential pieces of information: an error type (info, warning, error, or runtime_error), a message string that can be built incrementally, and an active flag that controls conditional rendering. This structure enables sophisticated logging patterns where you can build up detailed diagnostic information throughout your script's execution and decide later whether and how to display it. The Log object's methods support fluent chaining, allowing you to build complex messages in a readable way. The write() and write_line() methods append text to the log, while new_line() adds formatting. The clear() method resets the log for reuse, and the rendering methods ( render_now() , render_condition() , and the general render() ) control when and how messages appear. Defensive Programming Made Easy Light Log's argument validation functions transform how you write defensive code. Instead of cluttering your functions with verbose validation logic, you can use concise, self-documenting calls that make your intentions clear. The argument_error() function provides strict validation that halts execution when conditions aren't met – perfect for catching programming errors early. For less critical issues, argument_log_warning() and argument_log_error() record problems without stopping execution, while argument_log_info() provides debug visibility into your function's behavior. These functions follow a consistent pattern: they take a condition to check, the function name, the argument name, and a descriptive message. This consistency makes error messages predictable and helpful, automatically formatting them to show exactly where problems occurred. Building Modular, Reusable Code Light Log encourages a modular approach to Pine Script development by providing tools that make functions more self-contained and reliable. When functions validate their inputs and return wrapped values with error information, they become true black boxes that can be safely composed into larger systems. The void_return() function addresses Pine Script's requirement that all code paths return a value, even in error handling branches. This utility function provides a clean way to satisfy the compiler while making it clear that a particular code path should never execute. The static log pattern, initialized with init_static_log() , enables module-wide error tracking. You can create a persistent Log object that accumulates information across multiple function calls, building a comprehensive diagnostic report that helps you understand complex behaviors in your indicators and strategies. Real-World Applications In practice, Light Log shines when building sophisticated trading systems. Imagine developing a complex indicator that processes multiple data streams, performs statistical calculations, and generates trading signals. With Light Log, each processing stage can validate its inputs, perform calculations, and pass along both results and diagnostic information. For example, a moving average calculation might check that the period is positive, that sufficient data exists, and that the input series contains valid values. Instead of failing silently or throwing runtime errors, it can return a FLOAT object that contains either the calculated average or a detailed explanation of why the calculation couldn't be performed. Strategy developers benefit even more from Light Log's capabilities. Complex entry and exit logic often involves multiple conditions that must all be satisfied. With Light Log, each condition check can contribute to a comprehensive log that explains exactly why a trade was or wasn't taken, making strategy debugging and optimization much more straightforward. Performance Considerations While Light Log adds a layer of abstraction over raw Pine Script values, its design minimizes performance impact. The wrapper objects are lightweight, containing only two fields. The logging operations only consume resources when actually rendered, and the conditional rendering system ensures that production code can run with logging disabled for maximum performance. The library follows Pine Script best practices for performance, using appropriate data structures and avoiding unnecessary operations. The var keyword in init_static_log() ensures that persistent logs don't create new objects on every bar, maintaining efficiency even in real-time calculations. Getting Started Adopting Light Log in your Pine Script projects is straightforward. Import the library, wrap your critical values, add validation to your functions, and use Log objects to track important events. Start small by adding logging to a single function, then expand as you see the benefits of better error visibility and code organization. Remember that Light Log is designed to grow with your needs. You can use as much or as little of its functionality as makes sense for your project. Even simple uses, like adding argument validation to key functions, can significantly improve code reliability and debugging ease. Transform your Pine Script development experience with Light Log – because professional trading systems deserve professional development tools. Light Log Technical Deep Dive: Advanced Patterns and Architecture Understanding Errors as Values The concept of "errors as values" represents a fundamental shift in how we think about error handling in Pine Script. In traditional Pine Script development, errors are events – they happen at a specific moment in time and immediately interrupt program flow. Light Log transforms errors into data – they become information that flows through your program just like any other value. This transformation has profound implications. When errors are values, they can be stored, passed between functions, accumulated, transformed, and inspected. They become part of your program's data flow rather than exceptions to it. This approach, popularized by languages like Rust with its Result type and Haskell with its Either monad, brings functional programming's elegance to Pine Script. Consider a practical example. Traditional Pine Script might calculate a momentum indicator like this: momentum = close - close If period is invalid or if there isn't enough historical data, this calculation might produce na or cause subtle bugs. With Light Log's approach: calculate_momentum(src, period)=> result = src.FLOAT() if period <= 0 result.e.write("Invalid period: must be positive", true, ErrorType.error) result.v := na else if bar_index < period result.e.write("Insufficient data: need " + str.tostring(period) + " bars", true, ErrorType.warning) result.v := na else result.v := src - src result.e.write("Momentum calculated successfully", false, ErrorType.info) result Now the function returns not just a value but a complete computational result that includes diagnostic information. Calling code can make intelligent decisions based on both the value and its associated metadata. The Monad Pattern in Pine Script While Pine Script lacks the type system features to implement true monads, Light Log brings monadic thinking to Pine Script development. The wrapped types (INT, FLOAT, etc.) act as computational contexts that carry both values and metadata through a series of transformations. The key insight of monadic programming is that you can chain operations while automatically propagating context. In Light Log, this context is the error state. When you have a FLOAT that contains an error, operations on that FLOAT can check the error state and decide whether to proceed or propagate the error. This pattern enables what functional programmers call "railway-oriented programming" – your code follows a success track when all is well but can switch to an error track when problems occur. Both tracks lead to the same destination (a result with error information), but they take different paths based on the validity of intermediate values. Composable Error Handling Light Log's design encourages composition – building complex functionality from simpler, well-tested components. Each component can validate its inputs, perform its calculation, and return a result with appropriate error information. Higher-level functions can then combine these results intelligently. Consider building a complex trading signal from multiple indicators: generate_signal(src, fast_period, slow_period, signal_period) => log = init_static_log(ErrorType.info) // Calculate components with error tracking fast_ma = calculate_ma(src, fast_period) slow_ma = calculate_ma(src, slow_period) // Check for errors in components if fast_ma.has_error() log.write_line("Fast MA error: " + fast_ma.e.message, true) if slow_ma.has_error() log.write_line("Slow MA error: " + slow_ma.e.message, true) // Proceed with calculation if no errors signal = 0.0.FLOAT() if not (fast_ma.has_error() or slow_ma.has_error()) macd_line = fast_ma.v - slow_ma.v signal_line = calculate_ma(macd_line, signal_period) if signal_line.has_error() log.write_line("Signal line error: " + signal_line.e.message, true) signal.e := log else signal.v := macd_line - signal_line.v log.write("Signal generated successfully") else signal.e := log signal.v := na signal This composable approach makes complex calculations more reliable and easier to debug. Each component is responsible for its own validation and error reporting, and the composite function orchestrates these components while maintaining comprehensive error tracking. The Static Log Pattern The init_static_log() function introduces a powerful pattern for maintaining state across function calls. In Pine Script, the var keyword creates variables that persist across bars but are initialized only once. Light Log leverages this to create logging objects that can accumulate information throughout a script's execution. This pattern is particularly valuable for debugging complex strategies where you need to understand behavior across multiple bars. You can create module-level logs that track important events: // Module-level diagnostic log diagnostics = init_static_log(ErrorType.info) // Track strategy decisions across bars check_entry_conditions() => diagnostics.clear() // Start fresh each bar diagnostics.write_line("Bar " + str.tostring(bar_index) + " analysis:") if close > sma(close, 20) diagnostics.write_line("Price above SMA20", false) else diagnostics.write_line("Price below SMA20 - no entry", true, ErrorType.warning) if volume > sma(volume, 20) * 1.5 diagnostics.write_line("Volume surge detected", false) else diagnostics.write_line("Normal volume", false) // Render diagnostics based on verbosity setting if debug_mode diagnostics.render_now() Advanced Validation Patterns Light Log's argument validation functions enable sophisticated precondition checking that goes beyond simple null checks. You can implement complex validation logic while keeping your code readable: validate_price_data(open_val, high_val, low_val, close_val) => argument_error(na(open_val) or na(high_val) or na(low_val) or na(close_val), "validate_price_data", "OHLC values", "contain na values") argument_error(high_val < low_val, "validate_price_data", "high/low", "high is less than low") argument_error(close_val > high_val or close_val < low_val, "validate_price_data", "close", "is outside high/low range") argument_log_warning(high_val == low_val, "validate_price_data", "high/low", "are equal (no range)") This validation function documents its requirements clearly and fails fast with helpful error messages when assumptions are violated. The mix of errors (which halt execution) and warnings (which allow continuation) provides fine-grained control over how strict your validation should be. Performance Optimization Strategies While Light Log adds abstraction, careful design minimizes overhead. Understanding Pine Script's execution model helps you use Light Log efficiently. Pine Script executes once per bar, so operations that seem expensive in traditional programming might have negligible impact. However, when building real-time systems, every optimization matters. Light Log provides several patterns for efficient use: Lazy Evaluation: Log messages are only built when they'll be rendered. Use conditional logging to avoid string concatenation in production: if debug_mode log.write_line("Calculated value: " + str.tostring(complex_calculation)) Selective Wrapping: Not every value needs error tracking. Wrap values at API boundaries and critical calculation points, but use raw values for simple operations: // Wrap at boundaries input_price = close.FLOAT() validated_period = validate_period(input_period).INT() // Use raw values internally sum = 0.0 for i = 0 to validated_period.v - 1 sum += close Error Propagation: When errors occur early, avoid expensive calculations: process_data(input) => validated = validate_input(input) if validated.has_error() validated // Return early with error else // Expensive processing only if valid perform_complex_calculation(validated) Integration Patterns Light Log integrates smoothly with existing Pine Script code. You can adopt it incrementally, starting with critical functions and expanding coverage as needed. Boundary Validation: Add Light Log at the boundaries of your system – where user input enters and where final outputs are produced. This catches most errors while minimizing changes to existing code. Progressive Enhancement: Start by adding argument validation to existing functions. Then wrap return values. Finally, add comprehensive logging. Each step improves reliability without requiring a complete rewrite. Testing and Debugging: Use Light Log's conditional rendering to create debug modes for your scripts. Production users see clean output while developers get detailed diagnostics: // User input for debug mode debug = input.bool(false, "Enable debug logging") // Conditional diagnostic output if debug diagnostics.render_now() else diagnostics.render_condition() // Only shows errors/warnings Future-Proofing Your Code Light Log's patterns prepare your code for Pine Script's evolution. As Pine Script adds more sophisticated features, code that uses structured error handling and defensive programming will adapt more easily than code that relies on implicit assumptions. The type wrapper system, in particular, positions your code to take advantage of potential future features or more sophisticated type inference. By thinking in terms of wrapped values and error propagation today, you're building code that will remain maintainable and extensible tomorrow. Light Log doesn't just make your Pine Script better today – it prepares it for the trading systems you'll need to build tomorrow. Library "light_log" A lightweight logging and defensive programming library for Pine Script. Designed for modular and extensible scripts, this utility provides structured runtime validation, conditional logging, and reusable `Log` objects for centralized error propagation. It also introduces a typed wrapping system for all native Pine values (e.g., `INT`, `FLOAT`, `LABEL`), allowing values to carry errors alongside data. This enables functional-style flows with built-in validation tracking, error detection (`has_error()`), and fluent chaining. Inspired by structured logging patterns found in systems like C#, it reduces boilerplate, enforces argument safety, and encourages clean, maintainable code architecture. method INT(self, error_type)   Wraps an `int` value into an `INT` struct with an optional log severity.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The raw `int` value to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: An `INT` object containing the value and a default Log instance. method FLOAT(self, error_type)   Wraps a `float` value into a `FLOAT` struct with an optional log severity.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : The raw `float` value to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `FLOAT` object containing the value and a default Log instance. method BOOL(self, error_type)   Wraps a `bool` value into a `BOOL` struct with an optional log severity.   Namespace types: series bool, simple bool, input bool, const bool   Parameters:      self (bool) : The raw `bool` value to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `BOOL` object containing the value and a default Log instance. method STRING(self, error_type)   Wraps a `string` value into a `STRING` struct with an optional log severity.   Namespace types: series string, simple string, input string, const string   Parameters:      self (string) : The raw `string` value to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `STRING` object containing the value and a default Log instance. method COLOR(self, error_type)   Wraps a `color` value into a `COLOR` struct with an optional log severity.   Namespace types: series color, simple color, input color, const color   Parameters:      self (color) : The raw `color` value to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `COLOR` object containing the value and a default Log instance. method LINE(self, error_type)   Wraps a `line` object into a `LINE` struct with an optional log severity.   Namespace types: series line   Parameters:      self (line) : The raw `line` object to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `LINE` object containing the value and a default Log instance. method LABEL(self, error_type)   Wraps a `label` object into a `LABEL` struct with an optional log severity.   Namespace types: series label   Parameters:      self (label) : The raw `label` object to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `LABEL` object containing the value and a default Log instance. method BOX(self, error_type)   Wraps a `box` object into a `BOX` struct with an optional log severity.   Namespace types: series box   Parameters:      self (box) : The raw `box` object to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `BOX` object containing the value and a default Log instance. method TABLE(self, error_type)   Wraps a `table` object into a `TABLE` struct with an optional log severity.   Namespace types: series table   Parameters:      self (table) : The raw `table` object to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `TABLE` object containing the value and a default Log instance. method CHART_POINT(self, error_type)   Wraps a `chart.point` value into a `CHART_POINT` struct with an optional log severity.   Namespace types: chart.point   Parameters:      self (chart.point) : The raw `chart.point` value to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `CHART_POINT` object containing the value and a default Log instance. method POLYLINE(self, error_type)   Wraps a `polyline` object into a `POLYLINE` struct with an optional log severity.   Namespace types: series polyline, series polyline, series polyline, series polyline   Parameters:      self (polyline) : The raw `polyline` object to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `POLYLINE` object containing the value and a default Log instance. method LINEFILL(self, error_type)   Wraps a `linefill` object into a `LINEFILL` struct with an optional log severity.   Namespace types: series linefill   Parameters:      self (linefill) : The raw `linefill` object to wrap.      error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.   Returns: A `LINEFILL` object containing the value and a default Log instance. method from_INT(self)   Extracts the integer value from an INT wrapper.   Namespace types: INT   Parameters:      self (INT) : The wrapped INT instance.   Returns: The underlying `int` value. method from_FLOAT(self)   Extracts the float value from a FLOAT wrapper.   Namespace types: FLOAT   Parameters:      self (FLOAT) : The wrapped FLOAT instance.   Returns: The underlying `float` value. method from_BOOL(self)   Extracts the boolean value from a BOOL wrapper.   Namespace types: BOOL   Parameters:      self (BOOL) : The wrapped BOOL instance.   Returns: The underlying `bool` value. method from_STRING(self)   Extracts the string value from a STRING wrapper.   Namespace types: STRING   Parameters:      self (STRING) : The wrapped STRING instance.   Returns: The underlying `string` value. method from_COLOR(self)   Extracts the color value from a COLOR wrapper.   Namespace types: COLOR   Parameters:      self (COLOR) : The wrapped COLOR instance.   Returns: The underlying `color` value. method from_LINE(self)   Extracts the line object from a LINE wrapper.   Namespace types: LINE   Parameters:      self (LINE) : The wrapped LINE instance.   Returns: The underlying `line` object. method from_LABEL(self)   Extracts the label object from a LABEL wrapper.   Namespace types: LABEL   Parameters:      self (LABEL) : The wrapped LABEL instance.   Returns: The underlying `label` object. method from_BOX(self)   Extracts the box object from a BOX wrapper.   Namespace types: BOX   Parameters:      self (BOX) : The wrapped BOX instance.   Returns: The underlying `box` object. method from_TABLE(self)   Extracts the table object from a TABLE wrapper.   Namespace types: TABLE   Parameters:      self (TABLE) : The wrapped TABLE instance.   Returns: The underlying `table` object. method from_CHART_POINT(self)   Extracts the chart.point from a CHART_POINT wrapper.   Namespace types: CHART_POINT   Parameters:      self (CHART_POINT) : The wrapped CHART_POINT instance.   Returns: The underlying `chart.point` value. method from_POLYLINE(self)   Extracts the polyline object from a POLYLINE wrapper.   Namespace types: POLYLINE   Parameters:      self (POLYLINE) : The wrapped POLYLINE instance.   Returns: The underlying `polyline` object. method from_LINEFILL(self)   Extracts the linefill object from a LINEFILL wrapper.   Namespace types: LINEFILL   Parameters:      self (LINEFILL) : The wrapped LINEFILL instance.   Returns: The underlying `linefill` object. method has_error(self)   Returns true if the INT wrapper has an active log entry.   Namespace types: INT   Parameters:      self (INT) : The INT instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the FLOAT wrapper has an active log entry.   Namespace types: FLOAT   Parameters:      self (FLOAT) : The FLOAT instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the BOOL wrapper has an active log entry.   Namespace types: BOOL   Parameters:      self (BOOL) : The BOOL instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the STRING wrapper has an active log entry.   Namespace types: STRING   Parameters:      self (STRING) : The STRING instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the COLOR wrapper has an active log entry.   Namespace types: COLOR   Parameters:      self (COLOR) : The COLOR instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the LINE wrapper has an active log entry.   Namespace types: LINE   Parameters:      self (LINE) : The LINE instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the LABEL wrapper has an active log entry.   Namespace types: LABEL   Parameters:      self (LABEL) : The LABEL instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the BOX wrapper has an active log entry.   Namespace types: BOX   Parameters:      self (BOX) : The BOX instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the TABLE wrapper has an active log entry.   Namespace types: TABLE   Parameters:      self (TABLE) : The TABLE instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the CHART_POINT wrapper has an active log entry.   Namespace types: CHART_POINT   Parameters:      self (CHART_POINT) : The CHART_POINT instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the POLYLINE wrapper has an active log entry.   Namespace types: POLYLINE   Parameters:      self (POLYLINE) : The POLYLINE instance to check.   Returns: True if an error or message is active in the log. method has_error(self)   Returns true if the LINEFILL wrapper has an active log entry.   Namespace types: LINEFILL   Parameters:      self (LINEFILL) : The LINEFILL instance to check.   Returns: True if an error or message is active in the log. void_return()   Utility function used when a return is syntactically required but functionally unnecessary.   Returns: Nothing. Function never executes its body. argument_error(condition, function, argument, message)   Throws a runtime error when a condition is met. Used for strict argument validation.   Parameters:      condition (bool) : Boolean expression that triggers the runtime error.      function (string) : Name of the calling function (for formatting).      argument (string) : Name of the problematic argument.      message (string) : Description of the error cause.   Returns: Never returns. Halts execution if the condition is true. argument_log_info(condition, function, argument, message)   Logs an informational message when a condition is met. Used for optional debug visibility.   Parameters:      condition (bool) : Boolean expression that triggers the log.      function (string) : Name of the calling function.      argument (string) : Argument name being referenced.      message (string) : Informational message to log.   Returns: Nothing. Logs if the condition is true. argument_log_warning(condition, function, argument, message)   Logs a warning when a condition is met. Non-fatal but highlights potential issues.   Parameters:      condition (bool) : Boolean expression that triggers the warning.      function (string) : Name of the calling function.      argument (string) : Argument name being referenced.      message (string) : Warning message to log.   Returns: Nothing. Logs if the condition is true. argument_log_error(condition, function, argument, message)   Logs an error message when a condition is met. Does not halt execution.   Parameters:      condition (bool) : Boolean expression that triggers the error log.      function (string) : Name of the calling function.      argument (string) : Argument name being referenced.      message (string) : Error message to log.   Returns: Nothing. Logs if the condition is true. init_static_log(error_type, message, active)   Initializes a persistent (var) Log object. Ideal for global logging in scripts or modules.   Parameters:      error_type (series ErrorType) : Initial severity level (required).      message (string) : Optional starting message string. Default value of ("").      active (bool) : Whether the log should be flagged active on initialization. Default value of (false).   Returns: A static Log object with the given parameters. method new_line(self)   Appends a newline character to the Log message. Useful for separating entries during chained writes.   Namespace types: Log   Parameters:      self (Log) : The Log instance to modify.   Returns: The updated Log object with a newline appended. method write(self, message, flag_active, error_type)   Appends a message to a Log object without a newline. Updates severity and active state if specified.   Namespace types: Log   Parameters:      self (Log) : The Log instance being modified.      message (string) : The text to append to the log.      flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).      error_type (series ErrorType) : Optional override for the severity level. Default value of (na).   Returns: The updated Log object. method write_line(self, message, flag_active, error_type)   Appends a message to a Log object, prefixed with a newline for clarity.   Namespace types: Log   Parameters:      self (Log) : The Log instance being modified.      message (string) : The text to append to the log.      flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).      error_type (series ErrorType) : Optional override for the severity level. Default value of (na).   Returns: The updated Log object. method clear(self, flag_active, error_type)   Clears a Log object’s message and optionally reactivates it. Can also update the error type.   Namespace types: Log   Parameters:      self (Log) : The Log instance being cleared.      flag_active (bool) : Whether to activate the log after clearing. Default value of (false).      error_type (series ErrorType) : Optional new error type to assign. If not provided, the previous type is retained. Default value of (na).   Returns: The cleared Log object. method render_condition(self, flag_active, error_type)   Conditionally renders the log if it is active. Allows overriding error type and controlling active state afterward.   Namespace types: Log   Parameters:      self (Log) : The Log instance to evaluate and render.      flag_active (bool) : Whether to activate the log after rendering. Default value of (false).      error_type (series ErrorType) : Optional error type override. Useful for contextual formatting just before rendering. Default value of (na).   Returns: The updated Log object. method render_now(self, flag_active, error_type)   Immediately renders the log regardless of `active` state. Allows overriding error type and active flag.   Namespace types: Log   Parameters:      self (Log) : The Log instance to render.      flag_active (bool) : Whether to activate the log after rendering. Default value of (false).      error_type (series ErrorType) : Optional error type override. Allows dynamic severity adjustment at render time. Default value of (na).   Returns: The updated Log object. render(self, condition, flag_active, error_type)   Renders the log conditionally or unconditionally. Allows full control over render behavior.   Parameters:      self (Log) : The Log instance to render.      condition (bool) : If true, renders only if the log is active. If false, always renders. Default value of (false).      flag_active (bool) : Whether to activate the log after rendering. Default value of (false).      error_type (series ErrorType) : Optional error type override passed to the render methods. Default value of (na).   Returns: The updated Log object. Log   A structured object used to store and render logging messages.   Fields:      error_type (series ErrorType) : The severity level of the message (from the ErrorType enum).      message (series string) : The text of the log message.      active (series bool) : Whether the log should trigger rendering when conditionally evaluated. INT   A wrapped integer type with attached logging for validation or tracing.   Fields:      v (series int) : The underlying `int` value.      e (Log) : Optional log object describing validation status or error context. FLOAT   A wrapped float type with attached logging for validation or tracing.   Fields:      v (series float) : The underlying `float` value.      e (Log) : Optional log object describing validation status or error context. BOOL   A wrapped boolean type with attached logging for validation or tracing.   Fields:      v (series bool) : The underlying `bool` value.      e (Log) : Optional log object describing validation status or error context. STRING   A wrapped string type with attached logging for validation or tracing.   Fields:      v (series string) : The underlying `string` value.      e (Log) : Optional log object describing validation status or error context. COLOR   A wrapped color type with attached logging for validation or tracing.   Fields:      v (series color) : The underlying `color` value.      e (Log) : Optional log object describing validation status or error context. LINE   A wrapped line object with attached logging for validation or tracing.   Fields:      v (series line) : The underlying `line` value.      e (Log) : Optional log object describing validation status or error context. LABEL   A wrapped label object with attached logging for validation or tracing.   Fields:      v (series label) : The underlying `label` value.      e (Log) : Optional log object describing validation status or error context. BOX   A wrapped box object with attached logging for validation or tracing.   Fields:      v (series box) : The underlying `box` value.      e (Log) : Optional log object describing validation status or error context. TABLE   A wrapped table object with attached logging for validation or tracing.   Fields:      v (series table) : The underlying `table` value.      e (Log) : Optional log object describing validation status or error context. CHART_POINT   A wrapped chart point with attached logging for validation or tracing.   Fields:      v (chart.point) : The underlying `chart.point` value.      e (Log) : Optional log object describing validation status or error context. POLYLINE   A wrapped polyline object with attached logging for validation or tracing.   Fields:      v (series polyline) : The underlying `polyline` value.      e (Log) : Optional log object describing validation status or error context. LINEFILL   A wrapped linefill object with attached logging for validation or tracing.   Fields:      v (series linefill) : The underlying `linefill` value.      e (Log) : Optional log object describing validation status or error context.
ไลบรารี Pine Script®
โดย The_Peaceful_Lizard
3
CommonUtils█ OVERVIEW This library is a utility tool for Pine Script™ developers. It provides a collection of helper functions designed to simplify common tasks such as mapping user-friendly string inputs to Pine Script™ constants and formatting timeframe strings for display. The primary goal is to make main scripts cleaner, more readable, and reduce repetitive boilerplate code. It is envisioned as an evolving resource, with potential for new utilities to be added over time based on community needs and feedback. █  CONCEPTS The library primarily focuses on two main concepts: Input Mapping Pine Script™ often requires specific constants for function parameters (e.g., `line.style_dashed` for line styles, `position.top_center` for table positions). However, presenting these technical constants directly to users in script inputs can be confusing. Input mapping involves: Allowing users to select options from more descriptive, human-readable strings (e.g., "Dashed", "Top Center") in the script's settings. Providing functions within this library (e.g., `mapLineStyle`, `mapTablePosition`) that take these user-friendly strings as input. Internally, these functions use switch statements or similar logic to convert (map) the input string to the corresponding Pine Script™ constant required by built-in functions. This approach enhances user experience and simplifies the main script's logic by centralizing the mapping process. Timeframe Formatting Raw timeframe strings obtained from variables like `timeframe.period` (e.g., "1", "60", "D", "W") or user inputs are not always ideal for direct display in labels or panels. The `formatTimeframe` function addresses this by: Taking a raw timeframe string as input. Parsing this string to identify its numerical part and unit (e.g., minutes, hours, days, weeks, months, seconds, milliseconds). Converting it into a more standardized and readable format (e.g., "1min", "60min", "Daily", "Weekly", "1s", "10M"). Offering an optional `customSuffix` parameter (e.g., " FVG", " Period") to append to the formatted string, making labels more descriptive, especially in multi-timeframe contexts. The function is designed to correctly interpret various common timeframe notations used in TradingView. █  NOTES Ease of Use: The library functions are designed with simple and understandable signatures. They typically take a string input and return the corresponding Pine Script™ constant or a formatted string. Default Behaviors: Mapping functions (`mapLineStyle`, `mapTablePosition`, `mapTextSize`) generally return a sensible default value (e.g., `line.style_solid` for `mapLineStyle`) in case of a non-matching input. This helps prevent errors in the main script. Extensibility of Formatting: The `formatTimeframe` function, with its `customSuffix` parameter, allows for flexible customization of timeframe labels to suit the specific descriptive needs of different indicators or contexts. Performance Considerations: These utility functions primarily use basic string operations and switch statements. For typical use cases, their impact on overall script performance is negligible. However, if a function like `formatTimeframe` were to be called excessively in a loop with dynamic inputs (which is generally not its intended use), performance should be monitored. No Dependencies: This library is self-contained and does not depend on any other external Pine Script™ libraries. █  EXPORTED FUNCTIONS mapLineStyle(styleString)   Maps a user-provided line style string to its corresponding Pine Script™ line style constant.   Parameters:      styleString (simple string) : The input string representing the desired line style (e.g., "Solid", "Dashed", "Dotted" - typically from constants like LS1, LS2, LS3).   Returns: The Pine Script™ constant for the line style (e.g., line.style_solid). Defaults to line.style_solid if no match. mapTablePosition(positionString)   Maps a user-provided table position string to its corresponding Pine Script™ position constant.   Parameters:      positionString (simple string) : The input string representing the desired table position (e.g., "Top Right", "Top Center" - typically from constants like PP1, PP2).   Returns: The Pine Script™ constant for the table position (e.g., position.top_right). Defaults to position.top_right if no match. mapTextSize(sizeString)   Maps a user-provided text size string to its corresponding Pine Script™ size constant.   Parameters:      sizeString (simple string) : The input string representing the desired text size (e.g., "Tiny", "Small" - typically from constants like PTS1, PTS2).   Returns: The Pine Script™ constant for the text size (e.g., size.tiny). Defaults to size.small if no match. formatTimeframe(tfInput, customSuffix)   Formats a raw timeframe string into a more display-friendly string, optionally appending a custom suffix.   Parameters:      tfInput (simple string) : The raw timeframe string from user input or timeframe.period (e.g., "1", "60", "D", "W", "1S", "10M", "2H").      customSuffix (simple string) : An optional suffix to append to the formatted timeframe string (e.g., " FVG", " Period"). Defaults to an empty string.   Returns: The formatted timeframe string (e.g., "1min", "60min", "Daily", "Weekly", "1s", "10min", "2h") with the custom suffix appended.
ไลบรารี Pine Script®
โดย no1x