Harmonic, wave and Fibonacci [Hunter Algo]This Pine Script indicator is designed to identify various harmonic patterns, wave formations, and Fibonacci retracements directly on your TradingView charts. The script offers a comprehensive toolset for traders who use technical analysis to spot potential market reversals and continuation patterns.
Key Features:
Harmonic Pattern Detection: Automatically identifies and labels popular harmonic patterns like Bat, Gartley, Butterfly, Crab, Shark, and many more.
Fibonacci Levels: Displays key Fibonacci retracement levels, including 0.236, 0.382, 0.500, 0.618, 0.764, and 1.000, providing critical levels for entry, exit, and stop-loss placement.
Heiken Ashi Option: Option to use Heiken Ashi candles for pattern detection, providing smoother price action analysis.
Alternate Timeframe Support: Analyze patterns on different timeframes by enabling the alternate timeframe feature.
Customizable Display: Choose which patterns and Fibonacci levels to display, allowing you to focus on the most relevant data for your trading strategy.
This script is highly versatile, making it suitable for both novice and experienced traders looking to enhance their chart analysis with automated pattern recognition.
BEST
Sticky Notes, Checklist, To-do, Journal [algoat]I forgot to bring my notes again...
Ever feel like your trading notes are all over the place, much like your portfolio after a market dip? Worry not! With this script, you'll have all your trading notes, tasks, and brilliant (or not so brilliant) ideas neatly organized right on your chart. It's like having a sticky note board, but way cooler and without the risk of paper cuts.
⭐ Features :
To-Do Lists
Keep track of tasks with satisfying checkmarks for those dopamine hits.
Journal Entries
Document your market insights, trade plans, or just random thoughts. "I forgot something" – we've all been there.
Due Dates
Never miss an important deadline again. Red alert for overdue tasks because procrastination is a trader's worst enemy.
Customization
Choose the size and position of your notes because one size doesn't fit all.
Perfect for the organized trader who loves a bit of fun or the chaotic one who needs a bit of structure. Embrace the power of notes and stay on top of your trading game!
══════════════════
🧠 General advice
Trading effectively requires a range of techniques, experience, and expertise. From technical analysis to market fundamentals, traders must navigate multiple factors, including market sentiment and economic conditions. However, traders often find themselves overwhelmed by market noise, making it challenging to filter out distractions and make informed decisions. By integrating multiple analytical approaches, traders can tailor their strategies to fit their unique trading styles and objectives.
Confirming Signals with other indicators
As with all technical indicators, it is important to confirm potential signals with other analytical tools, such as support and resistance levels, as well as indicators like RSI, MACD, and volume. This helps increase the probability of a successful trade.
Use proper risk management
When using this or any other indicator, it is crucial to have proper risk management in place. Consider implementing stop-loss levels and thoughtful position sizing.
Combining with other technical indicators
The indicator can be effectively used alongside other technical indicators to create a comprehensive trading strategy and provide additional confirmation.
Keep in mind
Thorough research and backtesting are essential before making any trading decisions. Furthermore, it's crucial to have a solid understanding of the indicator and its behavior. Additionally, incorporating fundamental analysis and considering market sentiment can be vital factors to take into account in your trading approach.
══════════════════
⭐ Conclusion
We hold the view that the true path to success is the synergy between the trader and the tool, contrary to the common belief that the tool itself is the sole determinant of profitability. The actual scenario is more nuanced than such an oversimplification. A word to the wise is enough: developed by traders, for traders — pioneering innovations for the modern era.
Risk Notice
Everything provided by algoat — from scripts, tools, and articles to educational materials — is intended solely for educational and informational purposes. Past performance does not assure future returns.
FreedX Grid Backtest█ FreedX Grid Backtest is an open-source tool that offers accurate GRID calculations for GRID trading strategies. This advanced tool allows users to backtest GRID trading parameters with precision, accurately reflecting exchange functionalities. We are committed to enhancing trading strategies through precise backtesting solutions and address the issue of unreliable backtesting practices observed on GRID trading strategies. FreedX Grid Backtest is designed for optimal calculation speed and plotting efficiency, ensuring users to achieve fastest calculations during their analysis.
█ GRID TRADING STRATEGY SETTINGS
The core of the FreedX Grid Backtest tool lies in its ability to simulate grid trading strategies. Grid trading involves placing orders at regular intervals within a predefined price range, creating a grid of orders that capitalize on market volatility.
Features:
⚙️ Backtest Range:
→ Purpose: Allows users to specify the backtesting range of GRID strategy. Closes all positions at the end of this range.
→ How to Use: Drag the dates to fit the desired backtesting range.
⚙️ Investment & Compounding:
→ Purpose: Allows users to specify the total investment amount and select between fixed and compound investment strategies. Compounding adjusts trade quantities based on performance, enhancing the grid strategy's adaptability to market changes.
→ How to Use: Set the desired investment amount and choose between "Fixed" or "Compound" for the investment method.
⚙️ Leverage & Grid Levels:
→ Purpose: Leverage amplifies the investment amount, increasing potential returns (and risks). Users can define the number of grid levels, which determines how the investment is distributed across the grid.
→ How to Use: Input the desired leverage and number of grids. The tool automatically calculates the distribution of funds across each grid level.
⚙️ Distribution Type & Mode:
→ Purpose: Users can select the distribution type (Arithmetic or Geometric) to set how grid levels are determined. The mode (Neutral, Long, Short) dictates the direction of trades within the grid.
→ How to Use: Choose the distribution type and mode based on the desired trading strategy and market outlook.
⚙️ Enable LONG/SHORT Grids exclusively:
█ MANUAL LEVELS AND STOP TRIGGERS
Beyond automated settings, the tool offers manual adjustments for traders seeking finer control over their grid strategies.
Features:
⚙️ Manual Level Adjustment:
→ Purpose: Enables traders to manually set the top, reference, and bottom levels of the grid, offering precision control over the trading range.
→ How to Use: Activate manual levels and adjust the top, reference, and bottom levels as needed to define the grid's scope.
⚙️ Stop Triggers:
→ Purpose: Provides an option to set upper and lower price limits, acting as stop triggers to close or terminate trades. This feature safeguards investments against significant market movements outside the anticipated range.
→ How to Use: Enable stop triggers and specify the upper and lower limits. The tool will automatically manage positions based on these parameters.
---
This guide gives you a quick and clear overview of the FreedX Grid Backtest tool, explaining how you can use this cutting-edge tool to improve your trading strategies.
Multi Bollinger Bands with Over ZoneThis indicator is called "Multi Bollinger Bands with Over Zone". The indicator uses linear regression to calculate the regression line and standard deviation to calculate the upper and lower deviation lines. It also plots filled areas between the deviation lines to highlight overbought and oversold zones.
The indicator has several customizable inputs, including the length of the regression period, depth, and deviations used to calculate the deviation lines.
The regression line is plotted in green color with circle markers. The upper and lower deviation lines are plotted in blue and red colors, respectively. The area between the deviation lines is filled with light blue color for the overbought zone and light pink color for the oversold zone.
This indicator helps traders in identifying trends and potential price reversals. When the price is above the upper deviation line, it indicates a potential overbought zone, while when the price is below the lower deviation line, it indicates a potential oversold zone.
Please note that this indicator is only a tool for analysis and does not provide direct trading signals. It is important to combine this indicator with additional analysis and appropriate trading strategies.
Strongest Supports And ResistancesDraws the best support and resistance lines. How it works:
1) Tries every possible line through lows, highs, opens, closes
2) Finds the total hit counts given the confidence interval as input to the candlesticks
3) Calculates the strength of every line according to hit count, total volumes on hits, and timestamps
4) Eliminates similar lines, confidence interval is set as input
5) Selects the strongest 20(changable as an input) lines and draws them on the graph.
Makes your work way easier!!!
Feel free to adjust the parameters for your own style!
Cheers!!
HARKAT momentombest indicator for momentom and movement
in btcusdt 15 min just harkat above 1 indicates movment in market
in bearish or bullish trend
Bjorgum Double Tap█ OVERVIEW
Double Tap is a pattern recognition script aimed at detecting Double Tops and Double Bottoms. Double Tap can be applied to the broker emulator to observe historical results, run as a trading bot for live trade alerts in real time with entry signals, take profit, and stop orders, or to simply detect patterns.
█ CONCEPTS
How Is A Pattern Defined?
Doubles are technical formations that are both reversal patterns and breakout patterns. These formations typically have a distinctive “M” or a “W” shape with price action breaking beyond the neckline formed by the center of the pattern. They can be recognized when a pivot fails to break when tested for a second time and the retracement that follows breaks beyond the key level opposite. This can trap entrants that were playing in the direction of the prior trend. Entries are made on the breakout with a target projected beyond the neckline equal to the height of the pattern.
Pattern Recognition
Patterns are recognized through the use of zig-zag; a method of filtering price action by connecting swing highs and lows in an alternating fashion to establish trend, support and resistance, or derive shapes from price action. The script looks for the highest or lowest point in a given number of bars and updates a list with the values as they form. If the levels are exceeded, the values are updated. If the direction changes and a new significant point is made, a new point is added to the list and the process starts again. Meanwhile, we scan the list of values looking for the distinctive shape to form as previously described.
█ STRATEGY RESULTS
Back Testing
Historical back testing is the most common method to test a strategy due in part to the general ease of gathering quick results. The underlying theory is that any strategy that worked well in the past is likely to work well in the future, and conversely, any strategy that performed poorly in the past is likely to perform poorly in the future. It is easy to poke holes in this theory, however, as for one to accept it as gospel, one would have to assume that future results will match what has come to pass. The randomness of markets may see to it otherwise, so it is important to scrutinize results. Some commonly used methods are to compare to other markets or benchmarks, perform statistical analysis on the results over many iterations and on differing datasets, walk-forward testing, out-of-sample analysis, or a variety of other techniques. There are many ways to interpret the results, so it is important to do research and gain knowledge in the field prior to taking meaningful conclusions from them.
👉 In short, it would be naive to place trust in one good backtest and expect positive results to continue. For this reason, results have been omitted from this publication.
Repainting
Repainting is simply the difference in behaviour of a strategy in real time vs the results calculated on the historical dataset. The strategy, by default, will wait for confirmed signals and is thus designed to not repaint. Waiting for bar close for entires aligns results in the real time data feed to those calculated on historical bars, which contain far less data. By doing this we align the behaviour of the strategy on the 2 data types, which brings significance to the calculated results. To override this behaviour and introduce repainting one can select "Recalculate on every tick" from the properties tab. It is important to note that by doing this alerts may not align with results seen in the strategy tester when the chart is reloaded, and thus to do so is to forgo backtesting and restricts a strategy to forward testing only.
👉 It is possible to use this script as an indicator as opposed to a full strategy by disabling "Use Strategy" in the "Inputs" tab. Basic alerts for detection will be sent when patterns are detected as opposed to complex order syntax. For alerts mid-bar enable "Recalculate on every tick" , and for confirmed signals ensure it is disabled.
█ EXIT ORDERS
Limit and Stop Orders
By default, the strategy will place a stop loss at the invalidation point of the pattern. This point is beyond the pattern high in the case of Double Tops, or beneath the pattern low in the case of Double Bottoms. The target or take profit point is an equal-legs measurement, or 100% of the pattern height in the direction of the pattern bias. Both the stop and the limit level can be adjusted from the user menu as a percentage of the pattern height.
Trailing Stops
Optional from the menu is the implementation of an ATR based trailing stop. The trailing stop is designed to begin when the target projection is reached. From there, the script looks back a user-defined number of bars for the highest or lowest point +/- the ATR value. For tighter stops the user can look back a lesser number of bars, or decrease the ATR multiple. When using either Alertatron or Trading Connector, each change in the trail value will trigger an alert to update the stop order on the exchange to reflect the new trail price. This reduces latency and slippage that can occur when relying on alerts only as real exchange orders fill faster and remain in place in the event of a disruption in communication between your strategy and the exchange, which ensures a higher level of safety.
👉 It is important to note that in the case the trailing stop is enabled, limit orders are excluded from the exit criteria. Rather, the point in time that the limit value is exceeded is the point that the trail begins. As such, this method will exit by stop loss only.
█ ALERTS
Five Built-in 3rd Party Destinations
The following are five options for delivering alerts from Double Tap to live trade execution via third party API solutions or chat bots to share your trades on social media. These destinations can be selected from the input menu and alert syntax will automatically configure in alerts appropriately to manage trades.
Custom JSON
JSON, or JavaScript Object Notation, is a readable format for structuring data. It is used primarily to transmit data between a server and a web application. In regards to this script, this may be a custom intermediary web application designed to catch alerts and interface with an exchange API. The JSON message is a trade map for an application to read equipped with where its been, where its going, targets, stops, quantity; a full diagnostic of the current state and its previous state. A web application could be configured to follow the messages sent in this format and conduct trades in sync with alerts running on the TV server.
Below is an example of a rendered JSON alert:
{
"passphrase": "1234",
"time": "2022-05-01T17:50:05Z",
"ticker": "ETHUSDTPERP",
"plot": {
"stop_price": 2600.15,
"limit_price": 3100.45
},
"strategy": {
"position_size": 0.1,
"order_action": "buy",
"market_position": "long",
"market_position_size": 0,
"prev_market_position": "flat",
"prev_market_position_size": 0
}
}
Trading Connector
Trading Connector is a third party fully autonomous Chrome extension designed to catch alert webhooks from TradingView and interface with MT4/MT5 to execute live trades from your machine. Alerts to Trading Connector are simple; just select the destination from the input drop down menu, set your ticker in the "TC Ticker" box in the "Alert Strings" section and enter your URL in the alert window when configuring your alert.
Alertatron
Alertatron is an automated algo platform for cryptocurrency trading that is designed to automate your trading strategies. Although the platform is currently restricted to crypto, it offers a versatile interface with high flexibility syntax for complex market orders and conditions. To direct alerts to Alertatron, select the platform from the 3rd party drop down, configure your API key in the ”Alertatron Key” box and add your URL in the alert message box when making alerts.
3 Commas
3 Commas is an easy and quick to use click-and-go third party crypto API solution. Alerts are simple without overly complex syntax. Messages are simply pasted into alerts and executed as alerts are triggered. There are 4 boxes at the bottom of the "Inputs" tab where the appropriate messages to be placed. These messages can be copied from 3 Commas after the bots are set up and pasted directly into the settings menu. Remember to select 3 Commas as a destination from the third party drop down and place the appropriate URL in the alert message window.
Discord
Some may wish to share their trades with their friends in a Discord chat via webhook chat bot. Messages are configured to notify of the pattern type with targets and stop values. A bot can be configured through the integration menu in a Discord chat to which you have appropriate access. Select Discord from the 3rd party drop down menu and place your chat bot URL in the alert message window when configuring alerts.
👉 For further information regarding alert setup, refer to the platform specific instructions given by the chosen third party provider.
█ IMPORTANT NOTES
Setting Alerts
For alert messages to be properly delivered on order fills it is necessary to place the following placeholder in the alert message box when creating an alert.
{{strategy.order.alert_message}}
This placeholder will auto-populate the alert message with the appropriate syntax that is designated for the 3rd party selected in the user menu.
Order Sizing and Commissions
The values that are sent in alert messages are populated from live metrics calculated by the strategy. This means that the actual values in the "Properties" tab are used and must be set by the user. The initial capital, order size, commission, etc. are all used in the calculations, so it is important to set these prior to executing live trades. Be sure to set the commission to the values used by the exchange as well.
👉 It is important to understand that the calculations on the account size take place from the beginning of the price history of the strategy. This means that if historical results have inflated or depleted the account size from the beginning of trade history until now, the values sent in alerts will reflect the calculated size based on the inputs in the "Properties" tab. To start fresh, the user must set the date in the "Inputs" tab to the current date as to remove trades from the trade history. Failure to follow this instruction can result in an unexpected order size being sent in the alert.
█ FOR PINECODERS
• With the recent introduction of matrices in Pine, the script utilizes a matrix to track pivot points with the bars they occurred on, while tracking if that pivot has been traded against to prevent duplicate detections after a trade is exited.
• Alert messages are populated with placeholders ; capability that previously was only possible in alertcondition() , but has recently been extended to `strategy.*()` functions for use in the `alert_message` argument. This allows delivery of live trade values to populate in strategy alert messages.
• New arguments have been added to strategy.exit() , which allow differentiated messages to be sent based on whether the exit occurred at the stop or the limit. The new arguments used in this script are `alert_profit` and `alert_loss` to send messages to Discord
BjCandlePatternsLibrary "BjCandlePatterns"
Patterns is a Japanese candlestick pattern recognition Library for developers. Functions here within detect viable setups in a variety of popular patterns. Please note some patterns are without filters such as comparisons to average candle sizing, or trend detection to allow the author more freedom.
doji(dojiSize, dojiWickSize) Detects "Doji" candle patterns
Parameters:
dojiSize : (float) The relationship of body to candle size (ie. body is 5% of total candle size). Default is 5.0 (5%)
dojiWickSize : (float) Maximum wick size comparative to the opposite wick. (eg. 2 = bottom wick must be less than or equal to 2x the top wick). Default is 2
Returns: (series bool) True when pattern detected
dLab(showLabel, labelColor, textColor) Produces "Doji" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
bullEngulf(maxRejectWick, mustEngulfWick) Detects "Bullish Engulfing" candle patterns
Parameters:
maxRejectWick : (float) Maximum rejection wick size.
The maximum wick size as a percentge of body size allowable for a top wick on the resolution candle of the pattern. 0.0 disables the filter.
eg. 50 allows a top wick half the size of the body. Default is 0% (Disables wick detection).
mustEngulfWick : (bool) input to only detect setups that close above the high prior effectively engulfing the candle in its entirety. Default is false
Returns: (series bool) True when pattern detected
bewLab(showLabel, labelColor, textColor) Produces "Bullish Engulfing" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
bearEngulf(maxRejectWick, mustEngulfWick) Detects "Bearish Engulfing" candle patterns
Parameters:
maxRejectWick : (float) Maximum rejection wick size.
The maximum wick size as a percentge of body size allowable for a bottom wick on the resolution candle of the pattern. 0.0 disables the filter.
eg. 50 allows a botom wick half the size of the body. Default is 0% (Disables wick detection).
mustEngulfWick : (bool) Input to only detect setups that close below the low prior effectively engulfing the candle in its entirety. Default is false
Returns: (series bool) True when pattern detected
bebLab(showLabel, labelColor, textColor) Produces "Bearish Engulfing" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
hammer(ratio, shadowPercent) Detects "Hammer" candle patterns
Parameters:
ratio : (float) The relationship of body to candle size (ie. body is 33% of total candle size). Default is 33%.
shadowPercent : (float) The maximum allowable top wick size as a percentage of body size. Default is 5%.
Returns: (series bool) True when pattern detected
hLab(showLabel, labelColor, textColor) Produces "Hammer" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
star(ratio, shadowPercent) Detects "Star" candle patterns
Parameters:
ratio : (float) The relationship of body to candle size (ie. body is 33% of total candle size). Default is 33%.
shadowPercent : (float) The maximum allowable bottom wick size as a percentage of body size. Default is 5%.
Returns: (series bool) True when pattern detected
ssLab(showLabel, labelColor, textColor) Produces "Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
dragonflyDoji() Detects "Dragonfly Doji" candle patterns
Returns: (series bool) True when pattern detected
ddLab(showLabel, labelColor) Produces "Dragonfly Doji" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
Returns: (series label) A label visible at the chart level intended for the title pattern
gravestoneDoji() Detects "Gravestone Doji" candle patterns
Returns: (series bool) True when pattern detected
gdLab(showLabel, labelColor, textColor) Produces "Gravestone Doji" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
tweezerBottom(closeUpperHalf) Detects "Tweezer Bottom" candle patterns
Parameters:
closeUpperHalf : (bool) input to only detect setups that close above the mid-point of the candle prior increasing its bullish tendancy. Default is false
Returns: (series bool) True when pattern detected
tbLab(showLabel, labelColor, textColor) Produces "Tweezer Bottom" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
tweezerTop(closeLowerHalf) Detects "TweezerTop" candle patterns
Parameters:
closeLowerHalf : (bool) input to only detect setups that close below the mid-point of the candle prior increasing its bearish tendancy. Default is false
Returns: (series bool) True when pattern detected
ttLab(showLabel, labelColor, textColor) Produces "TweezerTop" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
spinningTopBull(wickSize) Detects "Bullish Spinning Top" candle patterns
Parameters:
wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.
Returns: (series bool) True when pattern detected
stwLab(showLabel, labelColor, textColor) Produces "Bullish Spinning Top" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
spinningTopBear(wickSize) Detects "Bearish Spinning Top" candle patterns
Parameters:
wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.
Returns: (series bool) True when pattern detected
stbLab(showLabel, labelColor, textColor) Produces "Bearish Spinning Top" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
spinningTop(wickSize) Detects "Spinning Top" candle patterns
Parameters:
wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.
Returns: (series bool) True when pattern detected
stLab(showLabel, labelColor, textColor) Produces "Spinning Top" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
morningStar() Detects "Bullish Morning Star" candle patterns
Returns: (series bool) True when pattern detected
msLab(showLabel, labelColor, textColor) Produces "Bullish Morning Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
eveningStar() Detects "Bearish Evening Star" candle patterns
Returns: (series bool) True when pattern detected
esLab(showLabel, labelColor, textColor) Produces "Bearish Evening Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
haramiBull() Detects "Bullish Harami" candle patterns
Returns: (series bool) True when pattern detected
hwLab(showLabel, labelColor, textColor) Produces "Bullish Harami" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
haramiBear() Detects "Bearish Harami" candle patterns
Returns: (series bool) True when pattern detected
hbLab(showLabel, labelColor, textColor) Produces "Bearish Harami" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
haramiBullCross() Detects "Bullish Harami Cross" candle patterns
Returns: (series bool) True when pattern detected
hcwLab(showLabel, labelColor, textColor) Produces "Bullish Harami Cross" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
haramiBearCross() Detects "Bearish Harami Cross" candle patterns
Returns: (series bool) True when pattern detected
hcbLab(showLabel, labelColor) Produces "Bearish Harami Cross" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
Returns: (series label) A label visible at the chart level intended for the title pattern
marubullzu() Detects "Bullish Marubozu" candle patterns
Returns: (series bool) True when pattern detected
mwLab(showLabel, labelColor, textColor) Produces "Bullish Marubozu" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
marubearzu() Detects "Bearish Marubozu" candle patterns
Returns: (series bool) True when pattern detected
mbLab(showLabel, labelColor, textColor) Produces "Bearish Marubozu" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
abandonedBull() Detects "Bullish Abandoned Baby" candle patterns
Returns: (series bool) True when pattern detected
abwLab(showLabel, labelColor, textColor) Produces "Bullish Abandoned Baby" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
abandonedBear() Detects "Bearish Abandoned Baby" candle patterns
Returns: (series bool) True when pattern detected
abbLab(showLabel, labelColor, textColor) Produces "Bearish Abandoned Baby" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
piercing() Detects "Piercing" candle patterns
Returns: (series bool) True when pattern detected
pLab(showLabel, labelColor, textColor) Produces "Piercing" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
darkCloudCover() Detects "Dark Cloud Cover" candle patterns
Returns: (series bool) True when pattern detected
dccLab(showLabel, labelColor, textColor) Produces "Dark Cloud Cover" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
tasukiBull() Detects "Upside Tasuki Gap" candle patterns
Returns: (series bool) True when pattern detected
utgLab(showLabel, labelColor, textColor) Produces "Upside Tasuki Gap" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
tasukiBear() Detects "Downside Tasuki Gap" candle patterns
Returns: (series bool) True when pattern detected
dtgLab(showLabel, labelColor, textColor) Produces "Downside Tasuki Gap" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
risingThree() Detects "Rising Three Methods" candle patterns
Returns: (series bool) True when pattern detected
rtmLab(showLabel, labelColor, textColor) Produces "Rising Three Methods" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
fallingThree() Detects "Falling Three Methods" candle patterns
Returns: (series bool) True when pattern detected
ftmLab(showLabel, labelColor, textColor) Produces "Falling Three Methods" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
risingWindow() Detects "Rising Window" candle patterns
Returns: (series bool) True when pattern detected
rwLab(showLabel, labelColor, textColor) Produces "Rising Window" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
fallingWindow() Detects "Falling Window" candle patterns
Returns: (series bool) True when pattern detected
fwLab(showLabel, labelColor, textColor) Produces "Falling Window" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
kickingBull() Detects "Bullish Kicking" candle patterns
Returns: (series bool) True when pattern detected
kwLab(showLabel, labelColor, textColor) Produces "Bullish Kicking" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
kickingBear() Detects "Bearish Kicking" candle patterns
Returns: (series bool) True when pattern detected
kbLab(showLabel, labelColor, textColor) Produces "Bearish Kicking" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
lls(ratio) Detects "Long Lower Shadow" candle patterns
Parameters:
ratio : (float) A relationship of the lower wick to the overall candle size expressed as a percent. Default is 75%
Returns: (series bool) True when pattern detected
llsLab(showLabel, labelColor, textColor) Produces "Long Lower Shadow" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
lus(ratio) Detects "Long Upper Shadow" candle patterns
Parameters:
ratio : (float) A relationship of the upper wick to the overall candle size expressed as a percent. Default is 75%
Returns: (series bool) True when pattern detected
lusLab(showLabel, labelColor, textColor) Produces "Long Upper Shadow" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
bullNeck() Detects "Bullish On Neck" candle patterns
Returns: (series bool) True when pattern detected
nwLab(showLabel, labelColor, textColor) Produces "Bullish On Neck" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
bearNeck() Detects "Bearish On Neck" candle patterns
Returns: (series bool) True when pattern detected
nbLab(showLabel, labelColor, textColor) Produces "Bearish On Neck" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
soldiers(wickSize) Detects "Three White Soldiers" candle patterns
Parameters:
wickSize : (float) Maximum allowable top wick size throughout pattern expressed as a percent of total candle height. Default is 5%
Returns: (series bool) True when pattern detected
wsLab(showLabel, labelColor, textColor) Produces "Three White Soldiers" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
crows(wickSize) Detects "Three Black Crows" candle patterns
Parameters:
wickSize : (float) Maximum allowable bottom wick size throughout pattern expressed as a percent of total candle height. Default is 5%
Returns: (series bool) True when pattern detected
bcLab(showLabel, labelColor, textColor) Produces "Three Black Crows" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
triStarBull() Detects "Bullish Tri-Star" candle patterns
Returns: (series bool) True when pattern detected
tswLab(showLabel, labelColor, textColor) Produces "Bullish Tri-Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
triStarBear() Detects "Bearish Tri-Star" candle patterns
Returns: (series bool) True when pattern detected
tsbLab(showLabel, labelColor, textColor) Produces "Bearish Tri-Star" identifier label
Parameters:
showLabel : (bool) Shows label when input is true. Default is false
labelColor : (series color) Color of the label border and arrow
textColor : (series color) Text color
Returns: (series label) A label visible at the chart level intended for the title pattern
wrap(cond, barsBack, borderColor, bgcolor) Produces a box wrapping the highs and lows over the look back.
Parameters:
cond : (series bool) Condition under which to draw the box.
barsBack : (series int) the number of bars back to begin drawing the box.
borderColor : (series color) Color of the four borders. Optional. The default is color.gray.
bgcolor : (series color) Background color of the box. Optional. The default is color.gray.
Returns: (series box) A box who's top and bottom are above and below the highest and lowest points over the lookback
topWick() returns the top wick size of the current candle
Returns: (series float) A value equivelent to the distance from the top of the candle body to its high
bottomWick() returns the bottom wick size of the current candle
Returns: (series float) A value equivelent to the distance from the bottom of the candle body to its low
body() returns the body size of the current candle
Returns: (series float) A value equivelent to the distance between the top and the bottom of the candle body
highestBody() returns the highest body of the current candle
Returns: (series float) A value equivelent to the highest body, whether it is the open or the close
lowestBody() returns the lowest body of the current candle
Returns: (series float) A value equivelent to the highest body, whether it is the open or the close
barRange() returns the height of the current candle
Returns: (series float) A value equivelent to the distance between the high and the low of the candle
bodyPct() returns the body size as a percent
Returns: (series float) A value equivelent to the percentage of body size to the overall candle size
midBody() returns the price of the mid-point of the candle body
Returns: (series float) A value equivelent to the center point of the distance bewteen the body low and the body high
bodyupGap() returns true if there is a gap up between the real body of the current candle in relation to the candle prior
Returns: (series bool) true if there is a gap up and no overlap in the real bodies of the current candle and the preceding candle
bodydwnGap() returns true if there is a gap down between the real body of the current candle in relation to the candle prior
Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle
gapUp() returns true if there is a gap down between the real body of the current candle in relation to the candle prior
Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle
gapDwn() returns true if there is a gap down between the real body of the current candle in relation to the candle prior
Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle
dojiBody() returns true if the candle body is a doji
Returns: (series bool) true if the candle body is a doji. Defined by a body that is 5% of total candle size
Bjorgum Key Levels
Key Levels Aims to capture 3 of the most significant points in price action
Breakouts
False Breakouts (Traps)
Back Checks
These 3 points alone, if properly identified, can be some of the most significant points of movement in the price history of an asset and bring significant gains to traders, if capitalized on. Here are a few examples of these setups
Breakouts
Breakouts can bring significant rallies as the market swings one sided after key levels are breached. This entry type can bring large trending runs to follow. Momentum is on your side, but the trade off is a higher entry.
False Breakouts
Also known as a bull trap or a bear trap, false breaks can lead to swift and significant reversals and potential for a large and sudden move to the opposite side. When a key level breakout fails to hold, parties entering to capitalize on the "epic breakout" can get left holding the bag forcing them to exit at a loss, which can double the force of pressure. Traps can bring swift gains from good entry prices. However, price is still in a larger trend against you so momentum is weak, so price action is susceptible to roll over.
Backchecks
Back checks are pull backs in trend that find middle ground to the 2 areas already described. Both momentum and entry price are decent, but risk is defined as a key level has flipped offering entry with stops below demand, or above supply.
Combining these 3 methods helps to diversify risk, understand trend development, and bring steady gains. This script helps to identify these points to traders with analysis of key levels, price structure, and trend direction, while providing visual signals and alerts for when they occur.
Best of luck in your coding and trading and thank you for your support
Bjorgum AutoTrailOne Time Trade Risk Management
Incorporating the new interactive feature, this script is meant as a one time trailing stop for the active trader to manage positional risk of an ongoing trade. As a crypto trader or Fx trader, many may find themselves in a position late into the evening, or perhaps daily life is calling while a trade progresses in their favor. Adding a trailing stop to a position thats trending can help to keep you in the trade and lock in gains if things turn around when you are unable to react.
To use the trail, the user would add the script to the chart. Once added, a set of crosshairs will appear allowing the user to choose a point to begin. Often choosing to start a trail from a swing high/ low can be an ideal option. This tends to provide some protection for a stop by placing it under support for a long trade or above resistance for a short trade.
Price based trail
The trail will automatically plot and the offset is a factor of the distance from price action selected by the crosshairs. If placed above price action the script will plot a short trail, if placed below it will trail for a long position.
Additionally, there are several other trail types other than price based. There is also percent based, which offsets the trail as a percent from close. A hard stop is placed at the cross hair value, then once the distance is exceeded by the percentage specified, the trail begins.
There are 2 more volatility based trails. There is a PSAR trail which can provide quicker and tighter stops that accelerate with the trend locking in gains faster, and an ATR trail that keeps a distance from price action as a function of volatility. Volatility levels can be adjusted from the menu.
Volatility based trail (ATR)
Volatility based trail (PSAR)
Lastly, within the code for more the more technical savvy, is some starting setups for string alerts to be sent to exchanges via 3rd party or custom API applications. Some string manipulation is required for specific providers to meet their requirements, but there is some building block alerts that will take the ticker symbol, recognize the asset your trading (Fx, Crypto, etc) and take input quantity or exchange names from the settings via inputs.
Complex strings can be built to perform almost any trade related task when to comes to alerts via web hook. A little setup this way with some technology to back your system can mean a semi-automated half man, half machine setup that actually manages your trail stop while you cannot. For those that don’t go this far, there is some basic alert functionality that well trigger when a trail is hit so you can react and make a decision.
Please note that for now, interactive mode is engaged only when the script is added to the chart. Additional stops, or for adjustments to be made it is best to add a new version. Also as real trades could be at play managing an actual position, alerts are designed to go off only once to ensure no duplicate orders are sent meaning alerts are not reoccurring. Once an alert is triggered, a new trail is to be set up.
A modified version of the TradingView built in SAR equation was used in this script. To provide the value of the SAR on the stop candle, it was necessary to alter the equation to extract this value as the regular SAR “flips” at this point. Thank you to TradingView for supplying access to the built in formula so that this SAR could behave the same as the built-in function outside of these alterations
Example of SAR value maintained in trigger candle
Cheers and happy trading.
3Commas BotBjorgum 3Commas Bot
A strategy in a box to get you started today
With 3rd party API providers growing in popularity, many are turning to automating their strategies on their favorite assets. With so many options and layers of customization possible, TradingView offers a place no better for young or even experienced coders to build a platform from to meet these needs. 3Commas has offered easy access with straight forward TradingView compatibility. Before long many have their brokers hooked up and are ready to send their alerts (or perhaps they have been trying with mixed success for some time now) only they realize there might just be a little bit more to building a strategy that they are comfortable letting out of their sight to trade their money while they eat, sleep, etc. Many may have ideas for entry criteria they are excited to try, but further questions arise... "What about risk mitigation?" "How can I set stop or limit orders?" "Is there not some basic shell of a strategy that has laid some of this out for me to get me going?"
Well now there is just that. This strategy is meant for those that have begun to delve into the world of algorithmic trading providing a template that offers risk defined positions complete with stops, limit orders, and even trailing stops should one so choose to employ any of these criteria. It provides a framework that is easily manipulated (with some basic working knowledge of pine coding) to encompass ones own ideas and entry criteria, while also providing an already functioning strategy.
The default settings have a basic 1:1 risk to reward ratio, which sets a limit and a stop equal distance from the entry. The entry is a simple MA cross (up for long, down for short). There a variety of MA's to choose from and the user can define the lengths of the averages. The ratio can be adjusted from the menu along with a volatility based adder (ATR) that helps to distance a stop from support or resistance. These values are calculated off the swing low/high of the user defined lookback period. Risk is calculated from position entry to stop, and projected upwards to the limit as a function of the desired risk to reward ratio. Of note: the default settings include 0.05% commissions. Competitive commissions of the leading cryptocurrency exchanges are .1% round trip (one buy and one sell) for market orders. There is also some slippage to allow time for alerts to be sent and orders to fill giving the back test results a more accurate representation of real time conditions. Its recommended to research the going rates for your exchange and set them to default for the strategy you use or build.
To get started a user would:
1) Make a copy of the code and paste in their bot keys in the area provided under the "3Comma Keys" section
- eg. Long bot "start deal" copied from 3commas in to define "Long" etc. (code is commented)
2) Place alert on desired asset with desired settings ensuring to select "Order fills and alert() function calls"
3) Paste webhook into the webhook box and select webhook URL alerts (3rd party provided webhook)
3) Delete contents of alert message box and replace with {{strategy.order.alert_message}} and nothing else
- the codes will be sent to the webhook appropriately as the strategy enters and exits positions. Only 1 alert is needed
settings used for the display image:
1hr chart on BTCUSD
-ATR stop
-Risk adjustment 1.2
-ATR multiplier 1.3
-RnR 0.6
-MAs HEMA/SMA
-MA Length 50/100
-Order size percent of equity
-Trail trigger 60% of target
Experiment with your own settings on your crypto of choice or implement your own code!
Implementing your trailing stop (optional)
Among the options for possible settings is a trailing stop. This stop will ratchet higher once triggered as a function of the Average True Range (ATR). There is a variable level to choose where the user would like to begin trailing the stop during the trade. The level can be assigned with a decimal between 0 and 1 (eg. 0.5 = 50% of the distance between entry and the target which must be exceeded before the trail triggers to begin). This can allow for some dips to occur during the trade possibly keeping you in the trade for longer, while potentially reducing risk of drawdown over time. The default for this setting is 0 meaning unless adjusted, the trail will trigger on entry if the trailing stop exit method is selected. An example can be seen below:
Again, optional as well is the choice to implement a limit order. If one were to select a trailing stop they could choose not to set a limit, which could allow a trail to run further until hit. Drawdowns of this strategy would be foregoing locking gains at highs on target on other trades. This is a trade-off the user can decide on and test. An example of this working in favor can be observed below:
Conclusion
Although a simple strategy is implemented here, the benefits of this script allow a user a starting platform to build their strategies from with built in risk mitigation. This allows the user to sidestep some of the potential difficulties' that can arise while learning Pine and taking on the endeavor of automating their trading strategies. It is meant as an aid, a structure, and an educational piece that can be seen as a "pick-up-and-go" strategy with easy 3Commas compatibility. Additionally, this can help users become more comfortable with strategy alert messages and sending strings in the form of alerts from Pine. As well, FAQs are often littered with questions regarding "strategy.exit" calls, how to implement stops. how to properly set a trailing stop based on ATR, and more. The time this can save an individual to get started is likely of the best "take-aways" here.
Happy trading
Bjorgum MTF MAScope:
Up to 3 MA's can be applied at the users discretion
Choose between 10 different average types including favorites from the Bjorgum series from HEMA to Reversal T3's
Each MA can be independently set
Go Multi-timeframe! Any MA can be set to any timeframe of reference you choose (ex. using 3 different timeframes of higher resolution to your chart reference to establish a multi-time frame trend)
RSI HEATMAP. Use the bar color or the MA color selection toggle to set your color to reference RSI on a gradient. This helps to establish clear visual reference to momentum on top of trend analysis
Assigning RSI bar color to an MA of a higher time frame can allow you to see visual reference of momentum of the greater trend that may be at play.
Example: trying to get short on a 15min while your 1hr and 4hr RSI Heatmap burns deep in oversold.
RSI color can be assigned to the bar color, the MA (1,2 or 3), or both. Alternatively, bar color can be assigned to a more simple rising/ falling MA color and price above/ below the MA for bar color.
ALL MTF FUNCTIONS ARE NON_REPAINTING.
The Idea
The original inspiration behind the script came from an observation of a constant struggle of Pinecoders of both youth or experience to find accurate multi-timeframe indicators that do not repaint, and appear as should on historical bars, while performing reliably in real time. I encourage you to scroll the Pinecoders FAQ on a recent piece explaining the difficulties and caveats of different approaches, but I would like to reference the elimination of the historical bar offset for THIS purpose. MA's are based on closing prices, that is to say they are confirmed and will not change once the bar has closed. There is no need to offset these for historical reference. The purpose of the historical offset is best exemplified, for example, with an intraday strategy involving daily breakouts. Let's entertain going long on a break to a new daily high. We would not know that in real time so we need to reference the previous bars close for BACKTESTING purposes, otherwise we get "lookahead bias". There is no shortage of strategies unintentionally employing this bias out there (I'm sure you have come across them with their unrealistic results).
There is no worry of repainting with the MTF security function included within this script, nor will it offset for something involving lookahead bias. I encourage those that are playing with the code or perhaps writing strategies of their own to borrow the functions within. There is also a function that will return the 10 MA variable selection - yours to keep.
With all that in mind, I wanted a practical script that is easily deployable in everyday trading for the average trader that gives the user a firm grip on their trading steering wheel equipped with the feel of the road. Incorporating several MA's of differing times with the RSI heatmap gives a good visual reference and feel to your trading environment, while offering a level of customization that will fit an individuals personal trading style. The RSI heatmap gradient is per percentage between 30 and 70 and your 2 colors - anything outside of those levels gives you the vibrant bias color
Below I walk through 2 examples of live trades scenarios I made using the mindset the script offers.
The Trade
LONG IZEA
Timeframe: 4hr chart
- 3 Tilson MA's of varying length are deployed at varying intraday time frames
- A bullish pattern in an uptrend offers a possible trade allowing entry from a low risk point from the pattern low
- See the chart for notes and observations using the script
- Notice how the heatmap brightens up as price extends far away from the averages - your risk has elevated for a new position
- Notice the heatmap cool off while price action consolidates sideways
The Trade
SHORT BTCUSDT
Timeframe: 4hr chart
- 3 EMAs are employed - same length (50), with 3 successive timeframe resolutions
- A downtrend is formed with a sharp move to stack the EMAs into layers
- A pull back opportunity presents itself in bearish consolidation
- Notice a Doji star at resistance establishing a swing high as RSI cools off into the EMA dynamic resistance for entry
- An '"equal legs" measured move can be used for a trade target with a stop out above the swing high.
- Again, take note of distance from EMA's, the heatmap in combination with trend development surrounding the MA's
These were just two ideas to show you an example of how to implement some strategy into your trading and to get some interesting use from the indicator. Hope you enjoyed the read and happy trading.
Bjorgum SuperScript
Bjorgum Reversal
Bj Reversal uses Tilson moving averages to identify trend changes
Bars change to yellow as bar close crosses the Tilson moving averages. Blue or red is confirmed as the two Tilson averages themselves cross.
Reversal is great for pinpointing trend change often giving the absolute best entry or exit
Its sensitive nature can mean more false signals on some assets
Be sure to use other indicators from the Bjorgum Collection to confirm signals, or use another strategy that fits the asset or time frame being viewed
Bjorgum HEMA Strategy
Hema uses HA smoothed EMAs to identify trend direction
Default EMA lengths are 5,9, and 21 period
Bar Color will change Malibu or Ruby on a cross of BOTH 5 and 9 EMA
The lengths are customizable to whatever lengths the user desires
Rolando Santos True Relative Movement (TRM)
This underrated momentum strategy conceptualized by Rolando Santos uses 2 indicators to give a 3 color scheme
A leading indicator (RSI) is combined with a lagging indicator (TSI) to produce bar colors based on the condition of each indicator
Both indicators in positive territory produce blue bars
Both indicators in negative bias produce yellow bars
If signals are mixed (one up one down) bars become grey
Speed Selection
The Bjorgum speed selector optimizes the strategy based on the users desires or trading style at the touch of a button
Fast setting is better for swing trades - more timely signals, more whipsaw
Slow setting is better for longer holds or more volatile assets - slower signals, smooths out whipsaw
RSI Bar Color
RSI color changes bar color based on user defined RSI values
Buy/ sell signals are typically given on a cross of the 50 level
Speed selector (fast/Slow) automatically changes lengths between Bj RSI (5 period) and a standard RSI (14 period)
Additional capabilities can be mixed and matched from strategies in the "Strategy Override" section
Add-ons include:
Tilson - The moving average system from Bjorgum Reversal can be toggled to couple with another bar color strategy by clicking this button
PSAR - Parabolic Stop and Reverse indicator can help with trend direction, volatility, and stop losses
HEMA - The 3 moving average system from the HEMA strategy can be coupled with any of the other strategies by clicking "Show HEMA"
Bj Arrows - These arrows plot at the bar level to draw attention to when the BJ TSI is "curling" (See profile for Bjorgum TSI and download today)
-Optional "Plotbar Overlay" plots bars with Heikin-Ashi Inputs when toggled
-This allows for the benefits of price smoothing without sacrificing moving average and indicator performance as real close value is still used
-This can also help on short time frames and improve results with crypto! The user must "mute" the main series candles when in use to avoid candle overlap.
-Optional price line as muting main bars will disable the TradingView default price line. The horizontal plot will track the real closing price while in HA mode!
[SK] Custom Klinger OscillatorThis Custom Klinger Oscillator allows you to change the time frames for the Force Volume and Signal calculations to use instead of it's default values. Although the default Fibonacci values ( 34, 55 and 13 ) provide exceptional signals, you can now explore using lower Fibonacci numbers and get faster signals for your own adventures in the market.
This indicator adds conditional coloring of the Klinger line when over / under the signal along with a transparent fill cloud between both lines colored by the same condition. You can change colors to your preference on the style configurations.
--
Below is more information on the KIinger Oscillator from investopedia:
Interpretations for Price Direction
The Klinger Oscillator is fairly complex to calculate, but it's based on the idea of force volume, which accounts for volume, trend (positive or negative), and temp (based on multiple inputs and if/then statements). Using this data, the oscillator is created by looking at the difference between two exponential moving averages of force volume involving different time frames (typically 34 and 55). The idea is to show how the volume flowing through the securities is impacting its long-term and short-term price direction.
The Signal Line
A signal line (13-period moving average) is used to trigger buy or sell signals. This technique is very similar to signals that are created with other indicators such as the moving average convergence divergence (MACD). While these are the basic signals generated by these indicators, it's important to note that these techniques may generate a lot of trading signals that may not be as effective in sideways markets.
The Uptrend
When an asset is in an overall uptrend—such as when it is above its 100-period moving average and the Klinger is above zero or moving above zero—traders could buy when the Klinger oscillator moves above the signal line from below.
Klinger noted that when a stock was in an uptrend, and then dropped to unusually low levels below zero, and then moved above its signal line, this was a favorable long position to take.
The Downtrend
When an asset is in an overall downtrend, traders could sell or short-sell when the Klinger oscillator moves below the signal line from above. Klinger noted this was especially noteworthy when the indicator had seen an uncharacteristic spike above zero.
The zero line is also used by some traders to mark the transition from an uptrend to downtrend, or vice versa. While such signals won't always agree with price movements, a move above zero helps confirm a rising price, while a drop below zero helps confirm a falling price.
Klinger Oscillator and Divergence
The Klinger oscillator also uses divergence to identify when the indicator's inputs are not confirming the direction of the price move. It's a bullish sign when the value of the indicator is heading upward while the price of the security continues to fall. It is a bearish signal when the price is rising but the indicator is falling. Divergence can be coupled with signal line crossovers to generate trades. For example, if a bearish divergence forms, a sell or short-sell could be initiated the next time the Klinger crosses below the signal line.
Cvwap-Pvwap 2.0A simple vwap based Intraday trend indicator.
Volume-Weighted Average Price (VWAP) - the average price weighted by volume, starts when trading opens and ends when it closes. This can help institutions buy or sell in large orders, without disturbing the market.
After buying or selling, institutions compare instrument price to closing VWAP values at end of the day.
For big financial institutions;
A buy order executed below the VWAP value, considered a good fill because the security was bought at a below average price.
A sell order executed above the VWAP would be deemed a good fill because it was sold at an above average price.
Simple price based moving average is not helpful for them; = as it doesn't incorporates volume traded. Hence - VWAP :)
So how it helps us in decoding the IntraDay-trend? - Through a 2 day vwap co-relation.
So, Closing value of previous day vwap = Pvwap
Today's running vwap = Cvwap
Defining the IntraDay Trend:
Moderately Bullish = candle closing price above Pvwap but below Cvwap
Super Bullish = Closing price is above both (Cvwap and Pvwap)
Moderately Bearish = Closing price is above Cvwap but below Pvwap
Super Bearish = Closing Price is below both (Cvwap and Pvwap)
A big gap between the Cvwap and the candle closing price defines the strong participation from institutions in that direction. (Strong Trend)
Moving with the smart money, in the overall trend is a wise decision for any intraday trader and this helps at its best.
MAST TrendHello Traders !!
This is a simple super trend based MAST trend.
By default the supertrend is 10 period with 3 ATR multiplier.
A moving average is used to benefit from the pullback entries.
Bullish Pullback : Price above Supertrend & below MA
Bullish: Price above Supertrend and above MA
Bearish pullback : Price below Supertrend & above MA
Bearish : Price below Supertrend & below MA
Refer to investopedia or any relevant articles for in detail about Supertrend.
Bjorgum RSIRSI output signals are displayed with color change to reflect the plotted value. This makes evaluating RSI conditions require but a glance.
RSI momentum buy signals are given on the cross of the 50 level, whereas sell signals are given on a fall below.
Default values a 5 period RSI which gives more timely entrances and exits for swing traders. This can be adjusted to the typical 14 period if the viewer desires slower signals.
Bullish and bearish area is shaded to accentuate the signal to the eye.
Excellent results can be found when coupling BJ RSI, with BJ TSI, and the reversal system using all 3 as a complete together simultaneously
Default color changes are plotted as a recorded value falls within the following levels:
RSI < 30 = green
RSI 30-50 = red
RSI 50-70 = blue
RSI 70-80 = yellow
RSI 80-90 = orange
RSI 90-100 = white hot
Bjorgum TSI-This script utilizes simple color changes of the TSI output signals to aid in interpretation of the classic TSI indicator.
-Crosses of the TSI value line and signal line are a bullish or bearish indication. TSI value line is colored green or yellow to help identify that the TSI value line is either dropping or rising, while over or under the signal line.
-This can help anticipate a cross, or significant points in the trend. TSI signal line changes color when rising or falling which can help to identify larger prevailing trends.
-Generally, a rising signal line can be an overall bullish move, while falling more bearish regardless of crosses.
*Resolution function enables multiple overlay for "Multi-timeframe analysis"*
FTSMA - Trend is your frendThis my new solid strategy: if you belive that "TREND IS YOUR FRIEND" this is for you!
I have tested with many pairs and at many timeframes and have profit with just minor changes in settings.
I suggest to use it for intraday trading .
VERY IMPORTANT NOTE: this is a trend following strategy, so the target is to stay in the trade as much as possible. If your trading style is more focused on scalping and/or pullbaks, this strategy is not for you.
This strategy uses moving averages applied to Fourier waves for forecasting trend direction.
How strategy works:
- Buy when fast MA is above mid MA and price is above slow MA, which acts as a trend indicator.
- Sell when fast MA is below mid MA and price is below slow MA, which acts as a trend indicator.
Strategy uses a lot of pyramiding orders because when you are in a flat market phase it will close 1 or 2 orders with a loss, but when a big trend starts, it will have profit in a lot of orders.
So, if you analize carefully the strategy results, you will note that "Percent Profitable" is very low (30% in this case) because strategy opened a lot of orders also in flat markets with small losses, BUT "Avg # bars in winning trades" is very high and overall Profit is very high: when a big trend starts, orders are kept open for long time generating big profits.
Thanks to all pinescripters mentioned in the code for their snippets.
I have also a study with alerts. Next improvement (only to whom is interested to this script and follows me): study with alerts on multiple tickers all at one. Leave a comment if you want to have access to study.
HOW TO USE STRATEGY AND STUDY TOGHETER:
1- Add to chart the strategy first, so your workspace will be as clean as possible.
2- Open the Strategy Tester tab at footer of the page.
3- Modify settings to get best results (Profit, Profit Factor, Drawdown).
4- Add study with alerts to your chart with same setting of strategy.
I WILL PROVIDE A DETAILED QUICK INSTALLATION GUIDE WITH THE STUDY!
Please use comment section for any feedback or contact me if you need support.
BEST IVFTHello traders
This is a Pine adaptation of this FXCM LUA indicator
Seems to be made mostly for tick data (< 1 min timeframe) and advanced scalpers
Always interesting to see that Pinescript is much easier than most of other trading programming languages out there :)
PS
You might like checking the data window panel from TradingView and mouseover your cursor on the chart. It will update the debug/historical data in real-time
imgur.com
Best,
Dave
BEST Supertrend CCIHello traders
Today I present you a Supertrend not based on candle close but based on a CCI (Commodity Channel Index)
How does it work?
Bull event: CCI crossing over the 0 line
Bear event: CCI crossing below the 0 line
When the event is triggered, the script will plot the Supertrend as follow
UP Trend = High + ATR * Factor
DOWN Trend = Low - ATR * Factor
This is an alternative of the classical Supertrend based on candle close being above/beyond the previous Supertrend level.
Hope you'll enjoy it and it will improve your trading making you a better trader
Dave
CCI Stochastic and a quick lesson on Scalping & Trading SystemsHello traders
Still on holidays but I don't and will never forget you <3
I realize more and more that you guys don't only want some indicators and learn about pinescript. You also want some guidance and get some mentors providing you with comprehensive and simple trading methods and tricks.
I'm against those posting many scripts a day that in the end will make you lose your money because they don't give you the methodology to use them
It might look nice on the charts but we're not here to do some painting.... but to improve our lifestyle right :)
The today indicator is based on an indicator that I used for scalping : Fxcodebase CCI Stochastic
A CCI stochastic is very reactive and allows us to take many scalps trades per day with a few pips/USD gain for each trade. I don't recommend novice traders to use it and I strongly recommend everyone reading my disclaimer below basically saying "I'm not a financial advisor, don't be dumb, stay safe"
(I also recommend the few scripts copy-pasters to read my disclaimer as well)
What's a novice trader, sir? Well... thanks for asking. A novice trader is any trader with less than 5 years of live trading experience
From a pinescript perspective, this script will be however interesting for everyone :)
How to use it?
The indicator gives 3 possible entries for Longs and Shorts:
- Arrows at Enter - Will give signals whenever the Stoch CCI will enter in the BUY/SELL zone
- Arrows at Exit - Will give signals whenever the Stoch CCI will exit the BUY/SELL zone
- Arrows at Center - Signals whenever the Stoch CCI will cross the mid-line (50)
All arrows have different colors because ... painting is cool and nice.... kidding.... it gives clearer and more readable signals on the chart (but painting sir...)
A possible trading method could be to use the 3 modes at the same time to get the maximum of opportunities.
The safer bet is to use the "Arrows at Exit" only mode but for those who want to accumulate more scalping positions, adding the "Arrows at Enter" mode is an option as well. In other words, you accumulate a few scalping positions whenever the Stoch CCI get in the BUY/SELL zone and will stop accumulating whenever it will exit the BUY/SELL zone
You can add a few extra positions whenever the Stoch CCI will cross the mid-line as it often translates in a trend continuation
Life hack
Very important note : (probably the most important gem I shared until now) The inputs set by default will have to be changed for your asset/timeframe and can't be generic for everything. You have to play with the inputs until the signals will make sense to you
The indicator/strategy with a unique configuration that you'll never check or update according to the market condition DOES NOT exit.
If you find such a tool and prove me that you're making constant gains with it over a year, please patent it and then show it to me as I'd like to study it to replicate :) But most likely this is a myth/unicorn
Who I am to say this? Well, I worked in a Bank with real traders and I have a good sense of what works and what will certainly not work
My guru said scalping crypto in 1 second timeframe was the way to get rich quick. Do you agree sir?
But in trading, this is not because you take the maximum of trades possible that your gains will increase. This is the contrary.
There is a strong and proven inverse correlation between the number of trades taken and how fast you'll burn your capital. A swing trader taking 2/3 trades a month is more likely to beat 99% of the scalpers out there trying to predict all market movements. (and I'm not even talking about how dangerous it is to scalp with leverage)
You're starting to know me a bit more right now. I prefer to tell you what you need to hear vs what you want to hear because the second option doesn't allow to stay in the game very long.
I might lose some futures clients along the way by saying that but for my own conscience and ethics, I prefer to warn about the true risks of trading and to select who you listen very carefully (the advice also works for me, if you feel what I said doesn't make sense, this is totally your right but I hope this is because I'm french and not because of the content ^^).
See you tomorrow for another indicator or idea
Love you all
Dave
____________________________________________________________
Be sure to hit the thumbs up. Building those indicators take a lot of time and likes are always rewarding for me :) (tips are accepted too)
- If you want to suggest some indicators that I can develop and share with the community, please use my personal TRELLO board
- I'm an officially approved PineEditor/LUA/MT4 approved mentor on codementor. You can request a coaching with me if you want and I'll teach you how to build kick-ass indicators and strategies
Jump on a 1 to 1 coaching with me
- You can also hire for a custom dev of your indicator/strategy/bot/chrome extension/python
Disclaimer:
Trading involves a high level of financial risk, and may not be appropriate because you may experience losses greater than your deposit. Leverage can be against you.
Do not trade with capital that you can not afford to lose. You must be aware and have a complete understanding of all the risks associated with the market and trading. We can not be held responsible for any loss you incur.
Trading also involves risks of gambling addiction.
Please notice I do not provide financial advice - my indicators, strategies, educational ideas are intended to provide only some source code for anyone interested in improving their trading
The proprietary indicators and strategies developed by Best Trading Indicator, the object of intellectual property rights are and remain the exclusive property of Best Trading Indicator, at the exclusion of images and videos and texts free of rights or provided by the Company or external legal or physical person.
No assignment of intellectual property rights is carried out through these Terms and Conditions.
Any total or partial reproduction, modification or use of these properties for any reason whatsoever is strictly prohibited without the express written authorization of the Company.
Fractal Adaptive Moving Average (real one)Ignore the other one (it contains some errors).
On this FRAMA you can play with length, SC and FC.
Just read on below links to understand more about this super useful moving average:
etfhq.com
etfhq.com
www.quantshare.com
