เริ่มกันเลย

Timesessions

Higher_Time_FrameLibrary "Higher_Time_Frame" IsGreenBar(oCandle)   Parameters:      oCandle (Candle) IsRedBar(oCandle)   Parameters:      oCandle (Candle) BarColor(oCandle)   / 1 = Green / -1 = Red / 0 = Doji   Parameters:      oCandle (Candle) CalculateEMA(oCandle, Period, InputValue, MAValue)   Parameters:      oCandle (Candle)      Period (int)      InputValue (float)      MAValue (float) Candle   Fields:      UID (series int)      HighPrice (series float)      LowPrice (series float)      OpenPrice (series float)      ClosePrice (series float)      HighIndex (series int)      LowIndex (series int)      OpenIndex (series int)      CloseIndex (series int)
ไลบรารี Pine Script®
โดย UkutaLabs
ONS_ForexSessionLibLibrary "ONS_ForexSessionLib" Library for DST-adjusted Forex session detection. Returns session state and timing for a given bar. Thanks to the author of "Sessions Full Markets Forex Stocks Index 7 Time by TFlab" DST_Detector(Start_Month, Start_Day, Start_CountDay, End_Month, End_Day, End_CountDay, TimeZone)   Detects whether DST is Active or Inactive for a given timezone.   Parameters:      Start_Month (int) : Month DST begins (int)      Start_Day (int) : Day-of-week DST begins (int, use dayofweek.* constants)      Start_CountDay (int) : Nth occurrence of Start_Day in Start_Month (int)      End_Month (int) : Month DST ends (int)      End_Day (int) : Day-of-week DST ends (int)      End_CountDay (int) : Nth occurrence of End_Day in End_Month (int)      TimeZone (string) : IANA timezone string, use "Australia/Sydney" to invert logic (string)   Returns: "Active" or "Inactive" (string) getDSTStates()   Returns DST state for Sydney, London and New York at the current bar.   Returns: — each "Active" or "Inactive" (tuple of strings) getForexSessionStrings(Sydney_DST, London_DST, NewYork_DST)   Returns UTC session strings for all Forex sessions, DST-adjusted.   Parameters:      Sydney_DST (string) : DST state string for Sydney ("Active"/"Inactive")      London_DST (string) : DST state string for London ("Active"/"Inactive")      NewYork_DST (string) : DST state string for New York ("Active"/"Inactive")   Returns: session strings (tuple of strings) isInSession(sessionStr, tz)   Returns 1 if the bar at the current series position is inside a session, 0 otherwise.   Parameters:      sessionStr (string) : Session string in "HHMM-HHMM" format (string)      tz (string) : IANA or UTC offset timezone string for the session (string)   Returns: 1 if inside session, 0 if outside (int) isBarInSession(targetIndex, sessionStr, tz)   Returns 1 if a specific bar_index is inside a session (for point-in-time lookup).   Parameters:      targetIndex (int) : bar_index to test (int)      sessionStr (string) : Session string "HHMM-HHMM" (string)      tz (string) : IANA or UTC offset timezone string (string)   Returns: 1 if the target bar is/was inside session, 0 otherwise (int) getAllForexSessions()   One-shot helper: given the current bar, returns open/closed state for all DST-adjusted Forex sessions simultaneously.   Returns: Each value is 1 (open) or 0 (closed). (tuple of ints)
ไลบรารี Pine Script®
โดย onskytvui9
Vantage_LO1_Sizing**Overview** Position-sizing library for the LO1 breakout box day-trading strategy. Provides a unified recoup (opposite-add) sizing pipeline and dollar-risk/profit helpers. Extracting these functions into a library avoids Pine Script's function inlining, reducing compiled token count in the main strategy. **Exported Type: RecoupSizingResult** Holds the output of the 8-step sizing pipeline: • Micro-level quantities (raw, DLL-capped, final) • YM-level quantities (pre/post min-1-YM policy, proxy-capped) • Risk gate values (projected loss, worst-case drawdown, pass/fail) • Recoup scenario P&L (net outcome if T1 stops and recoup wins) **Exported Functions** `f_calcTradeRiskDollars(entry, stop, qty)` → float Projected risk in dollars. Converts price distance to ticks via syminfo.mintick, then to dollars via syminfo.pointvalue. `f_calcTradeProfitDollars(entry, tp, qty)` → float Projected profit in dollars. Same tick-to-dollar conversion applied to the take-profit distance. `f_computeRecoupSizing(...)` → RecoupSizingResult 8-step recoup sizing pipeline: 1. Raw micro qty from risk multiplier (CEILING) 2. Daily loss limit cap at micro level 3. Micro-to-YM conversion (FLOOR) 4. Minimum-1-YM policy 5. Proxy capacity cap 6. Micro-equivalent for risk gating 7. Worst-case projection (base stop + opposing flatten + recoup stop) 8. Risk gate pass/fail Plus scenario P&L: net recoup outcome and T1-win profit. **Usage** import Vantage-Stack/Vantage_LO1_Sizing/1 as sz float risk = sz.f_calcTradeRiskDollars(entry, stop, qty) sz.RecoupSizingResult r = sz.f_computeRecoupSizing(baseQty, baseEntry, baseStop, recoupEntry, recoupStop, recoupTP, multiplier, proxyMul, minOneYM, curLoss, maxLoss, maxProxy, t1TP, oppTP, oppFrac, oppRemoval) ====================== Library "Vantage_LO1_Sizing" Position sizing library for LO1 breakout box strategy. Extracts pure-computation functions to reduce compiled token count in the main script. f_calcTradeRiskDollars(_entry, _stop, _qty)   Calculates projected risk in dollars for a position (qty × |entry−stop| in ticks × pointvalue).   Parameters:      _entry (float) : Entry price      _stop (float) : Stop-loss price      _qty (float) : Position quantity (contracts)   Returns: Risk in dollars f_calcTradeProfitDollars(_entry, _tp, _qty)   Calculates projected profit in dollars for a position (qty × |tp−entry| in ticks × pointvalue).   Parameters:      _entry (float) : Entry price      _tp (float) : Take-profit price      _qty (float) : Position quantity (contracts)   Returns: Profit in dollars f_computeRecoupSizing(baseQtyMicro, baseEntry, baseStop, recoupEntry, recoupStop, recoupTP, oppositeMultiplier, proxyQtyMul, minOneYMEnabled, currentLossDollars, maxDailyLossLimit, maxProxyCap, t1TPPrice, oppTPPrice, oppAddStopFrac, opposingRemovalEnabled)   Computes recoup (opposite-add) position sizing through an 8-step pipeline: raw micro qty, DLL cap, micro-to-YM conversion, min-1-YM policy, proxy cap, risk gating, worst-case projection, and recoup scenario P&L.   Parameters:      baseQtyMicro (int) : T1 micro-contract quantity      baseEntry (float) : T1 entry price      baseStop (float) : T1 stop-loss price      recoupEntry (float) : Recoup entry price      recoupStop (float) : Recoup stop-loss price      recoupTP (float) : Recoup take-profit price      oppositeMultiplier (float) : Target risk multiplier for recoup vs T1 (e.g., 4.0)      proxyQtyMul (float) : Micro-to-YM conversion factor (0 = no proxy)      minOneYMEnabled (bool) : Force minimum 1 YM contract when proxy is active      currentLossDollars (float) : Running session loss in dollars (0 for estimate mode)      maxDailyLossLimit (float) : Daily loss limit in dollars (-1 = disabled)      maxProxyCap (int) : Maximum proxy contracts cap (0 = unlimited)      t1TPPrice (float) : T1 take-profit price (for scenario P&L calculation)      oppTPPrice (float) : Opposing MYM TP price when T1 stops (for scenario profit calc)      oppAddStopFrac (float) : Fraction of base risk for opposite MYM emergency flatten      opposingRemovalEnabled (bool) : Whether opposing removal entry mode is active   Returns: RecoupSizingResult with quantities, risk values, and scenario P&L RecoupSizingResult   Holds the complete output of the 8-step recoup sizing pipeline: micro/YM quantities, risk gate results, worst-case projections, and recoup-scenario P&L.   Fields:      microQtyRaw (series int)      microCapByDLL (series int)      microQtyCapped (series int)      ymQtyPre (series int)      ymQtyFinal (series int)      microEqForGate (series int)      projectedLossRecoup (series float)      dllRemaining (series float)      totalWorstCase (series float)      riskOK (series bool)      oppMYMLoss (series float)      didMinOneOverride (series bool)      dllForcedZero (series bool)      recoupScenarioNet (series float)      t1WinProfit (series float)
ไลบรารี Pine Script®
โดย Vantage-Stack
SessionCandlesLibrary "SessionCandles" SessionCandles — A library for building OHLCV candlestick data per market session. Each session (e.g. Sydney, Tokyo, London, New York) is treated as a single candle: - Open : first bar's open price when session starts - High : highest high seen so far within the session - Low : lowest low seen so far within the session - Close : most recent close (or last close when session ends) - Volume: accumulated volume for the entire session - Time : bar timestamp at session open
ไลบรารี Pine Script®
โดย goldfanatic
Vantage_NewsVantage 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. 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
TPOSmartMoneyLibLibrary "TPOSmartMoneyLib" Library for TPO (Time Price Opportunity) and Smart Money concepts including session management, PDH/PDL detection, sweeping logic, and volume profile utilities f_price_to_tick(p)   Convert price to tick   Parameters:      p (float) : Price value   Returns: Tick value f_tick_to_row(t, row_ticks_in)   Convert tick to row   Parameters:      t (int) : Tick value      row_ticks_in (int) : Number of ticks per row   Returns: Row index f_row_to_price(row, row_ticks_in)   Convert row to price (midpoint)   Parameters:      row (int) : Row index      row_ticks_in (int) : Number of ticks per row   Returns: Price at row midpoint f_calc_row_ticks(natr_ref, row_gran_mult)   Calculate dynamic row size based on normalized ATR   Parameters:      natr_ref (float) : Daily normalized ATR reference value      row_gran_mult (float) : Row granularity multiplier   Returns: Number of ticks per row f_more_transp_pct(c, pct)   Increase color transparency by percentage   Parameters:      c (color) : Input color      pct (float) : Percentage to increase transparency (0.0 to 1.0)   Returns: Color with increased transparency f_dom_color(dom, buy_col, sell_col, gamma, transp_weak, transp_strong)   Calculate dominance color based on buy/sell ratio   Parameters:      dom (float) : Dominance ratio (-1 to 1, negative = sell, positive = buy)      buy_col (color) : Buy dominant color      sell_col (color) : Sell dominant color      gamma (float) : Gamma correction for color intensity      transp_weak (int) : Transparency for weak dominance      transp_strong (int) : Transparency for strong dominance   Returns: Blended color f_sess_part(sess_str, get_start)   Parse session string to get start or end time   Parameters:      sess_str (string) : Session string in format "HHMM-HHMM"      get_start (bool) : True to get start time, false to get end time   Returns: Time string in HHMM format f_hhmm_to_h(hhmm)   Convert HHMM string to hours   Parameters:      hhmm (string) : Time string in HHMM format   Returns: Hours (0-23) f_hhmm_to_m(hhmm)   Convert HHMM string to minutes   Parameters:      hhmm (string) : Time string in HHMM format   Returns: Minutes (0-59) f_prev_day_window_bounds(today_day_rth, win_start, win_end, session_tz)   Calculate previous day window bounds   Parameters:      today_day_rth (int) : Today's RTH start timestamp      win_start (string) : Window start time in HHMM format      win_end (string) : Window end time in HHMM format      session_tz (string) : Session timezone   Returns: Tuple of f_default_session_colors()   Get default session colors   Returns: Array of 4 colors f_session_names()   Get session names   Returns: Array of 4 session names f_process_hl(arr, rng, keep_bars, lock_to_live)   Process high/low lines with sweeping detection   Parameters:      arr (array) : Array of HLLine objects      rng (float) : Price range for visibility filtering      keep_bars (int) : Maximum bars to keep lines      lock_to_live (bool) : Whether to lock line end to current bar   Returns: 0 (for chaining) f_process_naked_lines(arr, calc_bars, bars_per_day, keep_to_day_end)   Process naked lines (POC/VAH/VAL) with sweeping detection   Parameters:      arr (array) : Array of NakedLine objects      calc_bars (int) : Maximum calculation bars      bars_per_day (int) : Bars per day for scope calculation      keep_to_day_end (bool) : Whether to extend to day end   Returns: 0 (for chaining) f_update_pdhl_lines(pd_hl, pdh, pdl, new_day, pd_rng, bars_per_day, pdh_color, pdl_color)   Detect and create PDH/PDL lines   Parameters:      pd_hl (array) : Array to store HLLine objects      pdh (float) : Previous day high      pdl (float) : Previous day low      new_day (bool) : Whether it's a new day      pd_rng (float) : Price range for visibility      bars_per_day (int) : Bars per day      pdh_color (color) : PDH line color      pdl_color (color) : PDL line color   Returns: 0 (for chaining) f_poc_from_vals(keys, vals)   Calculate POC from sorted keys and values   Parameters:      keys (array) : Sorted array of row keys      vals (array) : Array of volume values   Returns: POC row key f_value_area(keys, vals, poc_key, va_pct)   Calculate Value Area from volume distribution   Parameters:      keys (array) : Sorted array of row keys      vals (array) : Array of volume values      poc_key (int) : POC row key      va_pct (float) : Value Area percentage (typically 0.70)   Returns: Tuple of f_find_key_sorted(keys, target)   Find key in sorted array using binary search   Parameters:      keys (array) : Sorted array of keys      target (int) : Target key to find   Returns: Index of key, or -1 if not found f_zscore_safe(x, len)   Safe z-score calculation using built-in functions   Parameters:      x (float) : Input series      len (int) : Lookback length   Returns: Z-score HLLine   Represents a high/low line with sweeping detection   Fields:      ln (series line) : Line object      lb (series label) : Label object      lvl (series float) : Price level      startBar (series int) : Bar index where line starts      swept (series bool) : Whether the level has been swept      isHigh (series bool) : True if this is a high, false if low      col (series color) : Line color NakedLine   Represents a naked POC/VAH/VAL line   Fields:      ln (series line) : Line object      lb (series label) : Label object      lvl (series float) : Price level      startBar (series int) : Bar index where line starts      swept (series bool) : Whether the level has been swept      sweptBar (series int) : Bar index where swept occurred      endBar (series int) : Bar index where line should end
ไลบรารี Pine Script®
โดย cybermediaboy
QTCoreLibrary "QTCore" qt_config_default() qt_state_new() qt_daily_update(st, cfg, t, tClose)   Parameters:      st (CycleState)      cfg (QTConfig)      t (int)      tClose (int) qt_m90_update(st, cfg, t, tClose)   Parameters:      st (CycleState)      cfg (QTConfig)      t (int)      tClose (int) qt_micro_update(st, cfg, t, tClose)   Parameters:      st (CycleState)      cfg (QTConfig)      t (int)      tClose (int) qt_nano_update(st, cfg, t, tClose)   Parameters:      st (CycleState)      cfg (QTConfig)      t (int)      tClose (int) QTConfig   Fields:      tz (series string)      dayStartHour (series int)      dayStartMin (series int)      keepCycles (series int)      tfDaily (series string)      tfM90 (series string)      tfMicro (series string)      tfNano (series string) QuarterOHLC   Fields:      startTs (series int)      o (series float)      h (series float)      l (series float)      c (series float)      has (series bool) CycleResult   Fields:      startTs (series int)      endTs (series int)      startRealized (series bool)      endRealized (series bool)      q1Ts (series int)      q2Ts (series int)      q3Ts (series int)      q4Ts (series int)      q2Realized (series bool)      q3Realized (series bool)      q4Realized (series bool)      curQuarterIndex (series int)      inWindow (series bool)      q1 (QuarterOHLC)      q2 (QuarterOHLC)      q3 (QuarterOHLC)      q4 (QuarterOHLC) FixedCycleState   Fields:      starts (array)      lastStartTs (series int) CycleState   Fields:      daily (FixedCycleState)      m90 (FixedCycleState)      micro (FixedCycleState)      nano (FixedCycleState)
ไลบรารี Pine Script®
โดย Jaw1312
InfinityCandlePatternsLibrary "InfinityCandlePatterns" isMorningStar(o, c, atr)   Parameters:      o (float)      c (float)      atr (float) isEveningStar(o, c, atr)   Parameters:      o (float)      c (float)      atr (float) isThreeWhiteSoldiers(o, h, c, atr)   Parameters:      o (float)      h (float)      c (float)      atr (float) isThreeBlackCrows(o, l, c, atr)   Parameters:      o (float)      l (float)      c (float)      atr (float) isBullishHarami(o, c, atr)   Parameters:      o (float)      c (float)      atr (float) isBearishHarami(o, c, atr)   Parameters:      o (float)      c (float)      atr (float) isBullishEngulfing(o, c)   Parameters:      o (float)      c (float) isBearishEngulfing(o, c)   Parameters:      o (float)      c (float) isThreeInsideUp(o, h, c, atr)   Parameters:      o (float)      h (float)      c (float)      atr (float) isThreeInsideDown(o, l, c, atr)   Parameters:      o (float)      l (float)      c (float)      atr (float) isTweezerBottom(o, l, c, atr)   Parameters:      o (float)      l (float)      c (float)      atr (float) isTweezerTop(o, h, c, atr)   Parameters:      o (float)      h (float)      c (float)      atr (float) isBullishKicker(o, c)   Parameters:      o (float)      c (float) isBearishKicker(o, c)   Parameters:      o (float)      c (float) isBullishBreakaway(o, c, atr)   Parameters:      o (float)      c (float)      atr (float) isBearishBreakaway(o, c, atr)   Parameters:      o (float)      c (float)      atr (float) isHammer(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) isShootingStar(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) isStandardDoji(o, c, atr)   Parameters:      o (float)      c (float)      atr (float) isDragonflyDoji(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) isGravestoneDoji(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) isBullishMarubozu(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) isBearishMarubozu(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) isSpinningTop(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) bullAny(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) bearAny(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) neutralAny(o, h, l, c, atr)   Parameters:      o (float)      h (float)      l (float)      c (float)      atr (float) bullStrong(o, h, c, atr)   Parameters:      o (float)      h (float)      c (float)      atr (float) bearStrong(o, l, c, atr)   Parameters:      o (float)      l (float)      c (float)      atr (float)
ไลบรารี Pine Script®
โดย sapa3333
TimeframeAlignTHE PROBLEM THIS LIBRARY SOLVES When you use `request.security()` to get data from a Higher Timeframe (HTF) and try to draw objects like boxes, lines, or labels, they appear at the wrong horizontal position . This is the "floating in space" problem. Why does this happen? The `bar_index` in Pine Script refers to where data was RECEIVED , not where the event OCCURRED . Consider this scenario: • You're on a 5-minute chart • You request 1-hour data for drawing an FVG (Fair Value Gap) • A 1H candle spans 12 chart bars (60min / 5min = 12) • But your code draws at `bar_index - 1` or `bar_index - 3` • The result: your FVG box is only 2-3 bars wide instead of spanning the correct 12-36 bars This library solves that by tracking where HTF bars actually start and end on your chart timeframe. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ HOW TO USE THIS LIBRARY Step 1: Import the Library ``` import ArunaReborn/TimeframeAlign/1 as tfa ``` Step 2: Create a Tracker for Each HTF ``` var tfa.HTFTracker tracker1H = tfa.createTracker("60") ``` Step 3: Update the Tracker Every Bar ``` tfa.updateTracker(tracker1H, "60") ``` Step 4: Use Synced Drawing Functions ``` if tfa.htfBarChanged(tracker1H) tfa.syncedBox(tracker1H, 3, 1, topPrice, bottomPrice, color.new(color.green, 80)) ``` ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ EXPORTED TYPES TimeframePair Stores metadata about the relationship between source and chart timeframes. • sourceTimeframe - The HTF/LTF being compared • chartTimeframe - Current chart timeframe • isHTF - True if source is higher than chart • isLTF - True if source is lower than chart • barRatio - Chart bars per source bar • secondsRatio - Time ratio between timeframes MTFEventData Stores synchronized event data with correct bar positions. • price - Price level of the event • eventTime - Unix timestamp of the event • chartBarStart - Chart bar_index where event's TF bar started • chartBarEnd - Chart bar_index where event's TF bar ended • htfOffset - The HTF offset used • isValid - True if synchronization succeeded HTFTracker Tracks HTF bar boundaries. Create one per timeframe you need to track. • htfTimeframe - The timeframe being tracked • currentStartBar - Where current HTF bar started • currentEndBar - Where current HTF bar ends (provisional) • startHistory - Array of historical start positions • endHistory - Array of historical end positions • lastUpdateBar - Last bar_index when updated • barJustChanged - True if HTF bar changed on this chart bar (set by updateTracker) SyncedBox Managed box with synchronization metadata. • bx - The Pine Script box object • htfTimeframe - Source timeframe • leftHtfOffset / rightHtfOffset - HTF offsets for edges • topPrice / bottomPrice - Price boundaries • extendRight - Auto-extend flag SyncedLine Managed line with synchronization metadata. • ln - The Pine Script line object • htfTimeframe - Source timeframe • htfOffset - Anchor offset • price - Price level (horizontal lines) • isHorizontal - Line orientation • extendRight - Auto-extend flag SyncedLabel Managed label with synchronization metadata. • lbl - The Pine Script label object • htfTimeframe - Source timeframe • htfOffset - Anchor offset • price - Price level • anchorPoint - "start", "end", or "middle" ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ EXPORTED FUNCTIONS ━━ CORE FUNCTIONS ━━ getTimeframeInfo(sourceTimeframe) Analyzes relationship between a source TF and chart TF. Returns: TimeframePair with comparison metadata createTracker(htfTimeframe) Creates a new HTF tracker. Call once per timeframe, store with `var`. Returns: HTFTracker instance updateTracker(tracker, htfTimeframe, historyDepth) Updates tracker with current bar data. Call on every bar. • htfTimeframe: The timeframe string (must match createTracker) • historyDepth: Max HTF bars to track (default 500) Returns: Updated tracker getStartBar(tracker, htfOffset) Gets chart bar_index where a specific HTF bar started. • htfOffset: 0=current, 1=previous, 2=two bars ago, etc. Returns: bar_index or na getEndBar(tracker, htfOffset) Gets chart bar_index where a specific HTF bar ended. Returns: bar_index or na htfBarChanged(tracker) Detects when HTF bar just changed. Returns: True on first chart bar of new HTF bar findBarAtTime(timestamp, maxLookback) Searches backward to find chart bar containing a timestamp. • maxLookback: How far back to search (default 500) Returns: bar_index or na syncEventToChart(tracker, eventPrice, eventTime, anchorPoint) Generic sync function mapping any event to correct chart position. • anchorPoint: "start", "end", or "middle" Returns: MTFEventData ━━ DRAWING CREATION FUNCTIONS ━━ syncedBox(tracker, leftHtfOffset, rightHtfOffset, topPrice, bottomPrice, bgcolor, ...) Creates a box at correct HTF-aligned position. • leftHtfOffset: HTF bars back for left edge • rightHtfOffset: HTF bars back for right edge • extendRight: Auto-extend to current bar Returns: SyncedBox or na syncedHLine(tracker, htfOffset, price, lineColor, lineStyle, lineWidth, extendRight) Creates horizontal line anchored to HTF bar start. • extendRight: If true, extends to current bar (default true) Returns: SyncedLine or na syncedVLine(tracker, htfOffset, atStart, lineColor, lineStyle, lineWidth) Creates vertical line at HTF bar boundary. • atStart: True=start of HTF bar, False=end Returns: SyncedLine or na syncedLabel(tracker, htfOffset, price, labelText, anchorPoint, ...) Creates label at correct HTF-aligned position. • anchorPoint: "start", "end", or "middle" Returns: SyncedLabel or na syncedPlotValue(tracker, value, htfOffset) Returns value for plotting only at synced positions. Returns: value if current bar is within HTF range, otherwise na ━━ UPDATE FUNCTIONS ━━ updateSyncedBox(syncedBox, extendToCurrentBar) Extends existing box's right edge to current bar. Returns: Updated SyncedBox updateSyncedLine(syncedLine, extendToCurrentBar) Extends existing horizontal line to current bar. Returns: Updated SyncedLine updateSyncedLabel(syncedLabel, tracker, newText, newPrice) Updates label text/price while maintaining sync. Returns: Updated SyncedLabel ━━ CONVENIENCE FUNCTIONS ━━ htfBarStartIndex(htfTimeframe, htfOffset, historyDepth) Simple function to get HTF bar start without explicit tracker. ⚠️ Only tracks ONE timeframe. For multiple TFs, use createTracker pattern. Returns: bar_index or na htfBarEndIndex(htfTimeframe, htfOffset, historyDepth) Simple function to get HTF bar end without explicit tracker. ⚠️ Only tracks ONE timeframe. For multiple TFs, use createTracker pattern. Returns: bar_index or na ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ COMPLETE USAGE EXAMPLES Example 1: FVG Box with Auto-Extend ``` //@version=6 indicator("FVG with Synced Drawing", overlay=true) import ArunaReborn/TimeframeAlign/1 as tfa htfInput = input.timeframe("60", "HTF for FVG") // Create tracker for chosen timeframe var tfa.HTFTracker fvgTracker = tfa.createTracker(htfInput) tfa.updateTracker(fvgTracker, htfInput) // Get FVG data from HTF (confirmed bars with offset) = request.security(syminfo.tickerid, htfInput, [low , high , low > high ], lookahead=barmerge.lookahead_off) // Store managed box var tfa.SyncedBox fvgBox = na // Create synced box when FVG detected if fvgDetected and tfa.htfBarChanged(fvgTracker) fvgBox := tfa.syncedBox(fvgTracker, 3, 1, fvgTop, fvgBot, color.new(color.green, 85), color.green, 1, "FVG", color.white, true) // Extend box to current bar each tick if not na(fvgBox) tfa.updateSyncedBox(fvgBox, true) ``` Example 2: HTF Support/Resistance Lines ``` //@version=6 indicator("HTF S/R Lines", overlay=true) import ArunaReborn/TimeframeAlign/1 as tfa htfInput = input.timeframe("240", "HTF for S/R") // Create and update tracker var tfa.HTFTracker srTracker = tfa.createTracker(htfInput) tfa.updateTracker(srTracker, htfInput) // Get HTF high/low (confirmed with offset) = request.security(syminfo.tickerid, htfInput, [high , low ], lookahead=barmerge.lookahead_off) // Track lines var tfa.SyncedLine resistanceLine = na var tfa.SyncedLine supportLine = na // Create new lines when HTF bar changes if tfa.htfBarChanged(srTracker) resistanceLine := tfa.syncedHLine(srTracker, 1, htfHigh, color.red, line.style_solid, 2, true) supportLine := tfa.syncedHLine(srTracker, 1, htfLow, color.green, line.style_solid, 2, true) // Auto-extend lines each bar if not na(resistanceLine) tfa.updateSyncedLine(resistanceLine, true) if not na(supportLine) tfa.updateSyncedLine(supportLine, true) ``` Example 3: Multiple Timeframes ``` //@version=6 indicator("Multi-TF Boxes", overlay=true) import ArunaReborn/TimeframeAlign/1 as tfa // Create separate tracker for each timeframe var tfa.HTFTracker tracker1H = tfa.createTracker("60") var tfa.HTFTracker tracker4H = tfa.createTracker("240") var tfa.HTFTracker trackerD = tfa.createTracker("1D") // Update ALL trackers every bar (pass the same TF string) tfa.updateTracker(tracker1H, "60") tfa.updateTracker(tracker4H, "240") tfa.updateTracker(trackerD, "1D") // Now use each tracker independently for drawing // Each tracker maintains its own separate boundary history ``` ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ NON-REPAINTING COMPLIANCE To ensure non-repainting behavior, always use this pattern with request.security: ``` = request.security(syminfo.tickerid, htfTimeframe, [value1 , value2 ], // Use offset for confirmed data lookahead=barmerge.lookahead_off) // Never use lookahead_on ``` The ` ` offset ensures you're using the previous completed HTF bar, not the current forming bar. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ HISTORY DEPTH PARAMETER The `historyDepth` parameter controls how many HTF bars are tracked: • Default: 500 HTF bars • Maximum: Limited by Pine Script's array constraints • Higher values = more historical accuracy but more memory usage • Lower values = less memory but may return `na` for older offsets Adjust based on your needs: ``` tfa.updateTracker(tracker, 100) // Track 100 HTF bars (light) tfa.updateTracker(tracker, 1000) // Track 1000 HTF bars (heavier) ``` ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ IMPORTANT NOTES 1. One Tracker Per Timeframe : If you need multiple HTFs, create separate trackers for each. The convenience functions (htfBarStartIndex, htfBarEndIndex) only track one TF. 2. Update Every Bar : Always call updateTracker() unconditionally on every bar, not inside conditionals. 3. HTF Only : This library is designed for Higher Timeframe data. For LTF aggregation, use findBarAtTime() for time-based lookups. 4. Drawing Limits : Pine Script has limits on drawing objects. Use box.delete(), line.delete(), label.delete() to clean up old objects. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ TROUBLESHOOTING Q: My boxes/lines still appear at wrong positions A: Make sure you're calling updateTracker() on every bar (not inside an if statement) and using the correct htfOffset values. Q: Functions return na A: The htfOffset might be larger than available history. Increase historyDepth or use a smaller offset. Q: Multiple timeframes don't work correctly A: Don't use the convenience functions for multiple TFs. Create separate HTFTracker instances with createTracker() for each timeframe. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ CHANGELOG v1 - Initial release • HTFTracker pattern for reliable multi-TF tracking • Synced drawing functions for boxes, lines, labels • Update functions for extending drawings • Convenience functions for simple single-TF use cases
ไลบรารี Pine Script®
โดย ArunaReborn
Plan Limit TimerA Pine Script library that helps developers monitor script execution time against TradingView's plan-specific timeout limits. Displays a visual debug table with runtime metrics, percentage of limit consumed, and color-coded status warnings. WHAT THIS LIBRARY DOES TradingView enforces different script timeout limits based on subscription tier: • Basic : 20 seconds • Essential / Plus / Premium : 40 seconds • Ultimate : 100 seconds This library measures your script's total execution time and displays it relative to these limits, helping you optimize indicators for users on different plans. THE DEBUG TABLE When enabled, a table appears on your chart showing: • Plan : The selected TradingView subscription tier • Limit : Maximum allowed execution time for that plan • Runtime : Measured script execution time • Per Bar : Average time spent per bar • Bars : Number of bars processed • % Used : Percentage of timeout limit consumed (color-coded) • Status : OK (green), WARNING (yellow), DANGER (orange), or EXCEEDED (red) HOW IT WORKS The library captures a timestamp at the start of your script using timenow, then calculates the elapsed time at the end. It compares this against the selected plan's timeout limit to determine percentage used and status. Technical Note : Pine Script's timenow variable has approximately 1-second precision. Scripts that execute in under 1 second may display 0ms. This is a platform limitation, not a library issue. For detailed per-function profiling, use TradingView's built-in Pine Profiler (More → Profiler mode in the Editor). EXPORTED FUNCTIONS startTimer() Call at the very beginning of your script. Returns a timestamp. getStats(startTime, plan) Calculates timing statistics. Returns a TimingStats object with all metrics. showTimingTable(stats, plan, tablePosition, showOnlyOnLast) Renders the debug table on the chart. debugTiming(startTime, plan, tablePosition) Convenience function combining getStats() and showTimingTable() in one call. isApproachingLimit(stats, threshold) Returns true if execution time has reached the specified percentage of the limit. getRemainingMs(stats) Returns milliseconds remaining before timeout. formatSummary(stats) Returns a compact single-line string for labels or tooltips. addTimingLabel(stats, barIdx, price, labelStyle, textSize) Creates a color-coded chart label displaying timing statistics. Useful for visual debugging without the full table. Returns the label object for further customization. EXPORTED CONSTANTS • LIMIT_BASIC = 20 • LIMIT_ESSENTIAL = 40 • LIMIT_PLUS = 40 • LIMIT_PREMIUM = 40 • LIMIT_ULTIMATE = 100 EXPORTED TYPE: TimingStats Object containing: • totalTimeMs (float): Total execution time in milliseconds • timePerBarMs (float): Average time per bar • barsTimed (int): Number of bars measured • barsSkipped (int): Bars excluded from measurement • planLimitMs (int): Plan timeout in milliseconds • percentUsed (float): Percentage of limit consumed • status (string): "OK", "WARNING", "DANGER", or "EXCEEDED" HOW TO USE IN YOUR INDICATOR //@version=6 indicator("My Indicator", overlay = true) import YourUsername/PlanLimitTimer/1 as timer // User selects their TradingView plan planInput = input.string("basic", "Your Plan", options = ) // START TIMING - must be first startTime = timer.startTimer() // Your indicator calculations here sma20 = ta.sma(close, 20) rsi14 = ta.rsi(close, 14) plot(sma20) // END TIMING - must be last timer.debugTiming(startTime, planInput) ADVANCED USAGE EXAMPLE //@version=6 indicator("Advanced Example", overlay = true) import YourUsername/PlanLimitTimer/1 as timer planInput = input.string("basic", "Plan", options = ) startTime = timer.startTimer() // Your calculations... sma = ta.sma(close, 200) plot(sma) // Get stats for programmatic use stats = timer.getStats(startTime, planInput) // Option 1: Use addTimingLabel for a quick visual indicator if barstate.islast timer.addTimingLabel(stats, bar_index, high) // Option 2: Show custom warning label if approaching limit if timer.isApproachingLimit(stats, 70.0) and barstate.islast label.new(bar_index, low, "Warning: " + timer.formatSummary(stats), color = color.orange, textcolor = color.white, style = label.style_label_up) // Display the debug table timer.showTimingTable(stats, planInput, position.bottom_right) IMPORTANT LIMITATIONS 1. Precision : Timing precision is approximately 1 second due to timenow behavior. Fast scripts show 0ms. 2. Variability : Results vary based on TradingView server load. The same script may show different times across runs. 3. Total Time Only : This library measures total script execution time, not individual function timing. For per-function analysis, use the Pine Profiler in the Editor. 4. Historical Bars : On historical bars, timenow reflects when the script loaded, not individual bar processing times. USE CASES • Optimization Debugging : See how close your script is to timeout limits • Multi-Plan Support : Help users select appropriate settings for their subscription tier • Performance Regression : Detect when changes increase execution time • Documentation : Show users the performance characteristics of your indicator
ไลบรารี Pine Script®
โดย ArunaReborn
libSchedulerTLDR: This is a lightweight, easy-to-use way to throttle sections of Pinescript v6 scripts, the same as you'd use barstate.isconfirmed or barstate.islast. You can use this for enormous efficiency gains, provided you design your script to handle updates on differing intervals rather than computing everything on each cycle. Usage is easy: ``` import showmethegrail/libScheduler/1 as libScheduler i_tf_fetch = input.enum(libScheduler.Timeframes.C, "Fetch Interval", tooltip="Do things just once every interval, default=once per chart timeframe.") var scheduler = libScheduler.Scheduler.new().init() if scheduler.every(i_tf_fetch) // Do stuff ``` That's it. If you need to know more, the code is well-commented. Combine this with sensible caching, and you can right-size the compute-heavy sections of your script, for better stability and managed use of Pinescript compute quotas. You'll need to know the proper use of var and varip to make the most of this, but I found this effectively replaced a lot of boilerplate in throttling my own scripts. Sound software engineering, made Pinescript-level easy. That's all.
ไลบรารี Pine Script®
โดย showmethegrail
1
lib_ephemeris █ PLANETARY EPHEMERIS MASTER LIBRARY Unified API for calculating planetary positions. Import this single library to access all 11 celestial bodies: Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto. Theory: VSOP87 (planets), ELP2000-82 (Moon), Meeus (Pluto) ═══════════════════════════════════════════════════════════════ █ QUICK START //@version=6 indicator("Planetary Ephemeris Demo") import BlueprintResearch/lib_ephemeris/1 as eph // Get all planets sun = eph.string_to_planet("Sun") moon = eph.string_to_planet("Moon") mercury = eph.string_to_planet("Mercury") venus = eph.string_to_planet("Venus") mars = eph.string_to_planet("Mars") jupiter = eph.string_to_planet("Jupiter") saturn = eph.string_to_planet("Saturn") uranus = eph.string_to_planet("Uranus") neptune = eph.string_to_planet("Neptune") pluto = eph.string_to_planet("Pluto") // Get longitude for each planet (geocentric) sun_lon = eph.get_longitude(sun, time, true) moon_lon = eph.get_longitude(moon, time, true) mercury_lon = eph.get_longitude(mercury, time, true) venus_lon = eph.get_longitude(venus, time, true) mars_lon = eph.get_longitude(mars, time, true) jupiter_lon = eph.get_longitude(jupiter, time, true) saturn_lon = eph.get_longitude(saturn, time, true) uranus_lon = eph.get_longitude(uranus, time, true) neptune_lon = eph.get_longitude(neptune, time, true) pluto_lon = eph.get_longitude(pluto, time, true) // Plot all planets plot(sun_lon, "Sun", color.yellow) plot(moon_lon, "Moon", color.silver) plot(mercury_lon, "Mercury", color.orange) plot(venus_lon, "Venus", color.green) plot(mars_lon, "Mars", color.red) plot(jupiter_lon, "Jupiter", color.purple) plot(saturn_lon, "Saturn", color.olive) plot(uranus_lon, "Uranus", color.aqua) plot(neptune_lon, "Neptune", color.blue) plot(pluto_lon, "Pluto", color.gray) ═══════════════════════════════════════════════════════════════ █ AVAILABLE FUNCTIONS Core Data Access: • string_to_planet(string) → Planet enum • get_longitude(Planet, time, preferGeo) → degrees [0, 360) • get_declination(Planet, time) → degrees • get_speed(Planet, time) → degrees/day • is_retrograde(Planet, time) → true/false Planetary Averages: • get_avg6_geo_lon(time) → 6 outer planets average • get_avg6_helio_lon(time) • get_avg8_geo_lon(time) → 8 classical planets average • get_avg8_helio_lon(time) Utility: • normalizeLongitude(lon) → normalize to [0, 360) ═══════════════════════════════════════════════════════════════ █ SUPPORTED PLANET STRINGS Works with symbols or plain names (case-insensitive): • "☉︎ Sun" or "Sun" • "☽︎ Moon" or "Moon" • "☿ Mercury" or "Mercury" • "♀ Venus" or "Venus" • "🜨 Earth" or "Earth" • "♂ Mars" or "Mars" • "♃ Jupiter" or "Jupiter" • "♄ Saturn" or "Saturn" • "⛢ Uranus" or "Uranus" • "♆ Neptune" or "Neptune" • "♇ Pluto" or "Pluto" ═══════════════════════════════════════════════════════════════ █ COORDINATE SYSTEMS Geocentric: Positions relative to Earth (default for Sun/Moon) Heliocentric: Positions relative to the Sun Use the preferGeo parameter in get_longitude(): • true = geocentric • false = heliocentric Sun and Moon always return geocentric (heliocentric not applicable). ═══════════════════════════════════════════════════════════════ █ FUTURE PROJECTIONS Project planetary positions into the future using polylines: import BlueprintResearch/lib_vsop_core/1 as core // Get future timestamp (250 bars ahead) future_time = core.get_future_time(time, 250) // Calculate future position future_lon = eph.get_longitude(mars, future_time, true) Use with polyline.new() to draw projected paths on your chart. See the commented showcase code in this library's source for a complete 250-bar projection example. ═══════════════════════════════════════════════════════════════ █ OPEN SOURCE This library is part of an open-source planetary ephemeris project. Free to use with attribution. MIT License. ═══════════════════════════════════════════════════════════════ █ REFERENCES • Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998) • Bretagnon & Francou. "VSOP87 Solutions" (1988) • Chapront-Touzé & Chapront. "ELP2000-82" (1983) ═══════════════════════════════════════════════════════════════ © 2025 BlueprintResearch (Javonnii) • MIT License @version=6 normalizeLongitude(lon)   Normalizes any longitude value to the range [0, 360) degrees.   Parameters:      lon (float) : (float) Longitude in degrees (can be any value, including negative or >360).   Returns: (float) Normalized longitude in range [0, 360). string_to_planet(planetStr)   Converts a planet string identifier to Planet enum value.   Parameters:      planetStr (string) : (string) Planet name (case-insensitive). Supports formats: "Sun", "☉︎ Sun", "sun", "SUN"   Returns: (Planet) Corresponding Planet enum. Returns Planet.Sun if string not recognized. @note Supported planet strings: Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto get_longitude(p, t, preferGeo)   Returns planetary longitude with automatic coordinate system selection.   Parameters:      p (series Planet) : (Planet) Planet to query.      t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).      preferGeo (bool) : (bool) If true, return geocentric; if false, return heliocentric.   Returns: (float) Longitude in degrees, normalized to range [0, 360). @note Sun and Moon always return geocentric regardless of preference (heliocentric not applicable). get_declination(p, t)   Returns planetary geocentric equatorial declination.   Parameters:      p (series Planet) : (Planet) Planet to query.      t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).   Returns: (float) Geocentric declination in degrees, range where positive is north. @note Declination is always geocentric (no heliocentric equivalent in library). get_speed(p, t)   Returns planetary geocentric longitude speed (rate of change).   Parameters:      p (series Planet) : (Planet) Planet to query.      t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion. Returns na for Moon. @note Speed is always geocentric (no heliocentric equivalent in library). Moon speed calculation not implemented. get_avg6_geo_lon(t)   get_avg6_geo_lon @description Returns the arithmetic average of the geocentric longitudes for the six outer planets: Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.   Parameters:      t (float) : (float) Time in Unix timestamp (milliseconds).   Returns: (float) Average geocentric longitude of the six outer planets in degrees, range [0, 360). get_avg6_helio_lon(t)   get_avg6_helio_lon @description Returns the arithmetic average of the heliocentric longitudes for the six outer planets: Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.   Parameters:      t (float) : (float) Time in Unix timestamp (milliseconds).   Returns: (float) Average heliocentric longitude of the six outer planets in degrees, range [0, 360). get_avg8_geo_lon(t)   get_avg8_geo_lon @description Returns the arithmetic average of the geocentric longitudes for all eight classical planets: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.   Parameters:      t (float) : (float) Time in Unix timestamp (milliseconds).   Returns: (float) Average geocentric longitude of all eight classical planets in degrees, range [0, 360). get_avg8_helio_lon(t)   get_avg8_helio_lon @description Returns the arithmetic average of the heliocentric longitudes for all eight classical planets: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.   Parameters:      t (float) : (float) Time in Unix timestamp (milliseconds).   Returns: (float) Average heliocentric longitude of all eight classical planets in degrees, range [0, 360). is_retrograde(p, t)   Returns true if the planet is currently in retrograde motion (geocentric speed < 0) == 0 = stationary.   Parameters:      p (series Planet) : The planet to check.      t (float) : Time in Unix timestamp (milliseconds).   Returns: true if the planet is in retrograde, false otherwise.
ไลบรารี Pine Script®
โดย BlueprintResearch
lib_vsop87_mercuryLibrary "lib_vsop87_mercury" Heliocentric and geocentric position calculations for Mercury using VSOP87 theory. Provides longitude, latitude, radius, speed, and declination functions. @author BlueprintResearch (Javonnii) @license MIT License - Free to use with attribution @theory VSOP87A (Heliocentric rectangular coordinates) @accuracy Truncated series (~10-15 terms per series) - arcsecond precision @time_scale Julian millennia from J2000.0 (use core.get_julian_millennia) @reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998) Bretagnon & Francou. "VSOP87 Solutions" (1988) @showcase Includes commented showcase code with 250-bar future projection. Uncomment to display Mercury data with polyline projections. @open_source This library is part of an open-source alternative to proprietary astronomical libraries. Study, modify, and share freely. We believe knowledge of the cosmos belongs to everyone. ════════════════════════════════════════════════════════════════ © 2025 BlueprintResearch / Javonnii Licensed under MIT License ════════════════════════════════════════════════════════════════ @version=6 import BlueprintResearch/lib_vsop_core/1 as core get_helio_lon(t)   Computes Mercury's heliocentric ecliptic longitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). get_helio_lat(t)   Computes Mercury's heliocentric ecliptic latitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees. get_helio_radius(t)   Computes Mercury's heliocentric radius (distance from Sun) using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 0.31-0.47 AU. get_geo_speed(t)   Computes Mercury's geocentric longitude speed (rate of change over time).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement). get_geo_lon(t)   Computes Mercury's geocentric ecliptic longitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360). get_geo_ecl_lat(t)   Computes Mercury's geocentric ecliptic latitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic latitude in degrees, range approximately . get_geo_decl(t)   Computes Mercury's geocentric equatorial declination (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
ไลบรารี Pine Script®
โดย BlueprintResearch
lib_vsop87_venusLibrary "lib_vsop87_venus" Heliocentric and geocentric position calculations for Venus using VSOP87 theory. Provides longitude, latitude, radius, speed, and declination functions. @author BlueprintResearch (Javonnii) @license MIT License - Free to use with attribution @theory VSOP87A (Heliocentric rectangular coordinates) @accuracy Truncated series (~10-15 terms per series) - arcsecond precision @time_scale Julian millennia from J2000.0 (use core.get_julian_millennia) @reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998) Bretagnon & Francou. "VSOP87 Solutions" (1988) @showcase Includes commented showcase code with 250-bar future projection. Uncomment to display Venus data with polyline projections. @open_source This library is part of an open-source alternative to proprietary astronomical libraries. Study, modify, and share freely. We believe knowledge of the cosmos belongs to everyone. ════════════════════════════════════════════════════════════════ © 2025 BlueprintResearch / Javonnii Licensed under MIT License ════════════════════════════════════════════════════════════════ @version=6 import BlueprintResearch/lib_vsop_core/1 as core get_helio_lon(t)   Computes Venus's heliocentric ecliptic longitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). get_helio_lat(t)   Computes Venus's heliocentric ecliptic latitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees. get_helio_radius(t)   Computes Venus's heliocentric radius (distance from Sun) using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 0.72-0.73 AU. get_geo_speed(t)   Computes Venus's geocentric longitude speed (rate of change over time).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement). get_geo_lon(t)   Computes Venus's geocentric ecliptic longitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360). get_geo_ecl_lat(t)   Computes Venus's geocentric ecliptic latitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic latitude in degrees, range approximately . get_geo_decl(t)   Computes Venus's geocentric equatorial declination (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
ไลบรารี Pine Script®
โดย BlueprintResearch
4
lib_elp2000_moonLibrary "lib_elp2000_moon" get_geo_ecl_lon(T)   Parameters:      T (float) get_geo_ecl_lat(T)   Parameters:      T (float) get_obliquity(T)   Parameters:      T (float) get_declination(T)   Parameters:      T (float) get_true_node_lon(T)   Parameters:      T (float) get_true_south_node_lon(T)   Parameters:      T (float) get_node_declination(T)   Parameters:      T (float) get_south_node_declination(T)   Parameters:      T (float)
ไลบรารี Pine Script®
โดย BlueprintResearch
lib_vsop87_marsLibrary "lib_vsop87_mars" get_helio_lon(t)   Computes Mars's heliocentric ecliptic longitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). get_helio_lat(t)   Computes Mars's heliocentric ecliptic latitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees. get_helio_radius(t)   Computes Mars's heliocentric radius (distance from Sun) using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 1.38-1.67 AU. get_geo_speed(t)   Computes Mars's geocentric longitude speed (rate of change over time).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement). get_geo_lon(t)   Computes Mars's geocentric ecliptic longitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360). get_geo_ecl_lat(t)   Computes Mars's geocentric ecliptic latitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic latitude in degrees, range approximately . get_geo_decl(t)   Computes Mars's geocentric equatorial declination (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
ไลบรารี Pine Script®
โดย BlueprintResearch
lib_vsop87_jupiterLibrary "lib_vsop87_jupiter" get_helio_lon(t)   Computes Jupiter's heliocentric ecliptic longitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). get_helio_lat(t)   Computes Jupiter's heliocentric ecliptic latitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees. get_helio_radius(t)   Computes Jupiter's heliocentric radius (distance from Sun) using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 4.95-5.46 AU. get_geo_speed(t)   Computes Jupiter's geocentric longitude speed (rate of change over time).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement). get_geo_lon(t)   Computes Jupiter's geocentric ecliptic longitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360). get_geo_ecl_lat(t)   Computes Jupiter's geocentric ecliptic latitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic latitude in degrees, range approximately . get_geo_decl(t)   Computes Jupiter's geocentric equatorial declination (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
ไลบรารี Pine Script®
โดย BlueprintResearch
lib_vsop87_saturnLibrary "lib_vsop87_saturn" get_helio_lon(t)   Computes Saturn's heliocentric ecliptic longitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). get_helio_lat(t)   Computes Saturn's heliocentric ecliptic latitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees. get_helio_radius(t)   Computes Saturn's heliocentric radius (distance from Sun) using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 9.02-10.05 AU. get_geo_speed(t)   Computes Saturn's geocentric longitude speed (rate of change over time).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement). get_geo_lon(t)   Computes Saturn's geocentric ecliptic longitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360). get_geo_ecl_lat(t)   Computes Saturn's geocentric ecliptic latitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic latitude in degrees, range approximately . get_geo_decl(t)   Computes Saturn's geocentric equatorial declination (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
ไลบรารี Pine Script®
โดย BlueprintResearch
lib_vsop87_uranusLibrary "lib_vsop87_uranus" Heliocentric and geocentric position calculations for Uranus using VSOP87 theory. Provides longitude, latitude, radius, speed, and declination functions. @author BlueprintResearch (Javonnii) @license MIT License - Free to use with attribution @theory VSOP87A (Heliocentric rectangular coordinates) @accuracy Truncated series (~10-15 terms per series) - arcsecond precision @time_scale Julian millennia from J2000.0 (use core.get_julian_millennia) @reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998) Bretagnon & Francou. "VSOP87 Solutions" (1988) @showcase Includes commented showcase code with 250-bar future projection. Uncomment to display Uranus data with polyline projections. @open_source This library is part of an open-source alternative to proprietary astronomical libraries. Study, modify, and share freely. We believe knowledge of the cosmos belongs to everyone. ════════════════════════════════════════════════════════════════ © 2025 BlueprintResearch / Javonnii Licensed under MIT License ════════════════════════════════════════════════════════════════ @version=6 import BlueprintResearch/lib_vsop_core/1 as core get_helio_lon(t)   Computes Uranus's heliocentric ecliptic longitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). get_helio_lat(t)   Computes Uranus's heliocentric ecliptic latitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees. get_helio_radius(t)   Computes Uranus's heliocentric radius (distance from Sun) using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 18.28-20.09 AU. get_geo_speed(t)   Computes Uranus's geocentric longitude speed (rate of change over time).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement). get_geo_lon(t)   Computes Uranus's geocentric ecliptic longitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360). get_geo_ecl_lat(t)   Computes Uranus's geocentric ecliptic latitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic latitude in degrees, range approximately . get_geo_decl(t)   Computes Uranus's geocentric equatorial declination (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
ไลบรารี Pine Script®
โดย BlueprintResearch
lib_vsop87_neptuneLibrary "lib_vsop87_neptune" Heliocentric and geocentric position calculations for Neptune using VSOP87 theory. Provides longitude, latitude, radius, speed, and declination functions. @author BlueprintResearch (Javonnii) @license MIT License - Free to use with attribution @theory VSOP87A (Heliocentric rectangular coordinates) @accuracy Truncated series (~10-15 terms per series) - arcsecond precision @time_scale Julian millennia from J2000.0 (use core.get_julian_millennia) @reference Meeus, Jean. "Astronomical Algorithms" (2nd Ed., 1998) Bretagnon & Francou. "VSOP87 Solutions" (1988) @showcase Includes commented showcase code with 250-bar future projection. Uncomment to display Neptune data with polyline projections. @open_source This library is part of an open-source alternative to proprietary astronomical libraries. Study, modify, and share freely. We believe knowledge of the cosmos belongs to everyone. ════════════════════════════════════════════════════════════════ © 2025 BlueprintResearch / Javonnii Licensed under MIT License ════════════════════════════════════════════════════════════════ @version=6 import BlueprintResearch/lib_vsop_core/1 as core get_helio_lon(t)   Computes Neptune's heliocentric ecliptic longitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic longitude in degrees, normalized to range [0, 360). get_helio_lat(t)   Computes Neptune's heliocentric ecliptic latitude using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric ecliptic latitude in radians, range approximately . Note: Returns radians, not degrees. get_helio_radius(t)   Computes Neptune's heliocentric radius (distance from Sun) using VSOP87 theory.   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Heliocentric radius in astronomical units (AU). Typical range is 29.81-30.33 AU. get_geo_speed(t)   Computes Neptune's geocentric longitude speed (rate of change over time).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion (apparent backward movement). get_geo_lon(t)   Computes Neptune's geocentric ecliptic longitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic longitude in degrees, normalized to range [0, 360). get_geo_ecl_lat(t)   Computes Neptune's geocentric ecliptic latitude (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric ecliptic latitude in degrees, range approximately . get_geo_decl(t)   Computes Neptune's geocentric equatorial declination (as seen from Earth).   Parameters:      t (float) : (float) Julian millennia from J2000.0 (use core.get_julian_millennia(time)).   Returns: (float) Geocentric equatorial declination in degrees, range where positive is north.
ไลบรารี Pine Script®
โดย BlueprintResearch