Linearalgebra — Indicators and Strategies

regressions Library "regressions" This library computes least square regression models for polynomials of any form for a given data set of x and y values. fit(X, y, reg_type, degrees) Takes a list of X and y values and the degrees of the polynomial and returns a least square regression for the given polynomial on the dataset. Parameters: X (array) : (float ) X inputs for regression fit. y (array) : (float ) y outputs for regression fit. reg_type (string) : (string) The type of regression. If passing value for degrees use reg.type_custom degrees (array) : (int ) The degrees of the polynomial which will be fit to the data. ex: passing array.from(0, 3) would be a polynomial of form c1x^0 + c2x^3 where c2 and c1 will be coefficients of the best fitting polynomial. Returns: (regression) returns a regression with the best fitting coefficients for the selecected polynomial regress(reg, x) Regress one x input. Parameters: reg (regression) : (regression) The fitted regression which the y_pred will be calulated with. x (float) : (float) The input value cooresponding to the y_pred. Returns: (float) The best fit y value for the given x input and regression. predict(reg, X) Predict a new set of X values with a fitted regression. -1 is one bar ahead of the realtime Parameters: reg (regression) : (regression) The fitted regression which the y_pred will be calulated with. X (array) Returns: (float ) The best fit y values for the given x input and regression. generate_points(reg, x, y, left_index, right_index) Takes a regression object and creates chart points which can be used for plotting visuals like lines and labels. Parameters: reg (regression) : (regression) Regression which has been fitted to a data set. x (array) : (float ) x values which coorispond to passed y values y (array) : (float ) y values which coorispond to passed x values left_index (int) : (int) The offset of the bar farthest to the realtime bar should be larger than left_index value. right_index (int) : (int) The offset of the bar closest to the realtime bar should be less than right_index value. Returns: (chart.point ) Returns an array of chart points plot_reg(reg, x, y, left_index, right_index, curved, close, line_color, line_width) Simple plotting function for regression for more custom plotting use generate_points() to create points then create your own plotting function. Parameters: reg (regression) : (regression) Regression which has been fitted to a data set. x (array) y (array) left_index (int) : (int) The offset of the bar farthest to the realtime bar should be larger than left_index value. right_index (int) : (int) The offset of the bar closest to the realtime bar should be less than right_index value. curved (bool) : (bool) If the polyline is curved or not. close (bool) : (bool) If true the polyline will be closed. line_color (color) : (color) The color of the line. line_width (int) : (int) The width of the line. Returns: (polyline) The polyline for the regression. series_to_list(src, left_index, right_index) Convert a series to a list. Creates a list of all the cooresponding source values from left_index to right_index. This should be called at the highest scope for consistency. Parameters: src (float) : (float ) The source the list will be comprised of. left_index (int) : (float ) The left most bar (farthest back historical bar) which the cooresponding source value will be taken for. right_index (int) : (float ) The right most bar closest to the realtime bar which the cooresponding source value will be taken for. Returns: (float ) An array of size left_index-right_index range_list(start, stop, step) Creates an from the start value to the stop value. Parameters: start (int) : (float ) The true y values. stop (int) : (float ) The predicted y values. step (int) : (int) Positive integer. The spacing between the values. ex: start=1, stop=6, step=2: Returns: (float ) An array of size stop-start regression Fields: coeffs (array__float) degrees (array__float) type_linear (series__string) type_quadratic (series__string) type_cubic (series__string) type_custom (series__string) _squared_error (series__float) X (array__float)

FunctionLAPACKdsyrk Library "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.

FunctionLAPACKdtrsm Library "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)

Levinson-Durbin Autocorrelation Extrapolation of Price [Loxx]Levinson-Durbin Autocorrelation Extrapolation of Price is an indicator that uses the Levinson recursion or Levinson–Durbin recursion algorithm to predict price moves. This method is commonly used in speech modeling and prediction engines. What is Levinson recursion or Levinson–Durbin recursion? Is a linear algebra prediction analysis that is performed once per bar using the autocorrelation method with a within a specified asymmetric window. The autocorrelation coefficients of the window are computed and converted to LP coefficients using the Levinson algorithm. The LP coefficients are then transformed to line spectrum pairs for quantization and interpolation. The interpolated quantized and unquantized filters are converted back to the LP filter coefficients to construct the synthesis and weighting filters for each bar. Data inputs Source Settings: -Loxx's Expanded Source Types. You typically use "open" since open has already closed on the current active bar LastBar - bar where to start the prediction PastBars - how many bars back to model LPOrder - order of linear prediction model; 0 to 1 FutBars - how many bars you want to forward predict Things to know Normally, a simple moving average is caculated on source data. I've expanded this to 38 different averaging methods using Loxx's Moving Avreages. This indicator repaints Included Bar color muting Further reading Implementing the Levinson-Durbin Algorithm on the StarCore™ SC140/SC1400 Cores LevinsonDurbin_G729 Algorithm, Calculates LP coefficients from the autocorrelation coefficients. Intel® Integrated Performance Primitives for Intel® Architecture Reference Manual

