Começar

LINE

B1rd's Level ToolV0.1 Allows you to create arbitrary support levels based on bar data from a selected point in time and source. Features: - An interactive chart that lets you pick the level simply by dragging the vertical line associated with its start point. - A secondary vertical line (end point) sets up a point in time from where this indicator is going to check for price crossing the level. (so it doesn't trigger immediately if you are on a lower time frame) - There is also an option to hide the vertical lines once you're done initializing. - No matter what timeframe you are on, you can just pick the source and timeframe the level should be locked in on. - Optionally when line is crossed it stops plotting the line from that point onward and shows you a signal. - You can customize the name, color, size and style of each level. TODO: - Add the option to set up multiple levels. - Add Alerts. - Work on Improving the layout. - Bugfixed. - Give proper title names to the style tab.
Indicador Pine Script®
por dab1rd
Auto Trendline Indicator (based on fractals)A tool that automatically draws out trend lines by connecting the most recent fractals. Description: The process of manual drawing out trend lines is highly subjective. Many times, we don’t trade what we see, but what we “want to see”. As a result, we draw lines pointing to the direction that we wishfully want price to move towards. While there are no right/wrong ways to draw trend lines, there are, however, systematic/unsystematic ways to draw trend lines. This tool will systematically draw out trend lines based on fractals. Additional feature: This tool will also plot out symbols (default symbol “X”) to signify points of crossings. This can be useful for traders considering to use trend lines as part of their trading strategies. Here is an interesting observation on the price actions of NASDAQ futures on a 5 second chart during regular trading hours on July 14, 2022. It’s a phenomenon. People like to see straight lines connecting HL/LH, etc., so it's possible for the market as a whole to psychologically react to these lines. However, it is important to note that is is impossible to predict the direction of price. In the case above, price could have tanked below auto-drawn trend line. Fractal based trend lines should only be taken as references and regarded as price levels. No studies have ever proven that the slope of trend lines can indicate price's future direction. More about fractals: To understand more about fractals: www.investopedia.com www.tradingview.com Contrary to what it sounds like, fractal in "technical analysis" does not refer to the recursive self-repeating patterns that appear in nature, such as the mesmerizing patterns found in snowflakes. The Fractal Markets Hypothesis claims that market prices exhibit fractal properties over time. Assuming this assertion to be true, then fractals can be used a tool to represent the chaotic movements of price is a simplified manner. The purpose of this exercise is to take a tool that is readily available (ie. in this case, TradingView’s built-in fractals tool), and to create a newer tool based on it. Parameters: Fractal period (denoted as ‘n’ in code): It is the number of bars bounding a high/low point that must be lower/higher than it, respectively, in order for fractal to be considered valid. Period ‘n’ can be adjusted in this tool. Traditionally, chartists pick the value of 5. The longer it is, the less noise seen on the chart, and the pivot point may also be exhibited in higher timeframes. The drawback is that it will increase the period of lag, and it will take more bars to confirm the printed fractal. Others: Intuitive parameters such as whether to draw historical trend lines, what color to use, which way to extend the lines, and whether or not to show points of crossings.
Indicador Pine Script®
por DojiEmoji
64
PRIME - R.o.c.M Ind. W/ TrendsThis experimental script is a variant of a model that allows a separate indicator window to be opened, revealing data for on balance volume, rsi, consumer commodity index and momentum indications. By use of the settings key, you can change the parameter of the source input as well as the desired lengths. After data compilation, the indicator will automatically draw any trend lines applicable to what is presented. The additional code is an attempt to allow the system to apply pivot points for alerts within the indicator itself. Disclaimer: Trading success is all about following your trading strategy and the indicators should fit within your trading strategy, and not to be traded upon solely The script is for informational and educational purposes only. Use of the script does not constitute professional and/or financial advice. You alone have the sole responsibility of evaluating the script output and risks associated with the use of the script. In exchange for using the script, you agree not to hold the publishing TradingView user liable for any possible claim for damages arising from any decision you make based on use of the script
Indicador Pine Script®
por prim3associat3s
3
RelicusRoad - Signal LineWhen you have charts full of too many indicators, it can mess up with your analysis and cause analysis paralysis. Use RelicusRoad Signal Line to simply your charts with a beautiful color changing moving average line as per the strategies selected. 4 different strategies to choose from: 1) MACD 2) PMACD (Price Action + MACD) 3) Parabolic SAR 4) Momentum GREEN: BUY ZONE RED: SELL ZONE FUNCTIONS OVERVIEW MACD: Moving average convergence divergence ( MACD ) is a trend-following momentum indicator that shows the relationship between two moving averages of a security’s price. The MACD is calculated by subtracting the 26-period exponential moving average ( EMA ) from the 12-period EMA . The result of that calculation is the MACD line. A 9 EMA of the MACD called the "signal line," is then plotted on top of the MACD line, which can function as a trigger for buy and sell signals. Traders may buy the security when the MACD crosses above its signal line and sell—or short—the security when the MACD crosses below the signal line. Moving average convergence divergence ( MACD ) indicators can be interpreted in several ways, but the more common methods are crossovers, divergences, and rapid rises/falls. Moving average convergence divergence ( MACD ) is calculated by subtracting the 26-period exponential moving average ( EMA ) from the 12-period EMA . MACD triggers technical signals when it crosses above (to buy) or below (to sell) its signal line. The speed of crossovers is also taken as a signal of a market is overbought or oversold. MACD helps investors understand whether the bullish or bearish movement in the price is strengthening or weakening. PMACD: It's an improvement to MACD that you can use the Red/Green indications to make better decisions. Parabolic SAR: The parabolic SAR indicator, developed by J. Wells Wilder, is used by traders to determine trend direction and potential reversals in price. The indicator uses a trailing stop and reverse method called "SAR," or stop and reverse, to identify suitable exit and entry points. Traders also refer to the indicator as the parabolic stop and reverse , parabolic SAR , or PSAR. The parabolic SAR indicator appears on a chart as a series of dots, either above or below an asset's price, depending on the direction the price is moving. A dot is placed below the price when it is trending upward, and above the price when it is trending downward. The parabolic SAR (stop and reverse) indicator is used by technical traders to spot trends and reversals. The indicator utilizes a system of dots superimposed onto a price chart. A reversal occurs when these dots flip, but a reversal signal in the SAR does not necessarily mean a reversal in the price. A PSAR reversal only means that the price and indicator have crossed. Momentum: On paper, momentum investing seems less like an investing strategy and more like a knee-jerk reaction to market information. The idea of selling losers and buying winners is seductive, but it flies in the face of the tried and true Wall Street adage, "buy low, sell high." Momentum investing is a trading strategy in which investors buy securities that are rising and sell them when they look to have peaked. The goal is to work with volatility by finding buying opportunities in short-term uptrends and then sell when the securities start to lose momentum. Then, the investor takes the cash and looks for the next short-term uptrend, or buying opportunity, and repeats the process. Skilled traders understand when to enter into a position, how long to hold it for, and when to exit; they can also react to short-term, news-driven spikes or selloffs. Risks of momentum trading include moving into a position too early, closing out too late, and getting distracted and missing key trends and technical deviations.
Indicador Pine Script®
por Pyrem
VPLineVPLine is a brand-new line indicator which automatically draws historical POC line with volume profile histograms based on user input session and configurations. A colossal amount of function is deployed on the indicator: historical POC line, historical VA, historical VA high/low, volume profile histograms, volume profile value text (bid/ask/total), threshold function that limits the extension of the POC line based on user input etc.
Indicador Pine Script®
por rebasega
1
Dashed Line Moving AveragesHere's a simple script which i concocted using ideas from various authors with the goal of creating a slightly better Moving Average dashed line script imo...I think i managed to do just that and a bit more.. =) Features: - Contains one of each VWMA SMA EMA. You can set the input length. - Ability to set spacing between characters of the plotted moving average line - Horizontal offset of the moving average lines (just in case) - Can add any fancy characters that suits your taste e.g ( . , _ , -, !, *, rocket, lava, etc) to the moving average - If you duplicate the script and modify the "Size" parameter of the plotchar() function's variables with the choices provided in the commented-out code; you can have some fun! This script is for entertainment & educational purposes only.
Indicador Pine Script®
por KushC
3
Psychological LineThis indicator can be shown by the number of bars with consecutive higher closing prices over a period of time. The maximum value is equal to the period. The default period value is 12. Thresholds used with this period are 3, 6, and 9. A drop below 3 suggests an approaching low, and a crossover above 9 warns about an upcoming top. In this period, 6 is a neutral value and represents the borderline separating uptrends and downtrends.
Indicador Pine Script®
por arndav
2
MACD + Divergence + Line █  OVERVIEW Here's the classic MACD with some simples features in plus. █  CONCEPTS 4 features 1 — Classic MACD histogram, with 4 different colors such as above or below 0, and above or below the previous bar 2 — Display option to disable EMA 3 — A signal line that show the exact point, because the histogram view might be hard to be precise 4 — Looking for previous Divergences, Bullish, Bearish and Hidden Bullish and Bearish but I don't like Hidden divergences █  OTHER SECTIONS An oscillator is good to know where we are in the trends, but it's not enough to run a small business of trading, you need to learn how to use it. What is a divergence ? Thanks to The rational investor for teaching me how to use this indicator.
Indicador Pine Script®
por remilhoste
3
Vertical LinesThis script plots vertical lines on charts or indicators. Unfortunately pinescript is lacking a vertical line plotting function. Vertical lines are useful to mark events, such as crossover of levels, indicators signals or as a time marker. After searching the internet for a long time and trying different scripts, this script is the simplest and visually the best. You would think that plotting a vertical line would be relatively easy, it is not! I thank the unknow author for sharing this solution and now I will share it on tradingview to make it readily available to anybody that needs it. RSI crossover signals are used as an example in this script. When the RSI crosses over 70 or below 30, the script plots a red or green vertical line. The script plots a vertical line as a histogram bar. The histogram bar must have a height. Setting the height near infinity like 1e20 will cover all the ranges from top to bottom in most charts, but doesn't work all the time. If the chart range is small in values, the line is not plotted or the chart is visually compressed because the top of the bar is also a data point in the chart. Another solution is to find the highest point in the chart and multiply it by a number from 2 to 10 to set the top of the histogram bar. But this solution doesn't work if the line is drawn in the indicator window. additionally if the chart or indicator includes negative values, a histogram bar with a negative height must be concatenated to the histogram bar with a positive height to cover the positive and negative range. It would seem intuitive to include a vertical plot function since it is very useful and pinescript already has a horizontal line plot function called Hline. But pinescript is becoming less intuitive, and redundant. A case in point is Version 4 variable declaration and naming, it less intuitive and more redundant than previous versions. I beg Tradingview to adopt a more refined scripting language such as Matlab or Python for charting purposes. These languages can be easily ported to other analysis programs for AI or statistical analysis.
Indicador Pine Script®
por nagihatoum
4
Logarithmic Trend ChannelThis indicator automatically draws a regression channel plotted on logarithmic scale from the first quotation. This model is useful for the long term series data (such as 10 or 20 years time span). The Pearson correlation measures the strength of the linear relationship between two variables. It has a value between to 1, with a value of 0 meaning no correlation, and + 1 meaning a total positive correlation. Logarithmic price scales are a type of scale used on a chart, plotted such that two equivalent price changes are represented by the same vertical changes on the scale. They differ from linear price scales because they display percentage points and not dollar price increases for a stock. Technical issues *The user have to pan over the chart from the beginning to the end of the study range (such as 10 years of bars) so the pine script could generate those lines on the chart. *If on the chart the number of bar is less than the lookback period, it won't generate any lines as well.
Indicador Pine Script®
por Julien_Eche
7
Just a Vertical Line█ OVERVIEW This is Just a Vertical Line. Nothing fancy or complicated. Sometime, you might just need one vertical line on a specific date to appear on all of your charts for a quick comparison -or any other purposes-. With this script you you can do just that. You will need to select that date ONCE and scroll through your charts and through different assets and that line will still be there. You can also activate a label to appear on top on that line! and customize what it says. Perhaps.. you might want to see the asset's performance on that day, or since that day. Well... We got you. This script is equipped with a statistics box that includes the performance on that candle you chose or the performance TD -to date.- It's not really hard, you can drag that date and change it without going through the settings as well. █ Future Plans and upgrades to this script may include : 1. More statistics! 2. Range tools █ How to use : 1. Add the script to your chart. 2. Open the settings, activate the date then choose it. 3. Change the date -if you want to- outside the settings box by dragging the vertical line across the chart
Indicador Pine Script®
por NasserHumood
3
HAP Auto Trend Line [PRO]Hello Traders! The trend line is among the most important tools used by technical analysts. Instead of looking at past business performance or other fundamentals, technical analysts look for trends in price action. A trend line helps technical analysts determine the current direction in market prices. Technical analysts believe the trend is your friend, and identifying this trend is the first step in the process of making a good trade, and it can tell Support/resistance is very good. But when drawing Trend Lines, sometimes we're not sure where to start. From where is the starting point? And sometimes it can be drawn multiple lines with different support/resistance lines over time. This itself can be confusing, so I tried to create a tool that allows it to draw lines automatically. According to price movement. Let's take a look at the variables you need to understand from our indicators. For this indicator it works in two main parts: Section of Trend Line Trend Reversal section Therefore, these two parts have separate functions. To be used as a component for easier decision-making. Trend Line, as I said before, what it is. Next is Trend Reversal. I will simply say it is. A period of time when the candle tries to pump and dump. This will help point out the potential price reversal. And if there is a trend line area, it is an interesting point to consider. To identify possibilities. Some variables from the settings page Number of Bars to Check : It is the number of past candlesticks to consider. To identify the start of the Trend Line, if it meets the condition, it will automatically draw the Trend Line for you. Trend Line Depth : It is the frequency. Of identifying the starting point Trend Line. If the value is large, it will find a low Trend Line, and if it is low, it will find more Trend Line. This is flexible. So you have to try it yourself. On demand. Overview You can turn it on or off. Support/resistance position either. Select Emoji Support/resistance. Freely Line style you want your favorite color customizable line intensity the script is fast enough to run on 1sec chart: fun !
Indicador Pine Script®
por hapharmonic
47
Volume Profile Auto [line]This project is about: - VPSV - array.new_line() - array.new_box() VPSV (pine) is one of the rare features that draws lines/figures BETWEEN bars It doesn't run on Pine script, which makes it possible to do such things. I wanted to have something similar while a restriction of Pine script is the impossibility to draw between bars, the only way I could think of is by using line width In this script the higher timeframe is started with several lines (left) and a box, this box goes further until the higher timeframe ends. During the creation of the box, each candle (lower timeframe) in this box (higher timeframe - period) is checked for position and volume, the volume is added to the left line, so when you see a thicker line, this means at that level there is more volume traded. One of the big differences with other volume profiles is that many look back to a previous period, here when a period starts, the lines collect data - volume until the period ends, it is especially very visible in very low TF's (seconds) This is my first script with array.new_line() - array.new_box(), which is a very nice Pine feature! I hope this script can be helpful to see the possibilities Settings: 'Parts' -> amount of lines (left of box) 5 Parts: 15 Parts: 25 Parts: 50 Parts: 'Max Width' -> Sets the max width of the lines 'Automatic Settings' -> Sets the higher time frame automatically, see the tooltip ⓘ for more info The yellow line is the max volume line of that period, last period has a red line (POC), also referring the max. Cheers!
Indicador Pine Script®
por fikira
51
MTF WatchList Charts [Anan]█ OVERVIEW I am happy to present this script with a nice idea! You can now customize a watchlist with your preferred time frame and any symbol from any market. The main purpose is to be aware of any moves and watch a brief overview of the chart. █ FEATURES - 8 customizable symbols with the option to show/hide anyone - Multi time frame support - 3 Types of charts (Candles / Heikin Ashi / Line) - Displaying up to 10 candles for every chart - Customizable chart colors - Option to Show/hide Price - Option to Show/hide Price Line - Option to change Labels and Text Size - Show Symbol name and used time frame - Option to change gaps between charts - Hover over on the top of any candle to see (Open/High/Low/Close) Prices █ SCREENSHOTS ----------------------------------------------- Special thanks to @dgtrd for inspiration and for the amazing framework used here ( HTF Candles by DGT ) Special thanks to Pine Chat @fareidzulkifli @Bjorgum @JohnBaron @fpainchaud
Indicador Pine Script®
por Mohamed3nan
77
[CLX][#03] Object-Stack (Labels/Lines/Boxes)This script shows an example of how to manage objects (lines/labels/boxes) and prevent the need of garbage collecting and missing objects. You only have to push your object into the right array. *_FIXED (left-lock) or *_FORWARD (right-lock) We hope you enjoy it! 🎉 CRYPTOLINX - jango_blockchained 😊👍 Disclaimer: Trading success is all about following your trading strategy and the indicators should fit within your trading strategy, and not to be traded upon solely. The script is for informational and educational purposes only. Use of the script does not constitute professional and/or financial advice. You alone have the sole responsibility of evaluating the script output and risks associated with the use of the script. In exchange for using the script, you agree not to hold cryptolinx TradingView user liable for any possible claim for damages arising from any decision you make based on use of the script.
Indicador Pine Script®
por cryptolinx
3
Pinescript - Common Label & Line Array Functions Library by RRBPinescript - Common Label & Line Array Functions Library by RagingRocketBull 2021 Version 1.0 This script provides a library of common array functions for arrays of label and line objects with live testing of all functions. Using this library you can easily create, update, delete, join label/line object arrays, and get/set properties of individual label/line object array items. You can find the full list of supported label/line array functions below. There are several libraries: - Common String Functions Library - Standard Array Functions Library - Common Fixed Type Array Functions Library - Common Label & Line Array Functions Library - Common Variable Type Array Functions Library Features: - 30 array functions in categories create/update/delete/join/get/set with support for both label/line objects (45+ including all implementations) - Create, Update label/line object arrays from list/array params - GET/SET properties of individual label/line array items by index - Join label/line objects/arrays into a single string for output - Supports User Input of x,y coords of 5 different types: abs/rel/rel%/inc/inc% list/array, auto transforms x,y input into list/array based on type, base and xloc, translates rel into abs bar indexes - Supports User Input of lists with shortened names of string properties, auto expands all standard string properties to their full names for use in functions - Live Output for all/selected functions based on User Input. Test any function for possible errors you may encounter before using in script. - Output filters: hide all excluded and show only allowed functions using a list of function names - Output Panel customization options: set custom style, color, text size, and line spacing Usage: - select create function - create label/line arrays from lists or arrays (optional). Doesn't affect the update functions. The only change in output should be function name regardless of the selected implementation. - specify num_objects for both label/line arrays (default is 7) - specify common anchor point settings x,y base/type for both label/line arrays and GET/SET items in Common Settings - fill lists with items to use as inputs for create label/line array functions in Create Label/Line Arrays section - specify label/line array item index and properties to SET in corresponding sections - select label/line SET function to see the changes applied live Code Structure: - translate x,y depending on x,y type, base and xloc as specified in UI (required for all functions) - expand all shortened standard property names to full names (required for create/update* from arrays and set* functions, not needed for create/update* from lists) to prevent errors in label.new and line.new - create param arrays from string lists (required for create/update* from arrays and set* functions, not needed for create/update* from lists) - create label/line array from string lists (property names are auto expanded) or param arrays (requires already expanded properties) - update entire label/line array or - get/set label/line array item properties by index Transforming/Expanding Input values: - for this script to work on any chart regardless of price/scale, all x*,y* are specified as % increase relative to x0,y0 base levels by default, but user can enter abs x,price values specific for that chart if necessary. - all lists can be empty, contain 1 or several items, have the same/different lengths. Array Length = min(min(len(list*)), mum_objects) is used to create label/line objects. Missing list items are replaced with default property values. - when a list contains only 1 item it is duplicated (label name/tooltip is also auto incremented) to match the calculated Array Length - since this script processes user input, all x,y values must be translated to abs bar indexes before passing them to functions. Your script may provide all data internally and doesn't require this step. - at first int x, float y arrays are created from user string lists, transformed as described below and returned as x,y arrays. - translated x,y arrays can then be passed to create from arrays function or can be converted back to x,y string lists for the create from lists function if necessary. - all translation logic is separated from create/update/set functions for the following reasons: - to avoid redundant code/dependency on ext functions/reduce local scopes and to be able to translate everything only once in one place - should be faster - to simplify internal logic of all functions - because your script may provide all data internally without user input and won't need the translation step - there are 5 types available for both x,y: abs, rel, rel%, inc, inc%. In addition to that, x can be: bar index or time, y is always price. - abs - absolute bar index/time from start bar0 (x) or price (y) from 0, is >= 0 - rel - relative bar index/time from cur bar n (x) or price from y0 base level, is >= 0 - rel% - relative % increase of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0 - inc - relative increment (step) for each new level of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0 - inc% - relative % increment (% step) for each new level of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0 - x base level >= 0 - y base level can be 0 (empty) or open, close, high, low of cur bar - single item x1_list = "50" translates into: - for x type abs: "50, 50, 50 ..." num_objects times regardless of xloc => x = 50 - for x type rel: "50, 50, 50 ... " num_objects times => x = x_base + 50 - for x type rel%: "50%, 50%, 50% ... " num_objects times => x_base * (1 + 0.5) - for x type inc: "0, 50, 100 ... " num_objects times => x_base + 50 * i - for x type inc%: "0%, 50%, 100% ... " num_objects times => x_base * (1 + 0.5 * i) - when xloc = xloc.bar_index each rel*/inc* value in the above list is then subtracted from n: n - x to convert rel to abs bar index, values of abs type are not affected - x1_list = "0, 50, 100, ..." of type rel is the same as "50" of type inc - x1_list = "50, 50, 50, ..." of type abs/rel/rel% produces a sequence of the same values and can be shortened to just "50" - single item y1_list = "2" translates into (ragardless of yloc): - for y type abs: "2, 2, 2 ..." num_objects times => y = 2 - for y type rel: "2, 2, 2 ... " num_objects times => y = y_base + 2 - for y type rel%: "2%, 2%, 2% ... " num_objects times => y = y_base * (1 + 0.02) - for y type inc: "0, 2, 4 ... " num_objects times => y = y_base + 2 * i - for y type inc%: "0%, 2%, 4% ... " num_objects times => y = y_base * (1 + 0.02 * i) - when yloc != yloc.price all calculated values above are simply ignored - y1_list = "0, 2, 4" of type rel% is the same as "2" with type inc% - y1_list = "2, 2, 2" of type abs/rel/rel% produces a sequence of the same values and can be shortened to just "2" - you can enter shortened property names in lists. To lookup supported shortened names use corresponding dropdowns in Set Label/Line Array Item Properties sections - all shortened standard property names must be expanded to full names (required for create/update* from arrays and set* functions, not needed for create/update* from lists) to prevent errors in label.new and line.new - examples of shortened property names that can be used in lists: bar_index, large, solid, label_right, white, left, left, price - expanded to their corresponding full names: xloc.bar_index, size.large, line.style_solid, label.style_label_right, color.white, text.align_left, extend.left, yloc.price - all expanding logic is separated from create/update* from arrays and set* functions for the same reasons as above, and because param arrays already have different types, implying the use of final values. - all expanding logic is included in the create/update* from lists functions because it seemed more natural to process string lists from user input directly inside the function, since they are already strings. Creating Label/Line Objects: - use study max_lines_count and max_labels_count params to increase the max number of label/line objects to 500 (+3) if necessary. Default number of label/line objects is 50 (+3) - all functions use standard param sequence from methods in reference, except style always comes before colors. - standard label/line.get* functions only return a few properties, you can't read style, color, width etc. - label.new(na, na, "") will still create a label with x = n-301, y = NaN, text = "" because max default scope for a var is 300 bars back. - there are 2 types of color na, label color requires color(na) instead of color_na to prevent error. text_color and line_color can be color_na - for line to be visible both x1, x2 ends must be visible on screen, also when y1 == y2 => abs(x1 - x2) >= 2 bars => line is visible - xloc.bar_index line uses abs x1, x2 indexes and can only be within 0 and n ends, where n <= 5000 bars (free accounts) or 10000 bars (paid accounts) limit, can't be plotted into the future - xloc.bar_time line uses abs x1, x2 times, can't go past bar0 time but can continue past cur bar time into the future, doesn't have a length limit in bars. - xloc.bar_time line with length = exact number of bars can be plotted only within bar0 and cur bar, can't be plotted into the future reliably because of future gaps due to sessions on some charts - xloc.bar_index line can't be created on bar 0 with fixed length value because there's only 1 bar of horiz length - it can be created on cur bar using fixed length x < n <= 5000 or - created on bar0 using na and then assigned final x* values on cur bar using set_x* - created on bar0 using n - fixed_length x and then updated on cur bar using set_x*, where n <= 5000 - default orientation of lines (for style_arrow* and extend) is from left to right (from bar 50 to bar 0), it reverses when x1 and x2 are swapped - price is a function, not a line object property Variable Type Arrays: - you can't create an if/function that returns var type value/array - compiler uses strict types and doesn't allow that - however you can assign array of any type to another array of any type creating an arr pointer of invalid type that must be reassigned to a matching array type before used in any expression to prevent error - create_any_array2 uses this loophole to return an int_arr pointer of a var type array - this works for all array types defined with/without var keyword and doesn't work for string arrays defined with var keyword for some reason - you can't do this with var type vars, only var type arrays because arrays are pointers passed by reference, while vars are actual values passed by value. - you can only pass a var type value/array param to a function if all functions inside support every type - otherwise error - alternatively values of every type must be passed simultaneously and processed separately by corresponding if branches/functions supporting these particular types returning a common single type result - get_var_types solves this problem by generating a list of dummy values of every possible type including the source type, tricking the compiler into allowing a single valid branch to execute without error, while ignoring all dummy results Notes: - uses Pinescript v3 Compatibility Framework - uses Common String Functions Library, Common Fixed Type Array Functions Library, Common Variable Type Array Functions Library - has to be a separate script to reduce the number of local scopes/compiled file size, can't be merged with another library. - lets you live test all label/line array functions for errors. If you see an error - change params in UI - if you see "Loop too long" error - hide/unhide or reattach the script - if you see "Chart references too many candles" error - change x type or value between abs/rel*. This can happen on charts with 5000+ bars when a rel bar index x is passed to label.new or line.new instead of abs bar index n - x - create/update_label/line_array* use string lists, while create/update_label/line_array_from_arrays* use array params to create label/line arrays. "from_lists" is dropped to shorten the names of the most commonly used functions. - create_label/line_array2,4 are preferable, 5,6 are listed for pure demonstration purposes only - don't use them, they don't improve anything but dramatically increase local scopes/compiled file size - for this reason you would mainly be using create/update_label/line_array2,4 for list params or create/update_label/line_array_from_arrays2 for array params - all update functions are executed after each create as proof of work and can be disabled. Only create functions are required. Use update functions when necessary - when list/array params are changed by your script. - both lists and array item properties use the same x,y_type, x,y_base from common settings - doesn't use pagination, a single str contains all output - why is this so complicated? What are all these functions for? - this script merges standard label/line object methods with standard array functions to create a powerful set of label/line object array functions to simplify manipulation of these arrays. - this library also extends the functionality of Common Variable Type Array Functions Library providing support for label/line types in var type array functions (any_to_str6, join_any_array5) - creating arrays from either lists or arrays adds a level of flexibility that comes with complexity. It's very likely that in your script you'd have to deal with both string lists as input, and arrays internally, once everything is converted. - processing user input, allowing customization and targeting for any chart adds a whole new layer of complexity, all inputs must be translated and expanded before used in functions. - different function implementations can increase/reduce local scopes and compiled file size. Select a version that best suits your needs. Creating complex scripts often requires rewriting your code multiple times to fit the limits, every line matters. P.S. Don't rely too much on labels, for too often they are fables. List of functions*: * - functions from other libraries are not listed 1. Join Functions Labels - join_label_object(label_, d1, d2) - join_label_array(arr, d1, d2) - join_label_array2(arr, d1, d2, d3) Lines - join_line_object(line_, d1, d2) - join_line_array(arr, d1, d2) - join_line_array2(arr, d1, d2, d3) Any Type - any_to_str6(arr, index, type) - join_any_array4(arr, d1, d2, type) - join_any_array5(arr, d, type) 2. GET/SET Functions Labels - label_array_get_text(arr, index) - label_array_get_xy(arr, index) - label_array_get_fields(arr, index) - label_array_set_text(arr, index, str) - label_array_set_xy(arr, index, x, y) - label_array_set_fields(arr, index, x, y, str) - label_array_set_all_fields(arr, index, x, y, str, xloc, yloc, label_style, label_color, text_color, text_size, text_align, tooltip) - label_array_set_all_fields2(arr, index, x, y, str, xloc, yloc, label_style, label_color, text_color, text_size, text_align, tooltip) Lines - line_array_get_price(arr, index, bar) - line_array_get_xy(arr, index) - line_array_get_fields(arr, index) - line_array_set_text(arr, index, width) - line_array_set_xy(arr, index, x1, y1, x2, y2) - line_array_set_fields(arr, index, x1, y1, x2, y2, width) - line_array_set_all_fields(arr, index, x1, y1, x2, y2, xloc, extend, line_style, line_color, width) - line_array_set_all_fields2(arr, index, x1, y1, x2, y2, xloc, extend, line_style, line_color, width) 3. Create/Update/Delete Functions Labels - delete_label_array(label_arr) - create_label_array(list1, list2, list3, list4, list5, d) - create_label_array2(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array3(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array4(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array5(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array6(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - update_label_array2(label_arr, x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - update_label_array4(label_arr, x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d) - create_label_array_from_arrays2(x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d) - create_label_array_from_arrays4(x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d) - update_label_array_from_arrays2(label_arr, x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d) Lines - delete_line_array(line_arr) - create_line_array(list1, list2, list3, list4, list5, list6, d) - create_line_array2(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array3(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array4(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array5(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array6(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - update_line_array2(line_arr, x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - update_line_array4(line_arr, x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d) - create_line_array_from_arrays2(x1_arr, y1_arr, x2_arr, y2_arr, xloc_arr, extend_arr, style_arr, color_arr, width_arr, d) - update_line_array_from_arrays2(line_arr, x1_arr, y1_arr, x2_arr, y2_arr, xloc_arr, extend_arr, style_arr, color_arr, width_arr, d)
Indicador Pine Script®
por RagingRocketBull
13