Percentile Rank Market FilterA simple script to filter bull and bear markets by using percentile rank filter. Using market regimes to filter by bull/bear/sideways markets helps to understand how your strategy will
behave in various market regimes and allows you to avoid unprofitable regimes and only trade in profitable ones.
The idea of market regime filtering is used in the most successful technical algorithmic trading strategies, as one should always design a trading strategy with a particular market in mind according to trading legend, Larry Connors
Feel free to use this script in your strategies to improve your profits and lower drawdowns.
Search in scripts for "algo"
14/28 Day SMA Divergence and RSI - No RepaintIf you are interested in purchasing my algorithmic trading bot that receives Tradingview indicator alerts via email and then executes them in Bittrex, please visit my product page here: ilikestocks.com Additionally, I would love to create video/blog guides on creating Tradingview scripts or strategies. If you are a knowledgeable in finance or other related fields and would like to be featured on my page, please contact me at tanner@ilikestocks.com.
No crossovers were used in this script, and this is likely the reason for the no repaint(Correct me if wrong).
This strategy script uses a 14-day SMA signal line, a 28-day SMA and RSI. The strategy works by determining whether the (14-day SMA is above the 28-day SMA and the RSI levels are overbought(below 30)) or RSI is very overbought(below 13 or so). Once either of these conditions have been met, a long position is opened.
The initial long position must be partially closed by the take profit first and then the final close is executed if the 14-day signal SMA is below the 28-day SMA; you may also exclusively use take profit to close positions.
The green plotted spikes are the initial long position conditions. The orange plotted spikes are take profit signals once a long position is opened. The red plotted spikes are plotted when the SMA 14-day is below the 28-day SMA.
Please do leave constructive criticism or comments below because it helps me better create scripts!
Harish algo for nifty and bankniftyHarish algo for nifty and banknifty
Overview
Harish Algo - Buy and Sell 11 is a powerful trading indicator designed for intraday traders, incorporating multiple technical analysis concepts to identify potential breakout and breakdown levels. It uses pivot points, exponential moving averages (EMAs), and volatility-based levels to generate buy and sell signals with visual markers for better decision-making.
Features & Functionality
✅ Pivot Points Calculation:
The indicator calculates daily pivot points along with resistance (R1) and support (S1) levels.
Helps in identifying potential reversal or breakout areas.
✅ EMA Trend Confirmation:
Uses three EMAs (21, 55, and 200) to confirm trend direction.
Ensures that buy signals align with uptrends and sell signals align with downtrends.
✅ 15-Minute Candle Analysis for Precision:
Captures the last three 15-minute closes of the previous day.
Computes an average and determines volatility-based price levels to anticipate price movements.
✅ Dynamic Buy & Sell Signals:
Bullish (Buy) Signals:
Price breaks above key resistance levels and EMAs confirm an uptrend.
Displayed as yellow (tiny) or green (small) upward triangles below candles.
Bearish (Sell) Signals:
Price drops below key support levels with EMA confirmation of a downtrend.
Displayed as fuchsia (tiny) or red (small) downward triangles above candles.
✅ Alerts for Trade Execution:
Get notified instantly with alerts when a buy or sell signal is triggered.
✅ Customizable Settings:
Modify EMA lengths and adjust parameters to fit different trading strategies.
Usage & Benefits
🔹 Helps traders identify potential entry and exit points with precision.
🔹 Reduces false signals by combining pivot points, EMAs, and price action.
🔹 Works best for intraday traders in the Indian stock markets, but can be applied to other markets as well.
🔹 Suitable for both beginners and experienced traders looking for a structured approach to trading.
How to Use
Add the indicator to your chart.
Observe the plotted pivot points, EMAs, and price levels.
Watch for triangle markers (buy/sell signals).
Use alerts to receive real-time notifications.
Combine with your own risk management strategy for best results.
🔹 Works on all timeframes but optimized for intraday trading.
Disclaimer
📢 This indicator is for educational purposes only and should not be considered financial advice. Always perform your own analysis before taking trades.
PIP Algorithm
# **Script Overview (For Non-Coders)**
1. **Purpose**
- The script tries to capture the essential “shape” of price movement by selecting a limited number of “key points” (anchors) from the latest bars.
- After selecting these anchors, it draws straight lines between them, effectively simplifying the price chart into a smaller set of points without losing major swings.
2. **How It Works, Step by Step**
1. We look back a certain number of bars (e.g., 50).
2. We start by drawing a straight line from the **oldest** bar in that range to the **newest** bar—just two points.
3. Next, we find the bar whose price is *farthest away* from that straight line. That becomes a new anchor point.
4. We “snap” (pin) the line to go exactly through that new anchor. Then we re-draw (re-interpolate) the entire line from the first anchor to the last, in segments.
5. We repeat the process (adding more anchors) until we reach the desired number of points. Each time, we choose the biggest gap between our line and the actual price, then re-draw the entire shape.
6. Finally, we connect these anchors on the chart with red lines, visually simplifying the price curve.
3. **Why It’s Useful**
- It highlights the most *important* bends or swings in the price over the chosen window.
- Instead of plotting every single bar, it condenses the information down to the “key turning points.”
4. **Key Takeaway**
- You’ll see a small number of red line segments connecting the **most significant** points in the price data.
- This is especially helpful if you want a simplified view of recent price action without minor fluctuations.
## **Detailed Logic Explanation**
# **Script Breakdown (For Coders)**
//@version=5
indicator(title="PIP Algorithm", overlay=true)
// 1. Inputs
length = input.int(50, title="Lookback Length")
num_points = input.int(5, title="Number of PIP Points (≥ 3)")
// 2. Helper Functions
// ---------------------------------------------------------------------
// reInterpSubrange(...):
// Given two “anchor” indices in `linesArr`, linearly interpolate
// the array values in between so that the subrange forms a straight line
// from linesArr to linesArr .
reInterpSubrange(linesArr, segmentLeft, segmentRight) =>
float leftVal = array.get(linesArr, segmentLeft)
float rightVal = array.get(linesArr, segmentRight)
int segmentLen = segmentRight - segmentLeft
if segmentLen > 1
for i = segmentLeft + 1 to segmentRight - 1
float ratio = (i - segmentLeft) / segmentLen
float interpVal = leftVal + (rightVal - leftVal) * ratio
array.set(linesArr, i, interpVal)
// reInterpolateAllSegments(...):
// For the entire “linesArr,” re-interpolate each subrange between
// consecutive breakpoints in `lineBreaksArr`.
// This ensures the line is globally correct after each new anchor insertion.
reInterpolateAllSegments(linesArr, lineBreaksArr) =>
array.sort(lineBreaksArr, order.asc)
for i = 0 to array.size(lineBreaksArr) - 2
int leftEdge = array.get(lineBreaksArr, i)
int rightEdge = array.get(lineBreaksArr, i + 1)
reInterpSubrange(linesArr, leftEdge, rightEdge)
// getMaxDistanceIndex(...):
// Return the index (bar) that is farthest from the current “linesArr.”
// We skip any indices already in `lineBreaksArr`.
getMaxDistanceIndex(linesArr, closeArr, lineBreaksArr) =>
float maxDist = -1.0
int maxIdx = -1
int sizeData = array.size(linesArr)
for i = 1 to sizeData - 2
bool isBreak = false
for b = 0 to array.size(lineBreaksArr) - 1
if i == array.get(lineBreaksArr, b)
isBreak := true
break
if not isBreak
float dist = math.abs(array.get(linesArr, i) - array.get(closeArr, i))
if dist > maxDist
maxDist := dist
maxIdx := i
maxIdx
// snapAndReinterpolate(...):
// "Snap" a chosen index to its actual close price, then re-interpolate the entire line again.
snapAndReinterpolate(linesArr, closeArr, lineBreaksArr, idxToSnap) =>
if idxToSnap >= 0
float snapVal = array.get(closeArr, idxToSnap)
array.set(linesArr, idxToSnap, snapVal)
reInterpolateAllSegments(linesArr, lineBreaksArr)
// 3. Global Arrays and Flags
// ---------------------------------------------------------------------
// We store final data globally, then use them outside the barstate.islast scope to draw lines.
var float finalCloseData = array.new_float()
var float finalLines = array.new_float()
var int finalLineBreaks = array.new_int()
var bool didCompute = false
var line pipLines = array.new_line()
// 4. Main Logic (Runs Once at the End of the Current Bar)
// ---------------------------------------------------------------------
if barstate.islast
// A) Prepare closeData in forward order (index 0 = oldest bar, index length-1 = newest)
float closeData = array.new_float()
for i = 0 to length - 1
array.push(closeData, close )
// B) Initialize linesArr with a simple linear interpolation from the first to the last point
float linesArr = array.new_float()
float firstClose = array.get(closeData, 0)
float lastClose = array.get(closeData, length - 1)
for i = 0 to length - 1
float ratio = (length > 1) ? (i / float(length - 1)) : 0.0
float val = firstClose + (lastClose - firstClose) * ratio
array.push(linesArr, val)
// C) Initialize lineBreaks with two anchors: 0 (oldest) and length-1 (newest)
int lineBreaks = array.new_int()
array.push(lineBreaks, 0)
array.push(lineBreaks, length - 1)
// D) Iteratively insert new breakpoints, always re-interpolating globally
int iterationsNeeded = math.max(num_points - 2, 0)
for _iteration = 1 to iterationsNeeded
// 1) Re-interpolate entire shape, so it's globally up to date
reInterpolateAllSegments(linesArr, lineBreaks)
// 2) Find the bar with the largest vertical distance to this line
int maxDistIdx = getMaxDistanceIndex(linesArr, closeData, lineBreaks)
if maxDistIdx == -1
break
// 3) Insert that bar index into lineBreaks and snap it
array.push(lineBreaks, maxDistIdx)
array.sort(lineBreaks, order.asc)
snapAndReinterpolate(linesArr, closeData, lineBreaks, maxDistIdx)
// E) Save results into global arrays for line drawing outside barstate.islast
array.clear(finalCloseData)
array.clear(finalLines)
array.clear(finalLineBreaks)
for i = 0 to array.size(closeData) - 1
array.push(finalCloseData, array.get(closeData, i))
array.push(finalLines, array.get(linesArr, i))
for b = 0 to array.size(lineBreaks) - 1
array.push(finalLineBreaks, array.get(lineBreaks, b))
didCompute := true
// 5. Drawing the Lines in Global Scope
// ---------------------------------------------------------------------
// We cannot create lines inside barstate.islast, so we do it outside.
array.clear(pipLines)
if didCompute
// Connect each pair of anchors with red lines
if array.size(finalLineBreaks) > 1
for i = 0 to array.size(finalLineBreaks) - 2
int idxLeft = array.get(finalLineBreaks, i)
int idxRight = array.get(finalLineBreaks, i + 1)
float x1 = bar_index - (length - 1) + idxLeft
float x2 = bar_index - (length - 1) + idxRight
float y1 = array.get(finalCloseData, idxLeft)
float y2 = array.get(finalCloseData, idxRight)
line ln = line.new(x1, y1, x2, y2, extend=extend.none)
line.set_color(ln, color.red)
line.set_width(ln, 2)
array.push(pipLines, ln)
1. **Data Collection**
- We collect the **most recent** `length` bars in `closeData`. Index 0 is the oldest bar in that window, index `length-1` is the newest bar.
2. **Initial Straight Line**
- We create an array called `linesArr` that starts as a simple linear interpolation from `closeData ` (the oldest bar’s close) to `closeData ` (the newest bar’s close).
3. **Line Breaks**
- We store “anchor points” in `lineBreaks`, initially ` `. These are the start and end of our segment.
4. **Global Re-Interpolation**
- Each time we want to add a new anchor, we **re-draw** (linear interpolation) for *every* subrange ` [lineBreaks , lineBreaks ]`, ensuring we have a globally consistent line.
- This avoids the “local subrange only” approach, which can cause clustering near existing anchors.
5. **Finding the Largest Distance**
- After re-drawing, we compute the vertical distance for each bar `i` that isn’t already a line break. The bar with the biggest distance from the line is chosen as the next anchor (`maxDistIdx`).
6. **Snapping and Re-Interpolate**
- We “snap” that bar’s line value to the actual close, i.e. `linesArr = closeData `. Then we globally re-draw all segments again.
7. **Repeat**
- We repeat these insertions until we have the desired number of points (`num_points`).
8. **Drawing**
- Finally, we connect each consecutive pair of anchor points (`lineBreaks`) with a `line.new(...)` call, coloring them red.
- We offset the line’s `x` coordinate so that the anchor at index 0 lines up with `bar_index - (length - 1)`, and the anchor at index `length-1` lines up with `bar_index` (the current bar).
**Result**:
You get a simplified representation of the price with a small set of line segments capturing the largest “jumps” or swings. By re-drawing the entire line after each insertion, the anchors tend to distribute more *evenly* across the data, mitigating the issue where anchors bunch up near each other.
Enjoy experimenting with different `length` and `num_points` to see how the simplified lines change!
Han Algo - Moving average strategyHan Algo Indicator Strategy Description
Overview:
The Han Algo Indicator is designed to identify trend directions and signal potential buy and sell opportunities based on moving average crossovers. It aims to provide clear signals while filtering out noise and minimizing false signals.
Indicators Used:
Moving Averages:
200 SMA (Simple Moving Average): Used as a long-term trend indicator.
100 SMA: Provides a medium-term perspective on price movements.
50 SMA: Offers insights into shorter-term trends.
20 SMA: Provides a very short-term perspective on recent price actions.
Trend Identification:
The indicator identifies the trend based on the relationship between the closing price (close) and the 200 SMA (ma_long):
Uptrend: When the closing price is above the 200 SMA.
Downtrend: When the closing price is below the 200 SMA.
Sideways: When the closing price is equal to the 200 SMA.
Buy and Sell Signals:
Buy Signal: Generated when transitioning from a downtrend to an uptrend (buy_condition):
Displayed as a green "BUY" label above the price bar.
Sell Signal: Generated when transitioning from an uptrend to a downtrend (sell_condition):
Displayed as a red "SELL" label below the price bar.
Signal Filtering:
Signals are filtered to prevent consecutive signals occurring too closely (min_distance_bars parameter):
Ensures that only significant trend reversals are captured, minimizing false signals.
Visualization:
Background Color:
Changes to green for uptrend and red for downtrend (bgcolor function):
Provides visual cues for current market sentiment.
Usage:
Traders can customize the indicator's parameters (long_term_length, medium_term_length, short_term_length, very_short_term_length, min_distance_bars) to align with their trading preferences and timeframes.
The Han Algo Indicator helps traders make informed decisions by highlighting potential trend reversals and aligning with market trends identified through moving average analysis.
Disclaimer:
This indicator is intended for educational purposes and as a visual aid to support trading decisions. It should be used in conjunction with other technical analysis tools and risk management strategies.
Rocket Grid Algorithm - The Quant ScienceThe Rocket Grid Algorithm is a trading strategy that enables traders to engage in both long and short selling strategies. The script allows traders to backtest their strategies with a date range of their choice, in addition to selecting the desired strategy - either SMA Based Crossunder or SMA Based Crossover.
The script is a combination of trend following and short-term mean reversing strategies. Trend following involves identifying the current market trend and riding it for as long as possible until it changes direction. This type of strategy can be used over a medium- to long-term time horizon, typically several months to a few years.
Short-term mean reversing, on the other hand, involves taking advantage of short-term price movements that deviate from the average price. This type of strategy is usually applied over a much shorter time horizon, such as a few days to a few weeks. By rapidly entering and exiting positions, the strategy seeks to capture small, quick gains in volatile market conditions.
Overall, the script blends the best of both worlds by combining the long-term stability of trend following with the quick gains of short-term mean reversing, allowing traders to potentially benefit from both short-term and long-term market trends.
Traders can configure the start and end dates, months, and years, and choose the length of the data they want to work with. Additionally, they can set the percentage grid and the upper and lower destroyers to manage their trades effectively. The script also calculates the Simple Moving Average of the chosen data length and plots it on the chart.
The trigger for entering a trade is defined as a crossunder or crossover of the close price with the Simple Moving Average. Once the trigger is activated, the script calculates the total percentage of the side and creates a grid range. The grid range is then divided into ten equal parts, with each part representing a unique grid level. The script keeps track of each grid level, and once the close price reaches the grid level, it opens a trade in the specified direction.
The equity management strategy in the script involves a dynamic allocation of equity to each trade. The first order placed uses 10% of the available equity, while each subsequent order uses 1% less of the available equity. This results in the allocation of 9% for the second order, 8% for the third order, and so on, until a maximum of 10 open trades. This approach allows for risk management and can help to limit potential losses.
Overall, the Rocket Grid Algorithm is a flexible and powerful trading strategy that can be customized to meet the specific needs of individual traders. Its user-friendly interface and robust backtesting capabilities make it an excellent tool for traders looking to enhance their trading experience.
tvbot Trend Following with Mean Reversion algoDefault settings are for the ETHUSDT 5 min Binance Chart regular candles.
Back test Default settings are 10,000 usd to start, Commission 0.075%, capital deployment per position is 10%, slippage value of 1.
This algo uses the EMA to set the trend line . You are also able to turn the trend line into a range instead of just a static line. The algo uses the VWMA to set the base entry parameters. When a candle closes above or below the VWMA it will record that price and then wait for the VWMA to meet the candle close price. When that happens the Base entry condition is met. (it causes the vwma to create a hook like structure. essentially tell you that the momentum has changed directions.)
The algo will always check to see if the trend line has either breached or has been tested and held. If this condition has been met it will then go to the base entry condition to check to see if the momentum has changed.
There is a mean reversion component in this algo as well. When the price has moved away from the mean(set by user) by a certain amount the algo will start to look for a top or bottom. Once that condition has been met it will then use the base entry condition to look for a change in momentum, but the mean reversion base entry condition uses the HMA to check for a change in momentum.
This algo effectively looks like a hamburger. Mean reversion being the tops and bottoms(bun) and the trend following(beef patty)
[Fedra Algotrading LR + TTP Indicator Lite]How it works?
- It calculates the linear regression of the last X candles and define a range based on a linear regression deviation (represented by the 3 parallel lines over the last candle).
-Open trades based on the breakout of the deviation of the linear regression (represented by the yellow triangle).
-Advanced trend filter to not open trades against the trend consist in 2 SMA cross and and a few other conditions, including sptionally super trend (Represented by the red and green background).
-Percentage take profit (represented by the horizontal green line. configurable)
-Percentage stop loss (represented by the horizontal red line. Configurable
-Break even when a trade has already opened and there is a change of trend. Calculated in 1.5% when the price is under the yellow SMA.
Alerts in each case to receive notifications (BUY & SELL, TP BE SL).
Added labels with entry price and PnL of each closed trade to facilitate optimization
Daily Algo LevelsQuickly plot stoo's algo levels. Gives option to expand range based on algo error formula. Gives option to display suggested entry points.
FUNCTION: Goertzel algorithm -- DFT of a specific frequency binThis function implements the Goertzel algorithm (for integer N).
The Goertzel algorithm is a technique in digital signal processing (DSP) for efficient evaluation of the individual terms of the discrete Fourier transform (DFT).
In short, it measure the power of a specific frequency like one bin of a DFT, over a rolling window (N) of samples.
Here you see an input signal that changes frequency and amplitude (from 7 bars to 17). I am running the indicator 3 times to show it measuring both frequencies and one in between (13). You can see it very accurately measures the signals present and their power, but is noisy in the transition. Changing the block len will cause it to be more responsive but noisier.
Here is a picture of the same signal, but with white noise added.
If you have a cycle you think is present you could use this to test it, but the function is designed for integration in to more complicated scripts. I think power is best interrupted on a log scale.
Given a period (in bars or samples) and a block_len (N in Goertzel terminology) the function returns the Real (InPhase) and Quadrature (Imaginary) components of your signal as well as calculating the power and the instantaneous angle (in radians).
I hope this proves useful to the DSP folks here.
Patient Trendfollower (7)(alpha) Backtesting AlgorithmThis is an alpha version of backtesting algorithm for my Patient Trendfollower (7) strategy. It can help you adapt the indicator to other charts than EURUSD. Please bear in mind that price action, volume profiles and supzistences are a catalyst for successful trading, not an indicator. You can get significantly better results if you use these things in your trading and use Trendfollower only as a secondary tool.
Patient Trendfollower Indicator
Thanks belongs to @everget and Satik FX, their contributions are highlighted on an indicator page.
Forex Master v2.0 (EUR/USD)This is version 2 of my Forex Master algorithm originally posted here:
BACKTEST CONDITIONS:
Initial equity = $100,000 (no leverage)
Order size = 100% of equity
Pyramiding = disabled
TRADING RULES:
Long entry = EMA5(RSI20) cross> 50
Profit limit = 50 pips
Stop loss = 50 pips
Short entry = EMA5(RSI20) cross< 50
Profit limit = 50 pips
Stop loss = 50 pips
Long entry = Short exit
Short entry = long exit
DISCLAIMER: None of my ideas and posts are investment advice. Past performance is not an indication of future results. This strategy was constructed with the benefit of hindsight and its future performance cannot be guaranteed.
Daily Single Trade [SMRT Algo]The Daily Single Trade Indicator by SMRT Algo is a powerful yet simple tool designed for traders who value precision, discipline, and a focus on high-quality trade setups. With a unique approach, this indicator identifies just one signal daily, making it ideal for traders who prefer a structured and stress-free trading routine.
Please note that this indicator only works for timeframes below 1H.
Key Features:
Market Open & Pre-Market Analysis: The indicator focuses on the market’s opening range and identifies breakout opportunities based on price action during these critical periods.
Customizable Risk-Reward Ratio: Plan your trades with precision by setting your desired RR, ensuring that your take-profit (TP) levels are multiples of your stop-loss (SL). Stop loss is not shown with this indicator.
Price Offset for SL: Add a customizable buffer to your SL and TP levels. This offset accounts for market volatility, reducing the chances of premature stop-outs while maintaining alignment with your trading plan.
Increasing this value will lead to a greater invisible stop loss, which will increase the TP size. The opposite is occurs when decreasing this value (less than 0). If you set it as 2.5 for example for TSLA: price is 340 and SL is 330 for example, SL becomes 327.5. This calculation will then be applied to calculate the TP.
In simple terms, if the offset is positive, SL becomes larger, TP becomes larger as well.
Exit Point Visibility: Display exit points on your chart to better visualize trade targets and stop levels.
Adjustable Market Open Time: Easily modify the market open hour and minute to suit your asset’s trading session. For example, U.S. stock traders can set the market open time to 9:30 AM EST (UTC-5).
By providing a single signal each day, the indicator minimizes overtrading and keeps your focus on the best opportunities.
With predefined SL, TP, and RR settings, the indicator fosters disciplined trading, reducing the influence of emotional decision-making. Whether you’re trading stocks, indices, or forex, the customizable market open time and RR ratio make this indicator versatile and adaptable.
The combination of precise SL and TP calculations with offset pip adjustments helps protect your trades from market noise while maintaining a favorable RR.
Perfect for those who can’t monitor markets all day, the single-signal approach allows you to execute a high-quality trade and move on with your day.
How to Use:
Set the Market Open Time: Adjust the open time to align with your asset’s session. For example, set 9:30 AM EST for U.S. stocks.
Define Your Risk-Reward Ratio: Choose an RR multiple (e.g., 1:2 or 1:3) that aligns with your risk tolerance and trading goals.
Apply Pip Offset: Add a buffer to your SL and TP to account for market volatility and reduce false stops.
The Daily Single Trade Indicator simplifies trading by focusing on one high-probability setup per day. It’s perfect for traders looking to maintain consistency, improve risk management, and reduce the stress of overanalyzing the markets.
How Alerts Work:
Individual Alerts: Set separate notifications for specific actions, such as breakout signals, take-profit levels, or stop-loss activations.
Master Alert: Manage all notifications with one streamlined setting, ensuring you never miss an opportunity while keeping your setup simple and efficient.
Take control of your trading with a strategy built for clarity, precision, and success!
Harish Algo 2The script "Harish Algo 2" is a Pine Script-based TradingView indicator that automatically identifies significant trendlines based on fractal points and tracks price interactions with those trendlines. Key features include:
Fractal Detection: The script identifies fractal highs and lows, using a configurable fractal period, to serve as pivot points for generating trendlines. Fractal highs are marked in blue, and fractal lows are marked in red.
Dynamic Trendlines: It draws trendlines between consecutive fractal points, with a limit on the maximum number of active trendlines. The trendlines can be extended either in both directions or to the right, as per user input. The line width can also be customized.
Support/Resistance Counting: Each trendline tracks how many times the price interacts with it. If the price approaches the line from above and touches or stays near it, the line is considered a support. If the price approaches from below, it is considered a resistance. These counts are used to modify the trendline's color and appearance.
Trendlines with 2 support interactions turn green.
Trendlines with 2 resistance interactions turn red.
Trendlines with 3 or more interactions turn black.
Trendline Styling: Trendlines that extend over a long period (more than 100 bars) change to a dotted style to highlight their persistence.
Break Detection: The script monitors if the price crosses a trendline, signaling a potential breakout or breakdown. Once a trendline is broken, it stops extending further.
Trendline Removal: The script ensures that only a limited number of trendlines are active at a time. If the maximum number of trendlines is reached, the oldest trendline is removed to make space for new ones.
This indicator is designed to help traders visualize important trendlines, spot potential support and resistance levels, and detect breakouts or breakdowns based on price movement.
DTFX Algo Zones [LuxAlgo]DTFX Algo Zones are auto-generated Fibonacci Retracements based on market structure shifts.
These retracement levels are intended to be used as support and resistance levels to look for price to bounce off of to confirm direction.
🔶 USAGE
Due to the retracement levels only being generated from identified market structure shifts, the retracements are confined to only draw from areas considered more important due to the technical Break of Structure (BOS) or Change of Character (CHoCH).
The simple action that causes a market structure shift occurs is price breaking above or below a specific swing point. When a market structure shift happens, a retracement is drawn from the point of break to the highest or lowest point since that point. Due to the price action necessary for a market structure shift, these retracements will not always be immediately actionable.
These retracement levels are intended to be used as points to watch for price to retrace to and bounce from, confirming the current direction of price.
In the example below, after the retracement is initiated, by bouncing off of the retracement levels formed from the previous market structure shift it would further confirm the bias of the market structure shift. A break going through these levels would display a weakness from the current market structure shift, implying that it could simply be noise.
🔶 DETAILS
The script uses standard SMC Market structure identification to determine Break of Structures (BOS) and Change of Characters (CHoCH). The specific swing points can be identified by the shapes placed above or below the specific swing high/low candle.
By unchecking the "Display All Zones" setting, users are able to specify the exact number of retracement zones to display using the "Show Last" parameter. This is handy for cleaning up the chart to stay focused on the most recent retracements.
Additionally, when displaying multiple zones, the "Clean-Up Level Overlap" setting may be helpful for decluttering as well. This option optimizes the display of retracement levels to minimize their overlap on other adjacent zones.
The script allows for up to 5 Fib levels to be displayed from each zone, with options for display, value, line style, and color for each of the 5.
The calculation for Fib Levels changes depending on the direction of market structure shifts. When an upwards (Bullish) zone is generated, the retracement is drawn with the bottom of the zone being 0 and the top of the zone being 1. This is reversed for downwards (Bearish) zones.
🔶 SETTINGS
Structure Length: Sets the SMC structure length to use for finding MMS.
Show Last: Displays this number of retracement zones. (Display All Zones Must be Unchecked)
Display All Zones: Ignores "Show Last" number and displays all historical MMS Retracement Zones.
Zone Display: Choose which zones to display, only bearish, only bullish, or both.
Clean-Up Level Overlap: Minimizes overlap between adjacent zones and levels.
Fib Levels: Settings to display and customize up to 5 Fib levels for each zone.
EHRHART Algo Premium (V.2)EHRHART Algo Premium is a indicator designed to help traders analyze market flow. It work with multiple EMA for identifying the sentiment of market. It's very simple calculation but it's a good help for people who use price action. I think the visual of the chart is very important and and I wanted to create an indicator very visual. I'm price action lover like lots of people and I personally think it's very important to identify the flow of market because buying when the flow of market is up give you better chance to win your trade. It's not BUY and SELL signal, this indicator don't tell u when u need buy or when u need sell, it's principally here for helping the visual of trading chart (have a good clear chart). I decided to post this indicator because people were asking me how it worked and were curious about these colors, so here we go !
This indicator show:
The main flow ( green candle=buy pressure /red candle=seller pressure ), it's based on two EMA cross over, this two EMA are editable so u can take the combination you want depending on your trading strategy. When the first EMA is above the second EMA candle becoming green and when the second EMA is above the first EMA candle becoming red.
The trend of two EMA crossover (blue=bullish and violet=bearish), it's based on two EMA (two different than main flow) cross over, this two EMA are editable so u can take the combination you want depending on your trading strategy. When the first EMA is above the second EMA the trend becoming blue and when the second EMA is above the first EMA the trend becoming violet.
Potential trend reversals (violet candle), it's calculate with the two EMA of the main flow, when these two EMA becoming closer, the candle becoming violet. It meaning that the trend may reversals. I added sensitivity parameter, so u can adjust it depending on your trading strategy, the more sensitive it is, the more candle will be colored violet.
A system of RSI print on the chart, when the RSI becoming overbought (more than 75) a red triangle will pop up on the chart, and when the RSI becoming oversold (less than 25) a green triangle will pop up on the chart. U can show or hidden these setting.
Bullish candles are represented by hollow candles.
Bearish candles are represented by full candles.
You can use this indicator with multiple strategy, I personally use it with price action (support/resistance) and I made it for that (but it's your choice).
This is an example of how I'll use it:
Here we can see that the price is coming testing our weakly support, however the main flow is bullish (red candle), so I'm waiting my first signal (violet candle). When the first candle passed violet I decided to enter the trade because violet candle after red candle means that the two EMA start closed to themselves meaning that's the flow may turn green. My second signal will be candle passed green, because it meaning the two EMA start deviate from themselves, buyer are taking advantage. In this situation a green triangle on the support will be my third signal.
Candlestick Patterns [NAS Algo]Candlestick Patterns plots most commonly used chart patterns to help and understand the market structure.
Bullish Reversal Patterns:
Hammer:
Appearance: Small body near the high, long lower shadow.
Interpretation: Indicates potential bullish reversal after a downtrend.
Inverted Hammer:
Appearance: Small body near the low, long upper shadow.
Interpretation: Signals potential bullish reversal, especially when the preceding trend is bearish.
Three White Soldiers:
Appearance: Three consecutive long bullish candles with higher closes.
Interpretation: Suggests a strong reversal of a downtrend.
Bullish Harami:
Appearance: Small candle (body) within the range of the previous large bearish candle.
Interpretation: Implies potential bullish reversal.
Bearish Reversal Patterns:
Hanging Man:
Appearance: Small body near the high, long lower shadow.
Interpretation: Suggests potential bearish reversal after an uptrend.
Shooting Star:
Appearance: Small body near the low, long upper shadow.
Interpretation: Indicates potential bearish reversal, especially after an uptrend.
Three Black Crows:
Appearance: Three consecutive long bearish candles with lower closes.
Interpretation: Signals a strong reversal of an uptrend.
Bearish Harami:
Appearance: Small candle (body) within the range of the previous large bullish candle.
Interpretation: Implies potential bearish reversal.
Dark Cloud Cover:
Appearance: Bearish reversal pattern where a bullish candle is followed by a bearish candle that opens above the high of the previous candle and closes below its midpoint.
Continuation Patterns:
Rising Three Methods:
Appearance: Consists of a long bullish candle followed by three small bearish candles and another bullish candle.
Interpretation: Indicates the continuation of an uptrend.
Falling Three Methods:
Appearance: Consists of a long bearish candle followed by three small bullish candles and another bearish candle.
Interpretation: Suggests the continuation of a downtrend.
Gravestone Doji:
Appearance: Doji candle with a long upper shadow, little or no lower shadow, and an opening/closing price near the low.
Interpretation: Signals potential reversal, particularly in an uptrend.
Long-Legged Doji:
Appearance: Doji with long upper and lower shadows and a small real body.
Interpretation: Indicates indecision in the market and potential reversal.
Dragonfly Doji:
Appearance: Doji with a long lower shadow and little or no upper shadow.
Interpretation: Suggests potential reversal, especially in a downtrend.
ICT Clean Midnight [dR-Algo]
Are you a trader who values clean charts and precise indicators? Are you an avid follower of ICT Concepts? If so, the Midnight Marker is tailored for you. This ultra-simple, highly effective TradingView script draws a nearly transparent blue line at midnight on your chart, keeping your interface as clean as possible while delivering essential information.
Why is "ICT Clean Midnight" so Special?
Focus on Price Action: The minimalist design ensures that you can focus solely on price action, which is a core principle of ICT teachings.
Easy Back Testing: Whether you're trading live or back-testing strategies, the midnight marker helps you quickly identify key time points.
Customizable: Though designed to be subtle, the line's color and opacity can be easily customized to suit your charting needs.
This indicator embodies ICT's principle of maintaining a clutter-free, focus-driven trading environment. Perfect for both novice traders wanting to adopt ICT concepts and seasoned traders looking for minimalistic yet effective tools.
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
Bittrex ALT Index v0.0.3 @PEQUET - Trex Shalts by FA Algo Scoreusing the top 10 FA algo names via coincheckup.com
Absolute Momentum Indicator Covered intensevely by Gary Antonnacci in his paper " Absolute Momentum : A simple Rule Based Strategy and Universal Trend Following Overlay , Absolute momentum buys asset with excess return, which is calculated by taking the return of the asset for a giving period of time LESS the Treasury bill rate . The following indicator is based on the rules found in the paper. However you have the liberty to choose your time frame and symbol to calculate the excess return .
Read more about this indicator here
Cheers
AK_ TREND ID AS A STRATEGY : FOR EDUCATIONAL PURPOSES ONLYJust converted the AK_ TREND ID into a strategy , to show the efficiency of this simple indicator. I used SPX in this example, to display that the indicator has been accurate for a long time.