Matrix Library (Linear Algebra, incl Multiple Linear Regression)What's this all about? Ever since 1D arrays were added to Pine Script, many wonderful new opportunities have opened up. There has been a few implementations of matrices and matrix math (most notably by TradingView-user tbiktag in his recent Moving Regression script: ). However, so far, no comprehensive libraries for matrix math and linear algebra has been developed. This script aims to change that. I'm not math expert, but I like learning new things, so I took it upon myself to relearn linear algebra these past few months, and create a matrix math library for Pine Script. The goal with the library was to make a comprehensive collection of functions that can be used to perform as many of the standard operations on matrices as possible, and to implement functions to solve systems of linear equations. The library implements matrices using arrays, and many standard functions to manipulate these matrices have been added as well. The main purpose of the library is to give users the ability to solve systems of linear equations (useful for Multiple Linear Regression with K number of independent variables for example), but it can also be used to simulate 2D arrays for any purpose. So how do I use this thing? Personally, what I do with my private Pine Script libraries is I keep them stored as text-files in a Libraries folder, and I copy and paste them into my code when I need them. This library is quite large, so I have made sure to use brackets in comments to easily hide any part of the code. This helps with big libraries like this one. The parts of this script that you need to copy are labeled "MathLib", "ArrayLib", and "MatrixLib". The matrix library is dependent on the functions from these other two libraries, but they are stripped down to only include the functions used by the MatrixLib library. When you have the code in your script (pasted somewhere below the "study()" call), you can create a matrix by calling one of the constructor functions. All functions in this library start with "matrix_", and all constructors start with either "create" or "copy". I suggest you read through the code though. The functions have very descriptive names, and a short description of what each function does is included in a header comment directly above it. The functions generally come in the following order: Constructors: These are used to create matrices (empy with no rows or columns, set shape filled with 0s, from a time series or an array, and so on). Getters and setters: These are used to get data from a matrix (like the value of an element or a full row or column). Matrix manipulations: These functions manipulate the matrix in some way (for example, functions to append columns or rows to a matrix). Matrix operations: These are the matrix operations. They include things like basic math operations for two indices, to transposing a matrix. Decompositions and solvers: Next up are functions to solve systems of linear equations. These include LU and QR decomposition and solvers, and functions for calculating the pseudo-inverse or inverse of a matrix. Multiple Linear Regression: Lastly, we find an implementation of a multiple linear regression, including all the standard statistics one can expect to find in most statistical software packages. Are there any working examples of how to use the library? Yes, at the very end of the script, there is an example that plots the predictions from a multiple linear regression with two independent (explanatory) X variables, regressing the chart data (the Y variable) on these X variables. You can look at this code to see a real-world example of how to use the code in this library. Are there any limitations? There are no hard limiations, but the matrices uses arrays, so the number of elements can never exceed the number of elements supported by Pine Script (minus 2, since two elements are used internally by the library to store row and column count). Some of the operations do use a lot of resources though, and as a result, some things can not be done without timing out. This can vary from time to time as well, as this is primarily dependent on the available resources from the Pine Script servers. For instance, the multiple linear regression cannot be used with a lookback window above 10 or 12 most of the time, if the statistics are reported. If no statistics are reported (and therefore not calculated), the lookback window can usually be extended to around 60-80 bars before the servers time out the execution. Hopefully the dev-team at TradingView sees this script and find ways to implement this functionality diretly into Pine Script, as that would speed up many of the operations and make things like MLR (multiple linear regression) possible on a bigger lookback window. Some parting words This library has taken a few months to write, and I have taken all the steps I can think of to test it for bugs. Some may have slipped through anyway, so please let me know if you find any, and I'll try my best to fix them when I have time to do so. This library is intended to help the community. Therefore, I am releasing the library as open source, in the hopes that people may improving on it, or using it in their own work. If you do make something cool with this, or if you find ways to improve the code, please let me know in the comments.