Get started

MATH

TimeSeriesBenchmarkMeasuresLibrary "TimeSeriesBenchmarkMeasures" Time Series Benchmark Metrics. \ Provides a comprehensive set of functions for benchmarking time series data, allowing you to evaluate the accuracy, stability, and risk characteristics of various models or strategies. The functions cover a wide range of statistical measures, including accuracy metrics (MAE, MSE, RMSE, NRMSE, MAPE, SMAPE), autocorrelation analysis (ACF, ADF), and risk measures (Theils Inequality, Sharpness, Resolution, Coverage, and Pinball). ___ Reference: - github.com . - medium.com . - www.salesforce.com . - towardsdatascience.com . - github.com . mae(actual, forecasts)   In statistics, mean absolute error (MAE) is a measure of errors between paired observations expressing the same phenomenon. Examples of Y versus X include comparisons of predicted versus observed, subsequent time versus initial time, and one technique of measurement versus an alternative technique of measurement.   Parameters:      actual (array) : List of actual values.      forecasts (array) : List of forecasts values.   Returns: - Mean Absolute Error (MAE). ___ Reference: - en.wikipedia.org . - The Orange Book of Machine Learning - Carl McBride Ellis . mse(actual, forecasts)   The Mean Squared Error (MSE) is a measure of the quality of an estimator. As it is derived from the square of Euclidean distance, it is always a positive value that decreases as the error approaches zero.   Parameters:      actual (array) : List of actual values.      forecasts (array) : List of forecasts values.   Returns: - Mean Squared Error (MSE). ___ Reference: - en.wikipedia.org . rmse(targets, forecasts, order, offset)   Calculates the Root Mean Squared Error (RMSE) between target observations and forecasts. RMSE is a standard measure of the differences between values predicted by a model and the values actually observed.   Parameters:      targets (array) : List of target observations.      forecasts (array) : List of forecasts.      order (int) : Model order parameter that determines the starting position in the targets array, `default=0`.      offset (int) : Forecast offset related to target, `default=0`.   Returns: - RMSE value. nmrse(targets, forecasts, order, offset)   Normalised Root Mean Squared Error.   Parameters:      targets (array) : List of target observations.      forecasts (array) : List of forecasts.      order (int) : Model order parameter that determines the starting position in the targets array, `default=0`.      offset (int) : Forecast offset related to target, `default=0`.   Returns: - NRMSE value. rmse_interval(targets, forecasts)   Root Mean Squared Error for a set of interval windows. Computes RMSE by converting interval forecasts (with min/max bounds) into point forecasts using the mean of the interval bounds, then compares against actual target values.   Parameters:      targets (array) : List of target observations.      forecasts (matrix) : The forecasted values in matrix format with at least 2 columns (min, max).   Returns: - RMSE value for the combined interval list. mape(targets, forecasts)   Mean Average Percentual Error.   Parameters:      targets (array) : List of target observations.      forecasts (array) : List of forecasts.   Returns: - MAPE value. smape(targets, forecasts, mode)   Symmetric Mean Average Percentual Error. Calculates the Mean Absolute Percentage Error (MAPE) between actual targets and forecasts. MAPE is a common metric for evaluating forecast accuracy, expressed as a percentage, lower values indicate a better forecast accuracy.   Parameters:      targets (array) : List of target observations.      forecasts (array) : List of forecasts.      mode (int) : Type of method: default=0:`sum(abs(Fi-Ti)) / sum(Fi+Ti)` , 1:`mean(abs(Fi-Ti) / ((Fi + Ti) / 2))` , 2:`mean(abs(Fi-Ti) / (abs(Fi) + abs(Ti))) * 100`   Returns: - SMAPE value. mape_interval(targets, forecasts)   Mean Average Percentual Error for a set of interval windows.   Parameters:      targets (array) : List of target observations.      forecasts (matrix) : The forecasted values in matrix format with at least 2 columns (min, max).   Returns: - MAPE value for the combined interval list. acf(data, k)   Autocorrelation Function (ACF) for a time series at a specified lag.   Parameters:      data (array) : Sample data of the observations.      k (int) : The lag period for which to calculate the autocorrelation. Must be a non-negative integer.   Returns: - The autocorrelation value at the specified lag, ranging from -1 to 1. ___ The autocorrelation function measures the linear dependence between observations in a time series at different time lags. It quantifies how well the series correlates with itself at different time intervals, which is useful for identifying patterns, seasonality, and the appropriate lag structure for time series models. ACF values close to 1 indicate strong positive correlation, values close to -1 indicate strong negative correlation, and values near 0 indicate no linear correlation. ___ Reference: - statisticsbyjim.com acf_multiple(data, k)   Autocorrelation function (ACF) for a time series at a set of specified lags.   Parameters:      data (array) : Sample data of the observations.      k (array) : List of lag periods for which to calculate the autocorrelation. Must be a non-negative integer.   Returns: - List of ACF values for provided lags. ___ The autocorrelation function measures the linear dependence between observations in a time series at different time lags. It quantifies how well the series correlates with itself at different time intervals, which is useful for identifying patterns, seasonality, and the appropriate lag structure for time series models. ACF values close to 1 indicate strong positive correlation, values close to -1 indicate strong negative correlation, and values near 0 indicate no linear correlation. ___ Reference: - statisticsbyjim.com adfuller(data, n_lag, conf)   : Augmented Dickey-Fuller test for stationarity.   Parameters:      data (array) : Data series.      n_lag (int) : Maximum lag.      conf (string) : Confidence Probability level used to test for critical value, (`90%`, `95%`, `99%`).   Returns: - `adf` The test statistic. - `crit` Critical value for the test statistic at the 10 % levels. - `nobs` Number of observations used for the ADF regression and calculation of the critical values. ___ The Augmented Dickey-Fuller test is used to determine whether a time series is stationary or contains a unit root (non-stationary). The null hypothesis is that the series has a unit root (is non-stationary), while the alternative hypothesis is that the series is stationary. A stationary time series has statistical properties that do not change over time, making it suitable for many time series forecasting models. If the test statistic is less than the critical value, we reject the null hypothesis and conclude the series is stationary. ___ Reference: - www.jstor.org - en.wikipedia.org theils_inequality(targets, forecasts)   Calculates Theil's Inequality Coefficient, a measure of forecast accuracy that quantifies the relative difference between actual and predicted values.   Parameters:      targets (array) : List of target observations.      forecasts (array) : Matrix with list of forecasts, ordered column wise.   Returns: - Theil's Inequality Coefficient value, value closer to 0 is better. ___ Theil's Inequality Coefficient is calculated as: `sqrt(Sum((y_i - f_i)^2)) / (sqrt(Sum(y_i^2)) + sqrt(Sum(f_i^2)))` where `y_i` represents actual values and `f_i` represents forecast values. This metric ranges from 0 to infinity, with 0 indicating perfect forecast accuracy. ___ Reference: - en.wikipedia.org sharpness(forecasts)   The average width of the forecast intervals across all observations, representing the sharpness or precision of the predictive intervals.   Parameters:      forecasts (matrix) : The forecasted values in matrix format with at least 2 columns (min, max).   Returns: - Sharpness The sharpness level, which is the average width of all prediction intervals across the forecast horizon. ___ Sharpness is an important metric for evaluating forecast quality. It measures how narrow or wide the prediction intervals are. Higher sharpness (narrower intervals) indicates greater precision in the forecast intervals, while lower sharpness (wider intervals) suggests less precision. The sharpness metric is calculated as the mean of the interval widths across all observations, where each interval width is the difference between the upper and lower bounds of the prediction interval. Note: This function assumes that the forecasts matrix has at least 2 columns, with the first column representing the lower bounds and the second column representing the upper bounds of prediction intervals. ___ Reference: - Hyndman, R. J., & Athanasopoulos, G. (2018). Forecasting: principles and practice. OTexts. otexts.com resolution(forecasts)   Calculates the resolution of forecast intervals, measuring the average absolute difference between individual forecast interval widths and the overall sharpness measure.   Parameters:      forecasts (matrix) : The forecasted values in matrix format with at least 2 columns (min, max).   Returns: - The average absolute difference between individual forecast interval widths and the overall sharpness measure, representing the resolution of the forecasts. ___ Resolution is a key metric for evaluating forecast quality that measures the consistency of prediction interval widths. It quantifies how much the individual forecast intervals vary from the average interval width (sharpness). High resolution indicates that the forecast intervals are relatively consistent across observations, while low resolution suggests significant variation in interval widths. The resolution is calculated as the mean absolute deviation of individual interval widths from the overall sharpness value. This provides insight into the uniformity of the forecast uncertainty estimates across the forecast horizon. Note: This function requires the forecasts matrix to have at least 2 columns (min, max) representing the lower and upper bounds of prediction intervals. ___ Reference: - (sites.stat.washington.edu) - (www.jstor.org) coverage(targets, forecasts)   Calculates the coverage probability, which is the percentage of target values that fall within the corresponding forecasted prediction intervals.   Parameters:      targets (array) : List of target values.      forecasts (matrix) : The forecasted values in matrix format with at least 2 columns (min, max).   Returns: - Percent of target values that fall within their corresponding forecast intervals, expressed as a decimal value between 0 and 1 (or 0% and 100%). ___ Coverage probability is a crucial metric for evaluating the reliability of prediction intervals. It measures how well the forecast intervals capture the actual observed values. An ideal forecast should have a coverage probability close to the nominal confidence level (e.g., 90%, 95%, or 99%). For example, if a 95% prediction interval is used, we expect approximately 95% of the actual target values to fall within those intervals. If the coverage is significantly lower than the nominal level, the intervals may be too narrow; if it's significantly higher, the intervals may be too wide. Note: This function requires the targets array and forecasts matrix to have the same number of observations, and the forecasts matrix must have at least 2 columns (min, max) representing the lower and upper bounds of prediction intervals. ___ Reference: - (www.jstor.org) pinball(tau, target, forecast)   Pinball loss function, measures the asymmetric loss for quantile forecasts.   Parameters:      tau (float) : The quantile level (between 0 and 1), where 0.5 represents the median.      target (float) : The actual observed value to compare against.      forecast (float) : The forecasted value.   Returns: - The Pinball loss value, which quantifies the distance between the forecast and target relative to the specified quantile level. ___ The Pinball loss function is specifically designed for evaluating quantile forecasts. It is asymmetric, meaning it penalizes underestimates and overestimates differently depending on the quantile level being evaluated. For a given quantile τ, the loss function is defined as: - If target >= forecast: (target - forecast) * τ - If target < forecast: (forecast - target) * (1 - τ) This loss function is commonly used in quantile regression and probabilistic forecasting to evaluate how well forecasts capture specific quantiles of the target distribution. ___ Reference: - (www.otexts.com) pinball_mean(tau, targets, forecasts)   Calculates the mean pinball loss for quantile regression.   Parameters:      tau (float) : The quantile level (between 0 and 1), where 0.5 represents the median.      targets (array) : The actual observed values to compare against.      forecasts (matrix) : The forecasted values in matrix format with at least 2 columns (min, max).   Returns: - The mean pinball loss value across all observations. ___ The pinball_mean() function computes the average Pinball loss across multiple observations, making it suitable for evaluating overall forecast performance in quantile regression tasks. This function leverages the asymmetric Pinball loss function to evaluate how well forecasts capture specific quantiles of the target distribution. The choice of which column from the forecasts matrix to use depends on the quantile level: - For τ ≤ 0.5: Uses the first column (min) of forecasts - For τ > 0.5: Uses the second column (max) of forecasts This loss function is commonly used in quantile regression and probabilistic forecasting to evaluate how well forecasts capture specific quantiles of the target distribution. ___ Reference: - (www.otexts.com)
Pine Script® library
by RicardoSantos
Correlation HeatMap Matrix Data [TradingFinder]🔵 Introduction Correlation is a statistical measure that shows the degree and direction of a linear relationship between two assets. Its value ranges from -1 to +1 : +1 means perfect positive correlation, 0 means no linear relationship, and -1 means perfect negative correlation. In financial markets, correlation is used for portfolio diversification, risk management, pairs trading, intermarket analysis, and identifying divergences. Correlation HeatMap Matrix Data TradingFinder is a Pine Script v6 library that calculates and returns raw correlation matrix data between up to 20 symbols. It only provides the data – it does not draw or render the heatmap – making it ideal for use in other scripts that handle visualization or further analysis. The library uses ta.correlation for fast and accurate calculations. It also includes two helper functions for visual styling : CorrelationColor(corr) : takes the correlation value as input and generates a smooth gradient color, ranging from strong negative to strong positive correlation. CorrelationTextColor(corr) : takes the correlation value as input and returns a text color that ensures optimal contrast over the background color. Library "Correlation_HeatMap_Matrix_Data_TradingFinder" CorrelationColor(corr)   Parameters:      corr (float) CorrelationTextColor(corr)   Parameters:      corr (float) Data_Matrix(Corr_Period, Sym_1, Sym_2, Sym_3, Sym_4, Sym_5, Sym_6, Sym_7, Sym_8, Sym_9, Sym_10, Sym_11, Sym_12, Sym_13, Sym_14, Sym_15, Sym_16, Sym_17, Sym_18, Sym_19, Sym_20)   Parameters:      Corr_Period (int)      Sym_1 (string)      Sym_2 (string)      Sym_3 (string)      Sym_4 (string)      Sym_5 (string)      Sym_6 (string)      Sym_7 (string)      Sym_8 (string)      Sym_9 (string)      Sym_10 (string)      Sym_11 (string)      Sym_12 (string)      Sym_13 (string)      Sym_14 (string)      Sym_15 (string)      Sym_16 (string)      Sym_17 (string)      Sym_18 (string)      Sym_19 (string)      Sym_20 (string) 🔵 How to use Import the library into your Pine Script using the import keyword and its full namespace. Decide how many symbols you want to include in your correlation matrix (up to 20). Each symbol must be provided as a string, for example FX:EURUSD . Choose the correlation period (Corr\_Period) in bars. This is the lookback window used for the calculation, such as 20, 50, or 100 bars. Call Data_Matrix(Corr_Period, Sym_1, ..., Sym_20) with your selected parameters. The function will return an array containing the correlation values for every symbol pair (upper triangle of the matrix plus diagonal). For example : var string Sym_1 = '' , var string Sym_2 = '' , var string Sym_3 = '' , var string Sym_4 = '' , var string Sym_5 = '' , var string Sym_6 = '' , var string Sym_7 = '' , var string Sym_8 = '' , var string Sym_9 = '' , var string Sym_10 = '' var string Sym_11 = '', var string Sym_12 = '', var string Sym_13 = '', var string Sym_14 = '', var string Sym_15 = '', var string Sym_16 = '', var string Sym_17 = '', var string Sym_18 = '', var string Sym_19 = '', var string Sym_20 = '' switch Market 'Forex' => Sym_1 := 'EURUSD' , Sym_2 := 'GBPUSD' , Sym_3 := 'USDJPY' , Sym_4 := 'USDCHF' , Sym_5 := 'USDCAD' , Sym_6 := 'AUDUSD' , Sym_7 := 'NZDUSD' , Sym_8 := 'EURJPY' , Sym_9 := 'EURGBP' , Sym_10 := 'GBPJPY' ,Sym_11 := 'AUDJPY', Sym_12 := 'EURCHF', Sym_13 := 'EURCAD', Sym_14 := 'GBPCAD', Sym_15 := 'CADJPY', Sym_16 := 'CHFJPY', Sym_17 := 'NZDJPY', Sym_18 := 'AUDNZD', Sym_19 := 'USDSEK' , Sym_20 := 'USDNOK' 'Stock' => Sym_1 := 'NVDA' , Sym_2 := 'AAPL' , Sym_3 := 'GOOGL' , Sym_4 := 'GOOG' , Sym_5 := 'META' , Sym_6 := 'MSFT' , Sym_7 := 'AMZN' , Sym_8 := 'AVGO' , Sym_9 := 'TSLA' , Sym_10 := 'BRK.B' ,Sym_11 := 'UNH' , Sym_12 := 'V' , Sym_13 := 'JPM' , Sym_14 := 'WMT' , Sym_15 := 'LLY' , Sym_16 := 'ORCL', Sym_17 := 'HD' , Sym_18 := 'JNJ' , Sym_19 := 'MA' , Sym_20 := 'COST' 'Crypto' => Sym_1 := 'BTCUSD' , Sym_2 := 'ETHUSD' , Sym_3 := 'BNBUSD' , Sym_4 := 'XRPUSD' , Sym_5 := 'SOLUSD' , Sym_6 := 'ADAUSD' , Sym_7 := 'DOGEUSD' , Sym_8 := 'AVAXUSD' , Sym_9 := 'DOTUSD' , Sym_10 := 'TRXUSD' ,Sym_11 := 'LTCUSD' , Sym_12 := 'LINKUSD', Sym_13 := 'UNIUSD', Sym_14 := 'ATOMUSD', Sym_15 := 'ICPUSD', Sym_16 := 'ARBUSD', Sym_17 := 'APTUSD', Sym_18 := 'FILUSD', Sym_19 := 'OPUSD' , Sym_20 := 'USDT.D' 'Custom' => Sym_1 := Sym_1_C , Sym_2 := Sym_2_C , Sym_3 := Sym_3_C , Sym_4 := Sym_4_C , Sym_5 := Sym_5_C , Sym_6 := Sym_6_C , Sym_7 := Sym_7_C , Sym_8 := Sym_8_C , Sym_9 := Sym_9_C , Sym_10 := Sym_10_C ,Sym_11 := Sym_11_C, Sym_12 := Sym_12_C, Sym_13 := Sym_13_C, Sym_14 := Sym_14_C, Sym_15 := Sym_15_C, Sym_16 := Sym_16_C, Sym_17 := Sym_17_C, Sym_18 := Sym_18_C, Sym_19 := Sym_19_C , Sym_20 := Sym_20_C = Corr.Data_Matrix(Corr_period, Sym_1 ,Sym_2 ,Sym_3 ,Sym_4 ,Sym_5 ,Sym_6 ,Sym_7 ,Sym_8 ,Sym_9 ,Sym_10,Sym_11,Sym_12,Sym_13,Sym_14,Sym_15,Sym_16,Sym_17,Sym_18,Sym_19,Sym_20) Loop through or index into this array to retrieve each correlation value for your custom layout or logic. Pass each correlation value to CorrelationColor() to get the corresponding gradient background color, which reflects the correlation’s strength and direction (negative to positive). For example : Corr.CorrelationColor(SYM_3_10) Pass the same correlation value to CorrelationTextColor() to get the correct text color for readability against that background. For example : Corr.CorrelationTextColor(SYM_1_1) Use these colors in a table or label to render your own heatmap or any other visualization you need.
Pine Script® library
by TFlab
Primes_4These libraries (Primes_1 -> Primes_4) contain arrays of reduced Prime Numbers to minimize the amount of tokens, allowing more information to be exported. Values, for example: 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021 are reduced to: 7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21 With the restoreValues() function found in this library, the reduced values can be restored back to its original state. 7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21 is restored back to: 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021 The libraries contain all Prime Numbers from 2 to 1.340.011 ------------------------------------------------------------ Library "Primes_4" Prime Numbers 1.096.031 - 1.340.011 primes_a()   Prime numbers 1.096.031 - 1.205.999 primes_b()   Prime numbers 1.206.013 - 1.317.989 primes_c()   Prime numbers 1.318.003 - 1.340.011 method restoreValues(iArray, iShow, iFrom, iTo)   restoreValues : Restores reduced prime number values in an array to their original state, for example `7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21` is restored to `7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021`   Namespace types: array   Parameters:      iArray (array)      iShow (bool)      iFrom (int)      iTo (int)   Returns: Initial array with restored prime number values
Pine Script® library
by fikira
TUF_LOGICTUF_LOGIC: Three-Value Logic for Pine Script v6 The TUF_LOGIC library implements a robust three-valued logic system (trilean logic) for Pine Script v6, providing a formal framework for reasoning about uncertain or incomplete information in financial markets. By extending beyond binary True/False states to include an explicit "Uncertain" state, this library enables more nuanced algorithmic decision-making, particularly valuable in environments characterized by imperfect information. Core Architecture TUF_LOGIC offers two complementary interfaces for working with trilean values: Enum-Based API (Recommended): Leverages Pine Script v6's enum capabilities with Trilean.True , Trilean.Uncertain , and Trilean.False for improved type safety and performance. Integer-Based API (Legacy Support): Maintains compatibility with existing code using integer values 1 (True), 0 (Uncertain), and -1 (False). Fundamental Operations The library provides type conversion methods for seamless interaction between integer representation and enum types ( to_trilean() , to_int() ), along with validation functions to maintain trilean invariants. Logical Operators TUF_LOGIC extends traditional boolean operators to the trilean domain with NOT , AND , OR , XOR , and EQUALITY functions that properly handle the Uncertain state according to the principles of three-valued logic. The library implements three different implication operators providing flexibility for different logical requirements: IMP_K (Kleene's approach), IMP_L (Łukasiewicz's approach), and IMP_RM3 (Relevant implication under RM3 logic). Inspired by Tarski-Łukasiewicz's modal logic formulations, TUF_LOGIC includes modal operators: MA (Modal Assertion) evaluates whether a state is possibly true; LA (Logical Assertion) determines if a state is necessarily true; and IA (Indeterminacy Assertion) identifies explicitly uncertain states. The UNANIMOUS operator evaluates trilean values for complete agreement, returning the consensus value if one exists or Uncertain otherwise. This function is available for both pairs of values and arrays of trilean values. Practical Applications TUF_LOGIC excels in financial market scenarios where decision-making must account for uncertainty. It enables technical indicator consensus by combining signals with different confidence levels, supports multi-timeframe analysis by reconciling potentially contradictory signals, enhances risk management by explicitly modeling uncertainty, and handles partial information systems where some data sources may be unreliable. By providing a mathematically sound framework for reasoning about uncertainty, TUF_LOGIC elevates trading system design beyond simplistic binary logic, allowing for more sophisticated decision-making that better reflects real-world market complexity. Library "TUF_LOGIC" Three-Value Logic (TUF: True, Uncertain, False) implementation for Pine Script. This library provides a comprehensive set of logical operations supporting trilean logic systems, including Kleene, Łukasiewicz, and RM3 implications. Compatible with Pine v6 enums. method validate(self)   Ensures a valid trilean integer value by clamping to the appropriate range .   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The integer value to validate.   Returns: An integer value guaranteed to be within the valid trilean range. method to_trilean(self)   Converts an integer value to a Trilean enum value.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The integer to convert (typically -1, 0, or 1).   Returns: A Trilean enum value: True (1), Uncertain (0), or False (-1). method to_int(self)   Converts a Trilean enum value to its corresponding integer representation.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The Trilean enum value to convert.   Returns: Integer value: 1 (True), 0 (Uncertain), or -1 (False). method NOT(self)   Negates a trilean integer value (NOT operation).   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The integer value to negate.   Returns: Negated integer value: 1 -> -1, 0 -> 0, -1 -> 1. method NOT(self)   Negates a Trilean enum value (NOT operation).   Namespace types: series Trilean   Parameters:      self (series Trilean) : The Trilean enum value to negate.   Returns: Negated Trilean: True -> False, Uncertain -> Uncertain, False -> True. method AND(self, comparator)   Logical AND operation for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The first integer value.      comparator (int) : The second integer value to compare with.   Returns: Integer result of the AND operation (minimum value). method AND(self, comparator)   Logical AND operation for Trilean enum values following three-valued logic.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The first Trilean enum value.      comparator (series Trilean) : The second Trilean enum value to compare with.   Returns: Trilean result of the AND operation. method OR(self, comparator)   Logical OR operation for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The first integer value.      comparator (int) : The second integer value to compare with.   Returns: Integer result of the OR operation (maximum value). method OR(self, comparator)   Logical OR operation for Trilean enum values following three-valued logic.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The first Trilean enum value.      comparator (series Trilean) : The second Trilean enum value to compare with.   Returns: Trilean result of the OR operation. method EQUALITY(self, comparator)   Logical EQUALITY operation for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The first integer value.      comparator (int) : The second integer value to compare with.   Returns: Integer representation (1/-1) indicating if values are equal. method EQUALITY(self, comparator)   Logical EQUALITY operation for Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The first Trilean enum value.      comparator (series Trilean) : The second Trilean enum value to compare with.   Returns: Trilean.True if both values are equal, Trilean.False otherwise. method XOR(self, comparator)   Logical XOR (Exclusive OR) operation for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The first integer value.      comparator (int) : The second integer value to compare with.   Returns: Integer result of the XOR operation. method XOR(self, comparator)   Logical XOR (Exclusive OR) operation for Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The first Trilean enum value.      comparator (series Trilean) : The second Trilean enum value to compare with.   Returns: Trilean result of the XOR operation. method IMP_K(self, comparator)   Material implication using Kleene's logic for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The antecedent integer value.      comparator (int) : The consequent integer value.   Returns: Integer result of Kleene's implication operation. method IMP_K(self, comparator)   Material implication using Kleene's logic for Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The antecedent Trilean enum value.      comparator (series Trilean) : The consequent Trilean enum value.   Returns: Trilean result of Kleene's implication operation. method IMP_L(self, comparator)   Logical implication using Łukasiewicz's logic for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The antecedent integer value.      comparator (int) : The consequent integer value.   Returns: Integer result of Łukasiewicz's implication operation. method IMP_L(self, comparator)   Logical implication using Łukasiewicz's logic for Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The antecedent Trilean enum value.      comparator (series Trilean) : The consequent Trilean enum value.   Returns: Trilean result of Łukasiewicz's implication operation. method IMP_RM3(self, comparator)   Logical implication using RM3 logic for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The antecedent integer value.      comparator (int) : The consequent integer value.   Returns: Integer result of the RM3 implication operation. method IMP_RM3(self, comparator)   Logical implication using RM3 logic for Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The antecedent Trilean enum value.      comparator (series Trilean) : The consequent Trilean enum value.   Returns: Trilean result of the RM3 implication operation. method MA(self)   Modal Assertion (MA) operation for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The integer value to evaluate.   Returns: 1 if the value is 1 or 0, -1 if the value is -1. method MA(self)   Modal Assertion (MA) operation for Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The Trilean enum value to evaluate.   Returns: Trilean.True if value is True or Uncertain, Trilean.False if value is False. method LA(self)   Logical Assertion (LA) operation for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The integer value to evaluate.   Returns: 1 if the value is 1, -1 otherwise. method LA(self)   Logical Assertion (LA) operation for Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The Trilean enum value to evaluate.   Returns: Trilean.True if value is True, Trilean.False otherwise. method IA(self)   Indeterminacy Assertion (IA) operation for trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The integer value to evaluate.   Returns: 1 if the value is 0, -1 otherwise. method IA(self)   Indeterminacy Assertion (IA) operation for Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The Trilean enum value to evaluate.   Returns: Trilean.True if value is Uncertain, Trilean.False otherwise. method UNANIMOUS(self, comparator)   Evaluates the unanimity between two trilean integer values.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : The first integer value.      comparator (int) : The second integer value.   Returns: Integer value of self if both values are equal, 0 (Uncertain) otherwise. method UNANIMOUS(self, comparator)   Evaluates the unanimity between two Trilean enum values.   Namespace types: series Trilean   Parameters:      self (series Trilean) : The first Trilean enum value.      comparator (series Trilean) : The second Trilean enum value.   Returns: Value of self if both values are equal, Trilean.Uncertain otherwise. method UNANIMOUS(self)   Evaluates the unanimity among an array of trilean integer values.   Namespace types: array   Parameters:      self (array) : The array of integer values.   Returns: First value if all values are identical, 0 (Uncertain) otherwise. method UNANIMOUS(self)   Evaluates the unanimity among an array of Trilean enum values.   Namespace types: array   Parameters:      self (array) : The array of Trilean enum values.   Returns: First value if all values are identical, Trilean.Uncertain otherwise.
Pine Script® library
by The_Peaceful_Lizard
6
Primes_3These libraries (Primes_1 -> Primes_4) contain arrays of reduced Prime Numbers to minimize the amount of tokens, allowing more information to be exported. Values, for example: 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021 are reduced to: 7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21 With the restoreValues() function found in the Primes_4 library, the reduced values can be restored back to its original state. 7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21 is restored back to: 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021 The libraries contain all Prime Numbers from 2 to 1.340.011 ------------------------------------------------------------ Library "Primes_3" Prime Numbers 713.021 - 1.095.989 primes_a()   Prime numbers 713.021 - 820.997 primes_b()   Prime numbers 821.003 - 928.979 primes_c()   Prime numbers 929.003 - 1.038.953 primes_d()   Prime numbers 1.039.001 - 1.095.989
Pine Script® library
by fikira
Primes_1These libraries (Primes_1 -> Primes_4) contain arrays of reduced Prime Numbers to minimize the amount of tokens, allowing more information to be exported. Values, for example: 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021 are reduced to: 7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21 With the restoreValues() function found in the Primes_4 library, the reduced values can be restored back to its original state. 7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21 is restored back to: 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021 The libraries contain all Prime Numbers from 2 to 1.340.011 ------------------------------------------------------------ Library "Primes_1" Prime Numbers 2 - 339.991 primes_a()   Prime numbers 2 - 81.689 primes_b()   Prime numbers 81.701 - 175.897 primes_c()   Prime numbers 175.909 - 273.997 primes_d()   Prime numbers 274.007 - 339.991
Pine Script® library
by fikira
Primes_2These libraries (Primes_1 -> Primes_4) contain arrays of reduced Prime Numbers to minimize the amount of tokens, allowing more information to be exported. Values, for example: 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021 are reduced to: 7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21 With the restoreValues() function found in the Primes_4 library, the reduced values can be restored back to its original state. 7001, 13, 19, 27, 39, 43, 57, 69, 79, 7103, 9, 21 is restored back to: 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7021 The libraries contain all Prime Numbers from 2 to 1.340.011 ------------------------------------------------------------ Library "Primes_2" Prime Numbers 340.007 - 712.981 primes_a()   Prime numbers 340.007 - 441.971 primes_b()   Prime numbers 442.003 - 545.959 primes_c()   Prime numbers 546.001 - 650.987 primes_d()   Prime numbers 651.017 - 712.981
Pine Script® library
by fikira
SITFX_FuturesSpec_v17SITFX_FuturesSpec_v17 – Universal Futures Contract Library Full-scale futures contract specification library for Pine Script v6. Covers CME, CBOT, NYMEX, COMEX, CFE, Eurex, ICE, and more – including minis, micros, metals, energies, FX, and bonds. Key Features: ✅ Instrument‑agnostic: ES/MES, NQ/MNQ, YM/MYM, RTY/M2K, metals, energies, FX, bonds ✅ Full contract data: Tick size, tick value, point value, margins ✅ Continuation‑safe: Single‑line logic, no arrays or continuation errors ✅ Foundation for SITFX tools: Gann, Fibs, structure, and risk modules Usage example: import SITFX_FuturesSpec_v17/1 as fs spec = fs.get(syminfo.root) label.new(bar_index, high, str.format("{0}: Tick={1}, Value=${2}", spec.name, spec.tickSize, spec.tickValue))
Pine Script® library
by Solvere
FunctionADFLibrary "FunctionADF" Augmented Dickey-Fuller test (ADF), The ADF test is a statistical method used to assess whether a time series is stationary – meaning its statistical properties (like mean and variance) do not change over time. A time series with a unit root is considered non-stationary and often exhibits non-mean-reverting behavior, which is a key concept in technical analysis. Reference: - - rtmath.net - en.wikipedia.org adftest(data, n_lag, conf)   : Augmented Dickey-Fuller test for stationarity.   Parameters:      data (array) : Data series.      n_lag (int) : Maximum lag.      conf (string) : Confidence Probability level used to test for critical value, (`90%`, `95%`, `99%`).   Returns: `adf` The test statistic. \ `crit` Critical value for the test statistic at the 10 % levels. \ `nobs` Number of observations used for the ADF regression and calculation of the critical values.
Pine Script® library
by RicardoSantos
4
FastMetrixLibrary "FastMetrix" This is a library I've been tweaking and working with for a while and I find it useful to get valuable technical analysis metrics faster (why its called FastMetrix). A lot of is personal to my trading style, so sorry if it does not have everything you want. The way I get my variables from library to script is by copying the return function into my new script. TODO: Volatility and short term price analysis functions slope(source, smoothing)   Parameters:      source (float)      smoothing (int) integral(topfunction, bottomfunction, start, end)   Parameters:      topfunction (float)      bottomfunction (float)      start (int)      end (int) deviation(x, y)   Parameters:      x (float)      y (float) getema(len)   TODO: return important exponential long term moving averages and derivatives/variables   Parameters:      len (simple int) getsma(len)   TODO: return requested sma   Parameters:      len (int) kc(mult, len)   TODO: Return Keltner Channels variables and calculations   Parameters:      mult (simple float)      len (simple int) bollinger(len, mult)   TODO: returns bollinger bands with optimal settings   Parameters:      len (int)      mult (simple float) volatility(atrlen, smoothing)   TODO: Returns volatility indicators based on atr   Parameters:      atrlen (simple int)      smoothing (int) premarketfib() countinday(xcondition)   Parameters:      xcondition (bool) countinsession(condition, n)   Parameters:      condition (bool)      n (int)
Pine Script® library
by Pugh_trades
LMAsLibrary "LMAs" Credits Thank you to @QuantraSystems for dynamic calculations. Introduction This lightweight library offers dynamic implementations of popular moving averages that adapt their length automatically as new bars are added to the chart. Each function is built on a dynamic length formula: len = math.min(maxLength, bar_index + 1) This approach ensures that calculations begin as early as the first bar, allowing for smoother initialization and more consistent behavior across all timeframes. It’s especially useful in custom scripts that run from bar 0 or when historical data is limited. Usage You can use this library as a drop-in replacement for standard moving averages. It provides more flexibility and stability in live or backtesting environments where fixed-length indicators may delay or fail to initialize properly. Why Use This? • Works from the very first bar • Avoids na values during early bars • Great for real-time indicators, strategies, and bar-replay • Clean and efficient code with dynamic behavior How to Use Import the library into your script and call any of the included functions just like you would with their native counterparts. Summary A lightweight Pine Script™ library offering dynamic moving averages that work seamlessly from the very first bar. Ideal for strategies and indicators requiring robust initialization and adaptive behavior. SMA(sourceData, maxLength)   Dynamic SMA   Parameters:      sourceData (float)      maxLength (int) EMA(src, length)   Dynamic EMA   Parameters:      src (float)      length (int) DEMA(src, length)   Dynamic DEMA   Parameters:      src (float)      length (int) TEMA(src, length)   Dynamic TEMA   Parameters:      src (float)      length (int) WMA(src, length)   Dynamic WMA   Parameters:      src (float)      length (int) HMA(src, length)   Dynamic HMA   Parameters:      src (float)      length (int) VWMA(src, volsrc, length)   Dynamic VWMA   Parameters:      src (float)      volsrc (float)      length (int) SMMA(src, length)   Dynamic SMMA   Parameters:      src (float)      length (int) LSMA(src, length, offset)   Dynamic LSMA   Parameters:      src (float)      length (int)      offset (int) RMA(src, length)   Dynamic RMA   Parameters:      src (float)      length (int) ALMA(src, length, offset_sigma, sigma)   Dynamic ALMA   Parameters:      src (float)      length (int)      offset_sigma (float)      sigma (float) ZLSMA(src, length)   Dynamic ZLSMA   Parameters:      src (float)      length (int) FRAMA(src, length)   Parameters:      src (float)      length (int) KAMA(src, length)   Dynamic KAMA   Parameters:      src (float)      length (int) JMA(src, length, phase)   Dynamic JMA   Parameters:      src (float)      length (int)      phase (float) T3(src, length, volumeFactor)   Dynamic T3   Parameters:      src (float)      length (int)      volumeFactor (float)
Pine Script® library
by LyroRS
FvgCalculations█ OVERVIEW This library provides the core calculation engine for identifying Fair Value Gaps (FVGs) across different timeframes and for processing their interaction with price. It includes functions to detect FVGs on both the current chart and higher timeframes, as well as to check for their full or partial mitigation. █ CONCEPTS The library's primary functions revolve around the concept of Fair Value Gaps and their lifecycle. Fair Value Gap (FVG) Identification An FVG, or imbalance, represents a price range where buying or selling pressure was significant enough to cause a rapid price movement, leaving an "inefficiency" in the market. This library identifies FVGs based on three-bar patterns: Bullish FVG: Forms when the low of the current bar (bar 3) is higher than the high of the bar two periods prior (bar 1). The FVG is the space between the high of bar 1 and the low of bar 3. Bearish FVG: Forms when the high of the current bar (bar 3) is lower than the low of the bar two periods prior (bar 1). The FVG is the space between the low of bar 1 and the high of bar 3. The library provides distinct functions for detecting FVGs on the current (Low Timeframe - LTF) and specified higher timeframes (Medium Timeframe - MTF / High Timeframe - HTF). FVG Mitigation Mitigation refers to price revisiting an FVG. Full Mitigation: An FVG is considered fully mitigated when price completely closes the gap. For a bullish FVG, this occurs if the current low price moves below or touches the FVG's bottom. For a bearish FVG, it occurs if the current high price moves above or touches the FVG's top. Partial Mitigation (Entry/Fill): An FVG is partially mitigated when price enters the FVG's range but does not fully close it. The library tracks the extent of this fill. For a bullish FVG, if the current low price enters the FVG from above, that low becomes the new effective top of the remaining FVG. For a bearish FVG, if the current high price enters the FVG from below, that high becomes the new effective bottom of the remaining FVG. FVG Interaction This refers to any instance where the current bar's price range (high to low) touches or crosses into the currently unfilled portion of an active (visible and not fully mitigated) FVG. Multi-Timeframe Data Acquisition To detect FVGs on higher timeframes, specific historical bar data (high, low, and time of bars at indices and relative to the higher timeframe's last completed bar) is required. The requestMultiTFBarData function is designed to fetch this data efficiently. █ CALCULATIONS AND USE The functions in this library are typically used in a sequence to manage FVGs: 1. Data Retrieval (for MTF/HTF FVGs): Call requestMultiTFBarData() with the desired higher timeframe string (e.g., "60", "D"). This returns a tuple of htfHigh1, htfLow1, htfTime1, htfHigh3, htfLow3, htfTime3. 2. FVG Detection: For LTF FVGs: Call detectFvg() on each confirmed bar. It uses high , low, low , and high along with barstate.isconfirmed. For MTF/HTF FVGs: Call detectMultiTFFvg() using the data obtained from requestMultiTFBarData(). Both detection functions return an fvgObject (defined in FvgTypes) if an FVG is found, otherwise na. They also can classify FVGs as "Large Volume" (LV) if classifyLV is true and the FVG size (top - bottom) relative to the tfAtr (Average True Range of the respective timeframe) meets the lvAtrMultiplier. 3. FVG State Updates (on each new bar for existing FVGs): First, check for overall price interaction using fvgInteractionCheck(). This function determines if the current bar's high/low has touched or entered the FVG's currentTop or currentBottom. If interaction occurs and the FVG is not already mitigated: Call checkMitigation() to determine if the FVG has been fully mitigated by the current bar's currentHigh and currentLow. If true, the FVG's isMitigated status is updated. If not fully mitigated, call checkPartialMitigation() to see if the price has further entered the FVG. This function returns the newLevel to which the FVG has been filled (e.g., currentLow for a bullish FVG, currentHigh for bearish). This newLevel is then used to update the FVG's currentTop or currentBottom. The calling script (e.g., fvgMain.c) is responsible for storing and managing the array of fvgObject instances and passing them to these update functions. █ NOTES Bar State for LTF Detection: The detectFvg() function relies on barstate.isconfirmed to ensure FVG detection is based on closed bars, preventing FVGs from being detected prematurely on the currently forming bar. Higher Timeframe Data (lookahead): The requestMultiTFBarData() function uses lookahead = barmerge.lookahead_on. This means it can access historical data from the higher timeframe that corresponds to the current bar on the chart, even if the higher timeframe bar has not officially closed. This is standard for multi-timeframe analysis aiming to plot historical HTF data accurately on a lower timeframe chart. Parameter Typing: Functions like detectMultiTFFvg and detectFvg infer the type for boolean (classifyLV) and numeric (lvAtrMultiplier) parameters passed from the main script, while explicitly typed series parameters (like htfHigh1, currentAtr) expect series data. fvgObject Dependency: The FVG detection functions return fvgObject instances, and fvgInteractionCheck takes an fvgObject as a parameter. This UDT is defined in the FvgTypes library, making it a dependency for using FvgCalculations. ATR for LV Classification: The tfAtr (for MTF/HTF) and currentAtr (for LTF) parameters are expected to be the Average True Range values for the respective timeframes. These are used, if classifyLV is enabled, to determine if an FVG's size qualifies it as a "Large Volume" FVG based on the lvAtrMultiplier. MTF/HTF FVG Appearance Timing: When displaying FVGs from a higher timeframe (MTF/HTF) on a lower timeframe (LTF) chart, users might observe that the most recent MTF/HTF FVG appears one LTF bar later compared to its appearance on a native MTF/HTF chart. This is an expected behavior due to the detection mechanism in `detectMultiTFFvg`. This function uses historical bar data from the MTF/HTF (specifically, data equivalent to `HTF_bar ` and `HTF_bar `) to identify an FVG. Therefore, all three bars forming the FVG on the MTF/HTF must be fully closed and have shifted into these historical index positions relative to the `request.security` call from the LTF chart before the FVG can be detected and displayed on the LTF. This ensures that the MTF/HTF FVG is identified based on confirmed, closed bars from the higher timeframe. █ EXPORTED FUNCTIONS requestMultiTFBarData(timeframe)   Requests historical bar data for specific previous bars from a specified higher timeframe.   It fetches H , L , T (for the bar before last) and H , L , T (for the bar three periods prior) from the requested timeframe.   This is typically used to identify FVG patterns on MTF/HTF.   Parameters:      timeframe (simple string) : The higher timeframe to request data from (e.g., "60" for 1-hour, "D" for Daily).   Returns: A tuple containing: .   - htfHigh1 (series float): High of the bar at index 1 (one bar before the last completed bar on timeframe).   - htfLow1 (series float): Low of the bar at index 1.   - htfTime1 (series int) : Time of the bar at index 1.   - htfHigh3 (series float): High of the bar at index 3 (three bars before the last completed bar on timeframe).   - htfLow3 (series float): Low of the bar at index 3.   - htfTime3 (series int) : Time of the bar at index 3. detectMultiTFFvg(htfHigh1, htfLow1, htfTime1, htfHigh3, htfLow3, htfTime3, tfAtr, classifyLV, lvAtrMultiplier, tfType)   Detects a Fair Value Gap (FVG) on a higher timeframe (MTF/HTF) using pre-fetched bar data.   Parameters:      htfHigh1 (float) : High of the first relevant bar (typically high ) from the higher timeframe.      htfLow1 (float) : Low of the first relevant bar (typically low ) from the higher timeframe.      htfTime1 (int) : Time of the first relevant bar (typically time ) from the higher timeframe.      htfHigh3 (float) : High of the third relevant bar (typically high ) from the higher timeframe.      htfLow3 (float) : Low of the third relevant bar (typically low ) from the higher timeframe.      htfTime3 (int) : Time of the third relevant bar (typically time ) from the higher timeframe.      tfAtr (float) : ATR value for the higher timeframe, used for Large Volume (LV) FVG classification.      classifyLV (bool) : If true, FVGs will be assessed to see if they qualify as Large Volume.      lvAtrMultiplier (float) : The ATR multiplier used to define if an FVG is Large Volume.      tfType (series tfType enum from no1x/FvgTypes/1) : The timeframe type (e.g., types.tfType.MTF, types.tfType.HTF) of the FVG being detected.   Returns: An fvgObject instance if an FVG is detected, otherwise na. detectFvg(classifyLV, lvAtrMultiplier, currentAtr)   Detects a Fair Value Gap (FVG) on the current (LTF - Low Timeframe) chart.   Parameters:      classifyLV (bool) : If true, FVGs will be assessed to see if they qualify as Large Volume.      lvAtrMultiplier (float) : The ATR multiplier used to define if an FVG is Large Volume.      currentAtr (float) : ATR value for the current timeframe, used for LV FVG classification.   Returns: An fvgObject instance if an FVG is detected, otherwise na. checkMitigation(isBullish, fvgTop, fvgBottom, currentHigh, currentLow)   Checks if an FVG has been fully mitigated by the current bar's price action.   Parameters:      isBullish (bool) : True if the FVG being checked is bullish, false if bearish.      fvgTop (float) : The top price level of the FVG.      fvgBottom (float) : The bottom price level of the FVG.      currentHigh (float) : The high price of the current bar.      currentLow (float) : The low price of the current bar.   Returns: True if the FVG is considered fully mitigated, false otherwise. checkPartialMitigation(isBullish, currentBoxTop, currentBoxBottom, currentHigh, currentLow)   Checks for partial mitigation of an FVG by the current bar's price action.   It determines if the price has entered the FVG and returns the new fill level.   Parameters:      isBullish (bool) : True if the FVG being checked is bullish, false if bearish.      currentBoxTop (float) : The current top of the FVG box (this might have been adjusted by previous partial fills).      currentBoxBottom (float) : The current bottom of the FVG box (similarly, might be adjusted).      currentHigh (float) : The high price of the current bar.      currentLow (float) : The low price of the current bar.   Returns: The new price level to which the FVG has been filled (e.g., currentLow for a bullish FVG).   Returns na if no new partial fill occurred on this bar. fvgInteractionCheck(fvg, highVal, lowVal)   Checks if the current bar's price interacts with the given FVG.   Interaction means the price touches or crosses into the FVG's current (possibly partially filled) range.   Parameters:      fvg (fvgObject type from no1x/FvgTypes/1) : The FVG object to check.     Its isMitigated, isVisible, isBullish, currentTop, and currentBottom fields are used.      highVal (float) : The high price of the current bar.      lowVal (float) : The low price of the current bar.   Returns: True if price interacts with the FVG, false otherwise.
Pine Script® library
by no1x
WeightedVolumeUtilsLibrary "WeightedVolumeUtils" fun(x)   Returns the input value (placeholder function).   Parameters:      x (float) : A float value.   Returns: The same float value passed as input. weightedBSEVolume()   Calculates the weighted volume for BSE index based on top constituent stocks.   Returns: Weighted volume value based on fixed weights for BSE SENSEX stocks. getAdjustedVolume()   Returns the adjusted volume for SENSEX or regular volume otherwise.   Returns: Weighted BSE volume if current symbol is SENSEX, else raw volume.
Pine Script® library
by YOGI365
MathSpecialFunctionsConvolve1DLibrary "MathSpecialFunctionsConvolve1D" Convolution is one of the most important mathematical operations used in signal processing. This simple mathematical operation pops up in many scientific and industrial applications, from its use in a billion-layer large CNN to simple image denoising. ___ Reference: www.algorithm-archive.org numpy.org lloydrochester.com www.geeksforgeeks.org f(signal, filter)   Convolve   Parameters:      signal (array) : List with signal data.      filter (array) : List with weights to apply to the signal data.   Returns: Discrete, linear convolution of `signal` and `filter`.
Pine Script® library
by RicardoSantos
2
ErrorFunctionsLibrary "ErrorFunctions" A collection of functions used to approximate the area beneath a Gaussian curve. Because an ERF (Error Function) is an integral, there is no closed-form solution to calculating the area beneath the curve. Meaning all ERFs are approximations; precisely wrong, but mostly accurate. How close you need to get to the actual area depends entirely on your use case, with more precision being less efficient. The internal precision of floats in Pine Script is 1e-16 (16 decimals, aka. double precision). This library adapts well known algorithms designed to efficiently reach double precision. Single precision alternates are also included. All of them were made free to use, modify, and distribute by their original authors. HASTINGS Adaptation of a single precision ERF by Cecil Hastings Jr, published through Princeton University in 1955. It was later documented by Abramowitz and Stegun as equation 7.1.26 in their 1972 Handbook of Mathematical Functions. Fast, efficient, and ideal when precision beyond a few decimals is unnecessary. GILES Adaptation of a single precision Inverse ERF by Michael Giles, published through the University of Oxford in 2012. It reverses the ERF, estimating an X coordinate from an area. It too is fast, efficient, and ideal when precision beyond a few decimals is unnecessary. LIBC Adaptation of the double precision ERF & ERFC in the standard C library (aka. libc). It is also the same ERF & ERFC that SciPy uses. While not quite as efficient as the Hastings approximation, it's still very fast and fully maximizes Pines precision. BOOST Adaptation of the double precision Inverse ERF & Inverse ERFC in the Boost Math C++ library. SciPy uses these as well. These reverse the ERF & ERFC, estimating an X coordinate from an area. It too isn't quite as efficient as the Giles approximation, but still fast and fully maximizes Pines precision. While these algorithms are not exported directly, they are available through their exported counterparts. - - - ERROR FUNCTIONS erf(x, precise)   An Error Function estimates the theoretical error of a measurement.   Parameters:      x (float) : (float) Upper limit of the integration.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between -1 and 1. erfc(x, precise)   A Complementary Error Function estimates the difference between a theoretical error and infinity.   Parameters:      x (float) : (float) Lower limit of the integration.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and 2. erfinv(x, precise)   An Inverse Error Function reverses the erf() by estimating the original measurement from the theoretical error.   Parameters:      x (float) : (float) Theoretical error.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and ± infinity. erfcinv(x, precise)   An Inverse Complementary Error Function reverses the erfc() by estimating the original measurement from the difference between the theoretical error and infinity.   Parameters:      x (float) : (float) Difference between the theoretical error and infinity.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and ± infinity. - - - DISTRIBUTION FUNCTIONS pdf(x, m, s)   A Probability Density Function estimates the probability density . For clarity, density is not a probability .   Parameters:      x (float) : (float) X coordinate for which a density will be estimated.      m (float) : (float) Mean      s (float) : (float) Sigma   Returns: (float) Between 0 and ∞. cdf(z, precise)   A Cumulative Distribution Function estimates the area under a Gaussian curve between negative infinity and the Z Score.   Parameters:      z (float) : (float) Z Score.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and 1. cdfinv(a, precise)   An Inverse Cumulative Distribution Function reverses the cdf() by estimating the Z Score from an area.   Parameters:      a (float) : (float) Area between 0 and 1.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between -∞ and +∞ cdfab(z1, z2, precise)   A Cumulative Distribution Function from A to B estimates the area under a Gaussian curve between two Z Scores (A and B).   Parameters:      z1 (float) : (float) First Z Score.      z2 (float) : (float) Second Z Score.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and 1. ttt(z, precise)   A Two-Tailed Test estimates the area under a Gaussian curve between symmetrical ± Z scores and ± infinity.   Parameters:      z (float) : (float) One of the symmetrical Z Scores.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and 1. tttinv(a, precise)   An Inverse Two-Tailed Test reverses the ttt() by estimating the absolute Z Score from an area.   Parameters:      a (float) : (float) Area between 0 and 1.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and ∞. ott(z, precise)   A One-Tailed Test estimates the area under a Gaussian curve between an absolute Z Score and infinity.   Parameters:      z (float) : (float) Z Score.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and 1. ottinv(a, precise)   An Inverse One-Tailed Test Reverses the ott() by estimating the Z Score from a an area.   Parameters:      a (float) : (float) Area between 0 and 1.      precise (bool) : Double precision (true) or single precision (false).   Returns: (float) Between 0 and ∞.
Pine Script® library
by liquid-trader
7
pymath█  OVERVIEW This library ➕ enhances Pine Script's built-in types (`float`, `int`, `array`, `array`) with mathematical methods, mirroring 🪞 many functions from Python's `math` module. Import this library to overload or add to built-in capabilities, enabling calls like `myFloat.sin()` or `myIntArray.gcd()`. █  CONCEPTS This library wraps Pine's built-in `math.*` functions and implements others where necessary, expanding the mathematical toolkit available within Pine Script. It provides a more object-oriented approach to mathematical operations on core data types. █  HOW TO USE  • Import the library: i mport kaigouthro/pymath/1  • Call methods directly on variables: myFloat.sin() , myIntArray.gcd()  • For raw integer literals, you MUST use parentheses: `(1234).factorial()`. █  FEATURES  • **Infinity Handling:** Includes `isinf()` and `isfinite()` for robust checks. Uses `POS_INF_PROXY` to represent infinity.  • **Comprehensive Math Functions:** Implements a wide range of methods, including trigonometric, logarithmic, hyperbolic, and array operations.  • **Object-Oriented Approach:** Allows direct method calls on `int`, `float`, and arrays for cleaner code.  • **Improved Accuracy:** Some functions (e.g., `remainder()`) offer improved accuracy compared to default Pine behavior.  • **Helper Functions:** Internal helper functions optimize calculations and handle edge cases. █  NOTES This library improves upon Pine Script's built-in `math` functions by adding new ones and refining existing implementations. It handles edge cases such as infinity, NaN, and zero values, enhancing the reliability of your Pine scripts. For Speed, it wraps and uses built-ins, as thy are fastest. █  EXAMPLES //@version=6 indicator("My Indicator") // Import the library import kaigouthro/pymath/1 // Create some Vars float myFloat = 3.14159 int myInt = 10 array myIntArray = array.from(1, 2, 3, 4, 5) // Now you can... plot( myFloat.sin() ) // Use sin() method on a float, using built in wrapper plot( (myInt).factorial() ) // Factorial of an integer (note parentheses) plot( myIntArray.gcd() ) // GCD of an integer array method isinf(self)   isinf: Checks if this float is positive or negative infinity using a proxy value.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) value to check.   Returns: (bool) `true` if the absolute value of `self` is greater than or equal to the infinity proxy, `false` otherwise. method isfinite(self)   isfinite: Checks if this float is finite (not NaN and not infinity).   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The value to check.   Returns: (bool) `true` if `self` is not `na` and not infinity (as defined by `isinf()`), `false` otherwise. method fmod(self, divisor)   fmod: Returns the C-library style floating-point remainder of `self / divisor` (result has the sign of `self`).   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) Dividend `x`.      divisor (float) : (float) Divisor `y`. Cannot be zero or `na`.   Returns: (float) The remainder `x - n*y` where n is `trunc(x/y)`, or `na` if divisor is 0, `na`, or inputs are infinite in a way that prevents calculation. method factorial(self)   factorial: Calculates the factorial of this non-negative integer.   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : (int) The integer `n`. Must be non-negative.   Returns: (float) `n!` as a float, or `na` if `n` is negative or overflow occurs (based on `isinf`). method isqrt(self)   isqrt: Calculates the integer square root of this non-negative integer (floor of the exact square root).   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : (int) The non-negative integer `n`.   Returns: (int) The greatest integer `a` such that a² <= n, or `na` if `n` is negative. method comb(self, k)   comb: Calculates the number of ways to choose `k` items from `self` items without repetition and without order (Binomial Coefficient).   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : (int) Total number of items `n`. Must be non-negative.      k (int) : (int) Number of items to choose. Must be non-negative.   Returns: (float) The binomial coefficient nCk, or `na` if inputs are invalid (n<0 or k<0), `k > n`, or overflow occurs. method perm(self, k)   perm: Calculates the number of ways to choose `k` items from `self` items without repetition and with order (Permutations).   Namespace types: series int, simple int, input int, const int   Parameters:      self (int) : (int) Total number of items `n`. Must be non-negative.      k (simple int) : (simple int = na) Number of items to choose. Must be non-negative. Defaults to `n` if `na`.   Returns: (float) The number of permutations nPk, or `na` if inputs are invalid (n<0 or k<0), `k > n`, or overflow occurs. method log2(self)   log2: Returns the base-2 logarithm of this float. Input must be positive. Wraps `math.log(self) / math.log(2.0)`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number. Must be positive.   Returns: (float) The base-2 logarithm, or `na` if input <= 0. method trunc(self)   trunc: Returns this float with the fractional part removed (truncates towards zero).   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (int) The integer part, or `na` if input is `na` or infinite. method abs(self)   abs: Returns the absolute value of this float. Wraps `math.abs()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (float) The absolute value, or `na` if input is `na`. method acos(self)   acos: Returns the arccosine of this float, in radians. Wraps `math.acos()`. Input must be between -1 and 1.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number. Must be between -1 and 1.   Returns: (float) Angle in radians , or `na` if input is outside or `na`. method asin(self)   asin: Returns the arcsine of this float, in radians. Wraps `math.asin()`. Input must be between -1 and 1.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number. Must be between -1 and 1.   Returns: (float) Angle in radians , or `na` if input is outside or `na`. method atan(self)   atan: Returns the arctangent of this float, in radians. Wraps `math.atan()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (float) Angle in radians , or `na` if input is `na`. method ceil(self)   ceil: Returns the ceiling of this float (smallest integer >= self). Wraps `math.ceil()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (int) The ceiling value, or `na` if input is `na` or infinite. method cos(self)   cos: Returns the cosine of this float (angle in radians). Wraps `math.cos()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The angle in radians.   Returns: (float) The cosine, or `na` if input is `na`. method degrees(self)   degrees: Converts this float from radians to degrees. Wraps `math.todegrees()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The angle in radians.   Returns: (float) The angle in degrees, or `na` if input is `na`. method exp(self)   exp: Returns e raised to the power of this float. Wraps `math.exp()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The exponent.   Returns: (float) `e**self`, or `na` if input is `na`. method floor(self)   floor: Returns the floor of this float (largest integer <= self). Wraps `math.floor()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (int) The floor value, or `na` if input is `na` or infinite. method log(self)   log: Returns the natural logarithm (base e) of this float. Wraps `math.log()`. Input must be positive.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number. Must be positive.   Returns: (float) The natural logarithm, or `na` if input <= 0 or `na`. method log10(self)   log10: Returns the base-10 logarithm of this float. Wraps `math.log10()`. Input must be positive.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number. Must be positive.   Returns: (float) The base-10 logarithm, or `na` if input <= 0 or `na`. method pow(self, exponent)   pow: Returns this float raised to the power of `exponent`. Wraps `math.pow()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The base.      exponent (float) : (float) The exponent.   Returns: (float) `self**exponent`, or `na` if inputs are `na` or lead to undefined results. method radians(self)   radians: Converts this float from degrees to radians. Wraps `math.toradians()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The angle in degrees.   Returns: (float) The angle in radians, or `na` if input is `na`. method round(self)   round: Returns the nearest integer to this float. Wraps `math.round()`. Ties are rounded away from zero.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (int) The rounded integer, or `na` if input is `na` or infinite. method sign(self)   sign: Returns the sign of this float (-1, 0, or 1). Wraps `math.sign()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (int) -1 if negative, 0 if zero, 1 if positive, `na` if input is `na`. method sin(self)   sin: Returns the sine of this float (angle in radians). Wraps `math.sin()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The angle in radians.   Returns: (float) The sine, or `na` if input is `na`. method sqrt(self)   sqrt: Returns the square root of this float. Wraps `math.sqrt()`. Input must be non-negative.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number. Must be non-negative.   Returns: (float) The square root, or `na` if input < 0 or `na`. method tan(self)   tan: Returns the tangent of this float (angle in radians). Wraps `math.tan()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The angle in radians.   Returns: (float) The tangent, or `na` if input is `na`. method acosh(self)   acosh: Returns the inverse hyperbolic cosine of this float. Input must be >= 1.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number. Must be >= 1.   Returns: (float) The inverse hyperbolic cosine, or `na` if input < 1 or `na`. method asinh(self)   asinh: Returns the inverse hyperbolic sine of this float.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (float) The inverse hyperbolic sine, or `na` if input is `na`. method atanh(self)   atanh: Returns the inverse hyperbolic tangent of this float. Input must be between -1 and 1 (exclusive).   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number. Must be between -1 and 1 (exclusive).   Returns: (float) The inverse hyperbolic tangent, or `na` if input is outside (-1, 1) or `na`. method cosh(self)   cosh: Returns the hyperbolic cosine of this float.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (float) The hyperbolic cosine, or `na` if input is `na`. method sinh(self)   sinh: Returns the hyperbolic sine of this float.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (float) The hyperbolic sine, or `na` if input is `na`. method tanh(self)   tanh: Returns the hyperbolic tangent of this float.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The input number.   Returns: (float) The hyperbolic tangent, or `na` if input is `na`. method atan2(self, dx)   atan2: Returns the angle in radians between the positive x-axis and the point (dx, self). Wraps `math.atan2()`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The y-coordinate `y`.      dx (float) : (float) The x-coordinate `x`.   Returns: (float) The angle in radians , result of `math.atan2(self, dx)`. Returns `na` if inputs are `na`. Note: `math.atan2(0, 0)` returns 0 in Pine. Optimization: Use built-in math.atan2() method cbrt(self)   cbrt: Returns the cube root of this float.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The value to find the cube root of.   Returns: (float) The real cube root. Handles negative inputs correctly, or `na` if input is `na`. method exp2(self)   exp2: Returns 2 raised to the power of this float. Calculated as `2.0.pow(self)`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The exponent.   Returns: (float) `2**self`, or `na` if input is `na` or results in non-finite value. method expm1(self)   expm1: Returns `e**self - 1`. Calculated as `self.exp() - 1.0`. May offer better precision for small `self` in some environments, but Pine provides no guarantee over `self.exp() - 1.0`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The exponent.   Returns: (float) `e**self - 1`, or `na` if input is `na` or `self.exp()` is `na`. method log1p(self)   log1p: Returns the natural logarithm of (1 + self). Calculated as `(1.0 + self).log()`. Pine provides no specific precision guarantee for self near zero.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) Value to add to 1. `1 + self` must be positive.   Returns: (float) Natural log of `1 + self`, or `na` if input is `na` or `1 + self <= 0`. method modf(self)   modf: Returns the fractional and integer parts of this float as a tuple ` `. Both parts have the sign of `self`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The number `x` to split.   Returns: ( ) A tuple containing ` `, or ` ` if `x` is `na` or non-finite. method remainder(self, divisor)   remainder: Returns the IEEE 754 style remainder of `self` with respect to `divisor`. Result `r` satisfies `abs(r) <= 0.5 * abs(divisor)`. Uses round-half-to-even.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) Dividend `x`.      divisor (float) : (float) Divisor `y`. Cannot be zero or `na`.   Returns: (float) The IEEE 754 remainder, or `na` if divisor is 0, `na`, or inputs are non-finite in a way that prevents calculation. method copysign(self, signSource)   copysign: Returns a float with the magnitude (absolute value) of `self` but the sign of `signSource`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) Value providing the magnitude `x`.      signSource (float) : (float) Value providing the sign `y`.   Returns: (float) `abs(x)` with the sign of `y`, or `na` if either input is `na`. method frexp(self)   frexp: Returns the mantissa (m) and exponent (e) of this float `x` as ` `, such that `x = m * 2^e` and `0.5 <= abs(m) < 1` (unless `x` is 0).   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) The number `x` to decompose.   Returns: ( ) A tuple ` `, or ` ` if `x` is 0, or ` ` if `x` is non-finite or `na`. method isclose(self, other, rel_tol, abs_tol)   isclose: Checks if this float `a` and `other` float `b` are close within relative and absolute tolerances.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) First value `a`.      other (float) : (float) Second value `b`.      rel_tol (simple float) : (simple float = 1e-9) Relative tolerance. Must be non-negative and less than 1.0.      abs_tol (simple float) : (simple float = 0.0) Absolute tolerance. Must be non-negative.   Returns: (bool) `true` if `abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)`. Handles `na`/`inf` appropriately. Returns `na` if tolerances are invalid. method ldexp(self, exponent)   ldexp: Returns `self * (2**exponent)`. Inverse of `frexp`.   Namespace types: series float, simple float, input float, const float   Parameters:      self (float) : (float) Mantissa part `x`.      exponent (int) : (int) Exponent part `i`.   Returns: (float) The result of `x * pow(2, i)`, or `na` if inputs are `na` or result is non-finite. method gcd(self)   gcd: Calculates the Greatest Common Divisor (GCD) of all integers in this array.   Namespace types: array   Parameters:      self (array) : (array) An array of integers.   Returns: (int) The largest positive integer that divides all non-zero elements, 0 if all elements are 0 or array is empty. Returns `na` if any element is `na`. method lcm(self)   lcm: Calculates the Least Common Multiple (LCM) of all integers in this array.   Namespace types: array   Parameters:      self (array) : (array) An array of integers.   Returns: (int) The smallest positive integer that is a multiple of all non-zero elements, 0 if any element is 0, 1 if array is empty. Returns `na` on potential overflow or if any element is `na`. method dist(self, other)   dist: Returns the Euclidean distance between this point `p` and another point `q` (given as arrays of coordinates).   Namespace types: array   Parameters:      self (array) : (array) Coordinates of the first point `p`.      other (array) : (array) Coordinates of the second point `q`. Must have the same size as `p`.   Returns: (float) The Euclidean distance, or `na` if arrays have different sizes, are empty, or contain `na`/non-finite values. method fsum(self)   fsum: Returns an accurate floating-point sum of values in this array. Uses built-in `array.sum()`. Note: Pine Script does not guarantee the same level of precision tracking as Python's `math.fsum`.   Namespace types: array   Parameters:      self (array) : (array) The array of floats to sum.   Returns: (float) The sum of the array elements. Returns 0.0 for an empty array. Returns `na` if any element is `na`. method hypot(self)   hypot: Returns the Euclidean norm (distance from origin) for this point given by coordinates in the array. `sqrt(sum(x*x for x in coordinates))`.   Namespace types: array   Parameters:      self (array) : (array) Array of coordinates defining the point.   Returns: (float) The Euclidean norm, or 0.0 if the array is empty. Returns `na` if any element is `na` or non-finite. method prod(self, start)   prod: Calculates the product of all elements in this array.   Namespace types: array   Parameters:      self (array) : (array) The array of values to multiply.      start (simple float) : (simple float = 1.0) The starting value for the product (returned if the array is empty).   Returns: (float) The product of array elements * start. Returns `na` if any element is `na`. method sumprod(self, other)   sumprod: Returns the sum of products of values from this array `p` and another array `q` (dot product).   Namespace types: array   Parameters:      self (array) : (array) First array of values `p`.      other (array) : (array) Second array of values `q`. Must have the same size as `p`.   Returns: (float) The sum of `p * q ` for all i, or `na` if arrays have different sizes or contain `na`/non-finite values. Returns 0.0 for empty arrays.
Pine Script® library
by kaigouthro
7
SMCFunctionsLibrary "SMCFunctions" findSwingPoints(high, low, swing_size)   Parameters:      high (float)      low (float)      swing_size (int) detectBOS(close, high, low, prevHigh, prevLow, highActive, lowActive, bos_conf_type)   Parameters:      close (float)      high (float)      low (float)      prevHigh (float)      prevLow (float)      highActive (bool)      lowActive (bool)      bos_conf_type (string) getBOSDetails(highBroken, lowBroken, prevHigh, prevLow, prevSwing, prevHighIndex, prevLowIndex, input_show_choch)   Parameters:      highBroken (bool)      lowBroken (bool)      prevHigh (float)      prevLow (float)      prevSwing (int)      prevHighIndex (int)      prevLowIndex (int)      input_show_choch (bool) calculateRetracementLevels(start_price, end_price)   Parameters:      start_price (float)      end_price (float)
Pine Script® library
by viorel8
MLExtensions_CoreLibrary "MLExtensions_Core" A set of extension methods for a novel implementation of a Approximate Nearest Neighbors (ANN) algorithm in Lorentzian space, focused on computation. normalizeDeriv(src, quadraticMeanLength)   Returns the smoothed hyperbolic tangent of the input series.   Parameters:      src (float) : The input series (i.e., the first-order derivative for price).      quadraticMeanLength (int) : The length of the quadratic mean (RMS).   Returns: nDeriv The normalized derivative of the input series. normalize(src, min, max)   Rescales a source value with an unbounded range to a target range.   Parameters:      src (float) : The input series      min (float) : The minimum value of the unbounded range      max (float) : The maximum value of the unbounded range   Returns: The normalized series rescale(src, oldMin, oldMax, newMin, newMax)   Rescales a source value with a bounded range to anther bounded range   Parameters:      src (float) : The input series      oldMin (float) : The minimum value of the range to rescale from      oldMax (float) : The maximum value of the range to rescale from      newMin (float) : The minimum value of the range to rescale to      newMax (float) : The maximum value of the range to rescale to   Returns: The rescaled series getColorShades(color)   Creates an array of colors with varying shades of the input color   Parameters:      color (color) : The color to create shades of   Returns: An array of colors with varying shades of the input color getPredictionColor(prediction, neighborsCount, shadesArr)   Determines the color shade based on prediction percentile   Parameters:      prediction (float) : Value of the prediction      neighborsCount (int) : The number of neighbors used in a nearest neighbors classification      shadesArr (array) : An array of colors with varying shades of the input color   Returns: shade Color shade based on prediction percentile color_green(prediction)   Assigns varying shades of the color green based on the KNN classification   Parameters:      prediction (float) : Value (int|float) of the prediction   Returns: color color_red(prediction)   Assigns varying shades of the color red based on the KNN classification   Parameters:      prediction (float) : Value of the prediction   Returns: color tanh(src)   Returns the the hyperbolic tangent of the input series. The sigmoid-like hyperbolic tangent function is used to compress the input to a value between -1 and 1.   Parameters:      src (float) : The input series (i.e., the normalized derivative).   Returns: tanh The hyperbolic tangent of the input series. dualPoleFilter(src, lookback)   Returns the smoothed hyperbolic tangent of the input series.   Parameters:      src (float) : The input series (i.e., the hyperbolic tangent).      lookback (int) : The lookback window for the smoothing.   Returns: filter The smoothed hyperbolic tangent of the input series. tanhTransform(src, smoothingFrequency, quadraticMeanLength)   Returns the tanh transform of the input series.   Parameters:      src (float) : The input series (i.e., the result of the tanh calculation).      smoothingFrequency (int)      quadraticMeanLength (int)   Returns: signal The smoothed hyperbolic tangent transform of the input series. n_rsi(src, n1, n2)   Returns the normalized RSI ideal for use in ML algorithms.   Parameters:      src (float) : The input series (i.e., the result of the RSI calculation).      n1 (simple int) : The length of the RSI.      n2 (simple int) : The smoothing length of the RSI.   Returns: signal The normalized RSI. n_cci(src, n1, n2)   Returns the normalized CCI ideal for use in ML algorithms.   Parameters:      src (float) : The input series (i.e., the result of the CCI calculation).      n1 (simple int) : The length of the CCI.      n2 (simple int) : The smoothing length of the CCI.   Returns: signal The normalized CCI. n_wt(src, n1, n2)   Returns the normalized WaveTrend Classic series ideal for use in ML algorithms.   Parameters:      src (float) : The input series (i.e., the result of the WaveTrend Classic calculation).      n1 (simple int)      n2 (simple int)   Returns: signal The normalized WaveTrend Classic series. n_adx(highSrc, lowSrc, closeSrc, n1)   Returns the normalized ADX ideal for use in ML algorithms.   Parameters:      highSrc (float) : The input series for the high price.      lowSrc (float) : The input series for the low price.      closeSrc (float) : The input series for the close price.      n1 (simple int) : The length of the ADX. regime_filter(src, threshold, useRegimeFilter)   Parameters:      src (float)      threshold (float)      useRegimeFilter (bool) filter_adx(src, length, adxThreshold, useAdxFilter)   filter_adx   Parameters:      src (float) : The source series.      length (simple int) : The length of the ADX.      adxThreshold (int) : The ADX threshold.      useAdxFilter (bool) : Whether to use the ADX filter.   Returns: The ADX. filter_volatility(minLength, maxLength, sensitivityMultiplier, useVolatilityFilter)   filter_volatility   Parameters:      minLength (simple int) : The minimum length of the ATR.      maxLength (simple int) : The maximum length of the ATR.      sensitivityMultiplier (float) : Multiplier for the historical ATR to control sensitivity.      useVolatilityFilter (bool) : Whether to use the volatility filter.   Returns: Boolean indicating whether or not to let the signal pass through the filter.
Pine Script® library
by viorel8