OneThingToRuleThemAll [v1.4]This script was created because I wanted to be able to display a contextual chart of commonly used indicators for scalping and swing traders, with the ability to control the visual representation on the charts as their cross-overs, cross-unders, or changes of state happen in real time. Additionally, I wanted the ability to control how or when they are displayed. While looking through other community projects, I found they lacked the ability to full customize the output controls and values used for these indicators.
The script leverages standard RSI/MACD/VWAP/MVWAP/EMA calculations to help a trader visually make more informed decisions on entering or exiting a trade, depending on their understanding on what the indicators represent. Paired with a table directly on the chart, it allows a trader to quickly reference values to make more informed decisions without having to look away from the price action or look through multiple indicator outputs.
The main functionality of the indicator is controlled within the settings directly on the chart. There a user can enable the visual representations, or disable, and configure how they are displayed on the charts by altering their values or style types.
Users have the ability to enable/disable visual representations of:
The indicator chart
RSI Cross-over and RSI Reversals
MACD Uptrends and Downtrends
VWAP Cross-overs and Cross-unders
VWAP Line
MVWAP Cross-overs and Cross-unders
MVWAP Line
EMA Cross-overs and Cross-unders
EMA Line
Some traders like to use these visual indications as thresholds to enter or exit trades. Its best to find out which ones work the best with the security you are trying to trade. Personally, I use the table as a reference in conjunction with the RSI chart indicators to help me decide a logical trailing stop if I am scalping. Some users might like the track EMA200 crossovers, and have visual representations on the chart for when that happens. However, users may use the other indicators in other methods, and this script provides the ability to be able to configure those both visually and by value.
The pine script code is open source and itself is fairly straightforward, it is mostly written to provide the ultimate level of control the the user of the various indicators. Please reach out to me directly if you would like a further understanding of the code and an explanation on anything that may be unclear.
Enjoy :)
-dead1.
Tìm kiếm tập lệnh với "纳指ETF+加仓"
SMA Cross with a Price FilterA moving average strategy generates an entry (buy) signal when the price goes above the moving average, and an exit (sell) signal when the price goes below the moving average. But it gives lots of whipsaws and noise depends on the moving average we use. A fast moving average gives more whipsaws and a slow moving average gives less whipsaws. To reduce the noise/whipsaws, we can add a filter on a fast/slow moving average. It will improve entry/exit performance significantly specially for those who don't want to watch the market actively.
I created this indicator with a price filter. This means the price of an underlying asset must be at least a specific percentage above its moving average to generate a buy signal and a specific percentage below its moving average to generate a sell signal. This price filter can also be a confirmation after the price crosses above/below its SMA. I couldn't find any indicator yet based on this idea. So I wrote this indicator and publishing it so it helps those who are interested.
I use 200 SMA and 3% price filter as default and using SPY as an example. So,
ENTRY signal when the closing price of SPY is 3% above its 200 SMA.
EXIT signal when the closing price of SPY is 3% below its 200 SMA.
Enjoy and let me know if it works.
** This chart only generates entry (buy) and exit (sell) signals. Please, do your own diligence to make any investment or trading decisions.
Capital Accumulation Plan (CAP) Simulator 2.0Description:
This indicator serves as a simulation tool for the Capital Accumulation Plan (CAP). The CAP is an investment strategy involving regular contributions of a fixed amount at consistent intervals, regardless of market fluctuations. This simulator allows you to visualize how your invested capital might grow over time, considering a fixed monthly investment in a given financial instrument.
How to Use:
Customize the monthly investment amount, the day of the month for the investment, and the simulation period. Also, input the percentage of taxation on potential dividends and the Total Expense Ratio (TER) of the financial instrument. The indicator calculates the portfolio value over time, the invested capital, and the average cost. If applicable, it also calculates the dividend amounts over time and the corresponding taxes to be paid.
The indicator displays how these metrics would change over time following the PAC strategy.
Important Notes:
Apply exclusively to the daily chart; a fix for the chosen day absence will be implemented shortly.
Advanced Divergence OscillatorIntroduction to ADO
The Advanced Divergence Oscillator (ADO) is a modern tool crafted for traders in various markets like stocks, forex, or cryptocurrencies. Imagine it as a smart gadget that helps you understand the ebb and flow of market prices. Unlike standard tools, ADO provides a more nuanced view, enabling you to grasp subtle changes in market trends.
Functionality of ADO
ADO operates by observing and comparing market price movements over different timeframes. Picture a racetrack where cars are moving at various speeds. Some are racing ahead, while others are gradually picking up pace. ADO keeps track of these varying 'speeds' in market prices.
By analyzing these movements, ADO generates a smooth, flowing line – the oscillator. This line moves in a wave-like pattern, offering hints about the market's momentum and possible future trends. When the line moves up, it suggests increasing prices, and when it moves down, it hints at falling prices.
How to Use ADO
Setup: You can easily integrate ADO into your trading platform, adjusting settings like length and color to suit your preference.
Reading the Oscillator: Watch for the oscillator's movement. Rising and falling patterns can indicate potential buying or selling opportunities.
Identifying Divergences: ADO excels in spotting divergences – situations where market prices and the oscillator don't align. For instance, if prices are climbing but the oscillator is falling, it might signal a potential price drop ahead.
Brief History of the Ultimate Oscillator
The concept of oscillators in trading isn’t new. The Ultimate Oscillator, developed by Larry Williams in the 1970s, is a foundational tool in this field. Williams' innovation was to combine short, intermediate, and long-term market trends into a single oscillator. This approach offered a more comprehensive market view, helping traders make informed decisions.
The ADO is a step further in this evolution. It takes the core principles of the Ultimate Oscillator and enhances them with proper smoothing and divergence detection methods. This evolution represents the continuous effort in the trading community to refine tools for better market analysis and decision-making.
Opening Range & Prior Day High/Low [Gorb]Introduction:
Opening Range & Prior Day High/Low indicator is an easy to use day traders tool. This indicator automatically plots the previous days high and low, as well as drawing a box from the opening range that the user specifies in the settings. These two together can help provide an indication of market sentiment and price trends for the day. They are often used as a trading strategy for day traders.
Overview:
The Opening Range , draws a box from the high to the low of the user defined time period and is extended until the end of the trading session. Most common are the 5/15/30min opening ranges.
Prior Day High/Low , draws lines from the previous days high and low that extend across the current session. These are used as support/resistance and also a marker to see market sentiment by crossing one of these levels.
The indicator is designed for all kinds of traders, offering a simple approach to automatically plot levels for you.
Features:
All skill-level friendly presets, easy to enable with one-click
Opening Range: Allows user to choose what time the range starts and ends to measure the high & low.
Extend Range Lines: allows the user to choose when the box stops extending according to the trading session time.
Enable Opening Range Box: allows the user to choose to plot the opening range or not.
ORB Border Color: allows the user to change the box border color.
ORB Box Shade Color: allows the user to change the background of the opening range box.
ORB Line Width: allows users to chose the width of the opening range box lines.
Enable Previous Day High: allows users to enable the previous days high to be plotted.
Enable Previous Day Low: allows users to enable the previous days high to be plotted.
Previous Day High Color: allows users to choose the color for this line.
Previous Day Low Color: allows users to choose the color for this line.
All colors are changeable for the user to customize to their liking.
Usage Demonstration
In the image below, we can see a basic example of how these 3 features function.
As explained above, the opening range is customizable to meet the users needs and can be disabled with one click. Same goes for the prior day high(green) and low(red) lines. All 3 are plotted each day automatically for the user if enabled.
In the image below, we can see an example of using the opening range break and prior day high together for a trading strategy.
This is a great example of using the prior day high with the opening range to use as a day trading strategy. It provides the trader with levels to watch for price to break out from for possible trade setups.
In this next image, we can see a failed breakdown from the opening range that results in a bullish breakout.
The first move was a fake breakdown with the failed rejection on the retest of the opening range lows. This led to a breakout above the range and a confirmation bounce on the breakout retest. Price did break above the prior day high and confirmed with a retest bounce on that level as well.
In the image below, we can see how previous days levels can act as resistance to use with the opening range.
Price didn't reject the opening range low, but it did reject the prior day high for the second time. This could be used as an entry or once price breaks down out of the opening range again.
Conclusion:
We believe in providing user-friendly tools to help speed up traders technical analysis and implement easy trading strategies. The goal is to provide a user-friendly indicator to automatically draw opening ranges and previous days levels to suit the users needs and trading style.
RISK DISCLAIMER
All content, tools, scripts & education provided by Monstanzer or Gorb Algo LLC are for informational & educational purposes only. Trading is risk and most lose their money, past performance does not guarantee future results.
Cumulative New Highs - New LowsIndicator that plots the cumulative number of 52-Week New Highs minus New Lows with an added moving average. Settings allow the choice between S&P 500, Nasdaq 100 or the Overall Market as Index. You can also customize the length of the moving average.
Dynamic Trend Fusion (DTF)The "Dynamic Trend Fusion" (DTF) indicator is a powerful technical analysis tool for traders. It stands out from other indicators due to its adaptability and ability to provide insights into different trading styles. Users can choose from various trading options such as "Short-term Trading," "Long-term Trading," "Aggressive Short-term," "Conservative Long-term," "Balanced Approach," "High Sensitivity," "Low Sensitivity," "Day Trading," and "Swing Trading." These options allow traders to customize the indicator to suit their specific trading strategies.
DTF combines the Moving Average Convergence Divergence (MACD) and Relative Strength Index (RSI) indicators, normalizing them to a similar scale for a comprehensive view of market conditions. It then calculates a combined value and smoothes it using a moving average.
One of its standout features is the ability to identify bullish and bearish states, which is represented visually on the chart. When the indicator detects a transition from a bullish to a bearish state or vice versa, the color of the line changes.
Additionally, DTF offers alert conditions, notifying users when the market shifts into a bullish or bearish state, allowing for timely decision-making.
In summary, the DTF indicator sets itself apart by providing traders with a versatile tool that can be tailored to various trading styles and offers clear visual signals for trend changes, enhancing trading precision and efficiency.
MAC Spikes(Adam H Grimes)From Adam H Grimes: "Introducing a New Tool: The MAC Spike"
Mean Absolute Change Spikes (“MAC Spikes”).
Here are the steps to calculate it:
-Convert each day’s closing price to a change (difference) by subtracting it from the previous day’s closing price.
-Take the absolute value of that change.
-Average the past 20 days absolute values to create the baseline.
-Divide today’s change by yesterday’s baseline. (Still offsetting by one day.)
MAC Spikes- Indicator:
-Indicator Setup: The script defines an indicator with the name "MAC Spikes", not overlaying the main chart, and allows up to 99 lines to be plotted.
-User Inputs: It provides several user-configurable inputs, such as:
Length for standard deviation calculation (len).
-Type of spike to monitor (spikeType), with options for close, range, or open spikes.
-Option to filter spikes based on a threshold (filtered).
-The threshold value for spike significance (spike_thresh).
-Whether to display the spike histogram (disp_Spike).
-Line width for plotting (lw).
Market Pivot Levels [Past & Live]Market Levels provide a robust view of daily pivot points of markets such as high/low/close with both past and live values shown at the same time using the recently updated system of polylines of pinescript.
The main need for this script arose from not being able to use plots for daily points because plots are inherently once drawn can't be erased and because we can't plot stuff for previous bars after values are determined we can't use them reliably. And while we can use traditional lines, because we would have extremely high amount of lines and we would have to keep removing the previous ones it wouldn't be that effective way for us. So we try to do it with the new method of polylines .
Features of this script:
- Daily High/Low Points
- Yesterday High/Low/Close Points
- Pre-Market High-Low points.
Now let's preview some of the important points of code and see how we achieve this:
With the code below we make sure no matter which chart we are using we are getting the extended hours version of sessions so our calculations are made safely for viewing pre-market conditions.
// Let's get ticker extended no matter what the current chart is
tc = ticker.new(syminfo.prefix, syminfo.ticker, session.extended)
Coding our own function to calculate high's and low's because inbuilt pinescript function cannot take series and we send this function to retrieve our high's and lows.
// On the fly function to calculate daily highlows instead of tv inbuilt because tv's length cannot take series
f_highlow(int last) =>
bardiff = last
float _low = low, float _high = high
for i = bardiff to 0 by 1
if high > _high
_high := high
if low < _low
_low := low
With doing calculations at the bars of day ending points we can retrieve the correct points and values and push them for our polylines array so it can be used in best way possible.
// Daily change points
changeD = timeframe.change("D")
// When new day starts fill polyline arrays with previous day values for polylines to draw on chart
// We also update prevtime values with current ones after we pushed to the arrays
if changeD
f_arrFill(cpArrHigh, cpArrLow, prevArrh, prevArrl, prevArrc, prevMarh, prevMarl)
valHolder.unshift(valueHold.new(_high, _low, _high, _close, _low, time, pr_h, pr_l))
The rest of the code is annotated and commented. You can let me know in comments if you have any questions. Happy trading.
Heiken Ashi Colored Moving AverageThis indicator is meant to plot a moving average but the color of the moving average will change based on Heikin Ashi. Its seems to be slightly off, I would love any suggestions on improving this indicator.
Thanks
Williams Vix Fix [CC]The Vix Fix indicator was created by Larry Williams and is one of my giant backlog of unpublished scripts which I'm going to start publishing more of. This indicator is a great synthetic version of the classic Volatility Index and can be useful in combination with other indicators to determine when to enter or exit a trade due to the current volatility. The indicator creates this synthetic version of the Volatility Index by a fairly simple formula that subtracts the current low from the highest close over the last 22 days and then divides that result by the same highest close and multiplies by 100 to turn it into a percentage. The 22-day length is used by default since there is a max of 22 trading days in a month but this formula works well for any other timeframe. By itself, this indicator doesn't generate buy or sell signals but generally speaking, you will want to enter or exit a trade when the Vix fix indicator amount spikes and you get an entry or exit signal from another indicator of your choice. Keep in mind that the colors I'm using for this indicator are only a general idea of when volatility is high enough to enter or exit a trade so green colors mean higher volatility and red colors mean low volatility. This is one of the few indicators I have written that don't recommend to buy or sell when the colors change.
This was a custom request from one of my followers so please let me know if you guys have any other script requests you want to see!
Volatility Exponential Moving AverageVEMA is a custom indicator that enhances the traditional moving average by incorporating market volatility. Unlike standard moving averages that rely solely on price, VEMA integrates both the Simple Moving Average (SMA) and the Exponential Moving Average (EMA) of the closing price, alongside a measure of market volatility.
The unique aspect of VEMA is its approach. It calculates the standard deviation of the closing price and also computes the simple moving average of this volatility. This dual approach to understanding market fluctuations allows for a more nuanced understanding of market dynamics.
Key to VEMA's functionality is the dynamic weighting factor, which adjusts the influence of SMA and EMA based on current market volatility. This factor increases the weight of the EMA, which is more responsive to recent price changes, during periods of high volatility. Conversely, during periods of lower volatility, the SMA, which offers a smoother view of price trends, becomes more prominent.
The resultant is a hybrid moving average that responds adaptively to changes in market volatility. This adaptability makes VEMA particularly useful in dynamic markets, potentially offering more insightful trend analysis and reversal signals compared to traditional moving averages.
Bar Retracement Do you love Fibonacci ratios/levels? Have you ever thought to apply them to individual bars? If you are not familiar with these ratios and their significance, you can read about them here: www.investopedia.com
This simple indicator applies Fibonacci levels on the previous bar. This enables the quick determination of how far the current bar retraced relative to the precious one. Key levels are highlighted in yellow, orange, and red. You can choose to set an alert for "Large Retracements". This can be very useful for ending trades and avoiding full price reversals. There are other insights that can be gleaned as well.
Happy trading...
Dynamic 5-Day Moving AverageThe Dynamic 5-Day Moving Average (MA) indicator is designed to provide traders with a consistent, time-adjusted moving average line across various timeframes. This indicator is especially useful for traders who switch between multiple timeframes and want a moving average that represents a fixed 5-day period, ensuring that the MA reflects a consistent lookback period relative to the amount of trading time each candle represents.
Features:
Timeframe Adaptability: Automatically adjusts the MA period to correspond to a 5-day lookback, regardless of the selected timeframe.
Intraday Precision: For intraday charts (5m, 15m, 30m, 1h, 2h, 4h), the indicator calculates the number of periods within the 5-day span based on the chart's timeframe.
Daily and Weekly Timeframe Compatibility: Sets the period to 5 for daily charts to maintain the 5-day MA, and to 1 for weekly charts, where each candlestick represents a week's worth of trading days.
Calculation Logic:
The indicator begins by defining the total number of trading minutes in 5 days, based on a standard 6.5-hour trading day.
A dynamic period calculation function then determines the number of those intervals that fit into the 5-day minute total for the selected timeframe.
For daily charts, the period is a straightforward 5, while for weekly charts, the period is set to 1, reflecting the average of the past 5 trading days.
Bollinger Bands (Nadaraya Smoothed) | Flux ChartsTicker: AMEX:SPY , Timeframe: 1m, Indicator settings: default
General Purpose
This script is an upgrade to the classic Bollinger Bands. The idea behind Bollinger bands is the detection of price movements outside of a stock's typical fluctuations. Bollinger Bands use a moving average over period n plus/minus the standard deviation over period n times a multiplier. When price closes above or below either band this can be considered an abnormal movement. This script allows for the classic Bollinger Band interpretation while de-noising or "smoothing" the bands.
Efficacy
Ticker: AMEX:SPY , Timeframe: 1m, Indicator settings: Standard Dev: 2; Level 1 : off; Level 2: off; labels: off
Upper Band Key:
Blue: Bollinger No smoothing
Orange: Bollinger SMA smoothing period of 10
Purple: Bollinger EMA smoothing period of 10
Red: Nadaraya Smoothed Bollinger bandwidth of 6
Here we chose periods so that each would have a similar offset from the original Bollinger's. Notice that the Red Band has a much smoother result while on average having a similar fit to the other smoothing techniques. Increasing the EMA's or SMA's period would result in them being smoother however the offset would increase making them less accurate to the original data.
Ticker: AMEX:SPY , Timeframe: 1m, Indicator settings: Standard Dev: 2; Level 1: off; Level 2: off; labels: off
Upper Band Key:
Blue: Bollinger No smoothing
Orange: Bollinger SMA smoothing period of 20
Purple: Bollinger EMA smoothing period of 20
Red: Nadaraya Smoothed Bollinger bandwidth of 6
This makes the Nadaraya estimator a particularly efficacious technique in this use case as it achieves a superior smoothness to fit ratio.
How to Use
This indicator is not intended to be used on its own. Its use case is to identify outlier movements and periods of consolidation. The Smoothing Factor when lowered results in a more reactive but noisy graph. This setting is also known as the "bandwidth" ; it essentially raises the amplitude of the kernel function causing a greater weighting to recent data similar to lowering the period of a SMA or EMA. The repaint smoothing simply draws on the Bollinger's each chart update. Typically repaint would be used for processing and displaying discrete data however currently it's simply another way to display the Bollinger Bands.
What makes this script unique.
Since Bollinger bands use standard deviation they have excess noise. By noise we mean minute fluctuations which most traders will not find useful in their strategies. The Nadaraya-Watson estimator, as used, is essentially a weighted average akin to an ema. A gaussian kernel is placed at the candlestick of interest. That candlestick's value will have the highest weight. From that point the other candlesticks' values effect on the average will decrease with the slope of the kernel function. This creates a localized mean of the Bollinger Bands allowing for reduced noise with minimal distortion of the original Bollinger data.
Trend Line XrossTrend Line Xross (TLX) Uses User Input Points to draw trendlines and displays the exact intersection point of those trendlines.
This is the public indicator of the practical application for this intersection method included in my entry for Pinefest #1.
To determine the exact intersection point I am using the y-intercept method as seen below.
The code is notated for more information on the technical workings.
One difference to note between this version and the pinefest version is that I had to change the line drawings to use bar_index values so that I can use line.get_price() to grab the current value of the line to make alerts from.
Additionally, there are alerts built-in to this version for every type of cross on all of the visible lines.
Enjoy!
Ultimate Seasonality Indicator [SS]Hello everyone,
This is my seasonality indicator. I have been working on it for like 2 months, so hope you like it!
What it does?
The Ultimate Seasonality indicator is designed to provide you, the trader, an in-depth look at seasonality. The indicator gives you the ability to do the following functions:
View the most bearish and bullish months over a user defined amount of years back.
View the average daily change for each respective months over a user defined amount of years back.
See the most closely correlated month to the current month to give potential insights of likely trend.
Plot out areas of High and Low Seasonality.
Create a manual seasonal forecast model by selecting the desired month you would like to model the current month data after.
Have the indicator develop an autoregressive seasonal model based on seasonally lagged variables, using principles of machine learning.
I will go over these functions 1 by 1, its a whopper of an indicator so I will try to be as clear and concise as possible.
Viewing Bullish vs Bearish Months, Average Daily Change & Correlation to Current Month
The indicator will break down the average change, as well as the number of bullish and bearish days by month. See the image below as an example:
In the table to the right, you will see a breakdown of each month over the past 3 years.
In the first column, you will see the average daily change. A negative value, means it was a particularly bearish month, a positive value means it was a particularly bullish month.
The next column over shows the correlation to the current dataset. How this works is the indicator takes the size of the monthly data for each month, and compares it to the last X number of days up until the last trading day. It will then perform a correlation assessment to see how closely similar the past X number of trading days are to the various monthly data.
The last 2 columns break down the number of Bullish and Bearish days, so you can see how many red vs green candles happened in each respective month over your set timeframe. In the example above, it is over the pats 3 years.
Plot areas of High and Low Seasonality
In the chart above, you will see red and green highlighted zones.
Red represents areas of HIGH Seasonality .
Green represents areas of LOW Seasonality .
For this function, seasonality is measured by the autocorrelation function at various lags (12 lags). When there is an average autocorrelation of greater than 0.85 across all seasonal lags, it is considered likely the result of high seasonality/trend.
If the lag is less than or equal to 0.05, it is indicative of very low seasonality, as there is no predominate trend that can be found by the autocorrelation functions over the seasonally lagged variables.
Create Manual Seasonal Forecasts
If you find a month that has a particularly high correlation to the current month, you can have the indicator create a seasonal model from this month, and fit it onto the current dataset (past X days of trading).
If we look at the example below:
We can see that the most similar month to the current data is September. So, we can ask the indicator to create a seasonal forecast model from only September data and fit it to our current month. This is the result:
You will see, using September data, our most likely close price for this month is 450 and our model is y= 1.4305x + -171.67.
We can accept the 450 value but we can use the equation to model the data ourselves manually.
For example, say we have a target price on the month of 455 based on our own analysis. We can calculate the likely close price, should this target be reached, by substituting this target for x. So y = 1.4305x + -171.67 becomes
y = 1.4305(455) +- 171.67
y = 479.20
So the likely close price would be 479.20. No likely, and thus its not likely we are to see 455.
HOWEVER, in this current example, the model is far too statistically insignificant to be used. We can see the correlation is only 0.21 and the R squared is 0.04. Not a model you would want to use!
You want to see a correlation of at least 0.5 or higher and an R2 of 0.5 or higher.
We can improve the accuracy by reducing the number of years we look back. This is what happens when we reduce the lookback years to 1:
You can see reducing to 1 year gives December as the most similar month. However, our R2 value is still far too low to really rely on this data whole-heartedly. But it is a good reference point.
Automatic Autoregressive Model
So this is my first attempt at using some machine learning principles to guide statistical analysis.
In the main chart above, you will see the indicator making an autoregressive model of seasonally lagged variables. It does this in steps. The steps include:
1) Differencing the data over 12, seasonally lagged variables.
2) Determining stationarity using DF test.
3) Determining the highest, autocorrelated lags that fall within a significant stationary result.
4) Creating a quadratic model of the two identified lags that best represents a stationary model with a high autocorrelation.
What are seasonally lagged variables?
Seasonally lagged variables are variables that represent trading months. So a lag of 25 would be 1 month, 50, 2 months, 75, 3 months, etc.
When it displays this model, it will show us what the results of the t-statistic are for the DF test, whether the data is stationary, and the result of the autocorrelation assessment.
It will then display the model detail in the tip table, which includes the equation, the current lags being used, the R2 and the correlation value.
Concluding Remarks
That's the indicator in a nutshell!
Hope you like it!
One final thing, you MUST have your chart set to daily, otherwise you will get a runtime error. This can ONLY be used on the daily timeframe!
Feel free to leave your questions, comments and suggestions below.
Note:
My "ultimate" indicators are made to give the functionality of multiple indicators in one. If you like this one, you may like some of my others:
Ultimate P&L Indicator
Ultimate Customizable EMA/SMA
Thanks for checking out the indicator!
Volume SentimentIn 1994 Tushar Chande and Stanley Kroll published a epic book of modern trading indicators called "The New Technical Trader". I highly recommend it. Two indicators that stood out was the Market Thrust and Thrust Oscillator. They suggested these as alternatives to the Arms Index. Rather than using the Advancing Stocks and their associated volume, I applied their logic to individual bars.
Bar Sentiment can be defined and the difference between the low and the close relative to the bar width. Smaller values are bearish and larger one are bullish. A bullish candle would close above its mid-point. Conversely, a close below the candle mid-point is considered bearish.
With that, this script sums the bullish or bearish (as defined above) volume over a user defined number of bars. It gives a unique indication of the volume compared to typical volume indicators. It also gives the user the option to set a "High Volume" alert when the total volume is greater than the moving average. This is helpful for identify increasing activity in your security.
Enjoy and happy trading!
Smart MAThe Smart MA indicator is a tool designed for traders seeking insights into market trends, with its foundation rooted in moving averages. It offers two distinctive color options, with "Crossing" as the default choice and "Direction" as an alternative. Let's delve deeper into these options:
1. "Crossing" Color Option (Default):
Key Features:
Utilizes the interaction between fast and slow moving averages.
The color of the base moving average (MA) line dynamically changes based on crossovers between these moving averages.
Offers real-time visual signals for potential shifts in market sentiment.
Interpretation:
With the "Crossing" color option as the default setting, the base MA line's color responds to the interaction of the fast and slow moving averages.
A crossover where the fast MA crosses above the slow MA may prompt the base MA line to change to a bullish color (e.g., teal), indicating a potential bullish trend.
Conversely, if the fast MA crosses below the slow MA, the base MA line's color may alter to represent a bearish sentiment (e.g., red). This color shift provides a visual marker for a potential bearish trend, potentially guiding traders towards shorting opportunities.
2. "Direction" Color Option:
Key Features:
Focuses on the directional trend of the base moving average (MA).
The color of the base MA line signifies the direction in which the base MA is moving.
Aids in quickly identifying the prevailing market trend.
Interpretation:
Uptrend - Bullish Direction: When the base MA slopes upward, indicating an average price increase over the chosen base MA length, the base MA line's color may shift to a bullish hue (e.g., teal). This visual cue signals a potential uptrend, suggesting favorable long positions.
Downtrend - Bearish Direction: If the base MA slopes downward, signifying an average price decrease over the selected base MA length, the base MA line could change to a bearish shade (e.g., red). This color shift acts as an indicator of a potential downtrend, implying possible opportunities for shorting.
Customization:
Both color options allow traders to adjust the indicator's parameters, including base MA length, MA type, fast MA length, and slow MA length, to align with their trading strategies and preferred timeframes.
In summary, the Smart MA indicator, based on moving averages, provides traders with two color options: the default "Crossing" and "Direction" as an alternative. The "Crossing" option leverages fast and slow moving averages to offer real-time visual cues for dynamic market shifts. The "Direction" option simplifies trend analysis by focusing on the directional trend of the base MA. The choice between these options depends on your trading style and the depth of analysis you require. With the Smart MA indicator, you're equipped to make informed trading decisions in today's financial markets.
2 Moving Averages | Trend FollowingThe trading system is a trend-following strategy based on two moving averages (MA) and Parabolic SAR (PSAR) indicators.
How it works:
The strategy uses two moving averages: a fast MA and a slow MA.
It checks for a bullish trend when the fast MA is above the slow MA and the current price is above the fast MA.
It checks for a bearish trend when the fast MA is below the slow MA and the current price is below the fast MA.
The Parabolic SAR (PSAR) indicator is used for additional trend confirmation.
Long and short positions can be turned on or off based on user input.
The strategy incorporates risk management with stop-loss orders based on the Average True Range (ATR).
Users can filter the backtest date range and display various indicators.
The strategy is designed to work with the date range filter, risk management, and user-defined positions.
Features:
Trend-following strategy.
Two customizable moving averages.
Parabolic SAR for trend confirmation.
User-defined risk management with stop-loss based on ATR.
Backtest date range filter.
Flexibility to enable or disable long and short positions.
This trading system provides a comprehensive approach to trend-following and risk management, making it suitable for traders looking to capture trends with controlled risk.
TableLibrary "Table"
This library provides an easy way to convert arrays and matrixes of data into tables. There are a few different implementations of each function so you can get more or less control over the appearance of the tables. The basic rule of thumb is that all matrix rows must have the same number of columns, and if you are providing multiple arrays/matrixes to specify additional colors (background/text), they must have the same number of rows/columns as the data array. Finally, you do have the option of spanning cells across rows or columns with some special syntax in the data cell. Look at the examples to see how the arrays and matrixes need to be built before they can be used by the functions.
floatArrayToCellArray(floatArray)
Helper function that converts a float array to a Cell array so it can be rendered with the fromArray function
Parameters:
floatArray (float ) : (array) the float array to convert to a Cell array.
Returns: array The Cell array to return.
stringArrayToCellArray(stringArray)
Helper function that converts a string array to a Cell array so it can be rendered with the fromArray function
Parameters:
stringArray (string ) : (array) the array to convert to a Cell array.
Returns: array The Cell array to return.
floatMatrixToCellMatrix(floatMatrix)
Helper function that converts a float matrix to a Cell matrix so it can be rendered with the fromMatrix function
Parameters:
floatMatrix (matrix) : (matrix) the float matrix to convert to a string matrix.
Returns: matrix The Cell matrix to render.
stringMatrixToCellMatrix(stringMatrix)
Helper function that converts a string matrix to a Cell matrix so it can be rendered with the fromMatrix function
Parameters:
stringMatrix (matrix) : (matrix) the string matrix to convert to a Cell matrix.
Returns: matrix The Cell matrix to return.
fromMatrix(CellMatrix, position, verticalOffset, transposeTable, textSize, borderWidth, tableNumRows, blankCellText)
Takes a CellMatrix and renders it as a table.
Parameters:
CellMatrix (matrix) : (matrix) The Cells to be rendered in a table
position (string) : (string) Optional. The position of the table. Defaults to position.top_right
verticalOffset (int) : (int) Optional. The vertical offset of the table from the top or bottom of the chart. Defaults to 0.
transposeTable (bool) : (bool) Optional. Will transpose all of the data in the matrices before rendering. Defaults to false.
textSize (string) : (string) Optional. The size of text to render in the table. Defaults to size.small.
borderWidth (int) : (int) Optional. The width of the border between table cells. Defaults to 2.
tableNumRows (int) : (int) Optional. The number of rows in the table. Not required, defaults to the number of rows in the provided matrix. If your matrix will have a variable number of rows, you must provide the max number of rows or the function will error when it attempts to set a cell value on a row that the table hadn't accounted for when it was defined.
blankCellText (string) : (string) Optional. Text to use cells when adding blank rows for vertical offsetting.
fromMatrix(dataMatrix, position, verticalOffset, transposeTable, textSize, borderWidth, tableNumRows, blankCellText)
Renders a float matrix as a table.
Parameters:
dataMatrix (matrix) : (matrix_float) The data to be rendered in a table
position (string) : (string) Optional. The position of the table. Defaults to position.top_right
verticalOffset (int) : (int) Optional. The vertical offset of the table from the top or bottom of the chart. Defaults to 0.
transposeTable (bool) : (bool) Optional. Will transpose all of the data in the matrices before rendering. Defaults to false.
textSize (string) : (string) Optional. The size of text to render in the table. Defaults to size.small.
borderWidth (int) : (int) Optional. The width of the border between table cells. Defaults to 2.
tableNumRows (int) : (int) Optional. The number of rows in the table. Not required, defaults to the number of rows in the provided matrix. If your matrix will have a variable number of rows, you must provide the max number of rows or the function will error when it attempts to set a cell value on a row that the table hadn't accounted for when it was defined.
blankCellText (string) : (string) Optional. Text to use cells when adding blank rows for vertical offsetting.
fromMatrix(dataMatrix, position, verticalOffset, transposeTable, textSize, borderWidth, tableNumRows, blankCellText)
Renders a string matrix as a table.
Parameters:
dataMatrix (matrix) : (matrix_string) The data to be rendered in a table
position (string) : (string) Optional. The position of the table. Defaults to position.top_right
verticalOffset (int) : (int) Optional. The vertical offset of the table from the top or bottom of the chart. Defaults to 0.
transposeTable (bool) : (bool) Optional. Will transpose all of the data in the matrices before rendering. Defaults to false.
textSize (string) : (string) Optional. The size of text to render in the table. Defaults to size.small.
borderWidth (int) : (int) Optional. The width of the border between table cells. Defaults to 2.
tableNumRows (int) : (int) Optional. The number of rows in the table. Not required, defaults to the number of rows in the provided matrix. If your matrix will have a variable number of rows, you must provide the max number of rows or the function will error when it attempts to set a cell value on a row that the table hadn't accounted for when it was defined.
blankCellText (string) : (string) Optional. Text to use cells when adding blank rows for vertical offsetting.
fromArray(dataArray, position, verticalOffset, transposeTable, textSize, borderWidth, blankCellText)
Renders a Cell array as a table.
Parameters:
dataArray (Cell ) : (array) The data to be rendered in a table
position (string) : (string) Optional. The position of the table. Defaults to position.top_right
verticalOffset (int) : (int) Optional. The vertical offset of the table from the top or bottom of the chart. Defaults to 0.
transposeTable (bool) : (bool) Optional. Will transpose all of the data in the matrices before rendering. Defaults to false.
textSize (string) : (string) Optional. The size of text to render in the table. Defaults to size.small.
borderWidth (int) : (int) Optional. The width of the border between table cells. Defaults to 2.
blankCellText (string) : (string) Optional. Text to use cells when adding blank rows for vertical offsetting.
fromArray(dataArray, position, verticalOffset, transposeTable, textSize, borderWidth, blankCellText)
Renders a string array as a table.
Parameters:
dataArray (string ) : (array_string) The data to be rendered in a table
position (string) : (string) Optional. The position of the table. Defaults to position.top_right
verticalOffset (int) : (int) Optional. The vertical offset of the table from the top or bottom of the chart. Defaults to 0.
transposeTable (bool) : (bool) Optional. Will transpose all of the data in the matrices before rendering. Defaults to false.
textSize (string) : (string) Optional. The size of text to render in the table. Defaults to size.small.
borderWidth (int) : (int) Optional. The width of the border between table cells. Defaults to 2.
blankCellText (string) : (string) Optional. Text to use cells when adding blank rows for vertical offsetting.
fromArray(dataArray, position, verticalOffset, transposeTable, textSize, borderWidth, blankCellText)
Renders a float array as a table.
Parameters:
dataArray (float ) : (array_float) The data to be rendered in a table
position (string) : (string) Optional. The position of the table. Defaults to position.top_right
verticalOffset (int) : (int) Optional. The vertical offset of the table from the top or bottom of the chart. Defaults to 0.
transposeTable (bool) : (bool) Optional. Will transpose all of the data in the matrices before rendering. Defaults to false.
textSize (string) : (string) Optional. The size of text to render in the table. Defaults to size.small.
borderWidth (int) : (int) Optional. The width of the border between table cells. Defaults to 2.
blankCellText (string) : (string) Optional. Text to use cells when adding blank rows for vertical offsetting.
debug(message, position)
Renders a debug message in a table at the desired location on screen.
Parameters:
message (string) : (string) The message to render.
position (string) : (string) Optional. The position of the debug message. Defaults to position.middle_right.
Cell
Type for each cell's content and appearance
Fields:
content (series string)
bgColor (series color)
textColor (series color)
align (series string)
colspan (series int)
rowspan (series int)
UtilsLibrary "Utils"
A collection of convenience and helper functions for indicator and library authors on TradingView
formatNumber(num)
My version of format number that doesn't have so many decimal places...
Parameters:
num (float) : (float) the number to be formatted
Returns: (string) The formatted number
getDateString(timestamp)
Convenience function returns timestamp in yyyy/MM/dd format.
Parameters:
timestamp (int) : (int) The timestamp to stringify
Returns: (int) The date string
getDateTimeString(timestamp)
Convenience function returns timestamp in yyyy/MM/dd hh:mm format.
Parameters:
timestamp (int) : (int) The timestamp to stringify
Returns: (int) The date string
getInsideBarCount()
Gets the number of inside bars for the current chart. Can also be passed to request.security to get the same for different timeframes.
Returns: (int) The # of inside bars on the chart right now.
getLabelStyleFromString(styleString, acceptGivenIfNoMatch)
Tradingview doesn't give you a nice way to put the label styles into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
styleString (string)
acceptGivenIfNoMatch (bool) : (bool) If no match for styleString is found and this is true, the function will return styleString, otherwise it will return tradingview's preferred default
Returns: (string) The string expected by tradingview functions
getTime(hourNumber, minuteNumber)
Given an hour number and minute number, adds them together and returns the sum. To be used by getLevelBetweenTimes when fetching specific price levels during a time window on the day.
Parameters:
hourNumber (int) : (int) The hour number
minuteNumber (int) : (int) The minute number
Returns: (int) The sum of all the minutes
getHighAndLowBetweenTimes(start, end)
Given a start and end time, returns the high or low price during that time window.
Parameters:
start (int) : The timestamp to start with (# of seconds)
end (int) : The timestamp to end with (# of seconds)
Returns: (float) The high or low value
getPremarketHighsAndLows()
Returns an expression that can be used by request.security to fetch the premarket high & low levels in a tuple.
Returns: (tuple)
getAfterHoursHighsAndLows()
Returns an expression that can be used by request.security to fetch the after hours high & low levels in a tuple.
Returns: (tuple)
getOvernightHighsAndLows()
Returns an expression that can be used by request.security to fetch the overnight high & low levels in a tuple.
Returns: (tuple)
getNonRthHighsAndLows()
Returns an expression that can be used by request.security to fetch the high & low levels for premarket, after hours and overnight in a tuple.
Returns: (tuple)
getLineStyleFromString(styleString, acceptGivenIfNoMatch)
Tradingview doesn't give you a nice way to put the line styles into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
styleString (string) : (string) Plain english (or TV Standard) version of the style string
acceptGivenIfNoMatch (bool) : (bool) If no match for styleString is found and this is true, the function will return styleString, otherwise it will return tradingview's preferred default
Returns: (string) The string expected by tradingview functions
getPercentFromPrice(price)
Get the % the current price is away from the given price.
Parameters:
price (float)
Returns: (float) The % the current price is away from the given price.
getPositionFromString(position)
Tradingview doesn't give you a nice way to put the positions into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
position (string) : (string) Plain english position string
Returns: (string) The string expected by tradingview functions
getTimeframeOfChart()
Get the timeframe of the current chart for display
Returns: (string) The string of the current chart timeframe
getTimeNowPlusOffset(candleOffset)
Helper function for drawings that use xloc.bar_time to help you know the time offset if you want to place the end of the drawing out into the future. This determines the time-size of one candle and then returns a time n candleOffsets into the future.
Parameters:
candleOffset (int) : (int) The number of items to find singular/plural for.
Returns: (int) The future time
getVolumeBetweenTimes(start, end)
Given a start and end time, returns the sum of all volume across bars during that time window.
Parameters:
start (int) : The timestamp to start with (# of seconds)
end (int) : The timestamp to end with (# of seconds)
Returns: (float) The volume
isToday()
Returns true if the current bar occurs on today's date.
Returns: (bool) True if current bar is today
padLabelString(labelText, labelStyle)
Pads a label string so that it appears properly in or not in a label. When label.style_none is used, this will make sure it is left-aligned instead of center-aligned. When any other type is used, it adds a single space to the right so there is padding against the right end of the label.
Parameters:
labelText (string) : (string) The string to be padded
labelStyle (string) : (string) The style of the label being padded for.
Returns: (string) The padded string
plural(num, singular, plural)
Helps format a string for plural/singular. By default, if you only provide num, it will just return "s" for plural and nothing for singular (eg. plural(numberOfCats)). But you can optionally specify the full singular/plural words for more complicated nomenclature (eg. plural(numberOfBenches, 'bench', 'benches'))
Parameters:
num (int) : (int) The number of items to find singular/plural for.
singular (string) : (string) The string to return if num is singular. Defaults to an empty string.
plural (string) : (string) The string to return if num is plural. Defaults to 's' so you can just add 's' to the end of a word.
Returns: (string) The singular or plural provided strings depending on the num provided.
timeframeInSeconds(timeframe)
Get the # of seconds in a given timeframe. Tradingview's timeframe.in_seconds() expects a simple string, and we often need to use series string, so this is an alternative to get you the value you need.
Parameters:
timeframe (string)
Returns: (int) The number of secondsof that timeframe
timeframeToString(tf)
Convert a timeframe string to a consistent standard.
Parameters:
tf (string) : (string) The timeframe string to convert
Returns: (string) The standard format for the string, or the unchanged value if it is unknown.
AR Forecast Scatterplot [SS]This is a showcase indicator of my recently released SPTS library (the partner of the SPTS indicator).
This is just to show some of the practical applications of the boring statistical functions contained within the library/SPTS indicator :-).
This is an autoregressive (AR), scatter plot forecaster. What this means is it tags a lag of 1, performs an autoregressive assessment over the desired training time, then uses what it learns over that training time to forecast the likely outcome.
Its not a machine learning (I am in the process of creating one like this, but it is taking quite some time to complete), but the model needs to learn to plan the statistical coefficients that will best mimic the current trend.
As of its current state, this actually surpassed my own expectations. I can show you some QQQ examples:
Example #1:
Prediction:
Actual:
Example #2:
Prediction:
Actual:
Pretty nuts, eh?
Statistics, I'm telling you, its the answer haha.
So how do we determine the train time?
Because this is not using machine learning to control for over/under representation of datasize (again, I am making a version that does this, but its a slow process), some quick tips at determine appropriate train time is to use the Tradingview Regression tool:
When you set the parameters to align with the current, strongest trend, it is more reliable.
You will see, that it acutally is forecasting a move back to the exact top of this trend, that is because it is using the same processes as the linear regression trend on Tradingview.
You can use a bar counter indicator ( such as mine available here ) to calculate the number or bars back for your model training.
You can verify that these parameters are appropriate by looking at the Model Data table (which can be toggled on and off). You want to see both a high correlation and a high R2 value.
Quick note on colour:
Green = represents the upper confidence predictions (best case scenario)
Blue = represents the most likely result
red = represents that lower confidence (not as best case scenario)
Hope you enjoy!
Safe trades everyone!
