Şimdi başlat

Inputs

MRScoringLibraryLibrary "MRScoringLibrary" Mean-reversion graduated scoring: z-score any indicator into -3 to +3 integer scale. mrScore(src, lookback, alreadyZ, invert)   Converts any continuous indicator value into a graduated mean-reversion score from -3 (deep overbought) to +3 (deep oversold).   Parameters:      src (float) : Raw indicator value (or z-score if alreadyZ=true)      lookback (int) : Rolling lookback for z-score calc (ignored if alreadyZ=true)      alreadyZ (bool) : True if src is already a z-score — skips internal z-scoring      invert (bool) : True if HIGH indicator value = oversold (flips mapping)   Returns: Integer score: +3 to -3 zScore(src, lookback)   Returns the raw z-score without mapping to graduated scale. Useful for plotting or custom threshold logic.   Parameters:      src (float) : Raw indicator value      lookback (int) : Rolling lookback period   Returns: Float z-score mrScoreCustom(src, lookback, alreadyZ, invert, sd1, sd2, sd3)   Same as mrScore but with configurable SD band edges. For indicators where standard 1/2/3 SD bands don't fit well (e.g., an indicator only becomes useful at 1.5 SD).   Parameters:      src (float) : Raw indicator value (or z-score if alreadyZ=true)      lookback (int) : Rolling lookback for z-score calc      alreadyZ (bool) : True if src is already a z-score      invert (bool) : True if HIGH value = oversold      sd1 (float) : Inner band threshold (default would be 1.0)      sd2 (float) : Middle band threshold (default would be 2.0)      sd3 (float) : Outer band threshold (default would be 3.0)   Returns: Integer score: +3 to -3
Pine Script® kütüphanesi
Rafe-Promachos-LLP tarafından
MRTestingLibraryLibrary "MRTestingLibrary" Mean-reversion graduated scoring: z-score any indicator into -3 to +3 integer scale. mrScore(src, lookback, alreadyZ, invert)   Converts any continuous indicator value into a graduated mean-reversion score from -3 (deep overbought) to +3 (deep oversold).   Parameters:      src (float) : Raw indicator value (or z-score if alreadyZ=true)      lookback (int) : Rolling lookback for z-score calc (ignored if alreadyZ=true)      alreadyZ (bool) : True if src is already a z-score — skips internal z-scoring      invert (bool) : True if HIGH indicator value = oversold (flips mapping)   Returns: Integer score: +3 to -3 zScore(src, lookback)   Returns the raw z-score without mapping to graduated scale. Useful for plotting or custom threshold logic.   Parameters:      src (float) : Raw indicator value      lookback (int) : Rolling lookback period   Returns: Float z-score mrScoreCustom(src, lookback, alreadyZ, invert, sd1, sd2, sd3)   Same as mrScore but with configurable SD band edges. For indicators where standard 1/2/3 SD bands don't fit well (e.g., an indicator only becomes useful at 1.5 SD).   Parameters:      src (float) : Raw indicator value (or z-score if alreadyZ=true)      lookback (int) : Rolling lookback for z-score calc      alreadyZ (bool) : True if src is already a z-score      invert (bool) : True if HIGH value = oversold      sd1 (float) : Inner band threshold (default would be 1.0)      sd2 (float) : Middle band threshold (default would be 2.0)      sd3 (float) : Outer band threshold (default would be 3.0)   Returns: Integer score: +3 to -3
Pine Script® kütüphanesi
Rafe-Promachos-LLP tarafından
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® kütüphanesi
Vantage-Stack tarafından
BASCOOL_LibBASCOOL Library v1 Range–Body Structure Analysis Toolkit for Intraday Trading The BASCOOL Library provides high-quality, reusable Pine Script components for structural conviction analysis based purely on price action. It is designed for intraday traders who rely on volatility-adjusted range expansion and candle-body efficiency to identify strong, weak, or choppy market conditions. Included Functions rbm_from_ohlc() – Range–Body Measure (RBM) A volatility-normalized structure indicator that evaluates: Range Expansion: Smooth EMA of (High–Low), normalized by ATR → captures strength of movement relative to volatility Body Efficiency: Body-to-Range ratio smoothed with EMA → measures how much of the candle’s range is “directional” The RBM output is a smooth structural strength score typically between 0 and 1, where: High RBM → strong structure, clean movement, trend-friendly conditions Low RBM → compressed ranges, weak bodies, low-quality structure Flat RBM → choppy environment, avoid directional trades
Pine Script® kütüphanesi
gokul4trading tarafından
Input Library [1CG]Input Library (v1) – User Guide Overview The Input Library is a Pine Script® v6 utility library that standardizes and simplifies common user input patterns across indicators, strategies, and libraries. It provides: Predefined timezone enums mapped to IANA/Olson strings 24-hour and 60-minute enumerations Standardized line styles, sizes, label styles, and box alignment options Helper methods for converting enums into TradingView constants Utility functions for time formatting and span calculations This library is designed to: Reduce repetitive input boilerplate Improve UI consistency across scripts Prevent string-based input errors Encourage clean, readable configuration logic Library Declaration To use the library in your script: //@version=6 import OneCleverGuy/InputLibrary/1 as IL Timezone Enums Timezones Provides a comprehensive list of IANA timezone identifiers using short, intuitive enum names. Examples include: utc → "UTC" exch → Exchange timezone (syminfo.timezone) ny → "America/New_York" lon → "Europe/London" tokyo → "Asia/Tokyo" syd → "Australia/Sydney" Method: timezoneToString() Resolves the enum to a valid timezone string. tzString = tzInput.timezoneToString() Behavior: If Timezones.exch is selected, returns syminfo.timezone Otherwise returns the mapped IANA timezone string Time Formatting Enums hours Represents 24-hour values from "00" through "23". minutes Represents minute values from "00" through "59". Function: combineTime() Combines hour and minute enums into a "HHMM" formatted string. sessionTime = IL.combineTime(hourInput, minuteInput) Example output: "0930" "1600" Drawing Style Enums The library standardizes visual input options and converts them into TradingView constants. LineStyle solid dotted dashed lArrow rArrow bArrow Method: lineStyle() lineStyleValue = styleInput.lineStyle() LineSize thin → 1px normal → 2px heavy → 3px thick → 4px wide → 5px Method: lineSize() width = sizeInput.lineSize() TextSize auto tiny small normal large huge Method: textSize() textSizeValue = textSizeInput.textSize() Box Alignment Enums BoxHAlign left center right BoxVAlign top center bottom Methods: hAlign = hAlignInput.boxHAlign() vAlign = vAlignInput.boxVAlign() Line Extension LineExtend none right left both Method: lineExtend() extendValue = extendInput.lineExtend() Label Styles LabelStyle center down left right up lowLeft lowRight upperLeft upperRight Method: labelStyle() labelStyleValue = labelInput.labelStyle() String-Based Conversion Helpers For compatibility with legacy scripts or string inputs: lineStyleFromString() lineSizeFromString() These functions convert common string descriptions into valid TradingView constants. Timezone Offset Utility Function: getTZOffset() Calculates the difference between a specified timezone and UTC. offset = IL.getTZOffset("America/New_York") Returns: Millisecond difference between UTC and the specified timezone Accounts for daylight saving time Time Span Utility Function: timeSpan() Converts common span names into milliseconds. Supported values: "Minute" "Half Hour" "Hour" "4 Hours" "8 Hours" "12 Hours" "Day" "Week" Example: ms = IL.timeSpan("Hour") Best Practices Prefer enums over raw strings for safer configuration Use conversion methods directly on enum inputs Standardize visual settings across scripts using shared enums Avoid hardcoding timezone strings where possible Limitations timeSpan() supports predefined span names only getTZOffset() returns raw millisecond difference, not formatted hours Library does not enforce input validation beyond enum constraints Summary The Input Library centralizes common input patterns into a reusable, structured framework. It improves script consistency, reduces UI friction, and ensures proper conversion between user selections and TradingView internal constants. Designed for Pine Script® v6.
Pine Script® kütüphanesi
OneCleverGuy tarafından
CLLibrary "CL" Common Library method updateRealBodyPrices(candle)   Namespace types: TCandle   Parameters:      candle (TCandle) method indexOfBarIndex(candle_array, barIndex)   Namespace types: array   Parameters:      candle_array (array)      barIndex (int) method getCandleByBarIndex(candle_array, barIndex)   Namespace types: array   Parameters:      candle_array (array)      barIndex (int) newCandleSet(tickerid, timeframe)   Parameters:      tickerid (string)      timeframe (string) method copyTo(src, dest)   Namespace types: TPivot   Parameters:      src (TPivot)      dest (TPivot) method copyTo(src, dest)   Namespace types: TTrendReversalPoint   Parameters:      src (TTrendReversalPoint)      dest (TTrendReversalPoint) method copyPivotHL_LHtoFirst(trp)   Namespace types: TTrendReversalPoint   Parameters:      trp (TTrendReversalPoint) newPoolManager() method newCandleFromPool(poolManager)   Namespace types: TPoolManager   Parameters:      poolManager (TPoolManager) method newPivotFromPool(poolManager)   Namespace types: TPoolManager   Parameters:      poolManager (TPoolManager) method newTrendReversalPointFromPool(poolManager)   Namespace types: TPoolManager   Parameters:      poolManager (TPoolManager) method newTrendReversalPoint(poolManager, trendDirection, barIndex, barIndex_ctf, time_reversal)   Namespace types: TPoolManager   Parameters:      poolManager (TPoolManager)      trendDirection (int)      barIndex (int)      barIndex_ctf (int)      time_reversal (int) TCandle   Fields:      barIndex (series int)      timeOpen (series int)      timeClose (series int)      open (series float)      high (series float)      low (series float)      close (series float)      isFixed (series bool)      realBodyUpperPrice (series float)      realBodyLowerPrice (series float)      barIndex_ctf (series int) TCandleSet   Fields:      tickerid (series string)      timeframe (series string)      currentCandle (TCandle)      lastFixedCandle (TCandle)      candleArray (array)      minBarIndex (series int)      minCandleCount (series int) TPivot   Fields:      barIndex (series int)      price (series float)      isHigh (series bool)      isFixed (series bool)      barIndex_ctf (series int)      timeOpen (series int) TTrendReversalPoint   Fields:      id (series int)      trendDirection (series int)      barIndex (series int)      price_Highest (series float)      barIndex_Highest (series int)      barIndex_ctf_Highest (series int)      price_Lowest (series float)      barIndex_Lowest (series int)      barIndex_ctf_Lowest (series int)      price_HigherLow (series float)      barIndex_HigherLow (series int)      barIndex_ctf_HigherLow (series int)      price_LowerHigh (series float)      barIndex_LowerHigh (series int)      barIndex_ctf_LowerHigh (series int)      price_FirstHigherLow (series float)      barIndex_FirstHigherLow (series int)      barIndex_ctf_FirstHigherLow (series int)      price_FirstLowerHigh (series float)      barIndex_FirstLowerHigh (series int)      barIndex_ctf_FirstLowerHigh (series int)      isDeleted (series bool)      barIndex_Created_ctf (series int)      barIndex_Deleted_ctf (series int)      barIndex_ctf (series int)      timeReversal (series int)      barIndexValid (series int)      barIndexSnapshotValid (series int) TPoolManager   Fields:      all_candle (array)      pool_candle (array)      all_pivot (array)      pool_pivot (array)      all_trp (array)      pool_trp (array)
Pine Script® kütüphanesi
koh1_konno tarafından
moving_averages# MovingAverages Library - PineScript v6 A comprehensive PineScript v6 library containing **50+ Moving Average calculations** for TradingView. --- ## 📦 Installation ```pinescript import TheTradingSpiderMan/moving_averages/1 as MA ``` --- ## 📊 All Available Moving Averages (50+) ### Basic Moving Averages | Function | Selector Key | Description | | -------- | ------------ | ------------------------------------------ | | `sma()` | `SMA` | Simple Moving Average - arithmetic mean | | `ema()` | `EMA` | Exponential Moving Average | | `wma()` | `WMA` | Weighted Moving Average | | `vwma()` | `VWMA` | Volume Weighted Moving Average | | `rma()` | `RMA` | Relative/Smoothed Moving Average | | `smma()` | `SMMA` | Smoothed Moving Average (alias for RMA) | | `swma()` | - | Symmetrically Weighted MA (4-period fixed) | ### Hull Family | Function | Selector Key | Description | | -------- | ------------ | ------------------------------- | | `hma()` | `HMA` | Hull Moving Average | | `ehma()` | `EHMA` | Exponential Hull Moving Average | ### Double/Triple Smoothed | Function | Selector Key | Description | | -------------- | ------------ | --------------------------------- | | `dema()` | `DEMA` | Double Exponential Moving Average | | `tema()` | `TEMA` | Triple Exponential Moving Average | | `tma()` | `TMA` | Triangular Moving Average | | `t3()` | `T3` | Tillson T3 Moving Average | | `twma()` | `TWMA` | Triple Weighted Moving Average | | `swwma()` | `SWWMA` | Smoothed Weighted Moving Average | | `trixSmooth()` | `TRIXSMOOTH` | Triple EMA Smoothed | ### Zero/Low Lag | Function | Selector Key | Description | | --------- | ------------ | ----------------------------------- | | `zlema()` | `ZLEMA` | Zero Lag Exponential MA | | `lsma()` | `LSMA` | Least Squares Moving Average | | `epma()` | `EPMA` | Endpoint Moving Average | | `ilrs()` | `ILRS` | Integral of Linear Regression Slope | ### Adaptive Moving Averages | Function | Selector Key | Description | | ---------- | ------------ | ------------------------------- | | `kama()` | `KAMA` | Kaufman Adaptive Moving Average | | `frama()` | `FRAMA` | Fractal Adaptive Moving Average | | `vidya()` | `VIDYA` | Variable Index Dynamic Average | | `vma()` | `VMA` | Variable Moving Average | | `vama()` | `VAMA` | Volume Adjusted Moving Average | | `rvma()` | `RVMA` | Rolling VMA | | `apexMA()` | `APEXMA` | Apex Moving Average | ### Ehlers Filters | Function | Selector Key | Description | | ----------------- | --------------- | --------------------------------- | | `superSmoother()` | `SUPERSMOOTHER` | Ehlers Super Smoother | | `butterworth2()` | `BUTTERWORTH2` | 2-Pole Butterworth Filter | | `butterworth3()` | `BUTTERWORTH3` | 3-Pole Butterworth Filter | | `instantTrend()` | `INSTANTTREND` | Ehlers Instantaneous Trendline | | `edsma()` | `EDSMA` | Deviation Scaled Moving Average | | `mama()` | `MAMA` | Mesa Adaptive Moving Average | | `fama()` | `FAMAVAL` | Following Adaptive Moving Average | ### Laguerre Family | Function | Selector Key | Description | | -------------------- | ------------------ | ------------------------ | | `laguerreFilter()` | `LAGUERRE` | Laguerre Filter | | `adaptiveLaguerre()` | `ADAPTIVELAGUERRE` | Adaptive Laguerre Filter | ### Special Weighted | Function | Selector Key | Description | | ---------- | ------------ | -------------------------------- | | `alma()` | `ALMA` | Arnaud Legoux Moving Average | | `sinwma()` | `SINWMA` | Sine Weighted Moving Average | | `gwma()` | `GWMA` | Gaussian Weighted Moving Average | | `nma()` | `NMA` | Natural Moving Average | ### Jurik/McGinley/Coral | Function | Selector Key | Description | | ------------ | ------------ | --------------------- | | `jma()` | `JMA` | Jurik Moving Average | | `mcginley()` | `MCGINLEY` | McGinley Dynamic | | `coral()` | `CORAL` | Coral Trend Indicator | ### Mean Types | Function | Selector Key | Description | | -------------- | ------------ | ------------------------- | | `medianMA()` | `MEDIANMA` | Median Moving Average | | `gma()` | `GMA` | Geometric Moving Average | | `harmonicMA()` | `HARMONICMA` | Harmonic Moving Average | | `trimmedMA()` | `TRIMMEDMA` | Trimmed Moving Average | | `cma()` | `CMA` | Cumulative Moving Average | ### Volume-Based | Function | Selector Key | Description | | --------- | ------------ | -------------------------- | | `evwma()` | `EVWMA` | Elastic Volume Weighted MA | ### Other Specialized | Function | Selector Key | Description | | ----------------- | --------------- | --------------------------- | | `hwma()` | `HWMA` | Holt-Winters Moving Average | | `gdema()` | `GDEMA` | Generalized DEMA | | `rema()` | `REMA` | Regularized EMA | | `modularFilter()` | `MODULARFILTER` | Modular Filter | | `rmt()` | `RMT` | Recursive Moving Trendline | | `qrma()` | `QRMA` | Quadratic Regression MA | | `wilderSmooth()` | `WILDERSMOOTH` | Welles Wilder Smoothing | | `leoMA()` | `LEOMA` | Leo Moving Average | | `ahrensMA()` | `AHRENSMA` | Ahrens Moving Average | | `runningMA()` | `RUNNINGMA` | Running Moving Average | | `ppoMA()` | `PPOMA` | PPO-based Moving Average | | `fisherMA()` | `FISHERMA` | Fisher Transform MA | --- ## 🎯 Helper Functions | Function | Description | | ---------------- | ------------------------------------------------------------- | | `wcp()` | Weighted Close Price: (H+L+2\*C)/4 | | `typicalPrice()` | Typical Price: (H+L+C)/3 | | `medianPrice()` | Median Price: (H+L)/2 | | `selector()` | **Master selector** - choose any MA by string name | | `getAllTypes()` | Returns all supported MA type names as comma-separated string | --- ## 🔧 Usage Examples ### Basic Usage ```pinescript //@version=6 indicator("MA Example") import quantablex/moving_averages/1 as MA // Simple calls plot(MA.sma(close, 20), "SMA 20", color.blue) plot(MA.ema(close, 20), "EMA 20", color.red) plot(MA.hma(close, 20), "HMA 20", color.green) ``` ### Using the Selector Function (50+ MA Types) ```pinescript //@version=6 indicator("MA Selector") import quantablex/moving_averages/1 as MA // Full list of all supported types: // SMA,EMA,WMA,VWMA,RMA,SMMA,HMA,EHMA,DEMA,TEMA,TMA,T3,TWMA,SWWMA,TRIXSMOOTH, // ZLEMA,LSMA,EPMA,ILRS,KAMA,FRAMA,VIDYA,VMA,VAMA,RVMA,APEXMA,SUPERSMOOTHER, // BUTTERWORTH2,BUTTERWORTH3,INSTANTTREND,EDSMA,LAGUERRE,ADAPTIVELAGUERRE, // ALMA,SINWMA,GWMA,NMA,JMA,MCGINLEY,CORAL,MEDIANMA,GMA,HARMONICMA,TRIMMEDMA, // EVWMA,HWMA,GDEMA,REMA,MODULARFILTER,RMT,QRMA,WILDERSMOOTH,LEOMA,AHRENSMA, // RUNNINGMA,PPOMA,MAMA,FAMAVAL,FISHERMA,CMA maType = input.string("EMA", "MA Type", options= ) length = input.int(20, "Length") plot(MA.selector(close, length, maType), "Selected MA", color.orange) ``` ### Advanced Moving Averages ```pinescript //@version=6 indicator("Advanced MAs") import quantablex/moving_averages/1 as MA // ALMA with custom offset and sigma plot(MA.alma(close, 20, 0.85, 6), "ALMA", color.purple) // KAMA with custom fast/slow periods plot(MA.kama(close, 10, 2, 30), "KAMA", color.teal) // T3 with custom volume factor plot(MA.t3(close, 20, 0.7), "T3", color.yellow) // Laguerre Filter with custom gamma plot(MA.laguerreFilter(close, 0.8), "Laguerre", color.lime) ``` --- ## 📈 MA Selection Guide | Use Case | Recommended MAs | | ---------------------- | ------------------------------------------- | | **Trend Following** | EMA, DEMA, TEMA, HMA, CORAL | | **Low Lag Required** | ZLEMA, HMA, EHMA, JMA, LSMA | | **Volatile Markets** | KAMA, VIDYA, FRAMA, VMA, ADAPTIVELAGUERRE | | **Smooth Signals** | T3, LAGUERRE, SUPERSMOOTHER, BUTTERWORTH2/3 | | **Support/Resistance** | SMA, WMA, TMA, MEDIANMA | | **Scalping** | MCGINLEY, ZLEMA, HMA, INSTANTTREND | | **Noise Reduction** | MAMA, EDSMA, GWMA, TRIMMEDMA | | **Volume-Based** | VWMA, EVWMA, VAMA | --- ## ⚙️ Parameters Reference ### Common Parameters - `src` - Source series (close, open, hl2, hlc3, etc.) - `len` - Period length (integer) ### Special Parameters - `alma()`: `offset` (0-1), `sigma` (curve shape) - `kama()`: `fastLen`, `slowLen` - `t3()`: `vFactor` (volume factor) - `jma()`: `phase` (-100 to 100) - `laguerreFilter()`: `gamma` (0-1 damping) - `rema()`: `lambda` (regularization) - `modularFilter()`: `beta` (sensitivity) - `gdema()`: `mult` (multiplier, 2 = standard DEMA) - `trimmedMA()`: `trimPct` (0-0.5, percentage to trim) - `mama()/fama()`: `fastLimit`, `slowLimit` - `adaptiveLaguerre()`: Uses `len` for adaptation period --- ## 📝 Notes - All 50+ functions are exported for use in any PineScript v6 indicator/strategy - The `selector()` function supports **all MA types** via string key - Use `getAllTypes()` to get a comma-separated list of all supported MA names - Some MAs (CMA, INSTANTTREND, LAGUERRE, MAMA) don't use `len` parameter - Use `nz()` wrapper if handling potential NA values in your calculations --- **Author:** thetradingspiderman **Version:** 1.0 **PineScript Version:** 6 **Total MA Types:** 50+
Pine Script® kütüphanesi
TheTradingSpiderMan tarafından
ArgentinaBondsLib - Argentina Sovereign Bonds Cashflow LibraryArgentinaBondsLib A Pine Script v6 library providing cashflow data and financial calculation functions for Argentine sovereign bonds (Bonares and Globales). ## Supported Bonds **Bonares** (Argentina legislation, USD MEP): AE38, AL29, AL30, AL35, AL41, AN29 **Globales** (Foreign legislation, USD Cable): GD29, GD30, GD35, GD38, GD41, GD46 ## Exported Functions ### Cashflow Data - `getCashflows_ ()` - Returns timestamps, cashflows, and count for each bond ### Bond Identification - `getBondType(ticker)` - Returns BONAR() or GLOBAL() - `getBaseTicker(ticker)` - Extracts base ticker without prefix/suffix - `getCurrencyType(ticker)` - Returns 0=ARS, 1=MEP, 2=Cable - `isSupported(baseTicker)` - Checks if bond is supported ### Financial Calculations - `calcPV()` - Present Value calculation - `calcIRR()` - Internal Rate of Return using Newton-Raphson method - `calcPriceFromIRR()` - Calculate price from target IRR ### Currency Conversion - `convertToNativeCurrency()` - Converts price to cashflow currency (MEP for Bonares, Cable for Globales) ### Utilities - `getSettlementDate()` - Returns T+1 timestamp - `BONAR()` / `GLOBAL()` - Bond type constants ## Methodology - Day count convention: Actual/365 - Settlement: T+1 - IRR solver: Newton-Raphson iterative method ## Usage Example ``` import EcoValores/ArgentinaBondsLib/1 as Bonds = Bonds.getCashflows_AL30() settlementDate = Bonds.getSettlementDate() irr = Bonds.calcIRR(ts, cf, count, settlementDate, close) ``` --- ## Español Librería Pine Script v6 con datos de flujos de fondos y funciones de cálculo financiero para bonos soberanos argentinos. ### Bonos Soportados - **Bonares** (Legislación argentina, USD MEP): AE38, AL29, AL30, AL35, AL41, AN29 - **Globales** (Legislación extranjera, USD Cable): GD29, GD30, GD35, GD38, GD41, GD46 ### Metodología - Convención de días: Actual/365 - Liquidación: T+1 - Solver TIR: Método iterativo Newton-Raphson --- **DISCLAIMER**: This library is for informational and educational purposes only. Eco Valores S.A. does NOT provide investment advice or recommendations. Consult a qualified financial advisor before making investment decisions. **AVISO LEGAL**: Esta librería es solo para fines informativos y educativos. Eco Valores S.A. NO brinda asesoramiento ni recomendaciones de inversión. Consulte con un asesor financiero calificado antes de invertir.
Pine Script® kütüphanesi
Eco Valores tarafından
HSLevelsLibPubLibrary "HSLevelsLibPub" Centralized levels library for Heatseeker trading system. Update levels HERE ONCE - all consuming scripts auto-refresh. getVIXThresholds()   Returns VIX threshold levels for regime determination   Returns: as tuple of floats getVIXThresholdsCSV()   Returns VIX thresholds as CSV strings   Returns: as tuple of strings getExpiry()   Returns current options expiry date in YYMMDD format   Returns: string in YYMMDD format (e.g., "260108" for Jan 8, 2026) getAnchorStrike(symbol)   Returns the anchor strike price for a given symbol   Parameters:      symbol (simple string) : The ticker symbol (SPY, QQQ, SPX, VIX)   Returns: float anchor strike price getFractalPrices(symbol)   Returns fractal level prices as CSV for a symbol   Parameters:      symbol (simple string) : The ticker symbol (SPY, QQQ, SPX)   Returns: string of comma-separated prices getFractalLabels(symbol)   Returns fractal level labels as CSV for a symbol   Parameters:      symbol (simple string) : The ticker symbol (SPY, QQQ, SPX)   Returns: string of comma-separated labels getFractalLevels(symbol)   Returns both fractal prices and labels as CSV tuple   Parameters:      symbol (simple string) : The ticker symbol   Returns: tuple getAnchorStrikeAuto()   Auto-detect symbol and return appropriate anchor strike   Returns: float anchor strike for current chart symbol getFractalLevelsAuto()   Auto-detect symbol and return fractal levels   Returns: for current chart symbol getAllData(symbol)   Get all data for a symbol in one call   Parameters:      symbol (simple string) : The ticker symbol   Returns: getVersion()   Returns library version and last update timestamp   Returns: string with version info
Pine Script® kütüphanesi
DashingBixby tarafından
LECAPS_BONCAP_LibraryLibrary "LECAPS_BONCAP_Library" getInstrumentCount() getTicker(index)   Parameters:      index (int) getTickerShort(index)   Parameters:      index (int) getMaturityPrice(index)   Parameters:      index (int) getMaturityTimestamp(index)   Parameters:      index (int) getMaturityYear(index)   Parameters:      index (int) getMaturityMonth(index)   Parameters:      index (int) getMaturityDay(index)   Parameters:      index (int) isBoncap(index)   Parameters:      index (int) isLecap(index)   Parameters:      index (int) getInstrumentType(index)   Parameters:      index (int) getDolarFuturesCount() getDolarFuturesTicker(index)   Parameters:      index (int) getDolarFuturesShort(index)   Parameters:      index (int) getDolarFuturesExpiry(index)   Parameters:      index (int) getDaysToMaturity(index)   Parameters:      index (int) getDataSummary(index)   Parameters:      index (int)
Pine Script® kütüphanesi
Eco Valores tarafından
QuickInputsLevelParserLibrary "QuickInputsLevelParser" Provides a parsing library that indicator authors can use in order to parse Quick Inputs Levels. parseLevels(s)   Parses the string content and returns the `QILevels` found within.   Parameters:      s (string) : The string to parse.   Returns: The parsed WTD levels. zoneRange   Fields:      high (series float)      low (series float) QILevels   Fields:      supplyLines (array)      supplyZones (array)      majorLines (array)      onZones (array)      onLines (array)      highLines (array)      lowLines (array)      htfZones (array)      mansupLines (array)      mansupmajLines (array)      mansupZones (array)      mansupmajZones (array)      manresLines (array)      manresmajLines (array)      manresZones (array)      manresmajZones (array)
Pine Script® kütüphanesi
jmutrades tarafından
fibonacci2Library "fibonacci2" Useful methods to calculate and display fibonacci retracement modelParamsNew(point_0, point_1)   Parameters:      point_0 (chart.point)      point_1 (chart.point) modelParamsNew(this, point_0, point_1)   Parameters:      this (viewParams)      point_0 (chart.point)      point_1 (chart.point) method toModelParams(this, point_0, point_1)   Namespace types: viewParams   Parameters:      this (viewParams)      point_0 (chart.point)      point_1 (chart.point) method createModel(params)   Namespace types: modelParams   Parameters:      params (modelParams) method createView(this, params)   Namespace types: model   Parameters:      this (model)      params (viewParams) method delete(view)   Namespace types: view   Parameters:      view (view) levelModelParams   Fields:      level (series float) levelViewParams   Fields:      level (series float)      color (series color)      line_width (series int)      line_style (series lineStyleEnum enum from Hamster-Coder/drawing/1) levelModel   Represents a Fibonacci retracement level   Fields:      level (series float) : The Fibonacci level ratio (e.g., 0.382, 0.5, 0.618)      value (series float) : The Y-coordinate on the chart corresponding to this level modelParams   Represents the full parameter set for the Fibonacci retracement model   Fields:      point_1 (chart.point) : Coordinates of the anchor Point (1) of the model      point_0 (chart.point) : Coordinates of the anchor Point (0) of the model      levels (array) : List of levels to display for this model model   Fields:      point_1 (chart.point)      point_0 (chart.point)      levels (array) viewParams   Fields:      levels (array)      x1 (series int)      x2 (series int)      xloc (series string)      show_level_value (series bool)      value_format (series string)      force_overlay (series bool) view   Fields:      model (model)      lines (array)      labels (array)
Pine Script® kütüphanesi
Hamster-Coder tarafından
drawingLibrary "drawing" Contains common types and methods to draw objects on the chart. method toTextAlign(input)   Namespace types: series textHorizontalAlignEnum   Parameters:      input (series textHorizontalAlignEnum) method toTextAlign(input)   Namespace types: series textVertialAlignEnum   Parameters:      input (series textVertialAlignEnum) method toSize(input)   Namespace types: series sizeEnum   Parameters:      input (series sizeEnum) method toStyle(input)   Namespace types: series lineStyleEnum   Parameters:      input (series lineStyleEnum)
Pine Script® kütüphanesi
Hamster-Coder tarafından
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® kütüphanesi
n00btraders tarafından
2
AlgebraGeometryLabLibrary "AlgebraGeometryLab" Algebra & 2D geometry utilities absent from Pine built-ins. Rigorous, no-repaint, export-ready: vectors, robust roots, linear solvers, 2x2/3x3 det/inverse, symmetric 2x2 eigensystem, orthogonal regression (TLS), affine transforms, intersections, distances, projections, polygon metrics, point-in-polygon, convex hull (monotone chain), Bezier/Catmull-Rom/Barycentric tools. clamp(x, lo, hi)   clamp to   Parameters:      x (float)      lo (float)      hi (float) near(a, b, atol, rtol)   approximately equal with relative+absolute tolerance   Parameters:      a (float)      b (float)      atol (float)      rtol (float) sgn(x)   sign as {-1,0,1}   Parameters:      x (float) hypot(x, y)   stable hypot (sqrt(x^2+y^2))   Parameters:      x (float)      y (float) method length(v)   Namespace types: Vec2   Parameters:      v (Vec2) method length2(v)   Namespace types: Vec2   Parameters:      v (Vec2) method normalized(v)   Namespace types: Vec2   Parameters:      v (Vec2) method add(a, b)   Namespace types: Vec2   Parameters:      a (Vec2)      b (Vec2) method sub(a, b)   Namespace types: Vec2   Parameters:      a (Vec2)      b (Vec2) method muls(v, s)   Namespace types: Vec2   Parameters:      v (Vec2)      s (float) method dot(a, b)   Namespace types: Vec2   Parameters:      a (Vec2)      b (Vec2) method crossz(a, b)   Namespace types: Vec2   Parameters:      a (Vec2)      b (Vec2) method rotate(v, ang)   Namespace types: Vec2   Parameters:      v (Vec2)      ang (float) method apply(v, T)   Namespace types: Vec2   Parameters:      v (Vec2)      T (Affine2) affine_identity()   identity transform affine_translate(tx, ty)   translation   Parameters:      tx (float)      ty (float) affine_rotate(ang)   rotation about origin   Parameters:      ang (float) affine_scale(sx, sy)   scaling about origin   Parameters:      sx (float)      sy (float) affine_rotate_about(ang, px, py)   rotation about pivot (px,py)   Parameters:      ang (float)      px (float)      py (float) affine_compose(T2, T1)   compose T2∘T1 (apply T1 then T2)   Parameters:      T2 (Affine2)      T1 (Affine2) quadratic_roots(a, b, c)   Real roots of ax^2 + bx + c = 0 (numerically stable)   Parameters:      a (float)      b (float)      c (float)   Returns: with n∈{0,1,2}; r1<=r2 when n=2. cubic_roots(a, b, c, d)   Real roots of ax^3+bx^2+cx+d=0 (Cardano; returns up to 3 real roots)   Parameters:      a (float)      b (float)      c (float)      d (float)   Returns: (valid r2/r3 only if n>=2/n>=3) det2(a, b, c, d)   det2 of   Parameters:      a (float)      b (float)      c (float)      d (float) inv2(a, b, c, d)   inverse of 2x2; returns   Parameters:      a (float)      b (float)      c (float)      d (float) solve2(a, b, c, d, e, f)   solve 2x2 * = via Cramer   Parameters:      a (float)      b (float)      c (float)      d (float)      e (float)      f (float) det3(a11, a12, a13, a21, a22, a23, a31, a32, a33)   det3 of 3x3   Parameters:      a11 (float)      a12 (float)      a13 (float)      a21 (float)      a22 (float)      a23 (float)      a31 (float)      a32 (float)      a33 (float) inv3(a11, a12, a13, a21, a22, a23, a31, a32, a33)   inverse 3x3; returns   Parameters:      a11 (float)      a12 (float)      a13 (float)      a21 (float)      a22 (float)      a23 (float)      a31 (float)      a32 (float)      a33 (float) eig2_symmetric(a, b, d)   symmetric 2x2 eigensystem: [ , ]   Parameters:      a (float)      b (float)      d (float)   Returns: with unit eigenvectors tls_line(xs, ys)   Orthogonal (total least squares) regression line through point cloud Input arrays must be same length N>=2. Returns line in normal form n•x + c = 0   Parameters:      xs (array)      ys (array)   Returns: where (nx,ny) unit normal; (cx,cy) centroid. orient(a, b, c)   orientation (signed area*2): >0 CCW, <0 CW, 0 collinear   Parameters:      a (Vec2)      b (Vec2)      c (Vec2) project_point_line(p, a, d)   project point p onto infinite line through a with direction d   Parameters:      p (Vec2)      a (Vec2)      d (Vec2)   Returns: where proj = a + t*d closest_point_segment(p, a, b)   closest point on segment to p   Parameters:      p (Vec2)      a (Vec2)      b (Vec2)   Returns: where t∈ on segment dist_point_line(p, a, d)   distance from point to line (infinite)   Parameters:      p (Vec2)      a (Vec2)      d (Vec2) dist_point_segment(p, a, b)   distance from point to segment   Parameters:      p (Vec2)      a (Vec2)      b (Vec2) intersect_lines(p1, d1, p2, d2)   line-line intersection: L1: p1+d1*t, L2: p2+d2*u   Parameters:      p1 (Vec2)      d1 (Vec2)      p2 (Vec2)      d2 (Vec2)   Returns: intersect_segments(s1, s2)   segment-segment intersection (closed segments)   Parameters:      s1 (Segment2)      s2 (Segment2)   Returns: where kind: 0=no, 1=proper point, 2=overlap (ix/iy=na) circumcircle(a, b, c)   circle through 3 non-collinear points   Parameters:      a (Vec2)      b (Vec2)      c (Vec2) intersect_circle_line(C, p, d)   intersections of circle and line (param p + d t)   Parameters:      C (Circle2)      p (Vec2)      d (Vec2)   Returns: with n∈{0,1,2} intersect_circles(A, B)   circle-circle intersection   Parameters:      A (Circle2)      B (Circle2)   Returns: with n∈{0,1,2} polygon_area(xs, ys)   signed area (shoelace). Positive if CCW.   Parameters:      xs (array)      ys (array) polygon_centroid(xs, ys)   polygon centroid (for non-self-intersecting). Fallback to vertex mean if area≈0.   Parameters:      xs (array)      ys (array) point_in_polygon(px, py, xs, ys)   point-in-polygon test (ray casting). Returns true if inside; boundary counts as inside.   Parameters:      px (float)      py (float)      xs (array)      ys (array) convex_hull(xs, ys)   convex hull (monotone chain). Returns array of hull vertex indices in CCW order. Uses array.sort_indices(xs) (ascending by x). Ties on x are handled; result is deterministic.   Parameters:      xs (array)      ys (array) lerp(a, b, t)   linear interpolate between a and b   Parameters:      a (float)      b (float)      t (float) bezier2(p0, p1, p2, t)   quadratic Bezier B(t) for points p0,p1,p2   Parameters:      p0 (Vec2)      p1 (Vec2)      p2 (Vec2)      t (float) bezier3(p0, p1, p2, p3, t)   cubic Bezier B(t) for p0,p1,p2,p3   Parameters:      p0 (Vec2)      p1 (Vec2)      p2 (Vec2)      p3 (Vec2)      t (float) catmull_rom(p0, p1, p2, p3, t, alpha)   Catmull-Rom interpolation (centripetal form when alpha=0.5) t∈ , returns point between p1 and p2   Parameters:      p0 (Vec2)      p1 (Vec2)      p2 (Vec2)      p3 (Vec2)      t (float)      alpha (float) barycentric(A, B, C, P)   barycentric coordinates of P wrt triangle ABC   Parameters:      A (Vec2)      B (Vec2)      C (Vec2)      P (Vec2)   Returns: point_in_triangle(A, B, C, P)   point-in-triangle using barycentric (boundary included)   Parameters:      A (Vec2)      B (Vec2)      C (Vec2)      P (Vec2) Vec2   Fields:      x (series float)      y (series float) Line2   Fields:      p (Vec2)      d (Vec2) Segment2   Fields:      a (Vec2)      b (Vec2) Circle2   Fields:      c (Vec2)      r (series float) Affine2   Fields:      a (series float)      b (series float)      c (series float)      d (series float)      tx (series float)      ty (series float)
Pine Script® kütüphanesi
NotLazyBear tarafından
AdvancedOFPIAnalyzerLibrary "AdvancedOFPIAnalyzer" Advanced Order Flow Pressure Index Analyzer Library Implements sophisticated volume distribution analysis with candle microstructure Provides comprehensive order flow assessment for institutional activity detection analyzeAdvancedOrderFlow(priceOpen, priceHigh, priceLow, priceClose, volumeData, analysisWindow, institutionalSensitivity)   Performs comprehensive order flow analysis with advanced institutional detection   Parameters:      priceOpen (float) : float Opening price for analysis      priceHigh (float) : float High price for range calculation      priceLow (float) : float Low price for support detection      priceClose (float) : float Closing price for trend assessment      volumeData (float) : float Volume data for flow analysis      analysisWindow (int) : int Analysis window period      institutionalSensitivity (float) : float Institutional detection sensitivity   Returns: OFPI, momentum, institutional detected, strength, phase, overall strength, class, volume available, trend, efficiency, market structure calculateMicrostructurePressure(priceOpen, priceHigh, priceLow, priceClose, volumeData, microWindow)   Calculates sophisticated order flow pressure with comprehensive candle microstructure analysis   Parameters:      priceOpen (float) : float Opening price for pressure calculation      priceHigh (float) : float High price for range analysis      priceLow (float) : float Low price for support detection      priceClose (float) : float Closing price for trend assessment      volumeData (float) : float Volume data for pressure analysis      microWindow (int) : int Microstructure analysis window   Returns: Pressure index, buying pressure, selling pressure, body ratio, upper wick ratio, lower wick ratio, microstructure confidence, volume confirmation, institutional pressure, pressure velocity, microstructure quality generateInstitutionalAlerts(priceClose, volumeData, alertSensitivity, lookbackPeriod)   Generates sophisticated volume-weighted institutional activity alerts   Parameters:      priceClose (float) : float Close price for analysis      volumeData (float) : float Volume data for detection      alertSensitivity (float) : float Alert sensitivity threshold      lookbackPeriod (int) : int Analysis lookback period   Returns: Institutional detected, alert level, phase, strength, volume signature, pressure signature, time signature, absorption signature, impact signature, reliability, active methods, priority
Pine Script® kütüphanesi
Infinitefutures tarafından
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® kütüphanesi
no1x tarafından
Crypto_in_details_MAlibCrypto_in_details_MaLib — Advanced Moving Average Library for Pine Script Overview: Crypto_in_details_MaLib is a comprehensive, performance-optimized Moving Average (MA) library designed specifically for Pine Script v6 users seeking advanced technical analysis tools. Developed by Crypto_in_details, this library consolidates the most popular and sophisticated MA calculation methods — including classical, weighted, exponential, and Hull variants — into one seamless package. Key Features: Implements a wide range of Moving Averages: SMA, EMA, WMA, RMA, VWMA, HMA, TEMA, EHMA, THMA. Designed for precision and flexibility — suitable for diverse trading strategies and indicator development. Fully typed functions compatible with Pine Script v6 standards. Simplifies your scripting workflow by providing ready-to-use MA functions via clean and easy-to-import methods. Well-documented and maintained by an experienced Pine Script developer. Why Use Crypto_in_details_MaLib? Gain access to advanced MA calculations that enhance trend analysis, smoothing, and signal accuracy. Save time on coding complex moving averages from scratch. Easily extend or combine with your own strategies or indicators for improved performance. Rely on a tested and community-driven solution backed by a prolific Pine Script author. Ideal for: Traders and developers building custom indicators or strategies requiring versatile MA techniques. Anyone looking to improve their Pine Script efficiency and code maintainability. Pine Script enthusiasts wanting a professional-grade MA toolkit.
Pine Script® kütüphanesi
Crypto_in_details tarafından
jsonBuilderLibrary "jsonBuilder" jsonBuilder is a lightweight Pine Script utility library for building JSON strings manually. It includes functions to convert key-value pairs into JSON format and to combine multiple pairs into a complete JSON object. jsonString(key, value) – Converts a string key and string value into a valid JSON key-value pair. jsonObject(pair1, ..., pair20) – Merges up to 20 key-value pairs into a complete JSON object string. Empty arguments are skipped automatically. This is useful when sending structured JSON data via webhooks or external integrations from Pine Script.
Pine Script® kütüphanesi
xprophetx tarafından
TimezoneLibrary with pre-defined timezone enums that can be used to request a timezone input from the user. The library provides a `tostring()` function to convert enum values to a valid string that can be used as a `timezone` parameter in pine script built-in functions. The library also includes a bonus function to get a formatted UTC offset from a UNIX timestamp. The timezone enums in this library were compiled by referencing the available timezone options from TradingView chart settings as well as multiple Wikipedia articles relating to lists of time zones. Some enums from this library are used to retrieve an IANA time zone identifier, while other enums only use UTC/GMT offset notation. It is important to note that the Pine Script User Manual recommends using IANA notation in most cases. HOW TO USE This library is intended to be used by Pine Coders who wish to provide their users with a simple way to input a timezone. Using this library is as easy as 1, 2, 3: Step 1 Import the library into your script. Replace with the latest available version number for this library. //@version=6 indicator("Example") import n00btraders/Timezone/ as tz Step 2 Select one of the available enums from the library and use it as an input. Tip: view the library source code and scroll through the enums at the top to find the best choice for your script. timezoneInput = input.enum(tz.TimezoneID.EXCHANGE, "Timezone") Step 3 Convert the user-selected input into a valid string that can be used in one of the pine script built-in functions that have a `timezone` parameter. string timezone = tz.tostring(timezoneInput) EXPORTED FUNCTIONS There are multiple 𝚝𝚘𝚜𝚝𝚛𝚒𝚗𝚐() functions in this library: one for each timezone enum. The function takes a single parameter: any enum field from one of the available timezone enums that are exported by this library. Depending on the selected enum, the function will return a time zone string in either UTC/GMT notation or IANA notation. Note: to avoid confusion with the built-in `str.tostring()` function, it is recommended to use this library's `tostring()` as a method rather than a function: string timezone = timezoneInput.tostring() offset(timestamp, format, timezone, prefix, colon)   Formats the time offset from a UNIX timestamp represented in a specified timezone.   Namespace types: series OffsetFormat   Parameters:      timestamp (int) : (series int) A UNIX time.      format (series OffsetFormat) : (series OffsetFormat) A time offset format.      timezone (string) : (series string) A UTC/GMT offset or IANA time zone identifier.      prefix (string) : (series string) Optional 'UTC' or 'GMT' prefix for the result.      colon (bool) : (series bool) Optional usage of colon separator.   Returns: Time zone offset using the selected format. The 𝚘𝚏𝚏𝚜𝚎𝚝() function is provided as a convenient alternative to manually using `str.format_time()` and then manipulating the result. The OffsetFormat enum is used to decide the format of the result from the `offset()` function. The library source code contains comments above this enum declaration that describe how each enum field will modify a time offset. Tip: hover over the `offset()` function call in the Pine Editor to display a pop-up containing: Function description Detailed parameter list, including default values Example function calls Example outputs for different OffsetFormat.* enum values NOTES At the time of this publication, Pine cannot be used to access a chart's selected time zone. Therefore, the main benefit of this library is to provide a quick and easy way to create a pine script input for a time zone (most commonly, the same time zone selected in the user's chart settings). At the time of the creation of this library, there are 95 Time Zones made available in the TradingView chart settings. If any changes are made to the time zone settings, this library will be updated to match the new changes. All time zone enums (and their individual fields) in this library were manually verified and tested to ensure correctness. An example usage of this library is included at the bottom of the source code. Credits to HoanGhetti for providing a nice Markdown resource which I referenced to be able to create a formatted informational pop-up for this library's `offset()` function.
Pine Script® kütüphanesi
n00btraders tarafından
9
lib_input_enumLibrary "lib_input_enum" some enum wrappers for style identifiers, that can be used in input.enum calls to have nicer dropdown names to_size(select)   converts Size enum to builtin size.tiny / size.small / etc., ideally used around input: to_size(input.enum(Size.SMALL, ....))   Parameters:      select (series Size) to_size(select)   converts a string key to builtin size.tiny / size.small / etc., ideally used around input: to_size(input.string('small', ...., ))   Parameters:      select (string) reduce_size(select)   converting a builtin size identifier to one instance smaller (except tiny and auto)   Parameters:      select (string) to_linestyle(select)   converts LineStyle enum to builtin line.style_solid / line.style_dashed / line.style_dotted, ideally used around input: to_linestyle(input.enum(LineStyle.SOLID, ....))   Parameters:      select (series LineStyle) to_linestyle(select)   converts a string key to builtin line.style_solid / line.style_dashed / line.style_dotted, ideally used around input: to_linestyle(input.string('solid', ...., ))   Parameters:      select (string) to_labelstyle(select)   converts LineStyle enum to builtin line.style_solid / line.style_dashed / line.style_dotted, ideally used around input: to_linestyle(input.enum(LineStyle.SOLID, ....))   Parameters:      select (series LabelStyle) to_labelstyle(select)   converts a string key to builtin line.style_solid / line.style_dashed / line.style_dotted, ideally used around input: to_linestyle(input.string('solid', ...., ))   Parameters:      select (string)
Pine Script® kütüphanesi
robbatt tarafından
3