Downloading...
Download

Python

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
RSI Classic calculationClassic RSI with Moving Average This script implements the Classic RSI (Relative Strength Index) method with the option to use either an Exponential Moving Average (EMA) or a Simple Moving Average (SMA) for smoothing the gains and losses. This custom implementation primarily aims to resolve a specific issue I encountered when cross-referencing RSI values with Python-based data, which is calculated differently than in Pine Script. However, the methodology here can benefit anyone who needs to align RSI calculations across different programming languages or platforms. The Problem: When working with Python for data analysis, the RSI values are calculated differently. The smoothing method, for example, can vary—RMA (Relative Moving Average) may be used instead of SMA or EMA, resulting in discrepancies when comparing RSI values across systems. To solve this problem, this script allows for the same type of smoothing to be applied (EMA or SMA) as used in Python, ensuring consistency in the data. Why This Implementation: The main goal of this approach was to align RSI calculations across Python and Pine Script so that I could cross-check the results accurately. By offering both EMA and SMA options, this script bridges the gap between Pine Script and Python, ensuring that the data is comparable and consistent. While this particular issue arose from my work with Python, this solution is valuable for anyone dealing with cross-platform RSI comparisons in different coding languages or systems. Benefits: Cross-Platform Consistency: This script ensures that RSI values calculated in Pine Script are directly comparable to those from Python (or any other platform), which is crucial for accurate analysis, especially in automated trading systems. Flexibility: The ability to choose between EMA and SMA provides flexibility in line with the specific needs of your strategy or data source. Ease of Use: The RSI is plotted with overbought and oversold levels clearly marked, making it easy to visualize and use in decision-making processes. Limitations: Calculation Differences: While this script bridges the gap between Pine Script and Python, if you're working with a different platform or coding language that uses variations like RMA, small discrepancies may still arise. Sensitivity Trade-Off: The choice between EMA and SMA impacts the sensitivity of the RSI. EMA responds quicker to recent price changes, which could lead to faster signals, while SMA provides a more stable but slower response. Conclusion: This Classic RSI script, with its customizable moving average type (EMA or SMA), not only solves the issue I faced with Python-based calculations but also provides a solution for anyone needing consistency across different programming languages and platforms. Whether you're working with Pine Script, Python, or other languages, this script ensures that your RSI values are aligned for more accurate cross-platform analysis. However, always be mindful of the small differences that can arise when different smoothing techniques (like RMA) are used in other systems.
Pine Script® indicator
by Agent_R_Zeroth
iteratorThe "Iterator" library is designed to provide a flexible way to work with sequences of values. This library offers a set of functions to create and manage iterators for various data types, including integers, floats, and more. Whether you need to generate an array of values with specific increments or iterate over elements in reverse order, this library has you covered. Key Features: Array Creation: Easily generate arrays of integers or floats with customizable steps, both inclusive and exclusive of the end values. Flexible Iteration: Includes methods to iterate over arrays of different types, such as booleans, integers, floats, strings, colors, and drawing objects like lines and labels. Reverse Iteration: Support for reverse iteration, giving you control over the order in which elements are processed. Automatic Loop Control: One of the key advantages of this library is that when using the .iterate() method, it only loops over the array when there are values present. This means you don’t have to manually check if the array is populated before iterating, simplifying your code and reducing potential errors. Versatile Use Cases: Ideal for scenarios where you need to loop over an array without worrying about empty arrays or checking conditions manually. This library is particularly useful in cases where you need to perform operations on each element in an array, ensuring that your loops are efficient and free from unnecessary checks. Library "iterator" The "iterator" library provides a versatile and efficient set of functions for creating and managing iterators. It allows you to generate arrays of integers or floats with customizable steps, both inclusive and exclusive of the end values. The library also includes methods for iterating over various types, including booleans, integers, floats, strings, colors, and drawing objects like lines and labels. With support for reverse iteration and flexible customization options. iterator(stop, start, step)   Creates an array of integers from start to stop with a specified step, excluding the stop value.   Parameters:      stop (int) : The end value of the iterator, exclusive.      start (int) : The starting value of the iterator. Default is 0.      step (int) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of integers incremented by the step value from start to stop. Will return and empty array if start = stop. iterator(stop, start, step)   Creates an array of floats from start to stop with a specified step, excluding the stop value.   Parameters:      stop (float) : The end value of the iterator, exclusive.      start (float) : The starting value of the iterator. Default is 0.      step (float) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of floats incremented by the step value from start to stop. Will return and empty array if start = stop. iterator_inclusive(stop, start, step)   Creates an array of integers from start to stop with a specified step, including the stop value.   Parameters:      stop (int) : The end value of the iterator, inclusive.      start (int) : The starting value of the iterator. Default is 0.      step (int) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of integers incremented by the step value from start to stop, including the stop value. iterator_inclusive(stop, start, step)   Creates an array of floats from start to stop with a specified step, including the stop value.   Parameters:      stop (float) : The end value of the iterator, inclusive.      start (float) : The starting value of the iterator. Default is 0.      step (float) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of floats incremented by the step value from start to stop, including the stop value. itr(stop, start, step)   Creates an array of integers from start to stop with a specified step, excluding the stop value.   Parameters:      stop (int) : The end value of the iterator, exclusive.      start (int) : The starting value of the iterator. Default is 0.      step (int) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of integers incremented by the step value from start to stop. itr(stop, start, step)   Creates an array of floats from start to stop with a specified step, excluding the stop value.   Parameters:      stop (float) : The end value of the iterator, exclusive.      start (float) : The starting value of the iterator. Default is 0.      step (float) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of floats incremented by the step value from start to stop. itr_in(stop, start, step)   Creates an array of integers from start to stop with a specified step, including the stop value.   Parameters:      stop (int) : The end value of the iterator, inclusive.      start (int) : The starting value of the iterator. Default is 0.      step (int) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of integers incremented by the step value from start to stop, including the stop value. itr_in(stop, start, step)   Creates an array of floats from start to stop with a specified step, including the stop value.   Parameters:      stop (float) : The end value of the iterator, inclusive.      start (float) : The starting value of the iterator. Default is 0.      step (float) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of floats incremented by the step value from start to stop, including the stop value. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified.
Pine Script® library
by The_Peaceful_Lizard
2
csv_series_libraryThe CSV Series Library is an innovative tool designed for Pine Script developers to efficiently parse and handle CSV data for series generation. This library seamlessly integrates with TradingView, enabling the storage and manipulation of large CSV datasets across multiple Pine Script libraries. It's optimized for performance and scalability, ensuring smooth operation even with extensive data. Features: Multi-library Support: Allows for distribution of large CSV datasets across several libraries, ensuring efficient data management and retrieval. Dynamic CSV Parsing: Provides robust Python scripts for reading, formatting, and partitioning CSV data, tailored specifically for Pine Script requirements. Extensive Data Handling: Supports parsing CSV strings into Pine Script-readable series, facilitating complex financial data analysis. Automated Function Generation: Automatically wraps CSV blocks into distinct Pine Script functions, streamlining the process of integrating CSV data into Pine Script logic. Usage: Ideal for traders and developers who require extensive data analysis capabilities within Pine Script, especially when dealing with large datasets that need to be partitioned into manageable blocks. The library includes a set of predefined functions for parsing CSV data into usable series, making it indispensable for advanced trading strategy development. Example Implementation: CSV data is transformed into Pine Script series using generated functions. Multiple CSV blocks can be managed and parsed, allowing for flexible data series creation. The library includes comprehensive examples demonstrating the conversion of standard CSV files into functional Pine Script code. To effectively utilize the CSV Series Library in Pine Script, it is imperative to initially generate the correct data format using the accompanying Python program. Here is a detailed explanation of the necessary steps: 1. Preparing the CSV Data: The Python script provided with the CSV Series Library is designed to handle CSV files that strictly contain no-space, comma-separated single values. It is crucial that your CSV file adheres to this format to ensure compatibility and correctness of the data processing. 2. Using the Python Program to Generate Data: Once your CSV file is prepared, you need to use the Python program to convert this file into a format that Pine Script can interpret. The Python script performs several key functions: Reads the CSV file, ensuring that it matches the required format of no-space, comma-separated values. Formats the data into blocks, where each block is a string of data that does not exceed a specified character limit (default is 4,000 characters). This helps manage large datasets by breaking them down into manageable chunks. Wraps these blocks into Pine Script functions, each block being encapsulated in its own function to maintain organization and ease of access. 3. Generating and Managing Multiple Libraries: If the data from your CSV file exceeds the Pine Script or platform limits (e.g., too many characters for a single script), the Python script can split this data into multiple blocks across several files. 4. Creating a Pine Script Library: After generating the formatted data blocks, you must create a Pine Script library where these blocks are integrated. Each block of data is contained within its function, like my_csv_0(), my_csv_1(), etc. The full_csv() function in Pine Script then dynamically loads and concatenates these blocks to reconstruct the full data series. 5. Exporting the full_csv() Function: Once your Pine Script library is set up with all the CSV data blocks and the full_csv() function, you export this function from the library. This exported function can then be used in your actual trading projects. It allows Pine Script to access and utilize the entire dataset as if it were a single, continuous series, despite potentially being segmented across multiple library files. 6. Reconstructing the Full Series Using vec : When your dataset is particularly large, necessitating division into multiple parts, the vec type is instrumental in managing this complexity. Here’s how you can effectively reconstruct and utilize your segmented data: Definition of vec Type: The vec type in Pine Script is specifically designed to hold a dataset as an array of floats, allowing you to manage chunks of CSV data efficiently. Creating an Array of vec Instances: Once you have your data split into multiple blocks and each block is wrapped into its own function within Pine Script libraries, you will need to construct an array of vec instances. Each instance corresponds to a segment of your complete dataset. Using array.from(): To create this array, you utilize the array.from() function in Pine Script. This function takes multiple arguments, each being a vec instance that encapsulates a data block. Here’s a generic example: vec series_vector = array.from(vec.new(data_block_1), vec.new(data_block_2), ..., vec.new(data_block_n)) In this example, data_block_1, data_block_2, ..., data_block_n represent the different segments of your dataset, each returned from their respective functions like my_csv_0(), my_csv_1(), etc. Accessing and Utilizing the Data: Once you have your vec array set up, you can access and manipulate the full series through Pine Script functions designed to handle such structures. You can traverse through each vec instance, processing or analyzing the data as required by your trading strategy. This approach allows Pine Script users to handle very large datasets that exceed single-script limits by segmenting them and then methodically reconstructing the dataset for comprehensive analysis. The vec structure ensures that even with segmentation, the data can be accessed and utilized as if it were contiguous, thus enabling powerful and flexible data manipulation within Pine Script. Library "csv_series_library" A library for parsing and handling CSV data to generate series in Pine Script. Generally you will store the csv strings generated from the python code in libraries. It is set up so you can have multiple libraries to store large chunks of data. Just export the full_csv() function for use with this library. method csv_parse(data)   Namespace types: array   Parameters:      data (array) method make_series(series_container, start_index)   Namespace types: array   Parameters:      series_container (array)      start_index (int)   Returns: A tuple containing the current value of the series and a boolean indicating if the data is valid. method make_series(series_vector, start_index)   Namespace types: array   Parameters:      series_vector (array)      start_index (int)   Returns: A tuple containing the current value of the series and a boolean indicating if the data is valid. vec   A type that holds a dataset as an array of float arrays.   Fields:      data_set (array) : A chunk of csv data. (A float array)
Pine Script® library
by The_Peaceful_Lizard
Dictionary/Object LibraryThis Library is aimed to mitigate the limitation of Pinescript having only one structured data type which is only arrays. It lacks data types like Dictionaries(in Python) or Object (in JS) that are standard for other languages. Tuples do exist, but it hardly solves any problem. Working only with Arrays could be overwhelming if your codebase is large. I looked for alternatives to arrays but couldn't find any library. So I coded it myself and it's been working good for me. So I wanted to share it with you all. What does it do: ================== If you are familiar with Python or Javascript, this library tries to immimate Object/Dictonary like structure with Key Value Pairs. For Example: object= {name:"John Doe", age: 28 , org: "PineCoders"} And then it also tries to immitate the Array of Objects (I call it Stack) like this: stack= Array({name:"John Doe", age: 28 , org: "PineCoders"}, {name:"Adam Smith", age: 32 , org: "PineCoders"}, {name:"Paragjyoti Deka", age: 25 , org: "PineCoders"}) So there are basically two ideas: Objects and Stacks. But it looks whole different in Pinescript for obvious reasons. Limitation: The major limitation I couldn't overcome was that, for all of the values: both input and return values for properties will be of string type. This is due to the limiation of Pinecsript that there is no way to return a value on a if-else statement dynamically with different data types. And as the input data type must be explicitly defined when exporting the library functions, only string inputs are allowed. Now that doesn't mean you won't be able to use integer, float or boolens, you just need to pass the string value for it using str.tostring() method. And the output for the getter functions will be in strings as well. But I have added some type conversion methods that you could use from this library itself. From String to Float, String To Integer and String to Boolean: these three methods are included in this library. So basically the whole library is based on a manipulatiion of Array of strings under the hood. /////////////// Usage /////////////// Import the library using this statement: import paragjyoti2012/STR_Dict_Lib/4 as DictLib Objects First define an object using this method: for eample: object1= DictLib.init("name=John,age=26,org=") This is similar to object1= {name:"John",age:"26", org:""} in JS or Python Just like we did here in for "org", you can set initital value to "". But remember to pass string values, even for a numerical properties, like here in "age". You can use "age="+str.tostring(age). If you find it tedious, you can always add properties later on using .set() method. So it could also be initiated like this object= DictLib.init("name=John") and later on DictLib.set(object1,"age", str.toString(age)) DictLib.set(object1,"org", "PineCoders") The getter function looks like this age= DictLib.get(object1,"age") name=DictLib.get(object1,"name") The first argument for all methods .get, .set, and .remove is the pointer (name of the object). /////////////////////////// Array Of Objects (Stacks) /////////////////////////// As I mentioned earlier, I call the array of objects as Stack. Here's how to initialize a Stack. stack= DictLib.initStack(object1) The .initStack() method takes an object pointer as argument. It simply converts the array into a string and pushes it into the newly created stack. Rest of all the methods for Stacks, takes the stack pointer as it's first arument. For example: DictLib.pushStack(stack,object2) The second argument here is the object pointer. It adds the object to it's stack. Although it might feel like a two dimentional array, it's actually an one dimentional array with string values. Under the hood, it looks like this //////////////////// Methods //////////////////// For Objects ------------------- init() : Initializes the object. params: (string) e.g returns: The object ( ) example: object1=DictLib.init("name=John,age=26,org=") ................... get() : Returns the value for given property params: (string object_pointer, string property) returns: string example: age= DictLib.get(object1,"age") ....................... set() : Adds a new property or updates an existing property params: (string object_pointer, string property, string value) returns: void example: DictLib.set(object1,"age", str.tostring(29)) ........................ remove() : Removes a property from the object params : (string object_pointer, string property) returns: void example: DictLib.set(object1,"org") ........................ For Array Of Objects (Stacks) ------------------------------- initStack() : Initializes the stack. params: (string object_pointer) e.g returns: The Stack example: stack= DictLib.initStack(object1) ................... pushToStack() : Adds an object at at last index of the stack params: (string stack_pointer, string object_pointer) returns: void example: DictLib.pushToStack(stack,object2) ....................... popFromStack() : Removes the last object from the stack params: (string stack_pointer) returns: void example: DictLib.popFromStack(stack) ....................... insertToStack() : Adds an object at at the given index of the stack params: (string stack_pointer, string object_pointer, int index) returns: void example: DictLib.insertToStack(stack,object3,1) ....................... removeFromStack() : Removes the object from the given index of the stack params: (string stack_pointer, int index) returns: void example: DictLib.removeFromStack(stack,2) ....................... getElement () : Returns the value for given property from an object in the stack (index must be given) params: (string stack_pointer, int index, string property) returns: string example: ageFromObject1= DictLib.getElement(stack,0,"age") ....................... setElement() : Updates an existing property of an object in the stack (index must be given) params: (string stack_pointer, int index, string property, string value) returns: void example: DictLib.setElement(stack,0,"age", str.tostring(32)) ........................ includesElement() : Checks if any object exists in the stack with the given property-value pair params : (string stack_pointer, string property, string value) returns : Boolean example: doesExist= DictLib.includesElement(stack,"org","PineCoders") ........................ searchStack() : Search for a property-value pair in the stack and returns it's index params: (stringp stack_pointer, string property, string value) returns: int (-1 if doesn't exist) example: index= DictLib.searchElement(stack,"org","PineCoders") /////////////////////// Type Conversion Methods /////////////////////// strToFloat() : Converts String value to Float params: (string value) returns: float example: floatVal= DictLib.strToFloat("57.96") ............................. strToInt() : Converts String value to Integer params: (string value) returns: int example: intVal= DictLib.strToFloat("45") ............................. strToBool() : Converts String value to Boolean params: (string value) returns: boolean example: boolVal= DictLib.strToBool("true") ............................. Points to remember ............... 1. Always pass string values as arguments. 2. The return values will be of type string, so convert them before to avoid typecasting conflict. 3. Horses can't vomit. More Informations ==================== Yes, You can store this objects and stacks for persisting through the iterations of a script across successive bars. You just need to set the variable using "var" keyword. Remember this objects and stacks are just arrays, so any methods and properties an array have it pinescript, would be applicable for objects and stacks. It can also be used in security functions without any issues for MTF Analysis. If you have any suggestions or feedback, please comment on the thread, I would surely be happy to help.
Pine Script® library
by CyberMensch
20