Nadaraya-Watson Probability [Yosiet]The script calculates and displays probability bands around price movements, offering insights into potential market trends.
Setting Up the Script
Window Size: Determines the length of the window for the Nadaraya-Watson estimation. A larger window smooths the data more but might lag current market conditions.
Bandwidth: Controls the bandwidth for the kernel regression, affecting the smoothness of the probability bands.
Reading the Data Table
The script dynamically updates a table positioned at the bottom right of your chart, providing real-time insights into market probabilities. Here's how to interpret the table:
Table Columns: The table is organized into three columns:
Up: Indicates the probability or relative change percentage for the upper band.
Down: Indicates the probability or relative change percentage for the lower band.
Table Rows: There are two main rows of interest:
P%: Shows the price change percentage difference between the bands and the closing price. A positive value in the "Up" column suggests the upper band is above the current close, indicating potential upward momentum. Conversely, a negative value in the "Down" column suggests downward momentum.
R%: Displays the relative inner change percentage difference between the bands, offering a measure of the market's volatility or stability within the bands.
Utilizing the Insights
Market Trends: A widening gap between the "Up" and "Down" percentages in the "P%" row might indicate increasing market volatility. Traders can use this information to adjust their risk management strategies accordingly.
Entry and Exit Points: The "R%" row provides insights into the relative position of the current price within the probability bands. Traders might consider positions closer to the lower band as potential entry points and positions near the upper band as exit points or take-profit levels.
Conclusion
The Nadaraya-Watson Probability script offers a sophisticated tool for traders looking to incorporate statistical analysis into their trading strategy. By understanding and utilizing the data presented in the script's table, traders can gain insights into market trends and volatility, aiding in decision-making processes. Remember, no indicator is foolproof; always consider multiple data sources and analyses when making trading decisions.
Cerca negli script per "THE SCRIPT"
[-_-] DictionaryThe script shows an example implementation of dictionary-like data type which can store key:value pairs (Python style). Both keys and values can have any of the following type:
• string
• integer
• float
• boolean
• color
You can add items of different types to the same dictionary (e.g. key = 12 and value = "value" stored in the same dictionary with key = "key" and value = 0.23).
Under the hood dictionary is a custom Object (see www.tradingview.com), that has two array fields (one for storing keys, another for storing values). Keys and values of different types are converted into a string representation when adding a new item to the dictionary. The value is then converted back to certain type (bool/color/etc.) from that string representation when being retrieved. Script also utilises the new Methods (see www.tradingview.com).
The following methods are implemented:
• init() -> initialises the array fields of dictionary (without this the script throws an error "Array methods can't be called when ID of array is na"
• set(key, value) -> add a new item to dictionary; if an item for given key already exists - change it to new value
• getS(key) -> get value of string type
• getI(key) -> get value of integer type
• getF(key) -> get value of float type
• getB(key) -> get value of boolean type
• getC(key) -> get value of color type
• remove(key) -> removes item from dictionary
• len() -> get length of dictionary (the number of keys)
I could not make just one "get" function that returns any type of value (color/string/etc.), so instead I created a get function for each value type. Example usage:
• you add a string item: dictionary.set(2, "string here")
• you add a float item: dictionary.set(3, 24.56)
• to retrieve first value (key=2) do this: dictionary.getS(2)
• to retrieve second value (key=3) do this: dictionary.getF(3)
ICT Sessions_One Setup for Life [MK]The script plots the High/Low of the following trading sessions:
London - 02:00-05:00
NY AM - 09:30-12:00
New York Lunch - 12:00-13:30
New York PM - 13:30-16:00
Due to the high level of liquidity (resting orders), highs and lows of these sessions may be used as buy/sell areas and also as profit target areas. Typically, buy orders would be initiated below a session low and sell orders would be initiated above a
session high.
The script also plots 'RTH (Regular Trading Hours) Opening Gaps'. The RTH gaps are drawn from the closing price of regular trading at 16:15 (EST) to the open price of regular trading at 09:30 (EST). Gaps can be areas that traders might anticipate to be filled at some time in the future. A gap 'midline' is available if needed and yesterday RTH close line can be shown and extended to the current bar.
This script is simply a means to draw boxes around certain areas/periods on the charts. It is in no way a trading strategy and users should spend much time to study the concept and should also perform extensive back-testing before taking any trades.
By setting the lookback value to a much higher value then the default of 6, users can utilise the script to perform their own backtesting studies.
The above chart shows the default setup of the indicator. Note that the user has to choose how far (in days) to lookback and draw the sessions/gaps.
It is also possible to show the session high//low lines and extend them to the current bar time. If this is used it is advised to keep the lookback period as low as possible to ensure charts stay clean/uncluttered.
All boxes/lines styles/colors are fully customisable.
Data structure map[string, float]The script shows a workaround for map in pine-script via drawings.
There are few restrictions with them:
1. The size of the map cannot be more that amount of allowed drawings (about 40 by now)
2. Because the map shares the space of drawings throughout the whole script, using drawings with the map must be careful, with handly creating and removing of each drawing, because otherwise pine's garbage collector might break the stack. I'd recommend not using more drawings with the map.
3. setters and getters must be called on every bar, because of implementation of functions in pine there are inner serieses, which must be updated on every bar. So wherever you have a setter or getter in the code - it must be called on every bar. But if it's just an update, then you should pass 'false' as a param of the funtion.
The script shows a way to work with the map: filling it with some tickers and values for each of it and then plot the value if the symbol on the chart equals to one of the tickers in the map.
And there are some examples of updating of the value and removing of the item from the map.
Workaround for Arrays in pine and Bubble sortThe script shows a workaround for arrays in pine-script via drawings.
There are few restrictions with them:
1. The length of the array cannot be more that amount of allowed drawings (about 40 by now)
2. Because the "array" shares the space of drawings throughout the whole script, using drawings with the "array" must be careful, with handly creating and removing of each drawing, because otherwise pine's garbage collector might break the "array"
3. Getter and Setter must be called on every bar, because of implementation of functions in pine there are inner serieses, which must be updated on every bar. So wherever you have a setter or getter in the code - it must be called on every bar. But if it's just an update, then you should pass 'false' as a param of the funtion.
The script also shows an example of implementation of bubble sort of the array in pine: when the array have been created, it's filled with pseudo-random numbers and sorted on every bar. There are plotting of the array's numbers before/after soring to show the sorting result.
Real-Time Custom Candle Range Color Indicator
The script allows the user to input a custom range value (default set to 100 points) through the userDefinedRange variable. This value determines the minimum range required for a candle to change color.
Calculating Candle Range:
The script calculates the range of each candle by subtracting the low from the high price.
Determining Bullish or Bearish Candles:
It checks whether the close price is higher than the open price to determine if a candle is bullish (isBullish variable).
Coloring Candles:
Based on the custom range input, the script changes the color of the candles:
If the candle's range is greater than or equal to the custom range and it is bullish, the candle color is set to blue (bullishColor).
If the range condition is met and the candle is bearish, the color is set to orange (bearishColor).
If the range condition is not met, the color is set to na (not applicable).
Plotting Colored Candles:
The plotcandle function is used to plot candles with colors based on the custom range and bullish/bearish conditions. The candles will have a higher z-order to be displayed in front of default candles.
Displaying High and Low Price Points:
Triangular shapes are plotted at the high and low price levels using the plotshape function, with colors representing bullish (blue) and bearish (orange) conditions.
In trading, this indicator can help traders visually identify candles that meet a specific range criteria, potentially signaling strength or weakness in price movements. By customizing the range parameter, traders can adapt the indicator to different market conditions and trading strategies. It can be used in conjunction with other technical analysis tools to make informed trading decisions based on candlestick patterns and price movements.
HL range by durgaThe script we've been working on is an indicator designed to display the high-low range of the last candlestick on a TradingView chart. It does so by plotting two lines: one for the high and another for the low of the last completed candlestick.
Additionally, the script includes a label that shows the numerical value of the high-low range. This label is positioned between the plotted lines, showing the difference between the high and low prices of the last candlestick.
The script operates in real-time, updating dynamically as new candlesticks form. Furthermore, it automatically removes the label after the close of the candlestick, maintaining a clean and clutter-free chart.
This indicator can help traders quickly visualize and assess the range of the last completed candlestick, aiding in their analysis of price action.
"Daily Range with Filtre [Hunter_Algo]
- The script calculates the high and low ranges based on the specified session time, such as the Asia Liquidity session.
- It uses the timeinrange function to determine if the current bar is within the specified session.
- High and low values are updated based on whether the current high or low surpasses the previous values within the specified session.
- The script includes functions to convert day strings to integers and style strings to enumeration values.
- There are additional inputs related to the start and end of the day range, as well as colors and styles for various elements.
- The script calculates daily high (Dh), daily low (Dl), and other variables based on certain conditions, including the day of the week.
ETH Volume*Close Top Exchanges in millions $The script is designed to create a custom indicator that calculates the total volume of Ethereum traded on various exchanges, calculated in millions of dollars, and then plots a histogram of that volume along with a Simple Moving Average (SMA) of the volume.
The script starts by setting some input parameters such as the length of the SMA and the range period. It then requests data on the volume of Ethereum traded on several exchanges such as Binance, Coinbase, Kraken, and others. It calculates the combined total volume across all these exchanges and multiplies it by the close price of Ethereum to get a value in millions of dollars.
The script then checks if the volume is rising while the price is lower than the previous 5 bars high and higher than the previous 5 bars low, and if so, it sets the color of the histogram bars to white. It then plots the histogram bars and the SMA on the chart.
BTC Volume*Close from Top ExchangesThe script is designed to create a custom indicator that calculates the total volume of Bitcoin traded on various exchanges, calculated in millions of dollars, and then plots a histogram of that volume along with a Simple Moving Average (SMA) of the volume.
The script starts by setting some input parameters such as the length of the SMA and the range period. It then requests data on the volume of Bitcoin traded on several exchanges such as Binance, Coinbase, Kraken, and others. It calculates the combined total volume across all these exchanges and multiplies it by the close price of Bitcoin to get a value in millions of dollars.
The script then checks if the volume is rising while the price is lower than the previous 5 bars high and higher than the previous 5 bars low, and if so, it sets the color of the histogram bars to white. It then plots the histogram bars and the SMA on the chart.
Adaptive Weighted Moving Average (AWMA)The script is a technical analysis indicator that calculates a weighted moving average of a given data series. The weighted moving average is calculated using a custom weighting scheme that adjusts the weights based on the volatility of the market, as measured by the average true range (ATR) indicator. The resulting weighted moving average is smoothed using a Gaussian moving average, and the resulting smoothed moving average is plotted on the chart.
To use this script, the user can customize several input parameters, including the length of the moving average, the primary and secondary weights to use in the custom weighting scheme, the ATR length, and the smoothing parameter for the Gaussian moving average. With these inputs, the script calculates and plots the weighted moving average on the chart, allowing the user to analyze the trend and behavior of the data series using a custom weighted moving average.
Cash Gaps on a Future/CFD-ChartThe script is based on the great work of @NgUTech which very nicely prints the gaps on any given chart.
The purpose of this script is to show the gaps to futures or cfd of the underlying cash chart, because very often gap closing provides an opportunity to fade the move.
The script works in the way that the user provides the underlying chart symbol and the current spread of the instruments (cash-future/cfd) and it draws boxes where the cash-gaps are.
If you know a way to automatically calculate the spread of the two instruments, please let me know, thanks.
Michael
Mayer MultipleThe script implements a custom version of the Mayer multiple and it may be useful for analyzing the price of Bitcoin in a historical context.
Note n.1: Mayer multiple does not tell whether to buy, sell or hold, but highlights the best long-term area when the bitcoin price is below a threshold value (2.4).
Note n.2: the threshold value (2.4) has been determined in the past by simulations performed.
The script user may decide whether to use the shown graph or another graph for the calculation of the Mayer multiple.
The script is very easy to use and it is possible to change the following parameters:
the period of SMA (default value is 200)
the threshold (default value 2.4)
Show or not the sell area
Use or not the shown graph to calculate the Mayer multiple (default value is true)
name of exchange to use for calculation of the Mayer multiple (default value is BNC)
name of chart to use for calculation of the Mayer multiple (default value is BLX)
True Strength IndexThe script implements a custom version of TSI (True Strength Index). This index may be useful for determining overbought and oversold conditions, indicating potential trend direction changes via centerline or signal line crossovers, and warning of trend weakness through divergence.
The script highlights when TSI line crosses the signal line with a colored triangle, that is
when the TSI line crosses above the signal line from below, that may warrant buying, a green triangle that's pointing up is drawned;
when the TSI line crosses below the signal line from above, that may warrant selling, a red triangle that's pointing down is drawned.
Note: Signal line crossovers occur frequently, so should be utilized only in conjunction with other signals from the TSI.
The script is very easy to use and it is possible to change the following parameters:
EMA smoothing period for momentum (default value is 25)
EMA smoothing period for smoothed momentum (default value is 13)
Signal line period (default value is 7)
The type of signal line: EMA or SMA (default value is EMA)
Show or not the TSI line
Show or not the signal line
Data structure ListThe script shows a workaround for list in pine-script via drawings.
There are few restrictions with them:
1. The size of the list cannot be more that amount of allowed drawings (about 40 by now)
2. Because the list shares the space of drawings throughout the whole script, using drawings with the list must be careful, with handly creating and removing of each drawing, because otherwise pine's garbage collector might break the list
3. Setters and Getters must be called on every bar, because of implementation of functions in pine there are inner serieses, which must be updated on every bar. So wherever you have a setter or getter in the code - it must be called on every bar. But if it's just an update, then you should pass 'false' as a param of the funtion.
And an example of using the list - reversing of the list. When the list have been created, it's filled on every bar and then gets reversed. Plots show result before and after reversing of the list.
There are also some pieces of commented code showing possible way of working with another funtions of the list.
Data Structure StackThe script shows a workaround for stack in pine-script via drawings.
There are few restrictions with them:
1. The depth of the stack cannot be more that amount of allowed drawings (about 40 by now)
2. Because the stack shares the space of drawings throughout the whole script, using drawings with the stack must be careful, with handly creating and removing of each drawing, because otherwise pine's garbage collector might break the stack
3. push() and pop() must be called on every bar, because of implementation of functions in pine there are inner serieses, which must be updated on every bar. So wherever you have a setter or getter in the code - it must be called on every bar. But if it's just an update, then you should pass 'false' as a param of the funtion.
And the example of using the stack: if the stack is empty - then fill it and taking by a value per bar till the stack is emty and then fill it again.
USD BRL Exchange Rate Discrepancy Analysis ScriptThe script is designed to visualize and analyze discrepancies in the exchange rates of USDT to BRL (Tether to Brazilian Real) and USDT to BRZ (Tether to Brazilian Digital Token) across various trading platforms. It fetches the closing prices of multiple trading pairs from different platforms like Bybit, Binance, and Uniswap. The primary focus is to calculate and plot the conversion rate of BTCBRZ (Bitcoin to Brazilian Real) to USD. Additionally, the script highlights the differences in buy and sell rates for USDT-BRL and USDT-BRZ pairs, including fees and percentage adjustments. Visual elements like lines and areas are used to represent these rates, offering a comprehensive view of potential arbitrage opportunities in the Bitcoin market across different exchanges.
terrible financial advisorThe script you're looking at is a humorous "financial advisor" that places funny and non-traditional investment advice labels on a trading chart. The advice doesn't really have any meaningful connection to real financial indicators or market trends, and it's meant for entertainment purposes only.
Here's how it works:
Every 23 bars on the chart (a bar could represent a day, an hour, or another period, depending on the chart settings), the script places a new label.
The content of each label is determined by the remainder when the current bar number is divided by 10.
Keep in mind that this script is just for fun, and you shouldn't base any real investment decisions on its output!
it works as intended.
Light BalanceThe script is simple, going for a color scheme logic which tenderly avoids rigorous signals processing.
For the script to remain simple, logical derivatives are also out; as such, there are no secondary relations built off of primary ones. And it also ignores (unless you do this yourself) the logic in a varying order of lines.
Coloring has been done according to a limited set of relations between the four (4) plotted lines.
Quite a bit of information is capture, as you'll see when looking at line order, crossings, and transparency transitions and their patterns.
The approach makes the relations ones which can be learned over time; you become the algorithm to sort out signals. Ha ha. I know that sounds like a cop out doesn't it. Did I mention it's a simple script?
One thing you might want to play with right away are fills having red and green, and lime and fuchsia. It would be cool to reduce it all down to two (2) colors, but all the boolean relations might have to be listed, and it also may not be possible to cumulatively combine transparency overlays of the same value. Visually, that approach may not result to awaken a useful feature anyway. Also, fill() has its limitations in that it cannot be in a local scope; this includes function wrapped calls to fill(), or calls made using branching logic statements if/elseif, iff(), and var = (cond) ? t_val/exp : f_val/exp. So, to my knowledge, a fill() can not be made to be logically on/off.
Please, enjoy getting some use out of it.
FullPac4Trader (I.Denis)The script combines the three most important indicators on the chart.
1. A set of six moving averages ( EMA and SMA ), which can be turned on and adjusted at your discretion.
2. Indication of support and resistance levels, calculated according to the Bollinger scheme.
3. Pivot Point and the nearest goals using the Floor method with the possibility of selecting a time period.
The script version is v.1 (beta)
The development of this script will continue. Feedback and suggestions are welcome.
Beta 252 Days (NIFTY 50) by AkshayThe script derives the Beta Value of 252 days of a stock with Benchmark Index NIFTY 50. Note:- I have edited the script using an existing Beta script by Ricardo Santos. Thank you to him! :)
Optimized WaveletsThe script, High-Resolution Volume-Price Pressure Indicator with Wavelets, utilizes wavelet transforms and high-resolution data to analyze market pressure based on volume and price dynamics. The approach combines volume data from smaller timeframes (1 second) with non-linear transformation techniques to generate a refined view of market conditions. Here’s a detailed breakdown of how it works:
Key Components:
Wavelet Transform:
A wavelet function is applied to the price and volume data to capture patterns over a set time period. This technique helps identify underlying structures in the data that might be missed with traditional moving averages.
High-Resolution Data:
The indicator fetches 1-second high-resolution data for price movements and volume. This allows the strategy to capture granular price and volume changes, crucial for short-term trading decisions.
Normalized Difference:
The script calculates the normalized difference in price and volume data. By comparing changes over the selected length, it standardizes these movements to help detect sudden shifts in market pressure.
Sigmoid Transformation:
After combining the price and volume wavelet data, a sigmoid function is applied to smooth out the resulting values. This non-linear transformation helps highlight significant moves while filtering out minor fluctuations.
Volume-Price Pressure:
The up and down volume differences, together with price movements, are combined to create a "Volume-Price Pressure Score." The final indicator reflects the pressure exerted on the market by both buyers and sellers.
Indicator Plot:
The final transformed score is plotted, showing how price and volume dynamics, combined through wavelet transformation, interact. The indicator can be used to identify potential market turning points or pressure buildups based on volume and price movement patterns.
This approach is well-suited for traders looking for advanced signal detection based on high-frequency data and can provide insight into areas where typical indicators may lag or overlook short-term volatility.
Candle Pivot and Stop LossThe script plot upside and down side stop loss using pivot point and trure range.
The True Range, representing market volatility, is determined by finding the maximum value among the differences between the previous high-low, high-close, and low-close. The Downside Stop Loss is calculated by adding the True Range to the Pivot Point, while the Upside Stop Loss is calculated by subtracting the True Range from the Pivot Point.
These levels are plotted on the chart in blue (Pivot Point), red (Downside Stop Loss), and green (Upside Stop Loss), providing traders with essential reference points for their trading strategies.
The provided Pine Script calculates key trading levels for the current candle, including the Pivot Point, Downside Stop Loss, and Upside Stop Loss. The Pivot Point is computed as the average of the previous candle's high, low, and close prices.
