reversalchartpatternsLibrary "reversalchartpatterns"
User Defined Types and Methods for reversal chart patterns - Double Top, Double Bottom, Triple Top, Triple Bottom, Cup and Handle, Inverted Cup and Handle, Head and Shoulders, Inverse Head and Shoulders
method delete(this)
Deletes the drawing components of ReversalChartPatternDrawing object
Namespace types: ReversalChartPatternDrawing
Parameters:
this (ReversalChartPatternDrawing) : ReversalChartPatternDrawing object
Returns: current ReversalChartPatternDrawing object
method delete(this)
Deletes the drawing components of ReversalChartPattern object. In turn calls the delete of ReversalChartPatternDrawing
Namespace types: ReversalChartPattern
Parameters:
this (ReversalChartPattern) : ReversalChartPattern object
Returns: current ReversalChartPattern object
method lpush(this, obj, limit, deleteOld)
Array push with limited number of items in the array. Old items are deleted when new one comes and exceeds the limit
Namespace types: array
Parameters:
this (array) : array object
obj (ReversalChartPattern) : ReversalChartPattern object which need to be pushed to the array
limit (int) : max items on the array. Default is 10
deleteOld (bool) : If set to true, also deletes the drawing objects. If not, the drawing objects are kept but the pattern object is removed from array. Default is false.
Returns: current ReversalChartPattern object
method draw(this)
Draws the components of ReversalChartPatternDrawing
Namespace types: ReversalChartPatternDrawing
Parameters:
this (ReversalChartPatternDrawing) : ReversalChartPatternDrawing object
Returns: current ReversalChartPatternDrawing object
method draw(this)
Draws the components of ReversalChartPatternDrawing within the ReversalChartPattern object.
Namespace types: ReversalChartPattern
Parameters:
this (ReversalChartPattern) : ReversalChartPattern object
Returns: current ReversalChartPattern object
method scan(zigzag, patterns, errorPercent, shoulderStart, shoulderEnd, allowedPatterns, offset)
Scans zigzag for ReversalChartPattern occurences
Namespace types: zg.Zigzag
Parameters:
zigzag (Zigzag type from Trendoscope/Zigzag/11) : ZigzagTypes.Zigzag object having array of zigzag pivots and other information on each pivots
patterns (array) : Existing patterns array. Used for validating duplicates
errorPercent (float) : Error threshold for considering ratios. Default is 13
shoulderStart (float) : Starting range of shoulder ratio. Used for identifying shoulders, handles and necklines
shoulderEnd (float) : Ending range of shoulder ratio. Used for identifying shoulders, handles and necklines
allowedPatterns (array) : array of int containing allowed pattern types
offset (int) : Offset of zigzag to consider only confirmed pivots
Returns: int pattern type
method createPattern(zigzag, patternType, patternColor, properties, offset)
Create Pattern from ZigzagTypes.Zigzag object
Namespace types: zg.Zigzag
Parameters:
zigzag (Zigzag type from Trendoscope/Zigzag/11) : ZigzagTypes.Zigzag object having array of zigzag pivots and other information on each pivots
patternType (int) : Type of pattern being created. 1 - Double Tap, 2 - Triple Tap, 3 - Cup and Handle, 4 - Head and Shoulders
patternColor (color) : Color in which the patterns are drawn
properties (ReversalChartTradeProperties)
offset (int)
Returns: ReversalChartPattern object created
method getName(this)
get pattern name of ReversalChartPattern object
Namespace types: ReversalChartPattern
Parameters:
this (ReversalChartPattern) : ReversalChartPattern object
Returns: string name of the pattern
method getDescription(this)
get consolidated description of ReversalChartPattern object
Namespace types: ReversalChartPattern
Parameters:
this (ReversalChartPattern) : ReversalChartPattern object
Returns: string consolidated description
method init(this)
initializes the ReversalChartPattern object and creates sub object types
Namespace types: ReversalChartPattern
Parameters:
this (ReversalChartPattern) : ReversalChartPattern object
Returns: ReversalChartPattern current object
ReversalChartPatternDrawing
Type which holds the drawing objects for Reversal Chart Pattern Types
Fields:
patternLines (array type from Trendoscope/Drawing/2) : array of Line objects representing pattern
entry (Line type from Trendoscope/Drawing/2) : Entry price Line
targets (array type from Trendoscope/Drawing/2)
stop (Line type from Trendoscope/Drawing/2) : Stop price Line
patternLabel (Label type from Trendoscope/Drawing/2)
ReversalChartTradeProperties
Trade properties of ReversalChartPattern
Fields:
riskAdjustment (series float) : Risk Adjustment for calculation of stop
useFixedTarget (series bool) : Boolean flag saying use fixed target type wherever possible. If fixed target type is not possible, then risk reward/fib ratios are used for calculation of targets
variableTargetType (series int) : Integer value which defines whether to use fib based targets or risk reward based targets. 1 - Risk Reward, 2 - Fib Ratios
variableTargetRatios (array) : Risk reward or Fib Ratios to be used for calculation of targets when fixed target is not possible or not enabled
entryPivotForWm (series int) : which Pivot should be considered as entry point for WM patterns. 0 refers to the latest breakout pivot where as 5 refers to initial pivot of the pattern
ReversalChartPattern
Reversal Chart Pattern master type which holds the pattern components, drawings and trade details
Fields:
pivots (array type from Trendoscope/Zigzag/11) : Array of Zigzag Pivots forming the pattern
patternType (series int) : Defines the main type of pattern 1 - Double Tap, 1 - Triple Tap, 3 - Cup and Handle, 4 - Head and Shoulders, 5- W/M Patterns, 6 - Full Trend, 7 - Half Trend
patternColor (series color) : Color in which the pattern will be drawn on chart
properties (ReversalChartTradeProperties)
drawing (ReversalChartPatternDrawing) : ReversalChartPatternDrawing object which holds the drawing components
trade (Trade type from Trendoscope/TradeTracker/1) : TradeTracker.Trade object holding trade components
Cari dalam skrip untuk "trend"
Market Structure - HH, HL, LH, LL with Trendlines & AlertsMarket Structure Script – HH, HL, LH, LL with Trendlines & Alerts
This Pine Script is designed to help identify key market structure patterns such as Higher Highs (HH), Higher Lows (HL), Lower Highs (LH), and Lower Lows (LL) on price charts. It also draws trendlines connecting the respective swing points and provides alerts when these important price patterns occur.
Key Features:
Swing High and Low Detection:
The script uses the ta.pivothigh and ta.pivotlow functions to identify significant swing highs and swing lows based on the pivot length (pivotLen). These points mark local peaks and troughs in the price action.
Dynamic Pivot Length:
The script adjusts the pivotLen (which defines the number of bars used to calculate swing points) based on the current timeframe of the chart. For example, for a 15-minute chart, it uses a pivot length of 5 bars, while for a daily chart, it uses 10 bars. This dynamic adjustment ensures that the script works across different timeframes.
Higher Highs (HH), Higher Lows (HL), Lower Highs (LH), Lower Lows (LL):
Higher High (HH): Identifies a price peak that is higher than the previous swing high, indicating an uptrend.
Higher Low (HL): Identifies a price trough that is higher than the previous swing low, supporting the idea of an ongoing uptrend.
Lower High (LH): Identifies a price peak that is lower than the previous swing high, suggesting a potential reversal or downtrend.
Lower Low (LL): Identifies a price trough that is lower than the previous swing low, indicating a downtrend.
Trendlines:
For each identified Higher High, Higher Low, Lower High, or Lower Low, the script automatically draws a trendline connecting the corresponding swing points. These trendlines provide a visual representation of the market’s price structure, showing support and resistance levels.
Labels:
The script places labels on the chart next to the respective swing points. These labels mark whether the point is a Higher High (HH), Higher Low (HL), Lower High (LH), or Lower Low (LL). This helps traders easily visualize the price pattern at a glance.
Alerts:
Alert conditions are set for when a Higher High (HH), Higher Low (HL), Lower High (LH), or Lower Low (LL) is detected. Users can set up alerts to be notified whenever one of these key market structure patterns forms. Alerts are an essential feature for traders who want to act quickly when important trend changes are happening.
TrendLibrary "Trend"
calculateSlopeTrend(source, length, thresholdMultiplier)
Parameters:
source (float)
length (int)
thresholdMultiplier (float)
Purpose:
The primary goal of this function is to determine the short-term trend direction of a given data series (like closing prices). It does this by calculating the slope of the data over a specified period and then comparing that slope against a dynamic threshold based on the data's recent volatility. It classifies the trend into one of three states: Upward, Downward, or Flat.
Parameters:
`source` (Type: `series float`): This is the input data series you want to analyze. It expects a series of floating-point numbers, typically price data like `close`, `open`, `hl2` (high+low)/2, etc.
`length` (Type: `int`): This integer defines the lookback period. The function will analyze the `source` data over the last `length` bars to calculate the slope and standard deviation.
`thresholdMultiplier` (Type: `float`, Default: `0.1`): This is a sensitivity factor. It's multiplied by the standard deviation to determine how steep the slope needs to be before it's considered a true upward or downward trend. A smaller value makes it more sensitive (detects trends earlier, potentially more false signals), while a larger value makes it less sensitive (requires a stronger move to confirm a trend).
Calculation Steps:
Linear Regression: It first calculates the value of a linear regression line fitted to the `source` data over the specified `length` (`ta.linreg(source, length, 0)`). Linear regression finds the "best fit" straight line through the data points.
Slope Calculation: It then determines the slope of this linear regression line. Since `ta.linreg` gives the *value* of the line on the current bar, the slope is calculated as the difference between the current bar's linear regression value (`linRegValue`) and the previous bar's value (`linRegValue `). A positive difference means an upward slope, negative means downward.
Volatility Measurement: It calculates the standard deviation (`ta.stdev(source, length)`) of the `source` data over the same `length`. Standard deviation is a measure of how spread out the data is, essentially quantifying its recent volatility.
Adaptive Threshold: An adaptive threshold (`threshold`) is calculated by multiplying the standard deviation (`stdDev`) by the `thresholdMultiplier`. This is crucial because it means the definition of a "flat" trend adapts to the market's volatility. In volatile times, the threshold will be wider, requiring a larger slope to signal a trend. In quiet times, the threshold will be narrower.
Trend Determination: Finally, it compares the calculated `slope` to the adaptive `threshold`:
If the `slope` is greater than the positive `threshold`, the trend is considered **Upward**, and the function returns `1`.
If the `slope` is less than the negative `threshold` (`-threshold`), the trend is considered **Downward**, and the function returns `-1`.
If the `slope` falls between `-threshold` and `+threshold` (inclusive of 0), the trend is considered **Flat**, and the function returns `0`.
Return Value:
The function returns an integer representing the determined trend direction:
`1`: Upward trend
`-1`: Downward trend
`0`: Flat trend
In essence, this library function provides a way to gauge trend direction using linear regression, but with a smart filter (the adaptive threshold) to avoid classifying minor noise or low-volatility periods as significant trends.
Future Trend Indicator (FTI)Future Trend Indicator (FTI)
The Future Trend Indicator (FTI) is a versatile and innovative tool designed to analyze market trends, smooth out noise, and provide a forward-looking forecast of potential price movements. Built with advanced features such as polynomial regression, EMA smoothing, confidence bands, and cross-validation metrics, this indicator offers a comprehensive approach for traders to gain insights into future price trends while maintaining realistic error margins.
Key Features:
Exponential Moving Average (EMA) Integration
The FTI incorporates a user-configurable EMA to smooth out short-term price fluctuations and highlight the overall market trend. This provides a stable and reliable reference for assessing price action.
Noise Reduction via Median Filter
To improve signal clarity, the source data is processed using a Median Filter, effectively reducing the impact of outliers and market noise. This ensures that the forecast focuses on meaningful price movements.
Polynomial Regression Forecast
A polynomial regression model is used to project future price movements based on historical data. This advanced statistical approach models potential non-linear trends, offering a sophisticated and adaptive forecast for the next specified period.
Confidence Bands for Forecast Accuracy
Upper and lower confidence bands are calculated using standard deviation, visually representing the potential error margin around the forecast. This feature provides traders with an understanding of the forecast's reliability and the expected price range.
Dynamic Visualization
The indicator uses visually appealing and intuitive plotting techniques:
A forecast line dynamically shifts based on polynomial regression and historical data.
Confidence bands are displayed with semi-transparent green (upper) and red (lower) shading for quick visual interpretation.
The EMA is displayed as a blue line for smooth trend observation.
Cross-Validation with RMSE (Root Mean Square Error)
The indicator includes an error metric to measure the accuracy of its forecast against actual future price movements. The RMSE is displayed as a yellow label on the chart, helping traders evaluate the forecast's historical precision.
Flexible Data Source
By default, the FTI uses hlc3 (the average of high, low, and close prices) as its source, providing a balanced view of market activity. Traders can easily customize this input to suit their preferences.
Forecast Customization
Users can configure the length of the forecast, moving average, and EMA to tailor the indicator to different trading styles and timeframes.
EMA Length
Purpose: Smoothens the price action to identify the primary trend.
Recommendation:
Short-term traders (scalping/day trading): Use a shorter EMA length (e.g., 10 or 20) to make the indicator more responsive to recent price movements.
Medium-term traders (swing trading): Use a moderate EMA length (e.g., 50) to capture broader trends while avoiding short-term noise.
Long-term traders (position trading): Use a longer EMA length (e.g., 100 or 200) to focus on the dominant trend over a longer period.
Default Value: 20
Moving Average Length
Purpose: Used in trend calculations to smooth out data further.
Recommendation:
Similar to the EMA, shorter lengths provide faster signals but are more sensitive to noise, while longer lengths offer smoother signals but may lag.
For crypto or forex (volatile markets): Start with 10 to 20.
For stocks or indices (less volatile): Use 20 to 50 for more stable trends.
Default Value: 10
Forecast Length
Purpose: Determines how many bars into the future the indicator projects.
Recommendation:
Short-term trading: Use a smaller forecast length (e.g., 50) to project near-term price movements.
Medium- to long-term trading: Use a higher value (e.g., 100 to 200) to focus on longer-term forecasts.
Keep in mind that longer forecasts tend to have greater uncertainty. Confidence bands (enabled in this script) will widen as the forecast length increases, reflecting higher error potential.
Default Value: 100
EMA 50 + 200 Trend Signal TableEMA 50 + 200 Trend Signal Table (ETT)
This indicator provides a multi-timeframe trend signal table based on the 50-period and 200-period Exponential Moving Averages (EMAs). It visually plots the EMA 50 and EMA 200 on the chart, along with a customizable, compact table that indicates the trend direction across multiple timeframes. This tool is useful for traders looking to quickly identify market trends and momentum on various timeframes.
How It Works
- EMA Trend Analysis: The script compares the EMA 50 and EMA 200 values to determine the trend. When EMA 50 is above EMA 200, the trend is considered Bullish; if EMA 50 is below EMA 200, the trend is Bearish. If EMA 200 data is unavailable (e.g., on very short timeframes), the trend status will display as Neutral.
- Multi-Timeframe Trend Signals: The table displays the trend signals across five user-defined timeframes, updating in real time. Each timeframe row shows either Bullish, Bearish, or Neutral, with colors customizable to your preference.
Features
- EMA 50 and EMA 200 Visualization: Plots EMA 50 and EMA 200 lines directly on the chart. Users can customize the color and line thickness for each EMA to fit their charting style.
- Trend Signal Table: A table positioned on the chart (with options for positioning in the corners) shows the trend direction for the selected timeframes.
Bullish Trend: Highlighted in green (default) with 50% opacity.
Bearish Trend: Highlighted in red (default) with 50% opacity.
Neutral Trend: Highlighted in gray (default) with 50% opacity.
- Customizable Table Appearance: Allows users to select the position of the table (top-right, top-left, bottom-right, or bottom-left) and choose between compact sizes (Extra Small, Small, Normal).
- Adjustable Colors: Users can specify custom colors for each trend status (Bullish, Bearish, Neutral) as well as for the text and table border colors.
Inputs and Customizations
- Timeframes: Choose up to five different timeframes for trend analysis.
- EMA Colors and Line Widths: Customize the color and line width of EMA 50 and EMA 200 plotted on the chart.
- Table Settings: Control the position, size, and color options of the trend signal table for improved visibility and integration with your chart layout.
Use Case This indicator is ideal for traders who employ a multi-timeframe approach to confirm trends and filter entries. By monitoring the relative positions of EMA 50 and EMA 200 across various timeframes, traders can get a quick snapshot of trend strength and direction, aiding in informed trading decisions.
Universal Trend Following Strategy | QuantumRsearchUniversal All Assets Strategy by Rocheur
The Universal All Assets Strategy is a cutting-edge, trend-following algorithm designed to operate seamlessly across multiple asset classes, including equities, commodities, forex, and cryptocurrencies. This strategy leverages the power of eight unique indicators, offering traders robust, adaptive signals. Its dynamic logic, combined with a comprehensive risk management framework, allows for precision trading in a variety of market conditions.
Core Methodologies and Features
1. Eight Integrated Trend Indicators
At the heart of the Universal All Assets Strategy are eight sophisticated trend-following indicators, each designed to capture different facets of market behavior. These indicators work together to provide a multi-dimensional analysis of price trends, filtering out noise and reacting only to significant movements:
Directional Moving Averages : Tracks the primary market trend, offering a clear indication of long-term price direction, ideal for identifying sustained upward or downward movements.
Smoothed Moving Averages : Reduces short-term volatility and noise to reveal the underlying trend, enhancing signal clarity and helping traders avoid reacting to temporary price spikes.
RSI Loops : Utilizes the Relative Strength Index (RSI) to assess market momentum, using a unique for loop mechanism to smooth out data and enhance precision.
Supertrend Filters : This indicator dynamically adjusts to market volatility, closely following price action to detect significant breakouts or reversals. The Supertrend is a core component for identifying shifts in trend direction with minimal lag.
RVI for Loop : The Relative Volatility Index (RVI) measures the strength of market volatility. It is optimized with a for loop mechanism, which smooths out the data and improves directional cues, especially in choppy or sideways markets.
Hull for Loop : The Hull Moving Average is designed to minimize lag while offering a smooth, responsive trend line. The for loop mechanism further enhances this by making the Hull even more sensitive to trend shifts, ensuring faster reaction to market movements without generating excessive noise.
These indicators evaluate market conditions independently, assigning a score of 1 for bullish trends and -1 for bearish trends. The average score across all eight indicators is calculated for each time frame (or bar), and this score determines whether the strategy should enter, exit, or remain neutral in a trade.
2. Scoring and Signal Confirmation
The strategy’s confirmation system ensures that trades are initiated only when there is strong alignment across multiple indicators:
A Long Position (Buy) is initiated when the majority of indicators generate a bullish signal, i.e., the average score exceeds a predefined upper threshold.
A Short Position or Exit is triggered when the average score falls below a lower threshold, signaling a bearish trend or neutral market.
By using a majority-rule confirmation system, the strategy filters out weak signals, reducing the chances of reacting to market noise or false positives. This ensures that only robust trends—those supported by multiple indicators—trigger trades.
Adaptive Logic for All Asset Classes
The Universal All Assets Strategy stands out for its ability to adapt dynamically across different asset classes. Whether it’s applied to highly volatile assets like cryptocurrencies or more stable instruments like equities, the strategy fine-tunes its behavior to match the asset’s volatility profile and price behavior.
Volatility Filters : The system incorporates volatility-sensitive filters, such as the Average True Range (ATR) and standard deviation metrics, which dynamically adjust its sensitivity based on market conditions. This ensures the strategy remains responsive to significant price movements while filtering out inconsequential fluctuations.
This adaptability makes the Universal All Assets Strategy effective across diverse markets, providing consistent performance whether the market is trending, range-bound, or experiencing high volatility.
Customization and Flexibility
1. Directional Bias
The strategy offers traders the flexibility to set a customizable directional bias, allowing it to focus on:
Long-only trades during bullish markets.
Short-only trades during bear markets.
Bi-directional trades for those looking to capitalize on both uptrends and downtrends.
This bias can be fine-tuned based on market conditions, trader preference, or risk tolerance, without compromising the integrity of the overall signal-generation process.
2. Volatility Sensitivity
Traders can adjust the strategy’s volatility sensitivity through customizable settings. By modifying how the system reacts to volatility, traders can make the strategy more aggressive in high-volatility environments or more conservative in quieter markets, depending on their individual trading style.
Visual Representation of Component Behavior
One of the unique features of the strategy is its real-time visual representation of the eight indicators through a component table displayed on the chart. This table provides a clear overview of the current status of each indicator:
A score of 1 indicates a bullish signal.
A score of -1 indicates a bearish signal.
The table is updated at each time frame (bar), showing how each indicator is contributing to the overall trend decision. This real-time feedback allows traders to monitor the exact composition of the strategy’s signal, helping them better understand market dynamics.
Oscillator Visualization for Trend Detection
To complement the component table, the strategy includes a trend oscillator displayed beneath the price chart, offering a visual summary of the overall market direction:
Green bars represent bullish trends when the majority of indicators signal an uptrend.
Red bars represent bearish trends or a neutral (cash) position when the majority of indicators detect a downtrend.
This oscillator allows traders to quickly assess the market’s overall direction at a glance, without needing to analyze each individual indicator, providing a clear and immediate visual of the market trend.
Backtested and Forward-Tested for Real-World Conditions
The Universal All Assets Strategy has been thoroughly tested under real-world trading conditions, incorporating key factors like:
Slippage : Set at 20 ticks to represent real market fluctuations.
Order Size : Calculated as 10% of equity, ensuring appropriate risk exposure for realistic capital management.
Commission : A fee of 0.05% has been factored in to account for trading costs.
These settings ensure that the strategy’s performance metrics—such as the Sortino Ratio , Sharpe Ratio , Omega Ratio , and Profit Factor —are reflective of actual trading environments. The rigorous backtesting and forward-testing processes ensure that the strategy produces realistic results, making it compatible with the markets it is written for and demonstrating how the system would behave in live conditions. It also includes robust risk management tools to minimize drawdowns and preserve capital, making it suitable for both professional and retail traders.
Anti-Fragile Design and Realistic Expectations
The Universal All Assets Strategy is engineered to be anti-fragile, thriving in volatile markets by adjusting to turbulence rather than being damaged by it. This is a crucial feature that ensures the strategy remains effective even during times of significant market instability.
Moreover, the strategy is transparent about realistic expectations, acknowledging that no system can guarantee a 100% win rate and that past performance is not indicative of future results. This transparency fosters trust and provides traders with a realistic framework for long-term success, making it an ideal choice for traders looking to navigate complex market conditions with confidence.
Acknowledgment of External Code
Special credit goes to bii_vg, whose invite-only code was used with permission in the development of the Universal All Assets Strategy. Their contributions have been instrumental in refining certain aspects of this strategy, ensuring its robustness and adaptability across various markets.
Conclusion
The Universal All Assets Strategy by Rocheur offers traders a powerful, adaptable tool for capturing trends across a wide range of asset classes. Its eight-indicator confirmation system, combined with customizable settings and real-time visual representations, provides a comprehensive solution for traders seeking precision, flexibility, and consistency. Whether used in high-volatility markets or more stable environments, the strategy’s dynamic adaptability, transparent logic, and robust testing make it an excellent choice for traders aiming to maximize performance while managing risk effectively.
TP RSITP RSI - Integrated Trend, Momentum, and Volatility Analyzer
The TP RSI indicator is an innovative 3-in-1 technical analysis tool that combines RSI, Bollinger Bands, and an EMA ribbon to provide traders with a comprehensive view of trend, momentum, and volatility in a single, easy-to-interpret visual display.
Why This Combination? This mashup addresses three critical aspects of market analysis simultaneously:
Trend identification and strength (EMA ribbon)
Momentum measurement (RSI)
Volatility assessment (Bollinger Bands)
By integrating these components, traders can make more informed decisions based on multiple factors without switching between different indicators.
How Components Work Together:
1. EMA Ribbon (Trend):
10 EMAs form 5 color-coded bands
Blue: Uptrend, Red: Downtrend
Provides a nuanced view of trend strength and potential reversals
2. RSI (Momentum):
Color-coded for quick interpretation
Blue: Upward momentum, Red: Downward momentum, White: Neutral
Position relative to the ribbon offers additional insight
3. Bollinger Bands (Volatility):
Applied to RSI for dynamic overbought/oversold levels
Narrow bands indicate low volatility, suggesting potential breakouts
Unique Aspects and Originality:
Synergistic visual cues: Color coordination between ribbon and RSI
Multi-factor confirmation: Requires alignment of trend, momentum, and volatility for strong signals
Volatility-adjusted momentum: RSI interpreted within the context of Bollinger Bands
How these components work together:
Buy Signal: Blue ribbon with blue RSI outside the ribbon.
Sell Signal: Red ribbon with red RSI outside the ribbon.
Neutral: White RSI or RSI inside the ribbon (not recommended for trading)
Increasing Momentum: RSI crossing above upper Bollinger Band (upward) or below lower Band (downward).
Trend Strength: RSI rejection by the ribbon, while all bands are colored along with the trend direction, identifies a strong trend.
Follow The Trend - The Lazy Indicator**Understanding the 'Follow The Trend - The Lazy Indicator'**
This indicator is designed to help traders visualize the trend direction over both short-term and long-term periods. Let's dive deeper into understanding how it's designed and how it can be beneficial.
**1. How It's Designed:**
* **User Inputs:**
The first few lines ask the user for specific inputs related to the Average True Range (ATR) length and values for both short-term and long-term trends. ATR is a volatility indicator and, in this context, is used as part of the SuperTrend calculation.
* **SuperTrend Calculations:**
This indicator uses the SuperTrend, a popular trend-following indicator. Here, two SuperTrends are being calculated – one for short-term trends and another for long-term trends. The direction of the SuperTrend is also determined, signaling whether the trend is upwards or downwards.
* **Visual Representations:**
* The short-term SuperTrend is represented using green lines (for uptrend) and red lines (for downtrend).
* The indicator also provides a "cloud" between a Simple Moving Average (SMA) of the closing price (over the past 10 periods) and the long-term SuperTrend. This cloud changes color based on the direction of the long-term trend, providing another visual cue about market direction.
* **Signal Evaluation:**
This part of the code interprets the combination of short-term and long-term trends and assigns trading signals like "Strong Buy," "Weak Buy," "Strong Sell," "Weak Sell," and so on. This can act as a guide for traders, suggesting potential trading actions based on the prevailing trends.
* **Signal Coloration:**
The indicator also assigns colors to each signal. For instance, "Strong Buy" is green, "Strong Sell" is red, and there are transparency adjustments for weak signals to differentiate them from strong ones.
* **Tabular Presentation:**
At the end of the script, there’s a table displayed on the chart, summarizing the direction of both the long-term and short-term trends, as well as the overall trading signal. It provides a quick snapshot for traders to understand the current market scenario.
**2. How It May Be Helpful:**
* **Simplicity:**
The "Follow The Trend" indicator, despite its underlying complexity, is presented in a very user-friendly way. By just looking at the color cues and the table, traders can quickly understand the market's trend and potential direction.
* **Dual Trend Analysis:**
By analyzing both short-term and long-term trends, traders get a comprehensive view. This helps in understanding if the market is just having a short-term retracement (temporary reverse in direction) or if there's a genuine change in the long-term trend.
* **Adaptability:**
Traders can adjust the ATR values and lengths to customize the sensitivity of the indicator. This means it can be adapted to different assets or varying market conditions.
* **Actionable Signals:**
The signals like "Strong Buy" or "Weak Sell" are direct suggestions that can help in decision-making. Especially for beginners or those who might be overwhelmed by complex charts, such signals can be very beneficial.
* **Visual Appeal:**
The combination of trend lines, cloud coloring, and tabulated information provides a visually pleasing and easy-to-understand representation of market data. This can help reduce analysis fatigue and make chart reading more enjoyable.
In conclusion, the "Follow The Trend - The Lazy Indicator" is designed to make trend-following more accessible and actionable. By providing clear visual cues and combining short-term and long-term trend analysis, it offers traders a tool that's both comprehensive and user-friendly. Whether you're a beginner looking for clear signals or an experienced trader wanting an overview of the market trend, this indicator might be a useful addition to your toolkit.
Chatterjee CorrelationThis is my first attempt on implementing a statistical method. This problem was given to me by @lejmer (who also helped me later on building more efficient code to achieve this) when we were debating on the need for higher resource allocation to run scripts so it can run longer and faster. The major problem faced by those who want to implement statistics based methods is that they run out of processing time or need to limit the data samples. My point was that such things need be implemented with an algorithm which suits pine instead of trying to port a python code directly. And yes, I am able to demonstrate that by using this implementation of Chatterjee Correlation.
🎲 What is Chatterjee Correlation?
The Chatterjee rank Correlation Coefficient (CCC) is a method developed by Sourav Chatterjee which can be used to study non linear correlation between two series.
Full documentation on the method can be found here:
arxiv.org
In short, the formula which we are implementing here is:
Algorithm can be simplified as follows:
1. Get the ranks of X
2. Get the ranks of Y
3. Sort ranks of Y in the order of X (Lets call this SortedYIndices)
4. Calculate the sum of adjacent Y ranks in SortedYIndices (Lets call it as SumOfAdjacentSortedIndices)
5. And finally the correlation coefficient can be calculated by using simple formula
CCC = 1 - (3*SumOfAdjacentSortedIndices)/(n^2 - 1)
🎲 Looks simple? What is the catch?
Mistake many people do here is that they think in Python/Java/C etc while coding in Pine. This makes code less efficient if it involves arrays and loops. And the simple code may look something like this.
var xArray = array.new()
var yArray = array.new()
array.push(xArray, x)
array.push(yArray, y)
sortX = array.sort_indices(xArray)
sortY = array.sort_indices(yArray)
SumOfAdjacentSortedIndices = 0.0
index = array.get(xSortIndices, 0)
for i=1 to n > 1? n -1 : na
indexNext = array.get(sortX, i)
SumOfAdjacentSortedIndices += math.abs(array.get(sortY, indexNext)-array.get(sortY, index))
index := indexNext
correlation := 1 - 3*SumOfAdjacentSortedIndices/(math.pow(n,2)-1)
But, problem here is the number of loops run. Remember pine executes the code on every bar. There are loops run in array.sort_indices and another loop we are running to calculate SumOfAdjacentSortedIndices. Due to this, chances of program throwing runtime errors due to script running for too long are pretty high. This limits greatly the number of samples against which we can run the study. The options to overcome are
Limit the sample size and calculate only between certain bars - this is not ideal as smaller sets are more likely to yield false or inconsistent results.
Start thinking in pine instead of python and code in such a way that it is optimised for pine. - This is exactly what we have done in the published code.
🎲 How to think in Pine?
In order to think in pine, you should try to eliminate the loops as much as possible. Specially on the data which is continuously growing.
My first thought was that sorting takes lots of time and need to find a better way to sort series - specially when it is a growing data set. Hence, I came up with this library which implements Binary Insertion Sort.
Replacing array.sort_indices with binary insertion sort will greatly reduce the number of loops run on each bar. In binary insertion sort, the array will remain sorted and any item we add, it will keep adding it in the existing sort order so that there is no need to run separate sort. This allows us to work with bigger data sets and can utilise full 20,000 bars for calculation instead of few 100s.
However, last loop where we calculate SumOfAdjacentSortedIndices is not replaceable easily. Hence, we only limit these iterations to certain bars (Even though we use complete sample size). Plots are made for only those bars where the results need to be printed.
🎲 Implementation
Current implementation is limited to few combinations of x and fixed y. But, will be converting this into library soon - which means, programmers can plug any x and y and get the correlation.
Our X here can be
Average volume
ATR
And our Y is distance of price from moving average - which identifies trend.
Thus, the indicator here helps to understand the correlation coefficient between volume and trend OR volatility and trend for given ticker and timeframe. Value closer to 1 means highly correlated and value closer to 0 means least correlated. Please note that this method will not tell how these values are correlated. That is, we will not be able to know if higher volume leads to higher trend or lower trend. But, we can say whether volume impacts trend or not.
Please note that values can differ by great extent for different timeframes. For example, if you look at 1D timeframe, you may get higher value of correlation coefficient whereas lower value for 1m timeframe. This means, volume to trend correlation is higher in 1D timeframe and lower in lower timeframes.
Wolfe Scanner (Multi - zigzag) [HeWhoMustNotBeNamed]Before getting into the script, I would like to explain bit of history around this project. Wolfe was in the back of my mind for some time and I had several attempts so far.
🎯Initial Attempt
When I first developed harmonic patterns, I got many requests from users to develop script to automatically detect Wolfe formation. I thought it would be easy and started boasting everywhere that I am going to attempt this next. However I miserably failed that time and started realising it is not as simple as I thought it would be. I started with Wolfe in mind. But, ran into issues with loops. Soon figured out that finding and drawing wedge is more trickier. I decided will explore trendline first so that it can help find wedge better. Soon, the project turned into something else and resulted in Auto-TrendLines-HeWhoMustNotBeNamed and Wolfe left forgotten.
🎯Using predefined ratios
Wolfe also has predefined fib ratios which we can use to calculate the formation. But, upon initial development, it did not convince me that it matches visual inspection of Wolfe all the time. Hence, I decided to fall back on finding wedge first.
🎯 Further exploration in finding wedge
This attempt was not too bad. I did not try to jump into Wolfe and nor I bragged anywhere about attempting anything of this sort. My target this time was to find how to derive wedge. I knew then that if I manage to calculate wedge in efficient way, it can help further in finding Wolfe. While doing that, ended up deriving Wedge-and-Flag-Finder-Multi-zigzag - which is not a bad outcome. I got few reminders on Wolfe after this both in comments and in PM.
🎯You never fail until you stop trying!!
After 2 back to back hectic 50hr work weeks + other commitments, I thought I will spend some time on this. Took less than half weekend and here we are. I was surprised how much little time it took in this attempt. But, the plan was running in my subconscious for several weeks or even months. Last two days were just putting these plans into an action.
Now, let's discuss about the script.
🎲 Wolfe Concept
Wolfe concept is simple. Whenever a wedge is formed, draw a line joining pivot 1 and 4 as shown in the chart below:
Converging trendline forms the stop loss whereas line joining pivots 1 and 4 form the profit taking points.
🎲 Settings
Settings are pretty straightforward. Explained in the chart below.
Strategy Template - V2This is an educational script created to demonstrate few basic building blocks of a trend based strategy and how to achieve different entry and exit types. My initial intention was to create a comprehensive strategy template which covers all the aspects of strategy. But, ended up creating fully fledged strategy based on trend following.
This is an enhancement on Strategy-Template But this script is comparitively more complex. Hence I decided to create new version instead of updating the existing one.
Lets dive deep.
SIMPLE COMPONENTS OF TREND FOLLOWING STRATEGY
TREND BIAS - This defines the direction of trend. Idea is not to trade against the trend direction. If the bias is bullish, look for long opportunities and if bias is bearish, look for short opportunities. Stay out of the market when the bias is neutral.
Often, trend bias is determined based on longer timeframe conditions. Example - 200 Moving Average, Higher timeframe moving averages, Higher timeframe high-lows etc. can be used for determining the trend bias.
In this script, I am using Weekly donchian channels combined with daily donchian channels to define trend bias.
Long Bias - 40 Day donchian channel sits completely in upper portion of 40 Week dochnial channel.
Short Bias - 40 Day donchian channel sits completely in lower portion of 40 Week donchian channel.
ENTRY CONDITION - Entry signals are generated only in the direction of bias. Hence, when in LongBias, we only get Long signals and when in short bias, we only get short signals.
In our case, when in Long Bias - if price hits 40 day high for the first time, this creates our long entry signal. Similarly when in Short Bias , price hitting 40 day low will create signal for going short. Since we do not take trades opposite to trend, no entry conditions are formed when price hits 40 day high in Short Bias or 40 day low in Long Bias.
EXIT CONDITION - Exit conditions are formed when we get signals of trend failure.
In our case, when in long trade, price hitting 40 day low creates exit signal. Similarly when in short trade price hitting 40 day high creates exit signal for short trade.
DIFFERENT TYPES OF ENTRY AND EXIT
In this script, I have tried to demonstrate different entry and exit types.
Entry types
Market - Enter immediately when entry signal is received. That is, in this case when price crossover over high in long bias and crosses under low in short bias
Stop - This method includes estimating at what level new highs are made and creating a stop buy order at that level. This way, we do not miss if the break out is stronger. But, susciptible to fail during fakeouts.
Limit - This method includes executing a limit order to buy at lower price or sell at higher price. In trend following methods, downside of limit order is when there is genuine breakout, these limit orders may not hit and during trend failures the limit orders are likely to hit and go straight to stop.
Stop-Limit - this is same as stop order but will also place a limit condition to avoid buying on overextended breakout or with lots of slippage.
Exit types
Market - whether to keep the existing trade running or whether to close it is determined after close of each bar and exit orders are executed manually upon receiving exit signal.
Stop - We place stop loss orders beforehand when there is a trade in place. This can help in avoiding big movements against trade within bar. But, this may also stop on false signals or fakeouts.
Take profit
Stop - No take profits are configured.
Target - 30% of the positions are closed when take profit levels are hit. Take profit levels are defined by risk reward.
USING THE CODE AS TEMPLATE
As mentioned earlier, I intended to create a fully fledged strategy template. But, ended up creating a fully fledged stratgy. However, you can take some part of this code and use it to start your own strategy. Will explain what all things can be adopted without worrying about the strategy implementation within
Strategy definition : This can be copied as is and just change the title of strategy. This defines some of the commonly used parameters of strategy which can help with close to realistic backtesting results for your coded strategy and comparison with buy and hold.
Generic Strategy Parameters : The parameter which defines controlling alllowed trade direction and trading window are present here. This again can be copied as is and variable inDateRange can be directly used in entry conditions.
Generic Methods : f_getMovingAverage and f_secureSecurity are handy and can be used as is. atr method provideded by pine gives you ATR based on RMA. If you want SMA or any other moving average based ATR, you can use the method f_getCustomAtr
Trade Statements : This section has all types of trading instructions which includes market/stop/limit/stop-limit type of entries and exits and take profit statements. You can adopt the type of entry you are interested in and change when condition to suit your strategy.
Trade conditions and levels : This section is required. But, cannot be copied. All the trade logic goes here which also sets parameters which are used in when of Trade Statements.
Hope this helps.
TrendMaAlignmentStrategy - Long term tradesThis is another strategy based on moving average alignment and HighLow periods. This is more suitable for long term trend traders and mainly for stocks.
Candle is colored lime if : Lookback Period has at least one bar with moving averages fully aligned OR None of the bars in Lookback periods has negatively aligned moving averages (More than half are positively aligned).
Candle is colored orange if : Lookback Period has at least one bar with moving averages fully aligned in negative way OR none of the bars in lookback has positively aligned moving averages (More than half are negatively aligned).
If either of above conditions are met, candle is colored silver.
Moving average alignment parameters:
Moving Average Type : MA Type for calculating Aligned Moving Average Index
Lookback Period : Lookback period to check highest and lowest Moving Average index.
HighLow parameters:
Short High/Low Period: Short period to check highs and lows
Long High/Low Period: Longer Period to check highs and lows.
If short period high == long period high, which means, instrument has made new high in the short period.
ATR Parameters:
ATR Length: ATR periods
StopMultiplyer: To set stop loss.
ReentryStopMultiplyer: This is used when signal is green buy stop loss on previous trade is hit. In such cases, new order will not be placed until it has certain distance from stop line.
Trade Prameters:
Exit on Signal : To be used with caution. Enabling it will allow us to get out on bad trades early and helps exit trades in long consolidation periods. But, this may also cause early exit in the trend. If instrument is trending nicely, it is better to keep this setting unchecked.
Trade direction : Default is long only. Short trades are not so successful in backtest. Use it with caution.
Backtest years : limit backtesting to certain years.
Part of the logic used from study's below:
Other strategies based on these two studies are below (which are meant for short - medium terms):
Quantum TrendsOne of the oldest maxims in trading is ‘let the trend be your friend’. You must have come across it. This is easier said than done. First, you have to identify one, then you have to stay in – not easy. Staying in a trend to maximise your profits is extremely difficult. In addition, how do you know when a trend has started?
It’s very easy to look back and identify the trend. Not so easy at the live edge of the market.
The Quantum Trends indicator is the ‘sister’ indicator of the Quantum Trend Monitor. Together they go hand in hand to keep you in and surfing the trend. The Quantum Trends catches the shorter term trend, the Quantum Trend Monitor keeps you in for the longer term. A match made in heaven.
The Quantum Trends indicator paints a series of dots on the price chart as follows:
Bullish trend – blue
Bearish trend – red
Congestion – grey
Once a new trend starts, the dots change colour dynamically, from blue to red or grey.
Contrary to what you may have read, currency markets spend more time in congestion, than they do trending. Congestion phases are the most important aspect of price action. This is where trends pause, die or are reborn.
Now, you no longer need to guess if a new trend is starting. The Quantum Trends indicator will tell you, simply and clearly. When combined with the Quantum Trend Monitor, and trading in multiple timeframes, you will never again suffer from emotional trading decisions. Your trading account will grow, as will your confidence.
And of course, as with all Quantum indicators, there is always more. Again, the Quantum Trends indicator can be fine-tuned to match your own trading style. No two traders are the same. No two trading styles are the same. Strange then, most indicators are designed on the ‘one size fits all’ principle. Not with Quantum Trading.
The Quantum Trends indicator can be fine-tuned, giving you the right tools for the right job. If you prefer scalping, simply adjust the settings accordingly and increase the sensitivity. A precision tool for precision trading. If your approach is longer term, perhaps swing or trend trading, simply adjust the control and decrease the sensitivity. It ’s like the thermostat on your boiler. Choose your strategy, adjust your indicator, and watch your profits increase.
The Quantum Trends indicator works in all timeframes.
Range Trends Enhanced (eleven11)This indicator automatically draws your Range Trend lines based upon your timeframe. When you select a timeframe, in the options, those lines will be locked in, whenever you switch timeframes on the chart. This allows you to "lock in" a timeframe's trendlines and then view it on different timeframes. But if you want to view the current trendlines for a timeframe then you need to select that "lockdown" timeframe in the settings. The original code was created by eleven11
[blackcat] L3 Trend BoxOVERVIEW
The L3 Trend Box indicator is a sophisticated technical analysis tool designed to assist traders in identifying trends and pinpointing potential entry and exit points within the market. By leveraging multiple moving averages and price level analyses, this indicator provides a detailed view of market dynamics. It plots several key lines and labels directly onto the chart, offering clear visual signals for both bullish and bearish scenarios. Its adaptability through customizable parameters makes it suitable for various trading strategies and market conditions 📊✅.
FEATURES
Comprehensive Parameter Customization: Tailor the indicator to match specific trading preferences:
High Length: Defines the period over which the highest prices are considered.
Low Length: Specifies the period for evaluating the lowest prices.
Upper Box Length: Smoothes out the upper boundary of the trend box using a specified period.
Lower Box Length: Smoothes out the lower boundary of the trend box similarly.
Trend Line Length: Determines the period for calculating the overall trend line.
Fast EMA Length: Sets the period for the fast-moving exponential moving average (EMA), crucial for capturing short-term movements.
MA15 EMA Length: Configures the period for the medium-term moving average (MA15 EMA) to provide a balanced perspective.
Short Spirit Length: Influences how quickly the indicator responds to recent price changes.
Golden EMA Length: Fine-tunes the long-term EMA for stability and reliability.
Buy Price Length: Establishes the lookback period for determining optimal buy prices.
Var1 Length & Var2 Length: Adjusts periods for variance calculations, enhancing the accuracy of trend detection.
Detailed Chart Plots:
Upper Box Top: A fuchsia-colored line representing the smoothed highest prices, marking resistance levels.
Lower Box Bottom: A green-colored line showing the smoothed lowest prices, highlighting support zones.
MA15 Up/Down: Dynamic red and green lines illustrating the directionality of the 15-period EMA, helping gauge momentum shifts.
Conditional Plots: Multiple lines based on intricate price actions and computed values, such as closing below the lower box while also closing at or above/below the opening price, ensuring nuanced insights into market behavior.
Buy/Sell Labels: Clearly marked 'Buy' and 'Sell' labels positioned strategically on the chart, facilitating quick decision-making without missing critical signals 🎯.
Alert System: Automatically generates alerts based on predefined buy and sell conditions, enabling timely responses to market changes 🛎️.
HOW TO USE
Adding the Indicator: Start by adding the L3 Trend Box to your TradingView chart via the indicators menu.
Parameter Configuration: Adjust each parameter according to your trading style and market volatility. For instance, increasing the High Length can make the indicator less sensitive to minor fluctuations but more responsive to significant trends.
Monitoring Signals: Keep an eye on the plotted lines and labels. Pay special attention to the crossover events between the fast EMA and the lower box bottom, as these often signify strong buy signals.
Setting Alerts: Configure alerts based on the buy/sell conditions provided by the indicator. This ensures you never miss an opportunity due to inattention.
Combining Strategies: While powerful on its own, combining this indicator with others like RSI or Bollinger Bands can enhance its predictive power and reduce false positives.
LIMITATIONS
Market Volatility: In extremely volatile or sideways-trending markets, the indicator might produce false signals. Always verify with additional confirmations.
Asset-Specific Performance: Different assets and timeframes will yield varying results; thorough backtesting across diverse instruments is recommended.
Over-Reliance Risk: Avoid relying solely on this indicator. Integrate it into a broader analytical framework that includes fundamental analysis and other technical indicators.
NOTES
Data Sufficiency: Ensure ample historical data is available for precise computations. Lack of data can skew results and lead to inaccurate signals.
Demo Testing: Before deploying the indicator in real trades, rigorously test it on demo accounts under varied market conditions to understand its strengths and weaknesses.
Customization Flexibility: Feel free to tweak the parameters continuously until they align perfectly with your unique trading approach and risk tolerance.
Multi-Timeframe Trend Table📊 Multi-Timeframe Trend Table
Overview
This powerful trend-tracking tool gives you a real-time snapshot of market trends across multiple timeframes — all in one compact and color-coded table. Designed for traders who want fast, clean, and multi-timeframe awareness at a glance.
⸻
✅ Features
• 7 Key Timeframes Monitored:
2min · 5min · 15min · 1h · 4h · 1d · 1w
• Trend Detection Based on EMAs
Uses a fast (default 20) and slow (default 200) EMA to determine if a timeframe is trending:
• 🟢 Uptrend: Fast EMA is above slow EMA
• 🔴 Downtrend: Slow EMA is above fast EMA
• 🟠 Sideways: EMAs are close (configurable threshold)
• Raw EMA Distance
See the actual difference between fast and slow EMAs for each timeframe — great for gauging trend strength.
• EMA Slope Analysis
A unique “Slope” column tells you the current behavior of EMAs:
• 📈 Pointing Up
• 📉 Pointing Down
• 🔄 Crossing Up/Down
• ➡️ Lateral
• Instant Alerts
Alerts fire the moment a trend flips on any timeframe, keeping you ahead of market shifts.
• Optional Chart EMAs
Toggle on/off the fast and slow EMAs on your active chart for extra clarity.
⸻
🧠 Use Case Examples
• Confirm trades with alignment across multiple timeframes
• Spot early trend reversals with crossing behavior
• Add a higher-timeframe filter to your scalping system
• Monitor key EMAs without changing your chart timeframe
⸻
⚙️ Configuration
• EMA lengths and sideways threshold are fully adjustable
• Enable/disable chart overlays for EMAs
• Table dynamically updates in real time
⸻
💡 Pro Tip: Use this indicator alongside your entry strategy to only trade in the direction of the dominant trends.
⸻
projectiontrackingLibrary "projectiontracking"
Library contains few data structures and methods for tracking harmonic patterns and projections via pinescript.
method erase(this)
erase Harmonic Projection Drawing
Namespace types: HarmonicProjectionDrawing
Parameters:
this (HarmonicProjectionDrawing) : HarmonicProjectionDrawing object
Returns: void
method erase(this)
erase HarmonicProjection
Namespace types: HarmonicProjection
Parameters:
this (HarmonicProjection) : HarmonicProjection object
Returns: void
method draw(this)
draw HarmonicProjection
Namespace types: HarmonicProjection
Parameters:
this (HarmonicProjection) : HarmonicProjection object
Returns: HarmonicProjection object
method getRanges(projectionPrzRanges, dir)
Convert PRZRange to Projection ranges
Namespace types: array
Parameters:
projectionPrzRanges (array type from Trendoscope/HarmonicMapLib/1) : array of PrzRange objects
dir (int) : Projection direction
Returns: array
ProjectionRange
Harmonic Projection Range
Fields:
patterns (array) : array of pattern names
start (series float) : Start Range
end (series float) : End Range
status (series int) : Projection Status
ProjectionProperties
Harmonic Projection Properties
Fields:
fillMajorTriangles (series bool) : Use linefill for major triangles
fillMinorTriangles (series bool) : Use linefill for minor triangles
majorFillTransparency (series int) : transparency of major triangles
minorFillTransparency (series int) : transparency of minor triangles
showXABC (series bool) : Show XABC labels
lblSizePivots (series string) : Pivot labels size
showRatios (series bool) : Show ratio labels
useLogScaleForScan (series bool) : Log scale is used for scanning projections
activateOnB (series bool) : Activate projections on reaching B
activationRatio (series float) : Use activation ratio for activation
confirmationRatio (series float) : Confirmation ratio of projection before removal
HarmonicProjectionDrawing
Harmonic Projection Projection drawing objects
Fields:
xa (series line) : line xa
ab (series line) : line ab
bc (series line) : line bc
xb (series line) : line xb
ac (series line) : line ac
x (series label) : Pivot label x
a (series label) : Pivot label a
b (series label) : Pivot label b
c (series label) : Pivot label c
xabRatio (series label) : Label XAB Ratio
abcRatio (series label) : Label ABC Ratio
HarmonicProjection
Harmonic Projection Projection object
Fields:
patternId (series int) : id of the pattern
dir (series int) : projection direction
x (chart.point) : Pivot X
a (chart.point) : Pivot A
b (chart.point) : Pivot B
c (chart.point) : Pivot C
patternColor (series color) : Color in which pattern is displayed
przRange (PrzRange type from Trendoscope/HarmonicMapLib/1) : PRZ Range
activationPrice (series float) : Projection activation price
reversalPrice (series float) : Projection reversal price
status (series int) : Projection status
properties (ProjectionProperties) : Projection properties
projectionRanges (array) : array of Projection Ranges
initialD (series float) : Initial D pivot
d (chart.point) : Pivot D
drawing (HarmonicProjectionDrawing) : HarmonicProjectionDrawing Object
ACCURATE TREND LEVELS - TABLE PSv6.1Accurate Trend Level Indicator
Description:
The "Accurate Trend Level" indicator is a powerful tool designed to identify market trends and potential reversals with precision. Built on the concept (foundation) of Swing Highs and Swing Lows, this indicator easily detects uptrends and downtrends, providing traders with clear signals for trend continuation or reversal. Whether you are a swing trader or a trend follower, this indicator offers customization options to suit your trading style.
Key Features:
Trend Identification: Accurately identifies uptrends and downtrends based on Swing High and Swing Low points. This indicator provides signals for Up after Down and Down after Up.
Percentage Adjustment: Includes a customizable percentage factor that reduces false signals and helps identify accurate and strong trends.
Trend Table: Displays essential data in a table, such as:
Last and running Trend Position (Uptrend/Downtrend)
Date and Time of the last and running trend change
Reversal Level (price level for the next potential trend change)
Max. Run-up feature is also provided, which shows how much the market has moved according to the trend.
How It Works:
The indicator analyzes price action using Swing Highs and Lows to determine the current trend direction. A user-defined percentage threshold filters out minor fluctuations, ensuring only significant trends are highlighted. The table provides a quick snapshot of the latest trend data, while reversal levels help traders anticipate the next move.
Future Trend Indicator (FTI) with Heiken AshiDescription: Future Trend Indicator (FTI)
The Future Trend Indicator (FTI) is a versatile and innovative tool designed to analyze market trends, smooth out noise, and provide a forward-looking forecast of potential price movements. Built with advanced features such as polynomial regression, EMA smoothing, confidence bands, and cross-validation metrics, this indicator offers a comprehensive approach for traders to gain insights into future price trends while maintaining realistic error margins.
Key Features:
Exponential Moving Average (EMA) Integration
The FTI incorporates a user-configurable EMA to smooth out short-term price fluctuations and highlight the overall market trend. This provides a stable and reliable reference for assessing price action.
Noise Reduction via Median Filter
To improve signal clarity, the source data is processed using a Median Filter, effectively reducing the impact of outliers and market noise. This ensures that the forecast focuses on meaningful price movements.
Polynomial Regression Forecast
A polynomial regression model is used to project future price movements based on historical data. This advanced statistical approach models potential non-linear trends, offering a sophisticated and adaptive forecast for the next specified period.
Confidence Bands for Forecast Accuracy
Upper and lower confidence bands are calculated using standard deviation, visually representing the potential error margin around the forecast. This feature provides traders with an understanding of the forecast's reliability and the expected price range.
Dynamic Visualization
The indicator uses visually appealing and intuitive plotting techniques:
A forecast line dynamically shifts based on polynomial regression and historical data.
Confidence bands are displayed with semi-transparent green (upper) and red (lower) shading for quick visual interpretation.
The EMA is displayed as a blue line for smooth trend observation.
Cross-Validation with RMSE (Root Mean Square Error)
The indicator includes an error metric to measure the accuracy of its forecast against actual future price movements. The RMSE is displayed as a yellow label on the chart, helping traders evaluate the forecast's historical precision.
Flexible Data Source
By default, the FTI uses hlc3 (the average of high, low, and close prices) as its source, providing a balanced view of market activity. Traders can easily customize this input to suit their preferences.
Forecast Customization
Users can configure the length of the forecast, moving average, and EMA to tailor the indicator to different trading styles and timeframes.
Short-Term Traders (Scalping/Day Trading)
EMA Length: 10
Moving Average Length: 5 to 10
Forecast Length: 50
Source: hlc3 (default)
Adjust noise filter (src_filtered) only if necessary.
Medium-Term Traders (Swing Trading)
EMA Length: 20
Moving Average Length: 10 to 20
Forecast Length: 100
Source: hlc3 (default)
Confidence bands can help manage risk for swing trades.
Long-Term Traders (Position Trading)
EMA Length: 50 to 200
Moving Average Length: 20 to 50
Forecast Length: 200
Source: hlc3 or ohlc4 for smoothing.
General Adjustments for Specific Markets:
Crypto (Highly Volatile)
EMA Length: 10 to 20
Moving Average Length: 10
Forecast Length: 50 to 100
Median filter length: 5
Forex (Moderately Volatile)
EMA Length: 20 to 50
Moving Average Length: 20
Forecast Length: 100
Median filter length: 5
Stocks/Indices (Less Volatile)
EMA Length: 50
Moving Average Length: 20
Forecast Length: 100 to 200
Median filter length: 5
Dual Zigzag [Trendoscope®]🎲 Dual Zigzag indicator is built on recursive zigzag algorithm. It is very similar to other zigzag indicators published by us and other authors. However, the key point here is, the indicator draws zigzag on both price and any other plot based indicator on separate layouts.
Before we get into the indicator, here are some brief descriptions of the underlying concepts and key terminologies
🎯 Zigzag
Zigzag indicator breaks down price or any input series into a series of Pivot Highs and Pivot Lows alternating between each other. Zigzags though shows pivot high and lows, should not be used for buying at low and selling at high. The main application of zigzag indicator is for the visualisation of market structure and this can be used as basic building block for any pattern recognition algorithms.
🎯 Recursive Zigzag Algorithm
Recursive zigzag algorithm builds zigzag on multiple levels and each level of zigzag is based on the previous level pivots. The level zero zigzag is built on price. However, for level 1, instead of price level 0 zigzag pivots are used. Similarly for level 2, level 1 zigzag pivots are used as base.
🎲 Components Dual Zigzag Indicator
Here are the components of Dual zigzag indicator
Built in Oscillator - Indicator has built in oscillator options for plotting RSI (Relative Strength Index), MFI (Money Flow Index), cci (Commodity Channel Index) , CMO (Chande Momentum Oscillator), COG (Center of Gravity), and ROC (Rate of Change). Apart from the given built in oscillators, users can also use a custom external output as base. The oscillators are not printed on the price pane. But, printed on a separate indicator overlay.
Zigzag On Oscillator - Recursive zigzag is calculated and printed on the oscillator series. Each pivot high and pivot low also prints a label having the retracement ratios, and price levels at those points. Zigzag on the oscillator is also printed on the indicator overlay pane.
Zigzag on Price - Recursive zigzag calculated based on price and printed on the price pane. This is made possible by using force_overlay option present in the drawing objects. At each zigzag pivot levels, the label having price retracement ratios, and oscillator values are printed.
It is called dual zigzag because, the indicator calculates the zigzag on both price and oscillator series of values and prints them separately on different panes on the chart.
🎲 Indicator Settings
Settings include
Theme display settings to get the right colour combination to match the background.
Zigzag settings to be used for zigzag calculation and display
Oscillator settings to chose the oscillator to be used as base for 2nd zigzag
🎲 Applications
Useful in spotting divergences with both indicator and price having their own zigzag to highlight pivots
Spotting patterns in indicators/oscillators and correlate them with the patterns on price
🎲 Using External Input
If users want to use an external indicator such as OBV instead of the built in oscillators, then can do so by using the custom option.
Here is how this can be done.
Step1. Add both Dual Zigzag and the intended indicator (in this case OBV) on the chart. Notice that both OBV and Dual zigzag appear on different panes.
Step2. Edit the indicator settings of Dual zigzag and set custom indicator by selecting "custom" as oscillator name and then by setting the custom external indicator name and input.
Step 3. You would notice that the zigzag in Dual Zigzag indictor pane is already showing the zigzag pivots based on the OBV indicator and the price pivots display obv values at the pivot points. We can leave this as is.
Step 4. As an additional step, you can also merge the OBV pane and the Dual zigzag indicator pane into one by going into OBV settings and moving the indicator to above pane. Merge the scales so that there is no two scales on the same pane and the entire scale appear on the right.
At the end, you should see two panes - one with price and other with OBV and both having their zigzag plotted.
HTF Candles Overlay [Trendoscope®]🎲 HTF Candles Overlay is a simple indicator where you can overlay higher timeframe candles on current timeframe chart.
Most of the code is encapsulated in the library HTFCandlesLib . After publishing the library as open source, many people requested to convert that into an indicator. Based on this, we decided to publish this small code for the use of community.
🎯 Usage
The indicator is simple, it helps users visualise higher timeframe candles. We majorly use this for debugging or validating our implementations based on higher timeframe. Instead of switching back and forth to different timeframes, it helps us visualise higher timeframe candles on the same chart when we are validating the implementation that involves higher timeframe calculations.
🎯 Components
The indicator provides two types of displays
Candles - overlay candles built through lines and labels
Plot - close price of higher timeframe plotted on chart
🎯 Candles
The behaviour of the candles are similar to that of hollow candles. The color of the body and the border+wick demonstrates the movement of the candle.
Body color is lime if the HTF close is higher than HTF open. Body color is orange if the HTF close is lower than the HTF open.
Wick and border color is lime if HTF close price is higher than previous HTF close price. And they are orange if HTF close price is lower than the previous HTF close price
In most cases body color will be same as the wick color. In case of stocks and indices, it may happen that the open price is too far away from previous close price due to gaps. This can lead to close price being relatively in different direction when compared to open and previous close.
Wicks are not at the centre of the candle. Instead wicks are drawn on the current chart timeframe position where the current timeframe has reached the highest or lowest point within the given HTF candle
Candles also list OHLC price of HTF candle along with HTF bar index and the range of LTF bar index that the candle spawns
Here are some pictorial representations that can help understand better.
Here are the examples of candles with gaps where body and wick/border are in different directions (colours)
🎯 Indicator Settings
Simple settings allow users to select the timeframe, whether to display candles and plots and their specific colors.
🎯 Possible inconsistencies
The overlay can show inconsistent data in certain situations. Here are some of the scenarios where the indicator may not show consistent display of the data.
When the HTF data from request.security does not match that of combined LTF data . In such cases, HTF candles may not form inline with the current timeframe candles. This happens when there is a data issue of different OHLC data available in tradingview.
When using weekly candle as either chart timeframe or higher timeframe - end of week may not coincide with end of month or other timeframes. This can cause some inconsistencies in the visuals of the indicator.
When open and close time of either LTF or HTF falls under different day due to time zone used. - time is always the time on which the candle close. So, when we use time zone that causes the exchange day to open and close on different days, that can cause some inconsistencies in the candles being drawn.
PitchforkLibrary "Pitchfork"
Pitchfork class
method tostring(this)
Converts PitchforkTypes/Fork object to string representation
Namespace types: Fork
Parameters:
this (Fork) : PitchforkTypes/Fork object
Returns: string representation of PitchforkTypes/Fork
method tostring(this)
Converts Array of PitchforkTypes/Fork object to string representation
Namespace types: array
Parameters:
this (array) : Array of PitchforkTypes/Fork object
Returns: string representation of PitchforkTypes/Fork array
method tostring(this, sortKeys, sortOrder)
Converts PitchforkTypes/PitchforkProperties object to string representation
Namespace types: PitchforkProperties
Parameters:
this (PitchforkProperties) : PitchforkTypes/PitchforkProperties object
sortKeys (bool) : If set to true, string output is sorted by keys.
sortOrder (int) : Applicable only if sortKeys is set to true. Positive number will sort them in ascending order whreas negative numer will sort them in descending order. Passing 0 will not sort the keys
Returns: string representation of PitchforkTypes/PitchforkProperties
method tostring(this, sortKeys, sortOrder)
Converts PitchforkTypes/PitchforkDrawingProperties object to string representation
Namespace types: PitchforkDrawingProperties
Parameters:
this (PitchforkDrawingProperties) : PitchforkTypes/PitchforkDrawingProperties object
sortKeys (bool) : If set to true, string output is sorted by keys.
sortOrder (int) : Applicable only if sortKeys is set to true. Positive number will sort them in ascending order whreas negative numer will sort them in descending order. Passing 0 will not sort the keys
Returns: string representation of PitchforkTypes/PitchforkDrawingProperties
method tostring(this, sortKeys, sortOrder)
Converts PitchforkTypes/Pitchfork object to string representation
Namespace types: Pitchfork
Parameters:
this (Pitchfork) : PitchforkTypes/Pitchfork object
sortKeys (bool) : If set to true, string output is sorted by keys.
sortOrder (int) : Applicable only if sortKeys is set to true. Positive number will sort them in ascending order whreas negative numer will sort them in descending order. Passing 0 will not sort the keys
Returns: string representation of PitchforkTypes/Pitchfork
method createDrawing(this)
Creates PitchforkTypes/PitchforkDrawing from PitchforkTypes/Pitchfork object
Namespace types: Pitchfork
Parameters:
this (Pitchfork) : PitchforkTypes/Pitchfork object
Returns: PitchforkTypes/PitchforkDrawing object created
method createDrawing(this)
Creates PitchforkTypes/PitchforkDrawing array from PitchforkTypes/Pitchfork array of objects
Namespace types: array
Parameters:
this (array) : array of PitchforkTypes/Pitchfork object
Returns: array of PitchforkTypes/PitchforkDrawing object created
method draw(this)
draws from PitchforkTypes/PitchforkDrawing object
Namespace types: PitchforkDrawing
Parameters:
this (PitchforkDrawing) : PitchforkTypes/PitchforkDrawing object
Returns: PitchforkTypes/PitchforkDrawing object drawn
method delete(this)
deletes PitchforkTypes/PitchforkDrawing object
Namespace types: PitchforkDrawing
Parameters:
this (PitchforkDrawing) : PitchforkTypes/PitchforkDrawing object
Returns: PitchforkTypes/PitchforkDrawing object deleted
method delete(this)
deletes underlying drawing of PitchforkTypes/Pitchfork object
Namespace types: Pitchfork
Parameters:
this (Pitchfork) : PitchforkTypes/Pitchfork object
Returns: PitchforkTypes/Pitchfork object deleted
method delete(this)
deletes array of PitchforkTypes/PitchforkDrawing objects
Namespace types: array
Parameters:
this (array) : Array of PitchforkTypes/PitchforkDrawing object
Returns: Array of PitchforkTypes/PitchforkDrawing object deleted
method delete(this)
deletes underlying drawing in array of PitchforkTypes/Pitchfork objects
Namespace types: array
Parameters:
this (array) : Array of PitchforkTypes/Pitchfork object
Returns: Array of PitchforkTypes/Pitchfork object deleted
method clear(this)
deletes array of PitchforkTypes/PitchforkDrawing objects and clears the array
Namespace types: array
Parameters:
this (array) : Array of PitchforkTypes/PitchforkDrawing object
Returns: void
method clear(this)
deletes array of PitchforkTypes/Pitchfork objects and clears the array
Namespace types: array
Parameters:
this (array) : Array of Pitchfork/Pitchfork object
Returns: void
PitchforkDrawingProperties
Pitchfork Drawing Properties object
Fields:
extend (series bool) : If set to true, forks are extended towards right. Default is true
fill (series bool) : Fill forklines with transparent color. Default is true
fillTransparency (series int) : Transparency at which fills are made. Only considered when fill is set. Default is 80
forceCommonColor (series bool) : Force use of common color for forks and fills. Default is false
commonColor (series color) : common fill color. Used only if ratio specific fill colors are not available or if forceCommonColor is set to true.
PitchforkDrawing
Pitchfork drawing components
Fields:
medianLine (Line type from Trendoscope/Drawing/2) : Median line of the pitchfork
baseLine (Line type from Trendoscope/Drawing/2) : Base line of the pitchfork
forkLines (array type from Trendoscope/Drawing/2) : fork lines of the pitchfork
linefills (array type from Trendoscope/Drawing/2) : Linefills between forks
Fork
Fork object property
Fields:
ratio (series float) : Fork ratio
forkColor (series color) : color of fork. Default is blue
include (series bool) : flag to include the fork in drawing. Default is true
PitchforkProperties
Pitchfork Properties
Fields:
forks (array) : Array of Fork objects
type (series string) : Pitchfork type. Supported values are "regular", "schiff", "mschiff", Default is regular
inside (series bool) : Flag to identify if to draw inside fork. If set to true, inside fork will be drawn
Pitchfork
Pitchfork object
Fields:
a (chart.point) : Pivot Point A of pitchfork
b (chart.point) : Pivot Point B of pitchfork
c (chart.point) : Pivot Point C of pitchfork
properties (PitchforkProperties) : PitchforkProperties object which determines type and composition of pitchfork
dProperties (PitchforkDrawingProperties) : Drawing properties for pitchfork
lProperties (LineProperties type from Trendoscope/Drawing/2) : Common line properties for Pitchfork lines
drawing (PitchforkDrawing) : PitchforkDrawing object
utilsLibrary "utils"
Few essentials captured together (subset of arrayutils)
timer(timeStart, timeEnd)
finds difference between two timestamps
Parameters:
timeStart (int) : start timestamp
timeEnd (int)
Returns:
method check_overflow(pivots, barArray, dir)
finds difference between two timestamps
Namespace types: array
Parameters:
pivots (array) : pivots array
barArray (array) : pivot bar array
dir (int) : direction for which overflow need to be checked
Returns: bool overflow
method get_trend_series(pivots, length, highLow, trend)
finds series of pivots in particular trend
Namespace types: array
Parameters:
pivots (array) : pivots array
length (int) : length for which trend series need to be checked
highLow (int) : filter pivot high or low
trend (int) : Uptrend or Downtrend
Returns: int trendIndexes
method get_trend_series(pivots, firstIndex, lastIndex)
finds series of pivots in particular trend
Namespace types: array
Parameters:
pivots (array) : pivots array
firstIndex (int) : First index of the series
lastIndex (int) : Last index of the series
Returns: int trendIndexes
getConsolidatedLabel(include, labels, separator)
Consolidates labels into single string by concatenating it with given separator
Parameters:
include (array) : array of conditions to include label or not
labels (array) : string array of labels
separator (string) : Separator for concatenating labels
Returns: string labelText
method getColors(theme)
gets array of colors based on theme
Namespace types: series Theme
Parameters:
theme (series Theme) : dark or light theme
Returns: color themeColors
