Inizia

MATH

FunctionLAPACKdsyrkLibrary "FunctionLAPACKdsyrk" subroutine part of LAPACK: Linear Algebra Package, performs one of the symmetric rank k operations . C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, . where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. . reference: netlib.org dsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)   performs one of the symmetric rank k operations . C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, . where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. .   Parameters:      uplo : string specifies whether the upper or lower triangular part of the array C is to be referenced as follows: UPLO = 'U' or 'u' Only the upper triangular part of C is to be referenced. UPLO = 'L' or 'l' Only the lower triangular part of C is to be referenced. .      trans : string specifies the operation to be performed as follows: TRANS = 'N' or 'n' C := alpha*A*A**T + beta*C. TRANS = 'T' or 't' C := alpha*A**T*A + beta*C. TRANS = 'C' or 'c' C := alpha*A**T*A + beta*C. .      n : int specifies the order of the matrix C. N must be at least zero.      k : int On entry with: TRANS = 'N' or 'n', K specifies the number of columns of the matrix A. TRANS = 'T' or 't' or 'C' or 'c', K specifies the number of rows of the matrix A. K must be at least zero. .      alpha : float scalar.      a : matrix matrix A.      lda : int specifies the first dimension of A.      beta : float scalar.      c : matrix matrix C, is overwritten by the lower triangular part of the updated matrix.      ldc : int specifies the first dimension of C   Returns: void, C is overwritten by the lower triangular part of the updated matrix.
Pine Script® library
di RicardoSantos
FunctionLAPACKdtrsmLibrary "FunctionLAPACKdtrsm" subroutine in the LAPACK:linear algebra package, used to solve one of the following matrix equations: op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. The matrix X is overwritten on B. reference: netlib.org dtrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)   solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. The matrix X is overwritten on B.   Parameters:      side : string , On entry, SIDE specifies whether op( A ) appears on the left or right of X as follows: SIDE = 'L' or 'l' op( A )*X = alpha*B. SIDE = 'R' or 'r' X*op( A ) = alpha*B.      uplo : string , specifies whether the matrix A is an upper or lower triangular matrix as follows: UPLO = 'U' or 'u' A is an upper triangular matrix. UPLO = 'L' or 'l' A is a lower triangular matrix.      transa : string , specifies the form of op( A ) to be used in the matrix multiplication as follows: TRANSA = 'N' or 'n' op( A ) = A. TRANSA = 'T' or 't' op( A ) = A**T. TRANSA = 'C' or 'c' op( A ) = A**T.      diag : string , specifies whether or not A is unit triangular as follows: DIAG = 'U' or 'u' A is assumed to be unit triangular. DIAG = 'N' or 'n' A is not assumed to be unit triangular.      m : int , the number of rows of B. M must be at least zero.      n : int , the number of columns of B. N must be at least zero.      alpha : float , specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.      a : matrix, Triangular matrix.      lda : int , specifies the first dimension of A.      b : matrix, right-hand side matrix B, and on exit is overwritten by the solution matrix X.      ldb : int , specifies the first dimension of B.   Returns: void, modifies matrix b. usage: dtrsm ('L', 'U', 'N', 'N', 5, 3, 1.0, a, 7, b, 6)
Pine Script® library
di RicardoSantos
BoxLine_LibLibrary "BoxLine_Lib" personal Library for line and box built in functions lineXY(x)    get x1,y1,x2,y2 in a tuple   Parameters:      x : TODO: line   Returns: tuple of x1,y1,x2,y2 line(x)   Create line with only the y1 value(when line == na) or all when line != na set x1,y1,x2,y2 individually just 1 or all - use just the line value to set the x2 to current bar or time will set to time - will auto pick xloc.bar_index or xloc.bar_time if not used   Parameters:      x : (line line,int x1,float y1,int x2,float y2, string xloc,string extend,color color,string style,int width)   Returns: Line boxXY(x)    get left,top,right,bottom in a tuple   Parameters:      x : box   Returns: tuple of left,top,right,bottom box(x)   Create line with only the top,bottom value(when line == na) or all when box != na set left,top,right,bottom individually just 1 or all - use just the box value to set the right to current bar or time will set to time - if right is above a number that a bar_index wouldnt be   Parameters:      x : box box,int left,float top,int right, float bottom,color border_color, int border_width, string border_style,string extend,string xloc, color bgcolor,string text,string text_size, color text_color, string text_halign,string text_valign,string text_wrap)   Returns: TODO: Box
Pine Script® library
di FFriZz
2
calcLibrary "calc" Library for math functions. will expand over time. split(_sumTotal, _divideBy, _forceMinimum, _haltOnError)   Split a large number into integer sized chunks   Parameters:      _sumTotal : (int) Total numbert of items      _divideBy : (int) Groups to make      _forceMinimum : (bool) force minimum number 1/group      _haltOnError : (bool) force error if too few groups   Returns: int array of items per group
Pine Script® library
di kaigouthro
3
UtilityFunctionsLibrary "UtilityFunctions" Utility functions written by me printLabelOnLastBar_string(string)   Prints string in a label on the last bar   Parameters:      string : value to print   Returns: void printLabelOnLastBar_float(float)   Prints float in a label on the last bar   Parameters:      float : value to print   Returns: void printSeriesInReverseOnLabels(series)   Prints a float series in labels in reverse (the first value is on the last candle, the second value is on the second to last candle, etc.)   Parameters:      series : float values to print   Returns: void isPeriodDailyBased(string)   Returns true/false if the period is Daily based (1D, 3D, ...)   Parameters:      string : timeframe period   Returns: true/false get_multiplier(string)   Gets the mutliplier of the timeframe passed compared to the current timeframe. If current TF is 5m and the passed timeframe period is 30m, the result will be 6   Parameters:      string : timeframe param   Returns: simple float of the multiplier
Pine Script® library
di lyubooo
percentageLibLibrary "percentageLib" : every thing need anout percentage getPercentage(entry, exit)   : get percentage change of of two value   Parameters:      entry : : value of entry price      exit : : value of exit price   Returns: : negative or positive value applyPercentageNoAddUp(price, percentage)   : apply percentage change on value decrease or increase   Parameters:      price : : value of price      percentage : : percentage change can be negative or positive   Returns: : return only positive value applyPercentageAddUp(price, percentage)   : apply percentage change on value decrease or increase   Parameters:      price : : value of price      percentage : : percentage change can be negative or positive   Returns: : return only positive value reversePercentage(percentage)   : get percentage (positive or negative) and return the percentage need to back to previous price   Parameters:      percentage : : percentage change can be negative or positive   Returns: : return positive/negative value @example : reversePercentage(10) =>11.11111111111111111111111 , reversePercentage(10) =>9.0909090909090909 getReversePercentage(price, percentage)   : get two prices and return the percentage need to back to previous price   Parameters:      price : : value of price      percentage : : percentage change can be negative or positive   Returns: : return only positive value @example : getReversePercentage(100,90) =>11.11111111111111111111111 multipeBarTotalPercentage()
Pine Script® library
di crypto1-ejarehkhodro
Moving_AveragesLibrary "Moving_Averages" This library contains majority important moving average functions with int series support. Which means that they can be used with variable length input. For conventional use, please use tradingview built-in ta functions for moving averages as they are more precise. I'll use functions in this library for my other scripts with dynamic length inputs. ema(src, len)   Exponential Moving Average (EMA)   Parameters:      src : Source      len : Period   Returns: Exponential Moving Average with Series Int Support (EMA) alma(src, len, a_offset, a_sigma)   Arnaud Legoux Moving Average (ALMA)   Parameters:      src : Source      len : Period      a_offset : Arnaud Legoux offset      a_sigma : Arnaud Legoux sigma   Returns: Arnaud Legoux Moving Average (ALMA) covwema(src, len)   Coefficient of Variation Weighted Exponential Moving Average (COVWEMA)   Parameters:      src : Source      len : Period   Returns: Coefficient of Variation Weighted Exponential Moving Average (COVWEMA) covwma(src, len)   Coefficient of Variation Weighted Moving Average (COVWMA)   Parameters:      src : Source      len : Period   Returns: Coefficient of Variation Weighted Moving Average (COVWMA) dema(src, len)   DEMA - Double Exponential Moving Average   Parameters:      src : Source      len : Period   Returns: DEMA - Double Exponential Moving Average edsma(src, len, ssfLength, ssfPoles)   EDSMA - Ehlers Deviation Scaled Moving Average   Parameters:      src : Source      len : Period      ssfLength : EDSMA - Super Smoother Filter Length      ssfPoles : EDSMA - Super Smoother Filter Poles   Returns: Ehlers Deviation Scaled Moving Average (EDSMA) eframa(src, len, FC, SC)   Ehlrs Modified Fractal Adaptive Moving Average (EFRAMA)   Parameters:      src : Source      len : Period      FC : Lower Shift Limit for Ehlrs Modified Fractal Adaptive Moving Average      SC : Upper Shift Limit for Ehlrs Modified Fractal Adaptive Moving Average   Returns: Ehlrs Modified Fractal Adaptive Moving Average (EFRAMA) ehma(src, len)   EHMA - Exponential Hull Moving Average   Parameters:      src : Source      len : Period   Returns: Exponential Hull Moving Average (EHMA) etma(src, len)   Exponential Triangular Moving Average (ETMA)   Parameters:      src : Source      len : Period   Returns: Exponential Triangular Moving Average (ETMA) frama(src, len)   Fractal Adaptive Moving Average (FRAMA)   Parameters:      src : Source      len : Period   Returns: Fractal Adaptive Moving Average (FRAMA) hma(src, len)   HMA - Hull Moving Average   Parameters:      src : Source      len : Period   Returns: Hull Moving Average (HMA) jma(src, len, jurik_phase, jurik_power)   Jurik Moving Average - JMA   Parameters:      src : Source      len : Period      jurik_phase : Jurik (JMA) Only - Phase      jurik_power : Jurik (JMA) Only - Power   Returns: Jurik Moving Average (JMA) kama(src, len, k_fastLength, k_slowLength)   Kaufman's Adaptive Moving Average (KAMA)   Parameters:      src : Source      len : Period      k_fastLength : Number of periods for the fastest exponential moving average      k_slowLength : Number of periods for the slowest exponential moving average   Returns: Kaufman's Adaptive Moving Average (KAMA) kijun(_high, _low, len, kidiv)   Kijun v2   Parameters:      _high : High value of bar      _low : Low value of bar      len : Period      kidiv : Kijun MOD Divider   Returns: Kijun v2 lsma(src, len, offset)   LSMA/LRC - Least Squares Moving Average / Linear Regression Curve   Parameters:      src : Source      len : Period      offset : Offset   Returns: Least Squares Moving Average (LSMA)/ Linear Regression Curve (LRC) mf(src, len, beta, feedback, z)   MF - Modular Filter   Parameters:      src : Source      len : Period      beta : Modular Filter, General Filter Only - Beta      feedback : Modular Filter Only - Feedback      z : Modular Filter Only - Feedback Weighting   Returns: Modular Filter (MF) rma(src, len)   RMA - RSI Moving average   Parameters:      src : Source      len : Period   Returns: RSI Moving average (RMA) sma(src, len)   SMA - Simple Moving Average   Parameters:      src : Source      len : Period   Returns: Simple Moving Average (SMA) smma(src, len)   Smoothed Moving Average (SMMA)   Parameters:      src : Source      len : Period   Returns: Smoothed Moving Average (SMMA) stma(src, len)   Simple Triangular Moving Average (STMA)   Parameters:      src : Source      len : Period   Returns: Simple Triangular Moving Average (STMA) tema(src, len)   TEMA - Triple Exponential Moving Average   Parameters:      src : Source      len : Period   Returns: Triple Exponential Moving Average (TEMA) thma(src, len)   THMA - Triple Hull Moving Average   Parameters:      src : Source      len : Period   Returns: Triple Hull Moving Average (THMA) vama(src, len, volatility_lookback)   VAMA - Volatility Adjusted Moving Average   Parameters:      src : Source      len : Period      volatility_lookback : Volatility lookback length   Returns: Volatility Adjusted Moving Average (VAMA) vidya(src, len)   Variable Index Dynamic Average (VIDYA)   Parameters:      src : Source      len : Period   Returns: Variable Index Dynamic Average (VIDYA) vwma(src, len)   Volume-Weighted Moving Average (VWMA)   Parameters:      src : Source      len : Period   Returns: Volume-Weighted Moving Average (VWMA) wma(src, len)   WMA - Weighted Moving Average   Parameters:      src : Source      len : Period   Returns: Weighted Moving Average (WMA) zema(src, len)   Zero-Lag Exponential Moving Average (ZEMA)   Parameters:      src : Source      len : Period   Returns: Zero-Lag Exponential Moving Average (ZEMA) zsma(src, len)   Zero-Lag Simple Moving Average (ZSMA)   Parameters:      src : Source      len : Period   Returns: Zero-Lag Simple Moving Average (ZSMA) evwma(src, len)   EVWMA - Elastic Volume Weighted Moving Average   Parameters:      src : Source      len : Period   Returns: Elastic Volume Weighted Moving Average (EVWMA) tt3(src, len, a1_t3)   Tillson T3   Parameters:      src : Source      len : Period      a1_t3 : Tillson T3 Volume Factor   Returns: Tillson T3 gma(src, len)   GMA - Geometric Moving Average   Parameters:      src : Source      len : Period   Returns: Geometric Moving Average (GMA) wwma(src, len)   WWMA - Welles Wilder Moving Average   Parameters:      src : Source      len : Period   Returns: Welles Wilder Moving Average (WWMA) ama(src, _high, _low, len, ama_f_length, ama_s_length)   AMA - Adjusted Moving Average   Parameters:      src : Source      _high : High value of bar      _low : Low value of bar      len : Period      ama_f_length : Fast EMA Length      ama_s_length : Slow EMA Length   Returns: Adjusted Moving Average (AMA) cma(src, len)   Corrective Moving average (CMA)   Parameters:      src : Source      len : Period   Returns: Corrective Moving average (CMA) gmma(src, len)   Geometric Mean Moving Average (GMMA)   Parameters:      src : Source      len : Period   Returns: Geometric Mean Moving Average (GMMA) ealf(src, len, LAPercLen_, FPerc_)   Ehler's Adaptive Laguerre filter (EALF)   Parameters:      src : Source      len : Period      LAPercLen_ : Median Length      FPerc_ : Median Percentage   Returns: Ehler's Adaptive Laguerre filter (EALF) elf(src, len, LAPercLen_, FPerc_)   ELF - Ehler's Laguerre filter   Parameters:      src : Source      len : Period      LAPercLen_ : Median Length      FPerc_ : Median Percentage   Returns: Ehler's Laguerre Filter (ELF) edma(src, len)   Exponentially Deviating Moving Average (MZ EDMA)   Parameters:      src : Source      len : Period   Returns: Exponentially Deviating Moving Average (MZ EDMA) pnr(src, len, rank_inter_Perc_)   PNR - percentile nearest rank   Parameters:      src : Source      len : Period      rank_inter_Perc_ : Rank and Interpolation Percentage   Returns: Percentile Nearest Rank (PNR) pli(src, len, rank_inter_Perc_)   PLI - Percentile Linear Interpolation   Parameters:      src : Source      len : Period      rank_inter_Perc_ : Rank and Interpolation Percentage   Returns: Percentile Linear Interpolation (PLI) rema(src, len)   Range EMA (REMA)   Parameters:      src : Source      len : Period   Returns: Range EMA (REMA) sw_ma(src, len)   Sine-Weighted Moving Average (SW-MA)   Parameters:      src : Source      len : Period   Returns: Sine-Weighted Moving Average (SW-MA) vwap(src, len)   Volume Weighted Average Price (VWAP)   Parameters:      src : Source      len : Period   Returns: Volume Weighted Average Price (VWAP) mama(src, len)   MAMA - MESA Adaptive Moving Average   Parameters:      src : Source      len : Period   Returns: MESA Adaptive Moving Average (MAMA) fama(src, len)   FAMA - Following Adaptive Moving Average   Parameters:      src : Source      len : Period   Returns: Following Adaptive Moving Average (FAMA) hkama(src, len)   HKAMA - Hilbert based Kaufman's Adaptive Moving Average   Parameters:      src : Source      len : Period   Returns: Hilbert based Kaufman's Adaptive Moving Average (HKAMA)
Pine Script® library
di MightyZinger
Price Displacement - Candlestick (OHLC) CalculationsA Magical little helper friend for Candle Math. When composing scripts, it is often necessary to manipulate the math around the OHLC. At times, you want a scalar (absolute) value others you want a vector (+/-). Sometimes you want the open - close and sometimes you want just the positive number of the body size. You might want it in ticks or you might want it in points or you might want in percentages. And every time you try to put it together you waste precious time and brain power trying to think about how to properly structure what you're looking for. Not to mention it's normally not that aesthetically pleasing to look at in the code. So, this fixes all of that. Using this library. A function like 'pd.pt(_exp)' can call any kind of candlestick math you need. The function returns the candlestick math you define using particular expressions. Candle Math Functions Include: Points: pt(_exp) Absolute Point Displacement. Point quantity of given size parameters according to _exp. vpt(_exp) Vector Point Displacement. Point quantity of given size parameters according to _exp. Ticks: tick(_exp) Absolute Tick Displacement. Tick quantity of given size parameters according to _exp. vtick(_exp) Vector Tick Displacement. Tick quantity of given size parameters according to _exp. Percentages: pct(_exp, _prec) Absolute Percent Displacement. (w/rounding overload). Percent quantity of bar range of given size parameters according to _exp. vpct(_exp, _prec) Vector Percent Displacement (w/rounding overload). Percent quantity of bar range of given size parameters according to _exp. Expressions You Can Use with Formulas: The expressions are simple (simple strings that is) and I did my best to make them sensible, generally using just the ohlc abreviations. I also included uw, lw, bd, and rg for when you're just trying to pull a candle component out. That way you don't have to think about which of the ohlc you're trying to get just use pd.tick("uw") and now the variable is assigned the length of the upper wick, absolute value, in ticks. If you wanted the vector in pts its pd.vpt("uw"). It also makes changing things easy too as I write it out. Expression List: Combinations "oh" = open - high "ol" = open - low "oc" = open - close "ho" = high - open "hl" = high - low "hc" = high - close "lo" = low - open "lh" = low - high "lc" = low - close "co" = close - open "ch" = close - high "cl" = close - low Candle Components "uw" = Upper Wick "bd" = Body "lw" = Lower Wick "rg" = Range Pct() Only "scp" = Scalar Close Position "sop" = Scalar Open Position "vcp" = Vector Close Position "vop" = Vector Open Position The attributes are going to be available in the pop up dialogue when you mouse over the function, so you don't really have to remember them. I tried to make that look as efficient as possible. You'll notice it follows the OHLC pattern. Thus, "oh" precedes "ho" (heyo) because "O" would be first in the OHLC. Its a way to help find the expression you're looking for quickly. Like looking through an alphabetized list for traders. There is a copy/paste console friendly helper list in the script itself. Additional Notes on the Pct() Only functions: This is the original reason I started writing this. These concepts place a rating/value on the bar based on candle attributes in one number. These formulas put a open or close value in a percentile of the bar relative to another aspect of the bar. Scalar - Non-directional. Absolute Value. Scalar Position: The position of the price attribute relative to the scale of the bar range (high - low) Example: high = 100. low = 0. close = 25. (A) Measure price distance C-L. How high above the low did the candle close (e.g. close - low = 25) (B) Divide by bar range (high - low). 25 / (100 - 0) = .25 Explaination: The candle closed at the 25th percentile of the bar range given the bar range low = 0 and bar range high = 100. Formula: scp = (close - low) / (high - low) Vector = Directional. Vector Position: The position of the price attribute relative to the scale of the bar midpoint (Vector Position at hl2 = 0) Example: high = 100. low = 0. close = 25. (A) Measure Price distance C-L: How high above the low did the candle close (e.g. close - low = 25) (B) Measure Price distance H-C: How far below the high did the candle close (e.g. high - close = 75) (C) Take Difference: A - B = C = -50 (D) Divide by bar range (high - low). -50 / (100 - 0) = -0.50 Explaination: Candle close at the midpoint between hl2 and the low. Formula: vcp = { / (high - low) } Thank you for checking this out. I hope no one else has already done this (because it took half the day) and I hope you find value in it. Be well. Trade well. Library "PD" Price Displacement pt(_exp) Absolute Point Displacement. Point quantity of given size parameters according to _exp.   Parameters:      _exp : (string) Price Parameter   Returns: Point size of given expression as an absolute value. vpt(_exp) Vector Point Displacement. Point quantity of given size parameters according to _exp.   Parameters:      _exp : (string) Price Parameter   Returns: Point size of given expression as a vector. tick(_exp) Absolute Tick Displacement. Tick quantity of given size parameters according to _exp.   Parameters:      _exp : (string) Price Parameter   Returns: Tick size of given expression as an absolute value. vtick(_exp) Vector Tick Displacement. Tick quantity of given size parameters according to _exp.   Parameters:      _exp : (string) Price Parameter   Returns: Tick size of given expression as a vector. pct(_exp, _prec) Absolute Percent Displacement (w/rounding overload). Percent quantity of bar range of given size parameters according to _exp.   Parameters:      _exp : (string) Expression      _prec : (int) Overload - Place value precision definition   Returns: Percent size of given expression as decimal. vpct(_exp, _prec) Vector Percent Displacement (w/rounding overload). Percent quantity of bar range of given size parameters according to _exp.   Parameters:      _exp : (string) Expression      _prec : (int) Overload - Place value precision definition   Returns: Percent size of given expression as decimal.
Pine Script® library
di kurtsmock
1
honest personal libraryLibrary "honestpersonallibrary" thestratnumber() this will return the number 1,2 or 3 using the logic from Rob Smiths #thestrat which uses these type of bars for setups getBodySize() Gets the current candle's body size (in POINTS, divide by 10 to get pips)   Returns: The current candle's body size in POINTS getTopWickSize() Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's top wick size in POINTS getBottomWickSize() Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's bottom wick size in POINTS getBodyPercent() Gets the current candle's body size as a percentage of its entire size including its wicks   Returns: The current candle's body size percentage strictBearPinBar(float, float) This it to find pinbars with a very long wick compared to the body that are bearish   Parameters:      float : minTopMulitplier (default=4) The minimum number of times that the top wick has to be bigger than the candle body size      float : maxBottomMultiplier (default=2) The maximum number of times that the bottom wick can be bigger than the candle body size   Returns: a bool function true if current candle is withing the parameters strictBullPinBar(float, float) This it to find pinbars with a very long wick compared to the body that are bearish   Parameters:      float : minTopMulitplier (default=4) The minimum number of times that the top wick has to be bigger than the candle body size      float : maxBottomMultiplier (default=2) The maximum number of times that the bottom wick can be bigger than the candle body size   Returns: a bool function true if current candle is withing the parameters
Pine Script® library
di Honestcowboy
OrdinaryLeastSquaresLibrary "OrdinaryLeastSquares" One of the most common ways to estimate the coefficients for a linear regression is to use the Ordinary Least Squares (OLS) method. This library implements OLS in pine. This implementation can be used to fit a linear regression of multiple independent variables onto one dependent variable, as long as the assumptions behind OLS hold. solve_xtx_inv(x, y) Solve a linear system of equations using the Ordinary Least Squares method. This function returns both the estimated OLS solution and a matrix that essentially measures the model stability (linear dependence between the columns of 'x'). NOTE: The latter is an intermediate step when estimating the OLS solution but is useful when calculating the covariance matrix and is returned here to save computation time so that this step doesn't have to be calculated again when things like standard errors should be calculated.   Parameters:      x : The matrix containing the independent variables. Each column is regarded by the algorithm as one independent variable. The row count of 'x' and 'y' must match.      y : The matrix containing the dependent variable. This matrix can only contain one dependent variable and can therefore only contain one column. The row count of 'x' and 'y' must match.   Returns: Returns both the estimated OLS solution and a matrix that essentially measures the model stability (xtx_inv is equal to (X'X)^-1). solve(x, y) Solve a linear system of equations using the Ordinary Least Squares method.   Parameters:      x : The matrix containing the independent variables. Each column is regarded by the algorithm as one independent variable. The row count of 'x' and 'y' must match.      y : The matrix containing the dependent variable. This matrix can only contain one dependent variable and can therefore only contain one column. The row count of 'x' and 'y' must match.   Returns: Returns the estimated OLS solution. standard_errors(x, y, beta_hat, xtx_inv) Calculate the standard errors.   Parameters:      x : The matrix containing the independent variables. Each column is regarded by the algorithm as one independent variable. The row count of 'x' and 'y' must match.      y : The matrix containing the dependent variable. This matrix can only contain one dependent variable and can therefore only contain one column. The row count of 'x' and 'y' must match.      beta_hat : The Ordinary Least Squares (OLS) solution provided by solve_xtx_inv() or solve().      xtx_inv : This is (X'X)^-1, which means we take the transpose of the X matrix, multiply that the X matrix and then take the inverse of the result. This essentially measures the linear dependence between the columns of the X matrix.   Returns: The standard errors. estimate(x, beta_hat) Estimate the next step of a linear model.   Parameters:      x : The matrix containing the independent variables. Each column is regarded by the algorithm as one independent variable. The row count of 'x' and 'y' must match.      beta_hat : The Ordinary Least Squares (OLS) solution provided by solve_xtx_inv() or solve().   Returns: Returns the new estimate of Y based on the linear model.
Pine Script® library
di lejmer
FunctionPolynomialFitLibrary "FunctionPolynomialFit" Performs Polynomial Regression fit to data. In statistics, polynomial regression is a form of regression analysis in which the relationship between the independent variable x and the dependent variable y is modelled as an nth degree polynomial in x. reference: en.wikipedia.org www.bragitoff.com gauss_elimination(A, m, n) Perform Gauss-Elimination and returns the Upper triangular matrix and solution of equations.   Parameters:      A : float matrix, data samples.      m : int, defval=na, number of rows.      n : int, defval=na, number of columns.   Returns: float array with coefficients. polyfit(X, Y, degree) Fits a polynomial of a degree to (x, y) points.   Parameters:      X : float array, data sample x point.      Y : float array, data sample y point.      degree : int, defval=2, degree of the polynomial.   Returns: float array with coefficients. note: p(x) = p * x**deg + ... + p interpolate(coeffs, x) interpolate the y position at the provided x.   Parameters:      coeffs : float array, coefficients of the polynomial.      x : float, position x to estimate y.   Returns: float.
Pine Script® library
di RicardoSantos
10
DominantCycleCollection of Dominant Cycle estimators. Length adaptation used in the Adaptive Moving Averages and the Adaptive Oscillators try to follow price movements and accelerate/decelerate accordingly (usually quite rapidly with a huge range). Cycle estimators, on the other hand, try to measure the cycle period of the current market, which does not reflect price movement or the rate of change (the rate of change may also differ depending on the cycle phase, but the cycle period itself usually changes slowly). This collection may become encyclopaedic, so if you have any working cycle estimator, drop me a line in the comments below. Suggestions are welcome. Currently included estimators are based on the work of John F. Ehlers mamaPeriod(src, dynLow, dynHigh) MESA Adaptation - MAMA Cycle   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 Performs Hilbert Transform Homodyne Discriminator cycle measurement Unlike MAMA Alpha function (in LengthAdaptation library), this does not compute phase rate of change Introduced in the September 2001 issue of Stocks and Commodities Inspired by the @everget implementation: Inspired by the @anoojpatel implementation: paPeriod(src, dynLow, dynHigh, preHP, preSS, preHP) Pearson Autocorrelation   Parameters:      src : Series to use      dynLow : Lower bound for the dynamic length      dynHigh : Upper bound for the dynamic length      preHP : Use High Pass prefilter (default)      preSS : Use Super Smoother prefilter (default)      preHP : Use Hann Windowing prefilter   Returns: Calculated period Based on Pearson Autocorrelation Periodogram by John F. Ehlers Introduced in the September 2016 issue of Stocks and Commodities Inspired by the @blackcat1402 implementation: Inspired by the @rumpypumpydumpy implementation: Corrected many errors, and made small speed optimizations, so this could be the best implementation to date (still slow, though, so may revisit in future) High Pass and Super Smoother prefilters are used in the original implementation dftPeriod(src, dynLow, dynHigh, preHP, preSS, preHP) Discrete Fourier Transform   Parameters:      src : Series to use      dynLow : Lower bound for the dynamic length      dynHigh : Upper bound for the dynamic length      preHP : Use High Pass prefilter (default)      preSS : Use Super Smoother prefilter (default)      preHP : Use Hann Windowing prefilter   Returns: Calculated period Based on Spectrum from Discrete Fourier Transform by John F. Ehlers Inspired by the @blackcat1402 implementation: High Pass, Super Smoother and Hann Windowing prefilters are used in the original implementation phasePeriod(src, dynLow, dynHigh, preHP, preSS, preHP) Phase Accumulation   Parameters:      src : Series to use      dynLow : Lower bound for the dynamic length      dynHigh : Upper bound for the dynamic length      preHP : Use High Pass prefilter (default)      preSS : Use Super Smoother prefilter (default)      preHP : Use Hamm Windowing prefilter   Returns: Calculated period Based on Dominant Cycle from Phase Accumulation by John F. Ehlers High Pass and Super Smoother prefilters are used in the original implementation doAdapt(type, src, len, dynLow, dynHigh, chandeSDLen, chandeSmooth, chandePower, preHP, preSS, preHP) Execute a particular Length Adaptation or Dominant Cycle Estimator from the list   Parameters:      type : Length Adaptation or Dominant Cycle Estimator 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)      preHP : Use High Pass prefilter for the Estimators that support it (default)      preSS : Use Super Smoother prefilter for the Estimators that support it (default)      preHP : Use Hann Windowing prefilter for the Estimators that support it   Returns: Calculated period (float, not limited) doEstimate(type, src, dynLow, dynHigh, preHP, preSS, preHP) Execute a particular Dominant Cycle Estimator from the list   Parameters:      type : Dominant Cycle Estimator type to use      src : Series to use      dynLow : Lower bound for the dynamic length      dynHigh : Upper bound for the dynamic length      preHP : Use High Pass prefilter for the Estimators that support it (default)      preSS : Use Super Smoother prefilter for the Estimators that support it (default)      preHP : Use Hann Windowing prefilter for the Estimators that support it   Returns: Calculated period (float, not limited)
Pine Script® library
di lastguru
6
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® library
di 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® library
di 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® library
di dandrideng