Speedometer RevisitedSpeedometer Revisited is a new way to draw custom metric speedometers and is intended to be a utility for other coders to use.
@rumpypumpydumpy originally introduced the Speedometer Toolkit in version 4 of Pine Script. Since then, Pine Script has been updated to version 5, introducing some amazing new features such as polylines and chart.points. This indicator is an example of what can be done with these newer features.
The indicator starts off with a handful of functions that will be used to create the drawings. Notes are left throughout the code explaining what each line of the functions does. My goal was to make these functions user-friendly and somewhat easy to understand. I then demonstrate two examples: one speedometer with five segments and another with three.
The first example demonstrates how to visually represent the analysts' ratings for a stock using the built-in syminfo.recommendations. The speedometer is divided into five segments, each representing a different level of analyst recommendation: strong sell, sell, hold, buy, and strong buy.
Each segment is drawn using a polyline from the createSeg function, with colors assigned as follows:
Red for 'Strong Sell'
Maroon for 'Sell'
Yellow for 'Hold'
Green for 'Buy'
Lime for 'Strong Buy'
The script identifies the maximum value among the analyst ratings, calculates the midpoint of the corresponding segment, and draws a needle pointing to this midpoint.
The second example employs the speedometer design to display market sentiment through the put-call ratio. The put-call ratio is a gauge of investor sentiment, where values above 1 indicate a bearish sentiment (more puts being bought relative to calls), and values below 1 suggest a bullish outlook (more calls being bought relative to puts).
The speedometer is divided into three segments, reflecting different ranges of the put-call ratio:
Red for a ratio greater than 1 (bearish sentiment)
Yellow for a ratio between 0.8 and 1 (neutral to bearish sentiment)
Lime for a ratio less than 0.8 (bullish sentiment)
Depending on the value of the put-call ratio, the script calculates which segment the current value falls into and determines the appropriate segment number. The script calculates the midpoint of the selected segment and draws a needle pointing to this value.
Both examples show how the speedometer can be used as a visual indicator of certain market conditions, helping traders quickly recognize trends and adjust their strategies accordingly.
A big thanks to @rumpypumpydumpy for his original Speedometer Toolbox. I hope this take on it can be useful for other coders.
Pinescript
Volume Spike IndicatorHello dear traders,
Today we're discussing an indicator I've coded: the Volume Spike Indicator (VSI).
The indicator isn't a groundbreaking invention and certainly not a novelty. Nevertheless, I haven't seen this version of the indicator on TradingView before, so I'd like to introduce it.
1. The Origin of the Idea:
We're all familiar with volume charts: A volume chart visually represents the trading activity for a specific asset over a certain period, indicating the total number of shares or contracts traded.
We also know that volume spikes can significantly impact the market. A volume spike represents an extreme anomaly, a day, week, or month with an extraordinary amount of trading. However, recognizing these spikes in practice isn't always straightforward. What constitutes high volume? How do we define and identify it? The answers to these questions aren't easy.
It's commonly said that a volume spike could be identified if the volume is 25% more than the average of the two weeks prior, but how do you measure this 25%? It's not always easy to calculate, especially in real-time.
This challenge led me to develop the concept into an indicator.
How Does It Work?
Imagine being able to "feel" the market's energy like a surfer feels the ocean. The VSI does something similar by examining trading volume and comparing it to what has been typical over the past few weeks. Here's a quick look at the magic behind it:
Step 1: Establishing the Baseline: We start by establishing a baseline, i.e., the average trading volume over a given period. Let's use the last 10 days as the default setting. We choose 10 days because, in the traditional stock market, 10 days represent two weeks if you subtract weekends. This gives us a fixed line to compare against.
Step 2: Recognizing Peaks: Next, we look for days when the trading volume significantly exceeds this average. The size of the jump is where you have a say. You can set a threshold, such as 25%, to define what you consider a volume spike.
Step 3: The Calculation: This is where the math comes into play. We calculate the percentage change in today's volume compared to the average volume of the last 10 days. For example, if today's volume is 30% above the average and you've set your threshold at 25%, the VSI will recognize this as a spike.
Step 4: Visual Cue: These spikes are then plotted on a graph, with each spike represented as a bar. The height of the bar indicates the spike's percentage size, so you can see at a glance how significant a spike is.
Step 5: Intuitive Color Coding: For quick analysis, the VSI employs a color-coding system. Exceptionally high peaks, such as those exceeding a 100% increase, are highlighted in blue to emphasize their importance. Other peaks are shown in red, creating a visual hierarchy for quick volume data interpretation.
Why This Matters:
Identifying these spikes can help pinpoint the beginning or end of a trend. The idea is that when trading peaks at a certain level, there might be no more buyers or sellers willing to engage at that price level. Volume peaks, and a reversal is likely imminent. It's a simple yet effective concept. Therefore, it's crucial to use this indicator in the context of the trend, as not every spike carries the same significance.
Customizable:
The beauty of the VSI lies in its flexibility. Trading futures? You might want to adjust the averaging period to 14 days to better suit your market. You have full control over the settings to tailor them to your trading style.
Interpreting the Figures:
A positive percentage indicates a volume spike above the average – the higher the percentage, the more significant the spike.
If the percentage exceeds a certain threshold (which you can set, e.g., 25%), it signals a volume spike, indicating increased market activity that could precede significant price movement.
What makes the VSI genuinely adaptable is your ability to tweak the parameters to suit your needs.
Are you trading in a volatile market? Extend the SMA period to smooth out the noise. Trading in a 24-hour market? Adjust the length of your SMA. Seeking finer details? Shorten it. The VSI is yours to adapt to your trading strategy.
---------------------------------------------------------------------------------------------------------------------
As we wrap up this introduction to the Volume Spike Indicator, I hope you're as excited about its potential as I am. This tool, born out of curiosity and a desire for clarity in the vast ocean of market data, is designed to be your ally in navigating the waves of trading activity.
Remember, the true power of the VSI lies not just in its ability to highlight significant volume spikes, but in its adaptability to your unique trading style and needs. Whether you're charting courses through the tumultuous seas of day trading or navigating the broader currents of long-term investments, the VSI is here to offer insights and guidance.
I encourage you to experiment with it, customize it, and see how it can enhance your trading strategy. And as you do, remember that every tool, no matter how powerful, is just one piece of the puzzle. Combine the VSI with your knowledge, experience, and intuition to make informed and strategic trading decisions.
Thank you for taking the time to explore the Volume Spike Indicator with me.
Best Regards,
Karim Subhieh
Liquidity Heatmap [BigBeluga]The Liquidity Heatmap is an indicator designed to spot possible resting liquidity or potential stop loss using volume or Open interest.
The Open interest is the total number of outstanding derivative contracts for an asset—such as options or futures—that have not been settled. Open interest keeps track of every open position in a particular contract rather than tracking the total volume traded.
The Volume is the total quantity of shares or contracts traded for the current timeframe.
🔶 HOW IT WORKS
Based on the user choice between Volume or OI, the idea is the same for both.
On each candle, we add the data (volume or OI) below or above (long or short) that should be the hypothetical liquidation levels; More color of the liquidity level = more reaction when the price goes through it.
Gradient color is calculated between an average of 2 points that the user can select. For example: 500, and the script will take the average of the highest data between 500 and 250 (half of the user's choice), and the gradient will be based on that.
If we take volume as an example, a big volume spike will mean a lot of long or short activity in that candle. A liquidity level will be displayed below/above the set leverage (4.5 = 20x leverage as an example) so when the price revisits that zone, all the 20x leverage should be liquidated.
Huge volume = a lot of activity
Huge OI = a lot of positions opened
More volume / OI will result in a stronger color that will generate a stronger reaction.
🔶 ROUTE
Here's an example of a route for long liquidity:
Enable the filter = consider only green candles.
Set the leverage to 4.5 (20x).
Choose Data = Volume.
Process:
A green candle is formed.
A liquidity level is established.
The level is placed below to simulate the 20x leverage.
Color is applied, considering the average volume within the chosen area.
Route completed.
🔶 FEATURE
Possibility to change the color of both long and short liquidity
Manual opacity value
Manual opacity average
Leverage
Autopilot - set a good average automatically of the opacity value
Enable both long or short liquidity visualization
Filtering - grab only red/green candle of the corresponding side or grab every candle
Data - nzVolume - Volume - nzOI - OI
🔶 TIPS
Since the limit of the line is 500, it's best to plot 2 scripts: one with only long and another with only short.
🔶 CONCLUSION
The liquidity levels are an interesting way to think about possible levels, and those are not real levels.
Flag FinderFlag Finder Indicator is a technical analysis tool to identify bull and bear flags.
What are flags
Flags are continuation patterns that occur within the general trend of the security. A bull flag represents a temporary pause or consolidation before price resumes it's upward movement, while a bear flag occurs before price continues its downward movement.
Both flag patterns consist of two components:
The Pole
The Flag
The pole is the initial strong upward surge or decline that precedes the flag. The pole is usually a fast move accompanied by heavy volume signaling significant buying or selling pressure.
The flag is then formed as price consolidates after the initial surge or decline from the pole. For a bull flag price will drift slightly downward to sideways, a bear flag will drift upward to sideways. The best flags often see volume dry up during this phase of the pattern.
Indicator Settings
Both components are fully customizable in the indicator so the user can adjust for any time frame or volatility. Select the minimum and maximum accepted limits from the % gain loss required for the pole, the maximum acceptable flag depth or rally and the minimum and maximum number of bars for each component.
Colors and what components are visible at any time are also user controlled.
Trading flags
Traders typically use flags to enter on breakouts. A breakout occurs when price moves above the left side high of a bull flag or below the left side low of a bear flag.
Alerts
The Flag Finder allows for four different types of alerts
New Bull Flag
New Bear Flag
Bull Flag Breakout
Bear Flag Breakout
Pine Script
On top of the indicator identifying bull and bear flags, throughout the source code I left notes on nearly every line to help anyone who is interested in pine script see my thought process and explain which each line of code does. This code isn't too complex, but it offers a look into many different concepts one might use when writing pinescript such as:
input groups
declaring and reassigning variables
for loops
plotshapes & lines
alerts
PSESS1 - Learn PineScript InputsThis is a script written exclusively for people who are trying to learn Pine Script.
PSESS stands for "Pine Script Educational Script Series" which is a series of scripts that helps Pine Script programmers in 2 ways:
1. Learn Pine Script at more depth by an interactive environment where they can immediately see the effects of any change in the pre-written code and also comparing different lines code having tiny differences so they can grasp the details.
2. Have this script open while coding in order to copy the line they find useful
Pine Script Library couldn't be used for this purpose since this script has educational aspect and needs to be executable individually.
This is Script 1 of PSESS and focuses on inputs in Pine Script.
The script is densly commented in order to make it understandable. here is the outline of the script:
1. Inputs that can be received through the indicator() function
2. 12 possible types of input
3. Input() function arguments: defval - title - tooltip - inline - group - confirm
4. The different display of tooltip when inputs are inline
5. Multiple price and time inputs (on single request or multiple requests)
6. What happens when title argument is not specified
7. References and key points from them
Number Formatting Indian/USAThis is a Pine script that helps traders format numbers in different ways to make it easier to read and display big numbers on TradingView.
this script is specifically to help other fellow pinecoder. Its not a indicator.
The above code is an example of how to format numbers in TradingView using two different formats: Indian and USA. The code defines a function called `formatNumber()` which takes two arguments: num (the number to format) and format (the format to use - either "Indian" or "USA").
If the "Indian" format is selected, the function rounds the number to the nearest crore, lakh or thousand and adds the appropriate suffix (i.e. "Cr", "Lac" or "K"). If the "USA" format is selected, the function rounds the number to the nearest billion, million or thousand and adds the appropriate suffix (i.e. "B", "M" or "K").
In both cases, the function then adds commas to the formatted number. The example usage shows how to call the `formatNumber()` function with a given number and format, and then plot the formatted number as a label on the chart.
Dynamo
╭━━━╮
╰╮╭╮┃
╱┃┃┃┣╮╱╭┳━╮╭━━┳╮╭┳━━╮
╱┃┃┃┃┃╱┃┃╭╮┫╭╮┃╰╯┃╭╮┃
╭╯╰╯┃╰━╯┃┃┃┃╭╮┃┃┃┃╰╯┃
╰━━━┻━╮╭┻╯╰┻╯╰┻┻┻┻━━╯
╱╱╱╱╭━╯┃
╱╱╱╱╰━━╯
Overview
Dynamo is built to be the Swiss-knife for price-movement & strength detection, it aims to provide a holistic view of the current price across multiple dimensions. This is achieved by combining 3 very specific indicators(RSI, Stochastic & ADX) into a single view. Each of which serve a different purpose, and collectively provide a simple, yet powerful tool to gauge the true nature of price-action.
Background
Dynamo uses 3 technical analysis tools in conjunction to provide better insights into price movement, they are briefly explained below:
Relative Strength Index(RSI)
RSI is a popular indicator that is often used to measure the velocity of price change & the intensity of directional moves. RSI computes the relative strength of the current price by comparing the security’s bullish strength versus bearish strength for a given period, i.e. by comparing average gain to average loss.
It is a range bound(0-100) variable that generates a bullish reading if average gain is higher, and a bullish reading if average loss is higher. Values over 50 are generally considered bullish & values less than 50 indicate a bearish market. Values over 70 indicate an overbought condition, and values below 30 indicate oversold condition.
Stochastic
Stochastic is an indicator that aims to measure the momentum in the market, by comparing most recent closing price of the security to its price range for a given period. It is based on the assumption that price tends to close near the recent high in an up trend, and it closes near the recent low during a down trend.
It is also range bound(0-100), values over 80 indicate overbought condition and values below 20 indicate oversold condition.
Average Directional Index(ADX)
ADX is an indicator that can quantify trend strength, it is derived from two underlying indices, known as Directional Movement Index(DMI). +DMI represents strength of the up trend, and -DMI represents strength of the down trend, and ADX is the average of the two.
ADX is non-directional or trend-neutral, which means, it does not follow the direction of the price, instead ADX will rise only when there is a strong trend, it does not matter if it’s an up trend or a down trend. Typical ranges of ADX are 25-50 for a strong trend, anything below 25 is considered as no trend or weak trend. ADX can frequently shoot upto higher values, but it generally finds exhaustion levels around the 60-75 range.
About the script
All these indicators are very powerful tools, but just like any other indicator they have their limitations. Stochastic & ADX can generate false signals in volatile markets, meaning price wouldn’t always follow through with what’s being indicated. ADX may even fail to generate a signal in less volatile markets, simply because it is based on moving averages, it tends to react slower to price changes. RSI can also lose it’s effectiveness when markets are trending strong, as it can stay in the overbought or oversold ranges for an extended period of time.
Dynamo aims to provide the trader with a much broader perspective by bringing together these contrasting indicators into a single simplified view. When Stochastic becomes less reliable in highly volatile conditions, one can cross validate their deduction by looking at RSI patterns. When RSI gets stuck in overbought or oversold range, one can refer to ADX to get better picture about the current trend. Similarly, various combinations of rules & setups can be formulated to get a more deterministic view, when working with either of these indicators.
There many possible use cases for a tool like this, and it totally depends on how you want to use it. An obvious option is to use it to trigger signals only after it has been confirmed by two or more indicators, for example, RSI & Stochastic make a great combination for cross-over or cross-under strategies. Some of the other options include trend detection, strength detection, reversals or price rejection points, possible duration of a trend, and all of these can very easily be translated into effective entry and exit points for trades.
How to use it
Dynamo is an easy-to-use tool, just add it to your chart and you’re good to start with your market analysis. Output consists of three overlapping plots, each of which tackle price movement from a slightly different angle.
Stochastic: A momentum indicator that plots the current closing price in relation to the price-range over a given period of time.
Can be used to detect the direction of the price movement, potential reversals, or duration of an up/down move.
Plotted as grey coloured histograms in the background.
Relative Strength Index(RSI): RSI is also a momentum indicator that measures the velocity with which the price changes.
Can be used to detect the speed of the price movement, RSI divergences can be a nice way to detect directional changes.
Plotted as an aqua coloured line.
Average Directional Index(ADX): ADX is an indicator that is used to measure the strength of the current trend.
Can be used to measure how strong the price movement is, both up and down, or to establish long terms trends.
Plotted as an orange coloured line.
Features
Provides a well-rounded view of the market movement by amalgamating some of the best strength indicators, helping traders make better informed decisions with minimal effort.
Simplistic plots that aim to convey clean signals, as a result, reducing clutter on the chart, and hopefully in the trader's head too.
Combines different types of indicators into a single view, which leads to an optimised use of the precious screen real-estate.
Final Note
Dynamo is designed to be minimalistic in functionality and in appearance, as it is being built to be a general purpose tool that is not only beginner friendly, but can also be highly-configurable to meet the needs of pro traders.
Thresholds & default values for the indicators are only suggestions based on industry standards, they may not be an exact match for all markets & conditions. Hence, it is advisable for the user to test & adjust these values according their securities and trading styles.
The chart highlights one of many possible setups using this tool, and it can used to create various types of setups & strategies, but it is also worth noting that the usability & the effectiveness of this tool also depends on the user’s understanding & interpretation of the underlying indicators.
Lastly, this tool is only an indicator and should only be perceived that way. It does not guarantee anything, and the user should do their own research before committing to trades based on any indicator.
Lines and Table for risk managementABOUT THIS INDICATOR
This is a simple indicator that can help you manage the risk when you are trading, and especially if you are leverage trading. The indicator can also be used to help visualize and to find trades within a suitable or predefined trading range.
This script calculates and draws six “profit and risk lines” (levels) that show the change in percentage from the current price. The values are also shown in a table, to help you get a quick overview of risk before you trade.
ABOUT THE LINES/VALUES
This indicator draws seven percentage-lines, where the dotted line in the middle represents the current price. The other three lines on top of and below the middle line shows the different levels of change in percentage from current price (dotted line). The values are also shown in a table.
DEFAULT VALUES AND SETTINGS
By default the indicator draw lines 0.5%, 1.0%, and 1.5% from current price (step size = 0.5).
The default setting for leverage in this indicator = 1 (i.e. no leverage).
The line closest to dotted line (current price) is calculated by step size (%) * leverage (x) = % from price.
Pay attention to the %-values in the table, they represent the distance from the current price (dotted line) to where the lines are drawn.
* Be aware! If you change the leverage, the distance from the closest lines to the dotted line showing the current price increase.
SETTINGS
1. Leverage: set the leverage for what you are planning to trade on (1 = no leverage, 2 = 2 x leverage, 5 = 5 x leverage...).
2. Stepsize is used to set the distance between the lines and price.
EXAMPLES WITH DIFFERENT SETTINGS
1) Leverage = 1 (no leverage, default setting) and step size 0.5 (%). Lines plotted at (0.5%, 1%, 1.5%, and –0.5%, –1%, –1,5%) from the current price.
2) Leverage = 3 and stepsize 0.5(%). Lines plotted at (1.5%, 3.0%, 4.5%, and –1.5%, –3.0%, –4.5%) from the current price.
3) Leverage = 3 and stepsize 1(%). Lines plotted at (3%, 6%, 9%, and –3%, –6%, –9%) from the current price.
The distance to the nearest line from the current price is always calculated by the formula: Leverage * step size (%) = % to the nearest line from the current price.
Trendly
╭━━━━╮╱╱╱╱╱╱╱╱╭┳╮
┃╭╮╭╮┃╱╱╱╱╱╱╱╱┃┃┃
╰╯┃┃┣┻┳━━┳━╮╭━╯┃┃╭╮╱╭╮
╱╱┃┃┃╭┫┃━┫╭╮┫╭╮┃┃┃┃╱┃┃
╱╱┃┃┃┃┃┃━┫┃┃┃╰╯┃╰┫╰━╯┃
╱╱╰╯╰╯╰━━┻╯╰┻━━┻━┻━╮╭╯
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╭━╯┃
╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╰━━╯
About the script:
This script is an easy-to-use trend indicator, which is based on another popular indicator called "Supertrend" . The basic idea is very simple, i.e. to compute Average True Range(ATR) and use that as the basis for trend detection. The key difference lies in a custom trend detection method, that computes trends across different timeframes and projects them in a table view. The script also tries to improve the behaviour of the existing indicator by highlighting flat regions on the chart, indicating sideways market or potential trend reversals.
How to use it:
You can use it just like any other indicator, add it to your chart and start analysing market trends. Results can be interpreted as follows.
Indicator output is currently made up of two main components:
>> Trend Table:
Appears at the bottom right of your screen
Contains trend indicator for 9 different timeframes
Timeframes can be adjusted using indicator settings panel
Green Up Arrow --> Up Trend
Red Down Arrow --> Down Trend
>> Enhanced Supertrend:
Shows up as a line plot on the chart
Green line indicates up trend
Red line indicates down trend
White regions indicates slow moving markets or a potential trend reversal
Indicator can be used on any timeframe, it provides a view of current and historical market trend
Can be used as an indicator for entering/exiting trades
Can be used to build custom trading strategies
[-_-] Custom Type ExamplesDescription:
This script shows an example use of new Pinescript's feature called User Defined Types, which can be seen as analogue of from C++ or from Python. It is not an indicator for technical analysis, and serves only as an example of how to use the new feature mentioned above.
In the script I define 4 custom types and a custom initialisation function for each:
- Point (represents a coordinate with x -> bar_index, y -> price)
- Tria (creates a triangle using objects and objects as coordinates of 3 points)
- Path (creates a path-like object from an of )
- Trade (creates a visual representation of a Long/Short trade with set Take Profit and Stop Loss, and displays an info label with realized Profit/Loss)
I'd personally like to see this feature improved by adding methods (so that we could, for example, define functions inside a custom type), which could be an analogue of classes from other programming languages.
FUNCTION: Limited Historical Data WorkaroundFUNCTION: Limited Historical Data Workaround
If you are working with bitcoin weekly charts, or any other ticker with a low amount of price history this function may help you out. For example you want to apply indicators to some shitcoin that just launched? This can help you.
It can be frustrating to use certain built-ins since they will only give an output once the full lookback length is available. This function allows you to avoid that situation and start plotting things with almost no history whatsoever!
In this example code we do it by utilizing a replacement for the built in pine SMA function. This function allows us to pass a series instead of just a simple int to the length variable of the SMA. This can be achieved with all the pine built ins and I believe @pinecoders has a publication already detailing many of them with full coded examples.
Then we replace the length of the SMA with the custom history function. It checks to see if the current bar index is less than the length of the function. Then if it is, it changes the length to the bar index allowing us to get plots and series earlier than otherwise possible.
Symbol InfoFor those who likes clean chart:
Adjustable Symbol ticker and timeframe( AKA watermark) script is here.
1: You can place Symbol ticker and timeframe info anywhere on the chart.
Also you can hide one of them or both.
Position:
Horizontal options: Left Center Right
Vertical options: Top Middle Bottom
Size: Tiny Smal Normal Large Huge Auto
Color is adjustable. Background is optional too.
2: Even more cool part is you can add 2 different custom texts that can switch. (Idea from Pinecoders original script)
You don't have to use text function and reposition it everytime, your message will always stays at one place.
Let the chart deliver your message.
I put my favourite trading slangs there:
1. Do Your Own Research (DYOR)
2. Not a Financial Advice ( NFA)
No Active BarThis is probably the only script on TradingView that's clinically proven to lower your blood pressure!***
This script in conjunction with some chart settings changes can completely hide the active candle, only showing historic candles, thus, reducing risk of cardiac arrest and or panic attack.
What to do:
0. Make sure you are using a candlestick chart or this script won't work properly
1. Right click the chart and select "Settings..."
2. Select "Symbol" under the "Chart Settings" menu
3. Disable every item EXCEPT for the "Body"
4. Click on the boxes next to "Body" to access the color picker then change both box's transparency settings down to 0
(the script only colors closed bars, so the active bar will be present just transparent)
5. Right click on the price scale on the far left or far right side of the screen and hover the mouse over "Labels". If any selections have a check mark next to them click them to disable them (especially the "Ask & Bid" price setting since it tracks current price)
That's it! Instead of wicks the High & Low prices are plotted above and below the candles using a step line. It looks a bit strange at first but you'll get used to it. Check out the indicator settings to change the color and style of the High & Low lines.
***The statement could prove true for some but is mostly complete bullshit
Level 1 - Learn to code simply - PineScriptThe goal of this script is honestly to help everyone learn about trading with bots and algos.
At least, to get started.
Level 1:
10 lines of code.
learn to plot 2 moving averages on your chart.
learn to create a signal from a crossover.
learn the very basics of Pine Script algo.
SymMatrixTableSimple Example Table for Displaying Price, RSI, Volume of multiple Tickers on selected Timeframe
Displays Price, RSI and Volume of 3 Tickers and Timeframe selected by user input
Conditional Table Cell coloring
Price color green if > than previous candle close and red if < previous candle close
RSI color green if < 30 and red if > 70 (RSI14 by default)
Volume color green if above average volume and red if less than that (SMA20 volume by default)
Can turn on/off whole table, header columns, row indices, or select individual columns or rows to show/hide
// Example Mixed Type Matrix To Table //
access the simple example script by uncommenting the code at the end
Basically I wanted to have the headers and indices as strings and the rest of the matrix for the table body as floats, then conditional coloring on the table cells
And also the functionality to turn rows and columns on/off from table through checkboxes of user input
Before I was storing each of the values separately in arrays that didn't have a centralized way of controlling table structure
so now the structure is :
- string header array, string index array
- float matrix for table body
- color matrix with bool conditions for coloring table cells
- bool checkboxes for controlling table display
Study forloop Star Triangle'Study forloop' pinescript Program to print star Triangle
The Program Logic
For example, the following Pinescript programme will need two nested for loops. The outer forloop is for rows and the inner forloop is for columns or stars. to create a triangle shape.
Invisible FriendLooking into a question from user Alex100, i realized many people do want some kind of values displayed on chart when they hover the mouse over different bars.
As pinescript does not have any feature like pop up box, the only way is to plot a line and than see indicator values at top left. So when mouse is moved around the value displayed changes. As we just need the value, we do not want to clutter the chart with another line.
Using display.none will hide the value from indicator value also
Using color.white will also color the indicator value to white, making it invisible
So the solution is very simple, and requires a bit of creativity. We create an invisible line, in any color we like :)
This indicator is a tutorial on how to display indicator values without the line showing up and also this can be implemented as displaying data for each bar on mouse hover.
-----
Check My Public Creations In The Meantime:
Buy Monday Exit Tuesday with StopLoss and TakeProfit
Close Combination Lock Style Visual Appeal Indicator
High-Low Box between Earnings with ability to Add Custom Boxes
Sentiment Estimator [AstrideUnicorn]Sentiment Estimator is an indicator that estimates market sentiment using only its pricing data. It counts bullish and bearish candles in a rolling window and calculates their relative values as percentages of the total amount of candles in the window. Market sentiment shows the direction in which the market is biased to move or the current trend direction. Extreme values of the market sentiment are contrarian signals. When the market sentiment is too bullish, it is time to sell and vice versa.
HOW TO USE
Sentiment Estimator plots a pair of green and red circles for each candle. They represent bullish and bearish sentiments, respectively.
The vertical positions of the circles show corresponding sentiment values in percentage units. For example, if a green circle's height is 60, the market is 60% bullish. In this case, the red circle's height will be 40, as bullish and bearish parts of the market sentiment sum to 100%.
The blue line plotted at the 50% level shows the neutral sentiment level. If a green circle is above the blue line, the prevailing market sentiment at that time is bullish, and the market is biased to move up. If a red one is above, the market has predominantly bearish sentiment and is prone to move down.
The red level shows extreme sentiment level. If a green or red circle is above this line, it means that the market is extremely bullish or bearish, respectively. It is a contrarian signal, and one can expect a reversal soon. In this case, a blue label with the text "reversal expected" is shown.
SETTINGS
Timeframe - allows choosing a timeframe other than the chart's one for the indicator calculation.
Look-Back Window - sets the historical window length used to perform the calculations. You can adjust the window to get the best results for a particular market or timeframe.
RKs Notepad++ Pine Script V5█ OVERVIEW
After reading all the new names and renames that Pine Script V5 brought to us, I knew that my old Notepad++ User Defined Language (UDL) would need a big update, so I decided to do a complete remake using the same Dark color scheme theme of the Pine Editor.
Then, I create a Notepad++ Theme and the Auto-Completion file with the Parameter hints for every built-in function to make everything look nicer
█ IMPORTANT
This is not an indicator!!
These are 3 XML files to copy and paste inside the Notepad++ folder.
You can use any Notepad Software to create the XML files.
The main Notepad++ folder is normally on %AppData%\Notepad++\
To avoid mistakes, always make a Backup of your files before anything.
█ INSTALLATION
Just follow these steps:
1. open a New Document File;
2. Copy everything between ↓↓↓ and ↑↑↑ symbols to this new document;
3. Remove the "//" of every single line;
4. Save each document with the correct name in the right folder;
5. Restart the Notepad++
█ NOTES:
If you have some problem installing, ask me, and I will try to help you.
But, in any case, here is the link to these files on my GitHub:
2 Dimensional Array using one floating point entry This is an attempt to create a two dimensional floating point array from the pine single dimension array.
It enables some useful array functions like sorting, when you are trying to keep track of price and location in time or bars and you would like to sort the array.
Other array functions on this array will not work, like average and other statistical functions - they will provide bad results. I would suggest continuing to use a single dimensional array for each element where that kind of array function is required.
I wrote this simply as a mean of using the sort functions when I had to sort price and try to keep the bar location or time in synch.
Other array functions could be written to manipulate this kind of array, leave that to others. The goal here was to avoid using for loops which would be a performance impact on large arrays.
The basic concept is to create one floating point number from two, put that into an array, and then be able to pull the compound value out and parse out the individual components.
I imagine it could also accommodate a 3 or 4 dimensional array with some work, as long as you had some idea of how many digits are consumed by each element. For example you may be interested in storing price, RSI, x_loc values and then be able to sort and parse them out.
Indicator PanelHello All,
This script shows Indicator panel in a Table. Table.new() is a new feature and released today! Thanks a lot to Pine Team to add this new great feature! This new feature is a game changer!
The script shows indicator values for each symbol and changes background color of each cell by using current and last values of the indicators for each symbol. if current value is greater than last value then backgroung color is green, if lower than last value then red, if they are equals then gray.
You can choose the indicators to display. Number of columns in the table is dynamic and is changed by number of the indicators.
You can choose 5 different Symbols, 6 Indicators and 2 Simple or Exponential Moving averages, you can set type of moving averages and the lengths. You can also set the lengths for each Indicators.
Indicators:
- RSI
- MACD ( MACD and Signal and Histogram )
- DMI ( +DI and -DI + and ADX )
- CCI
- MFI
- Momentum
- MA with Length 50 (length can be set)
- MA with Length 200 (length can be set)
In this example RSI, MACD and MA 200 were chosen, you can see how table size changes dynamically:
Enjoy!
Dead Simple - 3 greens or 3 reds each bigger than the last High probability reversal pattern best used for scalping on lower time frame charts like the 15 second chart. very basic script for those just starting to learn pine
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)
