AlphaTrend For ProfitViewThis strategy is based on the AlphaTrend indicator by KivancOzbilgic A full description of this algorithm functionality may be found by clicking the linked image above.
Changes and/or additions:
It is now a backtestable strategy
Updated alert trigger logic
Easy integration with ProfitView to use this algorithm for automated trading
When you create an alert, and you are using ProfitView, select " alert() function calls only " as the condition option. If you would rather set your own custom alert message, select " Order fills only " instead.
There is a selectable setting in the options to trigger alert() function calls immediately, that you may use to see what text it will send.
Search in scripts for "algo"
least_squares_regressionLibrary "least_squares_regression"
least_squares_regression: Least squares regression algorithm to find the optimal price interval for a given time period
basic_lsr(series, series, series) basic_lsr: Basic least squares regression algorithm
Parameters:
series : int t: time scale value array corresponding to price
series : float p: price scale value array corresponding to time
series : int array_size: the length of regression array
Returns: reg_slop, reg_intercept, reg_level, reg_stdev
trend_line_lsr(series, series, series, string, series, series) top_trend_line_lsr: Trend line fitting based on least square algorithm
Parameters:
series : int t: time scale value array corresponding to price
series : float p: price scale value array corresponding to time
series : int array_size: the length of regression array
string : reg_type: regression type in 'top' and 'bottom'
series : int max_iter: maximum fitting iterations
series : int min_points: the threshold of regression point numbers
Returns: reg_slop, reg_intercept, reg_level, reg_stdev, reg_point_num
simple_squares_regressionLibrary "simple_squares_regression"
simple_squares_regression: simple squares regression algorithm to find the optimal price interval for a given time period
basic_ssr(series, series, series) basic_ssr: Basic simple squares regression algorithm
Parameters:
series : float src: the regression source such as close
series : int region_forward: number of candle lines at the right end of the regression region from the current candle line
series : int region_len: the length of regression region
Returns: left_loc, right_loc, reg_val, reg_std, reg_max_offset
search_ssr(series, series, series, series) search_ssr: simple squares regression region search algorithm
Parameters:
series : float src: the regression source such as close
series : int max_forward: max number of candle lines at the right end of the regression region from the current candle line
series : int region_lower: the lower length of regression region
series : int region_upper: the upper length of regression region
Returns: left_loc, right_loc, reg_val, reg_level, reg_std_err, reg_max_offset
Too Many Cooks trend indicatorToo many Cooks in The Kitchen
You have probably heard the adage "Too many cooks spoils the broth" before. The meaning behind it is obviously that when to many people are trying to work on the same task at once it simply devolves into a fight for control and creates a mess of the situation. But is this true for indicators is the question I had and thus I made this indicator, a simple combination of 8 random trend finding indicators I assembled (A list of these indicators and their authors will be available at the bottom of this page) . Is it any good though ? In short yes, it is a decent trend finding indicator and could likely be used in your strategy in the place of your current trend finding indicator if you so wish. However much of the versatility of the individual indicators IS lost and would not be possible to get back in this big mess of a broth, so this indicator will not be the be all end all of trend indicators nor will it be a free money machine like you may be expecting looking at the list of included indicators so the adage was correct to a degree.
List of Authors and their included indicators
Trading View defaults:
MACD (Modified by me)
Stochastic RSI (Modified by me)
Lazy Bear:
Wavetrend Oscilator (Modified by me)
Traders Dynamic Index (Modified by me)
HACOLT (Modified by me)
Algokid
AK Trend
Racer8
Average Force
KivancOzbilgic
Average Sentiment Osclilator
Critical Levels Mixing Price Action, Volatility and VolumeIntroduction
This indicator has the purpose of setting levels, automatically, basing its creation on three aspects of the market:
- price action
- volume
- volatility
Price Action Algorithm
I divided the candle into 3 parts:
- body => abs (close-open)
- lower tail => red candle (close-low) green candle (open-low)
- upper tail => red candle (high-open) green candle (high-close)
- total => high-low
to give the signal the following conditions must be respected
- the body must be smaller than a certain percentage ("MAX CORE SIZE%) and larger than a certain percentage (" MIN CORE SIZE%);
- furthermore, the shorter tail cannot be higher than a certain percentage ("MAXIMUM LENGTH FOR SHORTE TAIL%");
Volume Algorithm
The volume value must be greater than the volume EMA multiplied by a certain value ("Multiplier")
Volatility Algorithm
the True Range of the candle must be greater than the "ATR percentage" of the ATR
Trigger
If all these three conditions are met then and only then will the level be drawn that will include the prices of the longest tail of the candle (high/open or open/low or high/close or close/low).
How to use
Like any level, the situation in which the price is reached does not imply a market reaction, for this reason, the use together with moving averages or oscillators from which to extrapolate the divergences can be a valid tool.
Using this indicator alone you can enter the market by placing a pending order above the high or low of the candle touching the level.
Example:
a bearish candle touches a low level, we place a pending buy order above the high of the candle
a bullish candle touches a level located high, we place a pending sell order below the low of the candle
Gann FanHello All,
For long time I have been getting many requests about Gann Fan indicator. now we have linefill() function in Pine Language and I think it's right time to make Gann Fan Indicator. Many Thanks to Pine Team for adding many new features to the Pine Language!
How this indicator works:
- It calculates midline (1/1)
- By using midline it calculates other lines (1/2, 1/3, 1/4...etc)
- It calculates highest/lowest Pivot Points in last 280 bars.( by default it's 280 bars, you can change it and pivot period )
- It checks the location of highest/lowest Pivot Points
- After the calculation of the Gann Fan lines, it draws lines, puts Labels and paints the zones between the lines according to the colors set by the user
Long time ago I created a special algorithm for calculating the line with 45 degree and I used it for "1/1" line. Anybody who needs it can use this algorithm freely ;)
Options:
You can change following items;
- The colors
- Transparency. Possible values for transparency are from 0 (not transparent) to 100 (invisible)
- Line styles
- Loopback Period (by default it's 280)
- Pivot Period (by default it's 5)
- Enable/disable Labels
- Label location (by default it's 50
Tradingview Gann Fan page : The Gann Fan is a technical analysis tool created by WD Gann. The tool is comprised of 9 diagonal lines (extending indefinitely) designed to show different support and resistance levels on a chart. These angles -drawn from main tops and bottoms- divide time and price into proportionate parts and are often used to predict areas of support and resistance, key tops and bottoms and future price moves. Please note that the chart needs to be scaled properly to ensure the market has a square relationship....
Enjoy!
Kirill ChannelThis indicator shows overbought and oversold zones. Can be used on all time frames. I personally use 15m - 30m.
How to apply ?:
- There can be many strategies for use! I use this indicator to buy an asset in the green zone and then sell it in the middle of the channel or in the red zone.
- I strongly advise against entering counter-trend positions in a growing market if you have little trading experience and understanding of price action.
How do I place orders ?:
- I place orders in a grid.
- If the price is very close to the edge, but it is difficult to reach it, then it is better to open a position on the market and place orders deep into the grid.
- If the price is at the edge of the channel for a very long time, then you need to look at a higher timeframe.
Algorithm composition:
- ALMA
- Keltner Channel
- Fibonacci Retracement
- Custom price percent offset calculations and manipulations.
Settings:
- I strongly do not recommend changing ALMA. These numbers have been specially calculated.
- It's better not to change Borders either. The current algorithm dynamically changes the width of the extreme channels depending on the price movement.
- The Keltner Channel was specially selected.
- Fibonacci Retracement can be changed. This part of the algorithm can be modified to suit your needs. At the moment, there are settings for aggressive trading.
Channel type:
- Conservative: Fibonacci Retracement settings (100 ma, 100 atr, 8 mult, 100 smooth)
- Aggressive: Fibonacci Retracement settings (25 ma, 25 atr, 3.5 mult, 100 smooth)
Сonservative channel does not allow a large number of points to enter positions, however, it is more straightforward and safer for very large movements.
I prefer aggressive settings because they allow me to make more profit on the number of trades.
Try to use both modes and choose what is preferable for you.
TrendCalculusThis indicator makes visualising some of the core TrendCalculus algorithm's key information and features both fast and easy for casual analysis.
Interpretation:
a) The light blue channel is the lagged price channel calculated over the timeframe of your choosing for a period of N values. When the current price breaks out of this channel the previous price major high/low can be identified as a trend reversal. This helps in counting trend "waves" and is a rolling visual version of ideas I developed for counting Elliot Waves. For EW analysis, your mileage may vary depending on the asset inspected, but the chart allows you to clearly count waves on a particular scale of time (period) ignoring noise on other time scales.
b) The green/red channel is a support/resistance indicator region that shows the relationship of the current price to the key pivot points on this time scale (period) and these make for good visual indication that the current trend is up (green), or down (red). You may find them helpful for identifying breakouts and placing stops - but this was not their original intention. The pink line is the mid point of closing values in the lagged price channel, and the orange line the mid point of closing values in the current price channel.
About TrendCalculus (TC):
TC is implemented in several languages including Lua, Scala and Python. The Lua implementation is the reference and has the most advanced functionality and delivers a powerful data processing tool for both multi-scale trend reversal detection, reversal labelling, as well as trend feature production - all useful things helping it to produce training data for machine learning models that detect trend changes in real time.
This charting tool includes: (1) two consecutive lagged Donchian channels configured to a common period N, (2) the current price, and (3) the mid price of both Donchian channels. These calculations are all part of the TC codebase, and are brought to life in this charting tool.
Motivation:
By creating a TC charting tool - the machine learning model is swapped for *your eyes* and *your brain*. Using the same inputs as the machine, you can use this chart to learn to detect trend changes, and understand how time frame (long periods, short periods) affect your view of trend change. If you choose to use it to trade, or make investment decisions, do so at your own risk. This indicator does not deliver financial advice.
TrendCalculus is the invention of Andrew Morgan, author of Mastering Spark for Data Science (2017).
The original core TrendCalculus (TC) algorithm itself is published as open-source code on github under a GPL licence, and free to use and develop.
Jurik Moving Average//Sup TV. This script is inspired by (and dedicated to) closure of sales (today, Oct 20 '21) of the famous Jurik Research.
...
Jurik Research, the real people who been doing real things by using the real instruments, while many others been reading books "How to become a billionaire in 2 days", watching 5687 hours videos of how to use RSI, and studying+applying machine learning to everything cuz suddenly it became trendy xD
...
This is my remake of the original Jurik Moving Average (JMA) based on all the info I managed to get my hands on, some stuff is dated back to 2008 or smth.
The whole point of this filter, the point missed by other attempts of its remakes even posted there on TV, is that it takes into account volatility and adjusts its speed based on it.
Think about it as an EMA, where the alpha parameter is dynamic.
Now, by all means I'm not claiming that's this is the perfect replica of the original algo. I've tested it a lot, looks like it's working legit...
But we all can see together whether it's legit or nah, besides, the official sales are closed since today, you feel me?
...
@everget, does it differs from yours closed one?
...
Live Long And Prosper
FunctionSMCMCLibrary "FunctionSMCMC"
Methods to implement Markov Chain Monte Carlo Simulation (MCMC)
markov_chain(weights, actions, target_path, position, last_value) a basic implementation of the markov chain algorithm
Parameters:
weights : float array, weights of the Markov Chain.
actions : float array, actions of the Markov Chain.
target_path : float array, target path array.
position : int, index of the path.
last_value : float, base value to increment.
Returns: void, updates target array
mcmc(weights, actions, start_value, n_iterations) uses a monte carlo algorithm to simulate a markov chain at each step.
Parameters:
weights : float array, weights of the Markov Chain.
actions : float array, actions of the Markov Chain.
start_value : float, base value to start simulation.
n_iterations : integer, number of iterations to run.
Returns: float array with path.
Repeated Median Regression with Interactive Range SelectionGreetings to all!
As you probably know, TradingView now supports interactive inputs that can be directly set on a chart. I decided to build a tool that takes advantage of this incredible feature. This tool applies robust linear regression within a time interval on the chart that you can select interactively.
Method
The script uses an algorithm known as Repeated Median Regression . It belongs to the class of so-called robust regression methods. The reason they are called “robust” is that these methods are much less sensitive to outliers in the data than the ordinary least squares.
The calculation procedure is as follows: For each data point, this algorithm collects the slopes of the lines connecting that point to all other points in the sample, calculates the median slope, and then obtains the median value of these median slopes. Subsequently, it calculates the intercepts of the regression line and the mean absolute error (MAE) of the model.
Based on these results, a linear channel is plotted. The upper and lower channel boundaries are set by the MAE value multiplied by a user-defined coefficient.
Further reading
You can read more about robust linear regression on Wikipedia .
For more information on interactive inputs, see the User Manual's page .
Previous publication
I have already posted a script using the repeated median regression method. Although the core algorithm is essentially the same, interactive input provides fundamentally different functionality to the current script.
A word of caution
Currently, the interactive interval selection mode can be triggered only when the script is loaded to the chart. Thus, you might have to reload it when switching between different timeframes.
MathGeometryCurvesChaikinLibrary "MathGeometryCurvesChaikin"
Implements the chaikin algorithm to create a curved path, from assigned points.
chaikin(points_x, points_y, closed) Chaikin algorithm method, uses provided points to generate a smoothed path.
Parameters:
points_x : float array, the x value of points.
points_y : float array, the y value of points.
closed : bool, default=false, is the path closed or not.
Returns: tuple with 2 float arrays.
smooth(points_x, points_y, iterations, closed) Iterate the chaikin algorithm, to smooth a sample of points into a curve path.
Parameters:
points_x : float array, the x value of points.
points_y : float array, the y value of points.
iterations : int, number of iterations to apply the smoothing.
closed : bool, default=false, is the path closed or not.
Returns: array of lines.
draw(path_x, path_y, closed) Draw the path.
Parameters:
path_x : float array, the x value of the path.
path_y : float array, the y value of the path.
closed : bool, default=false, is the path closed or not.
Returns: array of lines.
Hx MTF Sorted MAs Panel with Freeze WarningThis script displays the close price and 4 sorted moving averages of your choice in a small repositionable panel and, when used on a higher timeframe, warns you when values may be different from actual values in the higher timeframe, inciting you to double check the actual values of the moving averages in the higher timeframe the panel is supposed to reflect.
The 4 moving averages and close are sorted together, providing you with a bird’s-eye view of their relative positions, the same way moving averages and last price values are displayed on the right scale.
The black header reminds of:
(1) the timeframe (resolution) used in the panel
(2) the remaining time before a new bar is created in the panel timeframe. Note that this remaining time is different from the one on the right scale, since it is only updated when a new transaction occurs.
Below, price and moving averages are sorted, color coded and followed by:
(1) a trend indicator ↗ or ↘ meaning that last change is up or down
(2) the number of bars since the moving average is above or below close (0 means current bar). This is obviously not displayed after the close price line (white background color).
Use
This panel was basically developed to display higher timeframe data but it can also be used with the same timeframe as chart for example if you do not want to plot moving averages on your chart but are still interested in their trends and relative positions vs price.
If you see something strange (like header is not black and displays NaN), it just means you requested moving averages that are not available in the panel timeframe. This may happen with newly introduced cryptos and “long” MA timeframes.
Different Timeframe
If you choose to use the panel on a different timeframe than the current one, be aware that you should only use timeframes higher than the current one, as per Tradingview recommendations.
If you select a lower timeframe than the current one, the panel timeframe header cell will turn to the alert color you set (fuchsia by default).
After tinkering for a while with the security function, I noticed that sometimes indicator values “freeze” (i.e. stop udating) and I have found no workaround.
What I mean is that when you look at a sma on a 5 minutes timeframe (the reference) and look at this same sma on a 5 minutes timeframe but from a lower timeframe through the security function set with a timeframe of 5 minutes, values returned by the security function are not always up to date and “freeze”. That’s the bad news.
Freeze warning
The better news is that this unexpected behaviour seems to be predictable, at least on minutes timeframes and I implemented an indicator that endeavors to detecting such situations. When the panel believes data may be frozen, the ‘Remaining Time’ header cell will turn to the alert color.
This feature is only implemented on minutes timeframes and can be switched on or off.
Other points of interest in this script
If you code, this function may also interest you:
sortWithIndexes (arrayToSort) returns a tuple (sortedArray, sortedIndexes) and therefore allows multi-dimensional arrays sorting without actually implementing a sorting algorithm 😉.
Default Settings
The default settings provide an example of commonly used moving averages with associated colors ranked from Hot (more nervous) to Cold (less nervous).
These settings are just an example and are NOT meant to be used as a trading system! DYOR!
Hope it will be useful.
Does the Freeze warning work for you? What do you think of my pseudo sorting algorithm?
Enjoy and please let me know what you think in the comments.
Six Moving Averages Study (use as a manual strategy indicator)I made this based on a really interesting conversation I had with a good friend of mine who ran a long/short hedge fund for seven years and worked at a major hedge fund as a manager for 20 years before that. This is an unconventional approach and I would not recommend it for bots, but it has worked unbelievably well for me over the last few weeks in a mixed market.
The first thing to know is that this indicator is supposed to work on a one minute chart and not a one hour, but TradingView will not allow 1m indicators to be published so we have to work around that a little bit. This is an ultra fast day trading strategy so be prepared for a wild ride if you use it on crypto like I do! Make sure you use it on a one minute chart.
The idea here is that you get six SMA curves which are:
1m 50 period
1m 100 period
1m 200 period
5m 50 period
5m 100 period
5m 200 period
The 1m 50 period is a little thicker because it's the most important MA in this algo. As price golden crosses each line it becomes a stronger buy signal, with added weight on the 1m 50 period MA. If price crosses all six I consider it a strong buy signal though your mileage may vary.
*** NOTE *** The screenshot is from a 1h chart which again, is not the correct way to use this. PLEASE don't use it on a one hour chart.
Easy Entry/Exit Trend Colors (With Alerts)This is an updated version of user Algokid's script called 'AK MACD BB INDICATOR V 1.00'. You can find that original script here:
I added many alerts along with the Bullish and Bearish alerts when the MACD crosses over the Upperband or crosses down on the Lowerband.
I personally use this indicator with Crypto charts (Bitcoin on a 15min, 1hour, and 4 hour timeframe) as one of many confirmations that it's a good time to enter a trade. This script was made to be easy to follow with the colors of GREEN triangles being a good uptrend or entry confirmation, and RED being a confirmation to sell/short or exit your trade.
It's important to use this indicator in combination with other indicators that can give you more confirmations to enter or exit a trade, and make sure you are on normal candles and not HA or any other candles as you can get wildly inaccurate results.
This script also has the Death & Golden crosses, which is the slow and fast moving averages crossing over each other. I don't use this as an additional confirmation, it's just nice to know where the cross happens.
Particle Physics Moving AverageThis indicator simulates the physics of a particle attracted by a distance-dependent force towards the evolving value of the series it's applied to.
Its parameters include:
The mass of the particle
The exponent of the force function f=d^x
A "medium damping factor" (viscosity of the universe)
Compression/extension damping factors (for simulating spring-damping functions)
This implementation also adds a second set of all of these parameters, and tracks 16 particles evenly interpolated between the two sets.
It's a kind of Swiss Army Knife of Moving Average-type functions; For instance, because the position and velocity of the particle include a "historical knowlege" of the series, it turns out that the Exponential Moving Average function simply "falls out" of the algorithm in certain configurations; instead of being configured by defining a period of samples over which to calculate an Exponential Moving Average, in this derivation, it is tuned by changing the mass and/or medium damping parameters.
But the algorithm can do much more than simply replicate an EMA... A particle acted on by a force that is a linear function of distance (force exponent=1) simulates the physics of a sprung-mass system, with a mass-dependent resonant frequency. By altering the particle mass and damping parameters, you can simulate something like an automobile suspension, letting your particle track a stock's price like a Cadillac or a Corvette (or both, including intermediates) depending on your setup. Particles will have a natural resonance with a frequency that depends on its mass... A higher mass particle (i.e. higher inertia) will resonate at a lower frequency than one with a lower mass (and of course, in this indicator, you can display particles that interpolate through a range of masses.)
The real beauty of this general-purpose algorithm is that the force function can be extended with other components, affecting the trajectory of the particle; For instance "volume" could be factored into the current distance-based force function, strengthening or weakening the impulse accordingly. (I'll probably provide updates to the script that incoroprate different ideas I come up with.)
As currently pictured above, the indicator is interpolating between a medium-damped EMA-like configuration (red) and a more extension-damped suspension-like configuration (blue).
This indicator is merely a tool that provides a space to explore such a simulation, to let you see how tweaking parameters affects the simulations. It doesn't provide buy or sell signals, although you might find that it could be adapted into an MACD-like signal generator... But you're on your own for that.
