立即開始

指標和策略

LengthAdaptationCollection of dynamic length adaptation algorithms. Mostly from various Adaptive Moving Averages (they are usually just EMA otherwise). Now you can combine Adaptations with any other Moving Averages or Oscillators (see my other libraries), to get something like Deviation Scaled RSI or Fractal Adaptive VWMA. This collection is not encyclopaedic. Suggestions are welcome. chande(src, len, sdlen, smooth, power) Chande's Dynamic Length   Parameters:      src : Series to use      len : Reference lookback length      sdlen : Lookback length of Standard deviation      smooth : Smoothing length of Standard deviation      power : Exponent of the length adaptation (lower is smaller variation)   Returns: Calculated period Taken from Chande's Dynamic Momentum Index (CDMI or DYMOI), which is dynamic RSI with this length Original default power value is 1, but I use 0.5 A variant of this algorithm is also included, where volume is used instead of price vidya(src, len, dynLow) Variable Index Dynamic Average Indicator (VIDYA)   Parameters:      src : Series to use      len : Reference lookback length      dynLow : Lower bound for the dynamic length   Returns: Calculated period Standard VIDYA algorithm. The period oscillates from the Lower Bound up (slow) I took the adaptation part, as it is just an EMA otherwise vidyaRS(src, len, dynHigh) Relative Strength Dynamic Length - VIDYA RS   Parameters:      src : Series to use      len : Reference lookback length      dynHigh : Upper bound for the dynamic length   Returns: Calculated period Based on Vitali Apirine's modification (Stocks and Commodities, January 2022) of VIDYA algorithm. The period oscillates from the Upper Bound down (fast) I took the adaptation part, as it is just an EMA otherwise kaufman(src, len, dynLow, dynHigh) Kaufman Efficiency Scaling   Parameters:      src : Series to use      len : Reference lookback length      dynLow : Lower bound for the dynamic length      dynHigh : Upper bound for the dynamic length   Returns: Calculated period Based on Efficiency Ratio calculation orifinally used in Kaufman Adaptive Moving Average developed by Perry J. Kaufman I took the adaptation part, as it is just an EMA otherwise ds(src, len) Deviation Scaling   Parameters:      src : Series to use      len : Reference lookback length   Returns: Calculated period Based on Derivation Scaled Super Smoother (DSSS) by John F. Ehlers Originally used with Super Smoother RMS originally has 50 bar lookback. Changed to 4x length for better flexibility. Could be wrong. maa(src, len, threshold) Median Average Adaptation   Parameters:      src : Series to use      len : Reference lookback length      threshold : Adjustment threshold (lower is smaller length, default: 0.002, min: 0.0001)   Returns: Calculated period Based on Median Average Adaptive Filter by John F. Ehlers Discovered and implemented by @cheatcountry: I took the adaptation part, as it is just an EMA otherwise fra(len, fc, sc) Fractal Adaptation   Parameters:      len : Reference lookback length      fc : Fast constant (default: 1)      sc : Slow constant (default: 200)   Returns: Calculated period Based on FRAMA by John F. Ehlers Modified to allow lower and upper bounds by an unknown author I took the adaptation part, as it is just an EMA otherwise mama(src, dynLow, dynHigh) MESA Adaptation - MAMA Alpha   Parameters:      src : Series to use      dynLow : Lower bound for the dynamic length      dynHigh : Upper bound for the dynamic length   Returns: Calculated period Based on MESA Adaptive Moving Average by John F. Ehlers Introduced in the September 2001 issue of Stocks and Commodities Inspired by the @everget implementation: I took the adaptation part, as it is just an EMA otherwise doAdapt(type, src, len, dynLow, dynHigh, chandeSDLen, chandeSmooth, chandePower) Execute a particular Length Adaptation from the list   Parameters:      type : Length Adaptation type to use      src : Series to use      len : Reference lookback length      dynLow : Lower bound for the dynamic length      dynHigh : Upper bound for the dynamic length      chandeSDLen : Lookback length of Standard deviation for Chande's Dynamic Length      chandeSmooth : Smoothing length of Standard deviation for Chande's Dynamic Length      chandePower : Exponent of the length adaptation for Chande's Dynamic Length (lower is smaller variation)   Returns: Calculated period (float, not limited) doMA(type, src, len) MA wrapper on wrapper: if DSSS is selected, calculate it here   Parameters:      type : MA type to use      src : Series to use      len : Filtering length   Returns: Filtered series Demonstration of a combined indicator: Deviation Scaled Super Smoother
Pine Script®腳本庫
由lastguru提供
2
divergenceLibrary "divergence" divergence: divergence algorithm with top and bottom kline tolerance regular_bull(series, series, simple, simple, simple, simple, simple) regular_bull: regular bull divergence, lower low src but higher low osc   Parameters:      series : float src: the source series      series : float osc: the oscillator index      simple : int lbL: look back left      simple : int lbR: look back right      simple : int rangeL: min look back range      simple : int rangeU: max look back range      simple : int tolerance: the number of tolerant klines   Returns: array: hidden_bull(series, series, simple, simple, simple, simple, simple) hidden_bull: hidden bull divergence, higher low src but lower low osc   Parameters:      series : float src: the source series      series : float osc: the oscillator index      simple : int lbL: look back left      simple : int lbR: look back right      simple : int rangeL: min look back range      simple : int rangeU: max look back range      simple : int tolerance: the number of tolerant klines   Returns: array: regular_bear(series, series, simple, simple, simple, simple, simple) regular_bear: regular bear divergence, higher high src but lower high osc   Parameters:      series : float src: the source series      series : float osc: the oscillator index      simple : int lbL: look back left      simple : int lbR: look back right      simple : int rangeL: min look back range      simple : int rangeU: max look back range      simple : int tolerance: the number of tolerant klines   Returns: array: hidden_bear(series, series, simple, simple, simple, simple, simple) hidden_bear: hidden bear divergence, lower high src but higher high osc   Parameters:      series : float src: the source series      series : float osc: the oscillator index      simple : int lbL: look back left      simple : int lbR: look back right      simple : int rangeL: min look back range      simple : int rangeU: max look back range      simple : int tolerance: the number of tolerant klines   Returns: array:
Pine Script®腳本庫
由dandrideng提供
least_squares_regressionLibrary "least_squares_regression" least_squares_regression: Least squares regression algorithm to find the optimal price interval for a given time period basic_lsr(series, series, series) basic_lsr: Basic least squares regression algorithm   Parameters:      series : int t: time scale value array corresponding to price      series : float p: price scale value array corresponding to time      series : int array_size: the length of regression array   Returns: reg_slop, reg_intercept, reg_level, reg_stdev trend_line_lsr(series, series, series, string, series, series) top_trend_line_lsr: Trend line fitting based on least square algorithm   Parameters:      series : int t: time scale value array corresponding to price      series : float p: price scale value array corresponding to time      series : int array_size: the length of regression array      string : reg_type: regression type in 'top' and 'bottom'      series : int max_iter: maximum fitting iterations      series : int min_points: the threshold of regression point numbers   Returns: reg_slop, reg_intercept, reg_level, reg_stdev, reg_point_num
Pine Script®腳本庫
由dandrideng提供
simple_squares_regressionLibrary "simple_squares_regression" simple_squares_regression: simple squares regression algorithm to find the optimal price interval for a given time period basic_ssr(series, series, series) basic_ssr: Basic simple squares regression algorithm   Parameters:      series : float src: the regression source such as close      series : int region_forward: number of candle lines at the right end of the regression region from the current candle line      series : int region_len: the length of regression region   Returns: left_loc, right_loc, reg_val, reg_std, reg_max_offset search_ssr(series, series, series, series) search_ssr: simple squares regression region search algorithm   Parameters:      series : float src: the regression source such as close      series : int max_forward: max number of candle lines at the right end of the regression region from the current candle line      series : int region_lower: the lower length of regression region      series : int region_upper: the upper length of regression region   Returns: left_loc, right_loc, reg_val, reg_level, reg_std_err, reg_max_offset
Pine Script®腳本庫
由dandrideng提供
2
on_balance_volumeLibrary "on_balance_volume" on_balance_volume: custom on balance volume obv_diff(string, simple) obv_diff: custom on balance volume diff version   Parameters:      string : type: the moving average type of on balance volume      simple : int len: the moving average length of on balance volume   Returns: obv_diff: custom on balance volume diff value obv_diff_norm(string, simple) obv_diff_norm: custom normalized on balance volume diff version   Parameters:      string : type: the moving average type of on balance volume      simple : int len: the moving average length of on balance volume   Returns: obv_diff: custom normalized on balance volume diff value
Pine Script®腳本庫
由dandrideng提供
NormalizedOscillatorsLibrary "NormalizedOscillators" Collection of some common Oscillators. All are zero-mean and normalized to fit in the -1..1 range. Some are modified, so that the internal smoothing function could be configurable (for example, to enable Hann Windowing, that John F. Ehlers uses frequently). Some are modified for other reasons (see comments in the code), but never without a reason. This collection is neither encyclopaedic, nor reference, however I try to find the most correct implementation. Suggestions are welcome. rsi2(upper, lower) RSI - second step   Parameters:      upper : Upwards momentum      lower : Downwards momentum   Returns: Oscillator value Modified by Ehlers from Wilder's implementation to have a zero mean (oscillator from -1 to +1) Originally: 100.0 - (100.0 / (1.0 + upper / lower)) Ignoring the 100 scale factor, we get: upper / (upper + lower) Multiplying by two and subtracting 1, we get: (2 * upper) / (upper + lower) - 1 = (upper - lower) / (upper + lower) rms(src, len) Root mean square (RMS)   Parameters:      src : Source series      len : Lookback period Based on by John F. Ehlers implementation ift(src) Inverse Fisher Transform   Parameters:      src : Source series   Returns: Normalized series Based on by John F. Ehlers implementation The input values have been multiplied by 2 (was "2*src", now "4*src") to force expansion - not compression The inputs may be further modified, if needed stoch(src, len) Stochastic   Parameters:      src : Source series      len : Lookback period   Returns: Oscillator series ssstoch(src, len) Super Smooth Stochastic (part of MESA Stochastic) by John F. Ehlers   Parameters:      src : Source series      len : Lookback period   Returns: Oscillator series Introduced in the January 2014 issue of Stocks and Commodities This is not an implementation of MESA Stochastic, as it is based on Highpass filter not present in the function (but you can construct it) This implementation is scaled by 0.95, so that Super Smoother does not exceed 1/-1 I do not know, if this the right way to fix this issue, but it works for now netKendall(src, len) Noise Elimination Technology by John F. Ehlers   Parameters:      src : Source series      len : Lookback period   Returns: Oscillator series Introduced in the December 2020 issue of Stocks and Commodities Uses simplified Kendall correlation algorithm Implementation by @QuantTherapy: rsi(src, len, smooth) RSI   Parameters:      src : Source series      len : Lookback period      smooth : Internal smoothing algorithm   Returns: Oscillator series vrsi(src, len, smooth) Volume-scaled RSI   Parameters:      src : Source series      len : Lookback period      smooth : Internal smoothing algorithm   Returns: Oscillator series This is my own version of RSI. It scales price movements by the proportion of RMS of volume mrsi(src, len, smooth) Momentum RSI   Parameters:      src : Source series      len : Lookback period      smooth : Internal smoothing algorithm   Returns: Oscillator series Inspired by RocketRSI by John F. Ehlers (Stocks and Commodities, May 2018) rrsi(src, len, smooth) Rocket RSI   Parameters:      src : Source series      len : Lookback period      smooth : Internal smoothing algorithm   Returns: Oscillator series Inspired by RocketRSI by John F. Ehlers (Stocks and Commodities, May 2018) Does not include Fisher Transform of the original implementation, as the output must be normalized Does not include momentum smoothing length configuration, so always assumes half the lookback length mfi(src, len, smooth) Money Flow Index   Parameters:      src : Source series      len : Lookback period      smooth : Internal smoothing algorithm   Returns: Oscillator series lrsi(src, in_gamma, len) Laguerre RSI by John F. Ehlers   Parameters:      src : Source series      in_gamma : Damping factor (default is -1 to generate from len)      len : Lookback period (alternatively, if gamma is not set)   Returns: Oscillator series The original implementation is with gamma. As it is impossible to collect gamma in my system, where the only user input is length, an alternative calculation is included, where gamma is set by dividing len by 30. Maybe different calculation would be better? fe(len) Choppiness Index or Fractal Energy   Parameters:      len : Lookback period   Returns: Oscillator series The Choppiness Index (CHOP) was created by E. W. Dreiss This indicator is sometimes called Fractal Energy er(src, len) Efficiency ratio   Parameters:      src : Source series      len : Lookback period   Returns: Oscillator series Based on Kaufman Adaptive Moving Average calculation This is the correct Efficiency ratio calculation, and most other implementations are wrong: the number of bar differences is 1 less than the length, otherwise we are adding the change outside of the measured range! For reference, see Stocks and Commodities June 1995 dmi(len, smooth) Directional Movement Index   Parameters:      len : Lookback period      smooth : Internal smoothing algorithm   Returns: Oscillator series Based on the original Tradingview algorithm Modified with inspiration from John F. Ehlers DMH (but not implementing the DMH algorithm!) Only ADX is returned Rescaled to fit -1 to +1 Unlike most oscillators, there is no src parameter as DMI works directly with high and low values fdmi(len, smooth) Fast Directional Movement Index   Parameters:      len : Lookback period      smooth : Internal smoothing algorithm   Returns: Oscillator series Same as DMI, but without secondary smoothing. Can be smoothed later. Instead, +DM and -DM smoothing can be configured doOsc(type, src, len, smooth) Execute a particular Oscillator from the list   Parameters:      type : Oscillator type to use      src : Source series      len : Lookback period      smooth : Internal smoothing algorithm   Returns: Oscillator series Chande Momentum Oscillator (CMO) is RSI without smoothing. No idea, why some authors use different calculations LRSI with Fractal Energy is a combo oscillator that uses Fractal Energy to tune LRSI gamma, as seen here: www.prorealcode.com doPostfilter(type, src, len) Execute a particular Oscillator Postfilter from the list   Parameters:      type : Oscillator type to use      src : Source series      len : Lookback period   Returns: Oscillator series
Pine Script®腳本庫
由lastguru提供
CommonFiltersLibrary "CommonFilters" Collection of some common Filters and Moving Averages. This collection is not encyclopaedic, but to declutter my other scripts. Suggestions are welcome, though. Many filters here are based on the work of John F. Ehlers sma(src, len) Simple Moving Average   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series ema(src, len) Exponential Moving Average   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series rma(src, len) Wilder's Smoothing (Running Moving Average)   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series hma(src, len) Hull Moving Average   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series vwma(src, len) Volume Weighted Moving Average   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series hp2(src) Simple denoiser   Parameters:      src : Series to use   Returns: Filtered series fir2(src) Zero at 2 bar cycle period by John F. Ehlers   Parameters:      src : Series to use   Returns: Filtered series fir3(src) Zero at 3 bar cycle period by John F. Ehlers   Parameters:      src : Series to use   Returns: Filtered series fir23(src) Zero at 2 bar and 3 bar cycle periods by John F. Ehlers   Parameters:      src : Series to use   Returns: Filtered series fir234(src) Zero at 2, 3 and 4 bar cycle periods by John F. Ehlers   Parameters:      src : Series to use   Returns: Filtered series hp(src, len) High Pass Filter for cyclic components shorter than langth. Part of Roofing Filter by John F. Ehlers   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series supers2(src, len) 2-pole Super Smoother by John F. Ehlers   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series filt11(src, len) Filt11 is a variant of 2-pole Super Smoother with error averaging for zero-lag response by John F. Ehlers   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series supers3(src, len) 3-pole Super Smoother by John F. Ehlers   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series hannFIR(src, len) Hann Window Filter by John F. Ehlers   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series hammingFIR(src, len) Hamming Window Filter (inspired by John F. Ehlers). Simplified implementation as Pedestal input parameter cannot be supplied, so I calculate it from the supplied length   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series triangleFIR(src, len) Triangle Window Filter by John F. Ehlers   Parameters:      src : Series to use      len : Filtering length   Returns: Filtered series doPrefilter(type, src) Execute a particular Prefilter from the list   Parameters:      type : Prefilter type to use      src : Series to use   Returns: Filtered series doMA(type, src, len) Execute a particular MA from the list   Parameters:      type : MA type to use      src : Series to use      len : Filtering length   Returns: Filtered series
Pine Script®腳本庫
由lastguru提供
3
WaddahAttarExplosionLibrary "WaddahAttarExplosion" wae(sensitivity, macdFastEMALength, macdSlowEMALength, bbChannelLength, bbStdevMultiplier, refHigh, refLow, refClose) Returns the Waddah Attar Uptrend, Downtrend, Explosion Line and Dead zone   Parameters:      sensitivity : simple float multiplicator for trend line calculation from macd      macdFastEMALength : simple int length for macd fast line      macdSlowEMALength : simple int length for macd slow line      bbChannelLength : simple int length for calculating the bb channel (for std deviation)      bbStdevMultiplier : simple float multiplier to increace bb std deviation      refHigh : series float optional if you want to use another timeframe or symbol, pass it's 'high' series here      refLow : series float optional if you want to use another timeframe or symbol, pass it's 'low' series here      refClose : series float optional if you want to use another timeframe or symbol, pass it's 'close' series here   Returns:
Pine Script®腳本庫
由robbatt提供
1
ATRStopLossFinderLibrary "ATRStopLossFinder" Average True Range Stop Loss Finder credits to www.tradingview.com for the initial version stopLossFinder(length, smoothing, multiplier, refHigh, refLow, refClose) Returns the stop losses for an entry on this candle, depending on the ATR   Parameters:      length : simple int optional to select the lookback amount of candles      smoothing : string optional to select the averaging method, options=      multiplier : simple float optional if you want to tweak the speed the trend changes.      refHigh : series float optional if you want to use another timeframe or symbol, pass it's 'high' series here      refLow : series float optional if you want to use another timeframe or symbol, pass it's 'low' series here      refClose : series float optional if you want to use another timeframe or symbol, pass it's 'close' series here   Returns: series float stopLossLong, series float stopLossShort, series float atr
Pine Script®腳本庫
由robbatt提供
AbdulLibraryLibrary "AbdulLibrary" The library consists of three sections: Technical Analysis Functions - A collection of tools commonly used by day traders Trading Setup Filters Functions - A number of filters that help day traders to screen trading signals Candlestick Pattern Detection Functions - To detect different candlestick patterns that are used in day trading setups Note that this would have been possible without the help of @ZenAndTheArtOfTrading as I build-up this library after completing his pine script mastery course so big thanks to him The content of the library are:- fibLevels(preDayClose, preDayHigh, preDayLow) Calculates Daily Pivot Point and Fibonacci Key Levels   Parameters:      preDayClose : The previous day candle close      preDayHigh : The previous day candle high      preDayLow : The previous day candle low   Returns: Returns Daily Pivot Point and Fibonacci Key Levels as a tuple bullishFib(canHigh, canLow, fibLevel) Calculates Fibonacci Levels in Bullish move   Parameters:      canHigh : The high of the move      canLow : The low of the move      fibLevel : The Fib level as % you want to calculate   Returns: Returns The Fib level for the Bullish move bearishFib(canHigh, canLow, fibLevel) Calculates Fibonacci Levels in Bearish move   Parameters:      canHigh : The high of the move      canLow : The low of the move      fibLevel : The Fib level as % you want to calculate   Returns: Returns The Fib level for the Bearish move getCandleSize() Calculates the size of candle (high - low) in points   Returns: Returns candle size in points getCandleBodySize() Calculates the size of candle (close - open) in points   Returns: Returns candle body size in points getHighWickSize() Calculates the high wick size of candle in points   Returns: Returns The high wick size of candle in points getLowWickSize() Calculates the low wick size of candle in points   Returns: Returns The low wick size of candle in points getBodyPercentage() Calculates the candle body size as % of overall candle size   Returns: Returns The candle body size as % of overall candle size isSwingHigh(period) Checks if the price has created new swing high over a period of time   Parameters:      period : The lookback time we want to check for swing high   Returns: Returns True if the current candle or the previous candle is a swing high isSwingLow(period) Checks if the price has created new swing low over a period of time   Parameters:      period : The lookback time we want to check for swing low   Returns: Returns True if the current candle or the previous candle is a swing low isDojiSwingHigh(period) Checks if a doji is a swing high over a period of time   Parameters:      period : The lookback time we want to check for swing high   Returns: Returns True if the doji is a swing high isDojiSwingLow(period) Checks if a doji is a swing low over a period of time   Parameters:      period : The lookback time we want to check for swing low   Returns: Returns True if the doji is a swing low isBigBody(atrFilter, atr, candleBodySize, multiplier) Checks if a candle has big body compared to ATR   Parameters:      atrFilter : Check if user wants to use ATR to filter candle-setup signals      atr : The ATR value to be used to compare candle body size      candleBodySize : The candle body size      multiplier : The multiplier to be used to compare candle body size   Returns: Returns Boolean true if the candle setup is big isSmallBody(atrFilter, atr, candleBodySize, multiplier) Checks if a candle has small body compared to ATR   Parameters:      atrFilter : Check if user wants to use ATR to filter candle-setup signals      atr : The ATR value to be used to compare candle body size      candleBodySize : The candle body size      multiplier : The multiplier to be used to compare candle body size   Returns: Returns Boolean true if the candle setup is small isHammer(fibLevel, colorMatch) Checks if a candle is a hammer based on user input parameters and candle conditions   Parameters:      fibLevel : Fib level to base candle body on      colorMatch : Checks if user needs for the candel to be green   Returns: Returns Boolean - True if the candle setup is hammer isShootingStar(fibLevel, colorMatch) Checks if a candle is a shooting star based on user input parameters and candle conditions   Parameters:      fibLevel : Fib level to base candle body on      colorMatch : Checks if user needs for the candel to be red   Returns: Returns Boolean - True if the candle setup is star isBullEngCan(allowance, period) Check if a candle is a bullish engulfing candle   Parameters:      allowance : How many points the candle open is allowed to be off (To allow for gaps)      period : The lookback period for swing low check   Returns: Boolean - True only if the candle is a bullish engulfing candle isBearEngCan(allowance, period) Check if a candle is a bearish engulfing candle   Parameters:      allowance : How many points the candle open is allowed to be off (To allow for gaps)      period : The lookback period for swing high check   Returns: Boolean - True only if the candle is a bearish engulfing candle isBullDoji(maxSize, wickLimit, colorFilter) Check if a candle is a bullish doji candle   Parameters:      maxSize : Maximum candle body size as % of total candle size to be considered as doji      wickLimit : Maximum wick size of one wick compared to the other wick      colorFilter : Checks if the doji is green   Returns: Boolean - True if the candle is a bullish doji isBearDoji(maxSize, wickLimit, colorFilter) Check if a candle is a bearish doji candle   Parameters:      maxSize : Maximum candle body size as % of total candle size to be considered as doji      wickLimit : Maximum wick size of one wick compared to the other wick      colorFilter : Checks if the doji is red   Returns: Boolean - True if the candle is a bearish doji isBullOutBar() Check if a candle is a bullish outside bar   Returns: Boolean - True if the candle is a bullish outside bar isInsideBar() Check if a candle is an inside bar   Returns: Returns Boolean - True if a candle is an inside bar
Pine Script®腳本庫
由Abdul_Saif提供
1
InitialiseArraysLibrary "InitialiseArrays" @description: Efficiently create arrays, populating them with an arbitrary number of elements and setting their starting values. Works with a mix of typed and na values. A limitation of the built-in functions to create arrays is that while you can create and populate arrays with a single command, you can only set all elements to the same value in this way. Or, you can create an array from a set of values or variables, but you can't include any na values. Now, it's easy enough to work around this, but I wanted to make something more efficient (because I want to use lots of arrays), hence this library. Calling a function from here is more efficient because you only do it once (assuming it's a var) and don't evaluate an if condition each run, and don't create unnecessary variables. It's also easier to read and takes less space. f_initialiseBoolArray() @function f_initialiseBoolArray(string _values) Creates a boolean array, populated with the values that you specify in the input string. @param _values is a string that contains a comma-separated list of the values that you want to initialise the boolean array with. Values other than true, false, and na are disregarded. Spaces are disregarded. @returns Returns a boolean array of arbitrary length. f_initialiseFloatArray() @function f_initialiseFloatArray(string _values) Creates a float array, populated with the values that you specify in the input string. @param _values is a string that contains a comma-separated list of the values that you want to initialise the float array with. Non-numerical entries are converted to NaN values. Spaces are disregarded. @returns Returns a float array of arbitrary length. f_initialiseIntArray() @function f_initialiseIntArray(string _values) Creates an int array, populated with the values that you specify in the input string. @param _values is a string that contains a comma-separated list of the values that you want to initialise the int array with. Floating-point numbers are rounded down to the nearest integer. Any na values are preserved. Spaces are disregarded. @returns Returns a float array of arbitrary length. V1 includes functions for bools, floats, and ints. I might extend it if people want.
Pine Script®腳本庫
由SimpleCryptoLife提供
2
PivotsLibrary "Pivots" This Library focuses in functions related to pivot highs and lows and some of their applications (i.e. divergences, zigzag, harmonics, support and resistance...) pivots(srcH, srcL, length) Delivers series of pivot highs, lows and zigzag.   Parameters:      srcH : Source series to look for pivot highs. Stricter applications might source from 'close' prices. Oscillators are also another possible source to look for pivot highs and lows. By default 'high'      srcL : Source series to look for pivot lows. By default 'low'      length : This value represents the minimum number of candles between pivots. The lower the number, the more detailed the pivot profile. The higher the number, the more relevant the pivots. By default 10   Returns: zigzagArray(pivotHigh, pivotLow) Delivers a Zigzag series based on alternating pivots. Ocasionally this line could paint a few consecutive lows or highs without alternating. That happens because it's finding a few consecutive Higher Highs or Lower Lows. If to use lines entities instead of series, that could be easily avoided. But in this one, I'm more interested outputting series rather than painting/deleting line entities.   Parameters:      pivotHigh : Pivot high series      pivotLow : Pivot low series   Returns: zigzagLine(srcH, srcL, colorLine, widthLine) Delivers a Zigzag based on line entities.   Parameters:      srcH : Source series to look for pivot highs. Stricter applications might source from 'close' prices. Oscillators are also another possible source to look for pivot highs and lows. By default 'high'      srcL : Source series to look for pivot lows. By default 'low'      colorLine : Color of the Zigzag Line. By default Fuchsia      widthLine : Width of the Zigzag Line. By default 4   Returns: Zigzag printed on screen divergence(h2, l2, h1, l1, length) Calculates divergences between 2 series   Parameters:      h2 : Series in which to locate divs: Highs      l2 : Series in which to locate divs: Lows      h1 : Series in which to locate pivots: Highs. By default high      l1 : Series in which to locate pivots: Lows. By default low      length : Length used to calculate Pivots: By default 10   Returns:
Pine Script®腳本庫
由gliderfund提供
2
Common FunctionsLibrary "CommonFunctions" This Library provides some handy functions commonly used in Pine Script. crosses(source1, offset1, source2, offset2) Checks the existance of crosses between the series   Parameters:      source1 : First series      offset1 : (Optional) Offset of First series. By default 0      source2 : (Optional) Second series. By default 'close' price      offset2 : (Optional) Offset of Second series. By default 0   Returns: marketState(source1, offset1, source2, offset2) Determines Bullish/Bearish state according to the relative position between the series.   Parameters:      source1 : Active series used to determine bullish/bearish states.      offset1 : (Optional) Offset of First series. By default 0.      source2 : (Optional) Second series. By default 'close' price.      offset2 : (Optional) Offset of Second series. By default 0.   Returns: histProfile(source) Histogram profiling   Parameters:      source : Histogram series   Returns: srcSelect(showSrc1, src1, showSrc2, src2) Selects the appropiate source. If multiple sources are activated simultaneously, the order within the switch clause prevails. The first one activated is the one being output.   Parameters:      showSrc1 : Boolean controlling the activation of Source #1.      src1 : Source #1.      showSrc2 : Boolean controlling the activation of Sources #2-10. By default 'false'.      src2 : Sources #2-10. By default 'number'.   Returns: Selected source.
Pine Script®腳本庫
由gliderfund提供
math_utilsLibrary "math_utils" Collection of math functions that are not part of the standard math library num_of_non_decimal_digits(number) num_of_non_decimal_digits - The number of the most significant digits on the left of the dot   Parameters:      number : - The floating point number   Returns: number of non digits num_of_decimal_digits(number) num_of_decimal_digits - The number of the most significant digits on the right of the dot   Parameters:      number : - The floating point number   Returns: number of decimal digits floor(number, precision) floor - floor with precision to the given most significant decimal point   Parameters:      number : - The floating point number      precision : - The number of decimal places a.k.a the most significant decimal digit - e.g precision 2 will produce 0.01 minimum change   Returns: number floored to the decimal digits defined by the precision ceil(number, precision) floor - ceil with precision to the given most significant decimal point   Parameters:      number : - The floating point number      precision : - The number of decimal places a.k.a the most significant decimal digit - e.g precision 2 will produce 0.01 minimum change   Returns: number ceiled to the decimal digits defined by the precision clamp(number, lower, higher, precision) clamp - clamp with precision to the given most significant decimal point   Parameters:      number : - The floating point number      lower : - The lowerst number limit to return      higher : - The highest number limit to return      precision : - The number of decimal places a.k.a the most significant decimal digit - e.g precision 2 will produce 0.01 minimum change   Returns: number clamped to the decimal digits defined by the precision
Pine Script®腳本庫
由jason5480提供
4
ConditionalAverages█   OVERVIEW This library is a Pine Script™ programmer’s tool containing functions that average values selectively. █   CONCEPTS Averaging can be useful to smooth out unstable readings in the data set, provide a benchmark to see the underlying trend of the data, or to provide a general expectancy of values in establishing a central tendency. Conventional averaging techniques tend to apply indiscriminately to all values in a fixed window, but it can sometimes be useful to average values only when a specific condition is met. As conditional averaging works on specific elements of a dataset, it can help us derive more context-specific conclusions. This library offers a collection of averaging methods that not only accomplish these tasks, but also exploit the efficiencies of the Pine Script™ runtime by foregoing unnecessary and ​​​resource-intensive for loops. █   NOTES To Loop or Not to Loop Though for and while loops are essential programming tools, they are often unnecessary in Pine Script™. This is because the Pine Script™ runtime already runs your scripts in a loop where it executes your code on each bar of the dataset. Pine Script™ programmers who understand how their code executes on charts can use this to their advantage by designing loop-less code that will run orders of magnitude faster than functionally identical code using loops. Most of this library's function illustrate how you can achieve loop-less code to process past values. See the User Manual page on loops for more information. If you are looking for ways to measure execution time for you scripts, have a look at our LibraryStopwatch library . Our `avgForTimeWhen()` and `totalForTimeWhen()` are exceptions in the library, as they use a while structure. Only a few iterations of the loop are executed on each bar, however, as its only job is to remove the few elements in the array that are outside the moving window defined by a time boundary. Cumulating and Summing Conditionally The ta.cum() or math.sum() built-in functions can be used with ternaries that select only certain values. In our `avgWhen(​src, ​cond)` function, for example, we use this technique to cumulate only the occurrences of `src` when `cond` is true: float cumTotal = ta.cum(cond ? ​src : 0) We then use: float cumCount = ta.cum(cond ? 1 : 0) to calculate the number of occurrences where `cond` is true, which corresponds to the quantity of values cumulated in `cumTotal`. Building Custom Series With Arrays The advent of arrays in Pine has enabled us to build our custom data series. Many of this library's functions use arrays for this purpose, saving newer values that come in when a condition is met, and discarding the older ones, implementing a queue . `avgForTimeWhen()` and `totalForTimeWhen()` These two functions warrant a few explanations. They operate on a number of values included in a moving window defined by a timeframe expressed in milliseconds. We use a 1D timeframe in our example code. The number of bars included in the moving window is unknown to the programmer, who only specifies the period of time defining the moving window. You can thus use `avgForTimeWhen()` to calculate a rolling moving average for the last 24 hours, for example, that will work whether the chart is using a 1min or 1H timeframe. A 24-hour moving window will typically contain many more values on a 1min chart that on a 1H chart, but their calculated average will be very close. Problems will arise on non-24x7 markets when large time gaps occur between chart bars, as will be the case across holidays or trading sessions. For example, if you were using a 24H timeframe and there is a two-day gap between two bars, then no chart bars would fit in the moving window after the gap. The `minBars` parameter mitigates this by guaranteeing that a minimum number of bars are always included in the calculation, even if including those bars requires reaching outside the prescribed timeframe. We use a minimum value of 10 bars in the example code. Using var in Constant Declarations In the past, we have been using var when initializing so-called constants in our scripts, which as per the Style Guide 's recommendations, we identify using UPPER_SNAKE_CASE. It turns out that var variables incur slightly superior maintenance overhead in the Pine Script™ runtime, when compared to variables initialized on each bar. We thus no longer use var to declare our "int/float/bool" constants, but still use it when an initialization on each bar would require too much time, such as when initializing a string or with a heavy function call. Look first. Then leap. █   FUNCTIONS avgWhen(​src, ​cond)   Gathers values of the source when a condition is true and averages them over the total number of occurrences of the condition.   Parameters:      src : (series int/float) The source of the values to be averaged.      cond : (series bool) The condition determining when a value will be included in the set of values to be averaged.   Returns: (float) A cumulative average of values when a condition is met. avgWhenLast(​src, ​cond, ​cnt)   Gathers values of the source when a condition is true and averages them over a defined number of occurrences of the condition.   Parameters:      src : (series int/float) The source of the values to be averaged.      cond : (series bool) The condition determining when a value will be included in the set of values to be averaged.      cnt : (simple int) The quantity of last occurrences of the condition for which to average values.   Returns: (float) The average of `src` for the last `x` occurrences where `cond` is true. avgWhenInLast(​src, ​cond, ​cnt)   Gathers values of the source when a condition is true and averages them over the total number of occurrences during a defined number of bars back.   Parameters:      src : (series int/float) The source of the values to be averaged.      cond : (series bool) The condition determining when a value will be included in the set of values to be averaged.      cnt : (simple int) The quantity of bars back to evaluate.   Returns: (float) The average of `src` in last `cnt` bars, but only when `cond` is true. avgSince(​src, ​cond)   Averages values of the source since a condition was true.   Parameters:      src : (series int/float) The source of the values to be averaged.      cond : (series bool) The condition determining when the average is reset.   Returns: (float) The average of `src` since `cond` was true. avgForTimeWhen(​src, ​ms, ​cond, ​minBars)   Averages values of `src` when `cond` is true, over a moving window of length `ms` milliseconds.   Parameters:      src : (series int/float) The source of the values to be averaged.      ms : (simple int) The time duration in milliseconds defining the size of the moving window.      cond : (series bool) The condition determining which values are included. Optional.      minBars : (simple int) The minimum number of values to keep in the moving window. Optional.   Returns: (float) The average of `src` when `cond` is true in the moving window. totalForTimeWhen(​src, ​ms, ​cond, ​minBars)   Sums values of `src` when `cond` is true, over a moving window of length `ms` milliseconds.   Parameters:      src : (series int/float) The source of the values to be summed.      ms : (simple int) The time duration in milliseconds defining the size of the moving window.      cond : (series bool) The condition determining which values are included. Optional.      minBars : (simple int) The minimum number of values to keep in the moving window. Optional.   Returns: (float) The sum of `src` when `cond` is true in the moving window.
Pine Script®腳本庫
由PineCoders提供
5
HighTimeframeTimingLibrary "HighTimeframeTiming" @description Library for sampling high timeframe (HTF) historical data at an arbitrary number of HTF bars back, using a single security() call. The data is fixed and does not alter over the course of the HTF bar. It also behaves consistently on historical and elapsed realtime bars. ‼ LIMITATIONS: This library function depends on there being a consistent number of chart timeframe bars within the HTF bar. This is almost always true in 24/7 markets like crypto. This might not be true if the chart doesn't produce an update when expected, for example because the asset is thinly traded and there is no volume or price update from the feed at that time. To mitigate this risk, use this function on liquid assets and at chart timeframes high enough to reliably produce updates at least once per bar period. The consistent ratio of bars might also break down in markets with irregular sessions and hours. I'm not sure if or how one could mitigate this. Another limitation is that because we're accessing a multiplied number of chart bars, you will run out of chart bars faster than you would HTF bars. This is only a problem if you use a large historical operator. If you call a function from this library, you should probably reproduce these limitations in your script description. However, all of this doesn't mean that this function might not still be the best available solution, depending what your needs are. If a single chart bar is skipped, for example, the calculation will be off by 1 until the next HTF bar opens. This is certainly inconsistent, but potentially still usable. @function f_offset_synch(float _HTF_X, int _HTF_H, int _openChartBarsIn, bool _updateEarly) Returns the number of chart bars that you need to go back in order to get a stable HTF value from a given number of HTF bars ago. @param float _HTF_X is the timeframe multiplier, i.e. how much bigger the selected timeframe is than the chart timeframe. The script shows a way to calculate this using another of my libraries without using up a security() call. @param int _HTF_H is the historical operator on the HTF, i.e. how many bars back you want to go on the higher timeframe. If omitted, defaults to zero. @param int _openChartBarsIn is how many chart bars have been opened within the current HTF bar. An example of calculating this is given below. @param bool _updateEarly defines whether you want to update the value at the closing calculation of the last chart bar in the HTF bar or at the open of the first one. @returns an integer that you can use as a historical operator to retrieve the value for the appropriate HTF bar. 🙏 Credits: This library is an attempt at a solution of the problems in using HTF data that were laid out by Pinecoders in "security() revisited" - Thanks are due to the authors of that work for an understanding of HTF issues. In addition, the current script also includes some of its code. Specifically, this script reuses the main function recommended in "security() revisited", for the purposes of comparison. And it extends that function to access historical data, again just for comparison. All the rest of the code, and in particular all of the code in the exported function, is my own. Special thanks to LucF for pointing out the limitations of my approach. ~~~~~~~~~~~~~~~~| EXPLANATION ~~~~~~~~~~~~~~~~| Problems with live HTF data: Many problems with using live HTF data from security() have been clearly explained by Pinecoders in "security() revisited" In short, its behaviour is inconsistent between historical and elapsed realtime bars, and it changes in realtime, which can cause calculations and alerts to misbehave. Various unsatisfactory solutions are discussed in "security() revisited", and understanding that script is a prerequisite to understanding this library. PineCoders give their own solution, which is to fix the data by essentially using the previous HTF bar's data. Importantly, that solution is consistent between historical and realtime bars. This library is an attempt to provide an alternative to that solution. Problems with historical HTF data: In addition to the problems with live HTF data, there are different issues when trying to access historical HTF data. Why use historical HTF data? Maybe you want to do custom calculations that involve previous HTF bars. Or to use HTF data in a function that has mutable variables and so can't be done in a security() call. Most obviously, using the historical operator (in this description, represented using { } because the square brackets don't render) on variables already retrieved from a security() call, e.g. HTF_Close{1}, is not very useful: it retrieves the value from the previous *chart* bar, not the previous HTF bar. Using {1} directly in the security() call instead does get data from the previous HTF bar, but it behaves inconsistently, as we shall see. This library addresses these concerns as well. Housekeeping: To follow what's going on with the example and comparisons, turn line labels on: Settings > Scales > Indicator Name Label. The following explanation assumes "close" as the source, but you can change it if you want. To quickly see the difference between historical and realtime bars, set the HTF to something like 3 minutes on a 15s chart. The bars at the top of the screen show the status. Historical bars are grey, elapsed realtime bars are red, and the realtime bar is green. A white vertical line shows the open of a HTF bar. A: This library function f_offset_synch(): When supplied with an input offset of 0, it plots a stable value of the close of the *previous* HTF bar. This value is thus safe to use for calculations and alerts. For a historical operator of {1}, it gives the close of the *last-but-one* bar. Sounds simple enough. Let's look at the other options to see its advantages. B: Live HTF data: Represented on the line label as "security(){0}". Note: this is the source that f_offset_synch() samples. The raw HTF data is very different on historical and realtime bars: + On historical bars, it uses a flat value from the end of the previous HTF bar. It updates at the close of the HTF bar. + On realtime bars, it varies between and within each chart bar. There might be occasions where you want to use live data, in full knowledge of its drawbacks described above. For example, to show simple live conditions that are reversible after a chart bar close. This library transforms live data to get the fixed data, thus giving you access to both live and fixed data with only one security() call. C: Historical data using security(){H}: To see how this behaves, set the {H} value in the settings to 1 and show options A, B, and C. + On historical bars, this option matches option A, this library function, exactly. It behaves just like security(){0} but one HTF bar behind, as you would expect. + On realtime bars, this option takes the value of security(){0} at the end of a HTF bar, but it takes it from the previous *chart* bar, and then persists that. The easiest way to see this inconsistency is on the first realtime bar (marked red at the top of the screen). This option suddenly jumps, even if it's in the middle of a HTF bar. Contrast this with option A, which is always constant, until it updates, once per HTF bar. D: PineCoders' original function: To see how this behaves, show options A, B, and D. Set the {H} value in the settings to 0, then 1. The PineCoders' original function (D) and extended function (E) do not have the same limitations as this library, described in the Limitations section. This option has all of the same advantages that this library function, option A, does, with the following differences: + It cannot access historical data. The {H} setting makes no difference. + It always updates at the open of the first chart bar in a new HTF bar. By contrast, this library function, option A, is configured by default to update at the close of the last chart bar in a HTF bar. This little frontrunning is only a few seconds but could be significant in trading. E.g. on a 1D HTF with a 4H chart, an alert that involves a HTF change set to trigger ON CLOSE would trigger 4 hours later using this method - but use exactly the same value. It depends on the market and timeframe as to whether you could actually trade this. E.g. at the very end of a tradfi day your order won't get executed. This behaviour mimics how security() itself updates, as is easy to see on the chart. If you don't want it, just set in_updateEarly to false. Then it matches option D exactly. E: PineCoders' function, extended to get history: To see how this behaves, show options A and E. Set the {H} value in the settings to 0, then 1. I modified the original function to be able to get historical values. In all other respects it is the same. Apart from not having the option to update earlier, the only disadvantage of this method vs this library function is that it requires one security() call for each historical operator. For example, if you wanted live data, and fixed data, and fixed data one bar back, you would need 3 security() calls. My library function requires just one. This is the essential tradeoff: extra complexity and less robustness in certain circumstances (the PineCoders function is simple and universal by comparison) for more flexibility with fewer security() calls.
Pine Script®腳本庫
由SimpleCryptoLife提供
7
harmonicpatternsarraysLibrary "harmonicpatternsarrays" Library provides an alternative method to scan harmonic patterns and contains utility functions using arrays. These are mostly customized for personal use. Hence, will not add documentation for arrays. All credit to @HeWhoMustNotBeNamed getLabel() delete() delete() delete() delete() delete() pop() pop() pop() pop() pop() shift() shift() shift() shift() shift() unshift() unshift() unshift() unshift() unshift() unshift() unshift() unshift() unshift() unshift() clear() clear() clear() clear() clear() push() push() push() push() push() push() push() push() push() push() get_trend_series() getrange() getSupportedPatterns() scan_xab() scan_abc_axc() scan_bcd() scan_xad_xcd() get_prz_range() isHarmonicPattern()
Pine Script®腳本庫
由CryptoArch_提供
2