GL LineIntroduction
The GL Line Indicator is a versatile tool designed to assist traders in identifying market trends by utilizing three different types of moving averages (EMA, SMA, VWMA) across multiple timeframes. This indicator provides a comprehensive view of market conditions, making it easier to spot potential trading opportunities.
Features
Multiple Moving Average Types:
Choose between Exponential Moving Average (EMA), Simple Moving Average (SMA), and Volume Weighted Moving Average (VWMA) for more tailored analysis.
Triple Timeframe Analysis:
Analyze trends across three different timeframes (Main, Secondary, Tertiary) to get a clearer picture of market direction.
Configurable Parameters:
Customizable lengths for fast and slow-moving averages. Adjustable ATR length and multiplier to refine trend detection sensitivity.
Visual Trend Indication:
Bullish and bearish trends are marked with color-coded lines and fills, enhancing visual clarity.
Confluence Table:
Optional confluence table that shows trend direction across the selected timeframes, aiding in decision-making.
How It Works
Main Trend Calculation:
Select the type of moving average and set the lengths for fast and slow MAs. The difference between these MAs, adjusted by the ATR multiplier, determines the trend direction.
Secondary and Tertiary Trends:
Similar calculations are done for secondary and tertiary timeframes, providing a broader market overview.
Trend Direction and Plotting:
The indicator plots the moving averages and fills the area between them with colors to denote bullish (green) and bearish (red) trends.
How to Use
Select Moving Average Type:
Choose between EMA, SMA, or VWMA based on your trading strategy.
Set Lengths and Multipliers:
Customize the lengths for the fast and slow-moving averages and adjust the ATR length and multiplier for better trend sensitivity.
Analyze Trends:
Use the color-coded plots and fills to identify market trends and make informed trading decisions.
Check Confluence Table:
Optionally display the confluence table to see trend directions across different timeframes.
Disclaimer
This indicator is designed to work best when the secondary and tertiary trends are set to higher timeframes than the chart's timeframe. Using higher timeframes for additional trends provides a broader market perspective and enhances the reliability of trend signals.
在腳本中搜尋"Table"
Machine Learning: Optimal RSI [YinYangAlgorithms]This Indicator, will rate multiple different lengths of RSIs to determine which RSI to RSI MA cross produced the highest profit within the lookback span. This ‘Optimal RSI’ is then passed back, and if toggled will then be thrown into a Machine Learning calculation. You have the option to Filter RSI and RSI MA’s within the Machine Learning calculation. What this does is, only other Optimal RSI’s which are in the same bullish or bearish direction (is the RSI above or below the RSI MA) will be added to the calculation.
You can either (by default) use a Simple Average; which is essentially just a Mean of all the Optimal RSI’s with a length of Machine Learning. Or, you can opt to use a k-Nearest Neighbour (KNN) calculation which takes a Fast and Slow Speed. We essentially turn the Optimal RSI into a MA with different lengths and then compare the distance between the two within our KNN Function.
RSI may very well be one of the most used Indicators for identifying crucial Overbought and Oversold locations. Not only that but when it crosses its Moving Average (MA) line it may also indicate good locations to Buy and Sell. Many traders simply use the RSI with the standard length (14), however, does that mean this is the best length?
By using the length of the top performing RSI and then applying some Machine Learning logic to it, we hope to create what may be a more accurate, smooth, optimal, RSI.
Tutorial:
This is a pretty zoomed out Perspective of what the Indicator looks like with its default settings (except with Bollinger Bands and Signals disabled). If you look at the Tables above, you’ll notice, currently the Top Performing RSI Length is 13 with an Optimal Profit % of: 1.00054973. On its default settings, what it does is Scan X amount of RSI Lengths and checks for when the RSI and RSI MA cross each other. It then records the profitability of each cross to identify which length produced the overall highest crossing profitability. Whichever length produces the highest profit is then the RSI length that is used in the plots, until another length takes its place. This may result in what we deem to be the ‘Optimal RSI’ as it is an adaptive RSI which changes based on performance.
In our next example, we changed the ‘Optimal RSI Type’ from ‘All Crossings’ to ‘Extremity Crossings’. If you compare the last two examples to each other, you’ll notice some similarities, but overall they’re quite different. The reason why is, the Optimal RSI is calculated differently. When using ‘All Crossings’ everytime the RSI and RSI MA cross, we evaluate it for profit (short and long). However, with ‘Extremity Crossings’, we only evaluate it when the RSI crosses over the RSI MA and RSI <= 40 or RSI crosses under the RSI MA and RSI >= 60. We conclude the crossing when it crosses back on its opposite of the extremity, and that is how it finds its Optimal RSI.
The way we determine the Optimal RSI is crucial to calculating which length is currently optimal.
In this next example we have zoomed in a bit, and have the full default settings on. Now we have signals (which you can set alerts for), for when the RSI and RSI MA cross (green is bullish and red is bearish). We also have our Optimal RSI Bollinger Bands enabled here too. These bands allow you to see where there may be Support and Resistance within the RSI at levels that aren’t static; such as 30 and 70. The length the RSI Bollinger Bands use is the Optimal RSI Length, allowing it to likewise change in correlation to the Optimal RSI.
In the example above, we’ve zoomed out as far as the Optimal RSI Bollinger Bands go. You’ll notice, the Bollinger Bands may act as Support and Resistance locations within and outside of the RSI Mid zone (30-70). In the next example we will highlight these areas so they may be easier to see.
Circled above, you may see how many times the Optimal RSI faced Support and Resistance locations on the Bollinger Bands. These Bollinger Bands may give a second location for Support and Resistance. The key Support and Resistance may still be the 30/50/70, however the Bollinger Bands allows us to have a more adaptive, moving form of Support and Resistance. This helps to show where it may ‘bounce’ if it surpasses any of the static levels (30/50/70).
Due to the fact that this Indicator may take a long time to execute and it can throw errors for such, we have added a Setting called: Adjust Optimal RSI Lookback and RSI Count. This settings will automatically modify the Optimal RSI Lookback Length and the RSI Count based on the Time Frame you are on and the Bar Indexes that are within. For instance, if we switch to the 1 Hour Time Frame, it will adjust the length from 200->90 and RSI Count from 30->20. If this wasn’t adjusted, the Indicator would Timeout.
You may however, change the Setting ‘Adjust Optimal RSI Lookback and RSI Count’ to ‘Manual’ from ‘Auto’. This will give you control over the ‘Optimal RSI Lookback Length’ and ‘RSI Count’ within the Settings. Please note, it will likely take some “fine tuning” to find working settings without the Indicator timing out, but there are definitely times you can find better settings than our ‘Auto’ will create; especially on higher Time Frames. The Minimum our ‘Auto’ will create is:
Optimal RSI Lookback Length: 90
RSI Count: 20
The Maximum it will create is:
Optimal RSI Lookback Length: 200
RSI Count: 30
If there isn’t much bar index history, for instance, if you’re on the 1 Day and the pair is BTC/USDT you’ll get < 4000 Bar Indexes worth of data. For this reason it is possible to manually increase the settings to say:
Optimal RSI Lookback Length: 500
RSI Count: 50
But, please note, if you make it too high, it may also lead to inaccuracies.
We will conclude our Tutorial here, hopefully this has given you some insight as to how calculating our Optimal RSI and then using it within Machine Learning may create a more adaptive RSI.
Settings:
Optimal RSI:
Show Crossing Signals: Display signals where the RSI and RSI Cross.
Show Tables: Display Information Tables to show information like, Optimal RSI Length, Best Profit, New Optimal RSI Lookback Length and New RSI Count.
Show Bollinger Bands: Show RSI Bollinger Bands. These bands work like the TDI Indicator, except its length changes as it uses the current RSI Optimal Length.
Optimal RSI Type: This is how we calculate our Optimal RSI. Do we use all RSI and RSI MA Crossings or just when it crosses within the Extremities.
Adjust Optimal RSI Lookback and RSI Count: Auto means the script will automatically adjust the Optimal RSI Lookback Length and RSI Count based on the current Time Frame and Bar Index's on chart. This will attempt to stop the script from 'Taking too long to Execute'. Manual means you have full control of the Optimal RSI Lookback Length and RSI Count.
Optimal RSI Lookback Length: How far back are we looking to see which RSI length is optimal? Please note the more bars the lower this needs to be. For instance with BTC/USDT you can use 500 here on 1D but only 200 for 15 Minutes; otherwise it will timeout.
RSI Count: How many lengths are we checking? For instance, if our 'RSI Minimum Length' is 4 and this is 30, the valid RSI lengths we check is 4-34.
RSI Minimum Length: What is the RSI length we start our scans at? We are capped with RSI Count otherwise it will cause the Indicator to timeout, so we don't want to waste any processing power on irrelevant lengths.
RSI MA Length: What length are we using to calculate the optimal RSI cross' and likewise plot our RSI MA with?
Extremity Crossings RSI Backup Length: When there is no Optimal RSI (if using Extremity Crossings), which RSI should we use instead?
Machine Learning:
Use Rational Quadratics: Rationalizing our Close may be beneficial for usage within ML calculations.
Filter RSI and RSI MA: Should we filter the RSI's before usage in ML calculations? Essentially should we only use RSI data that are of the same type as our Optimal RSI? For instance if our Optimal RSI is Bullish (RSI > RSI MA), should we only use ML RSI's that are likewise bullish?
Machine Learning Type: Are we using a Simple ML Average, KNN Mean Average, KNN Exponential Average or None?
KNN Distance Type: We need to check if distance is within the KNN Min/Max distance, which distance checks are we using.
Machine Learning Length: How far back is our Machine Learning going to keep data for.
k-Nearest Neighbour (KNN) Length: How many k-Nearest Neighbours will we account for?
Fast ML Data Length: What is our Fast ML Length? This is used with our Slow Length to create our KNN Distance.
Slow ML Data Length: What is our Slow ML Length? This is used with our Fast Length to create our KNN Distance.
If you have any questions, comments, ideas or concerns please don't hesitate to contact us.
HAPPY TRADING!
regressionUtilitiesLibrary "regressionUtilities"
get_linear_regression(bar_index_array, prices_array, stdDev_mult)
: Generates the linear regression channel for an array of values.
Parameters:
bar_index_array (array) : (array): Array with bar indexes
prices_array (array) : (array): Array with prices
stdDev_mult (float) : (float): Standard deviation multiple for the channels
Returns: : Returns x1, x2, y1_mid, y2_mid, y1_up, y2_up, y1_dn, y2_dn, m, b, R2, stdDev
get_optimal_linearRegression_channel(max_length, min_length, source, stdDev_mult, show_data_table, tableYpos, tableXpos, table_textSize, barsToRight, plot_labels, include_levels)
: Gets the best fitting linear regression using optimum length
Parameters:
max_length (int) : (int): Maximum bar length
min_length (int) : (int): Minimum bar length
source (float) : (float): Source for the regression
stdDev_mult (float) : (float): Array with prices
show_data_table (bool) : (bool): Activates and shows the data table
tableYpos (string)
tableXpos (string)
table_textSize (string)
barsToRight (int)
plot_labels (bool)
include_levels (bool)
Returns: : Returns three line objects that conform the regression channel, plus the optimal length and maximum r2
get_regressionChannel_data(max_length, min_length, source, stdDev_mult, plot_linearRegression, plot_labels, include_levels, barsToRight)
: Gets data for the linear regression channel
Parameters:
max_length (int) : (int): Maximum length for the linear regression.
min_length (int) : (int): Minimum length for the linear regression.
source (float) : (float): Source for the linear regression
stdDev_mult (float) : (float): Multiple for the standar deviations for the linear regression channel.
plot_linearRegression (bool)
plot_labels (bool)
include_levels (bool)
barsToRight (int)
Returns: : Returns a maps with the regression levels, the direction flag and the datatable map.
get_regressionChannel_data_v2(max_length, min_length, source, stdDev_mult, plot_linearRegression, plot_labels, include_levels, barsToRight)
Parameters:
max_length (int)
min_length (int)
source (float)
stdDev_mult (float)
plot_linearRegression (bool)
plot_labels (bool)
include_levels (bool)
barsToRight (int)
get_cuadratic_regression(x_array, y_array, bars_to_project, max_length)
: Gets the best fitting linear regression using optimum length
Parameters:
x_array (array) : (array): Maximum bar length
y_array (array) : (array): Minimum bar length
bars_to_project (int) : (int): Array with prices
max_length (int)
Returns: : Returns three line objects
Indicator DashboardThis script creates an 'Indicator Dashboard' designed to assist you in analyzing financial markets and making informed decisions. The indicator provides a summary of current market conditions by presenting various technical analysis indicators in a table format. The dashboard evaluates popular indicators such as Moving Averages, RSI, MACD, and Stochastic RSI. Below, we'll explain each part of this script in detail and its purpose:
### Overview of Indicators
1. **Moving Averages (MA)**:
- This indicator calculates Simple Moving Averages (“SMA”) for 5, 14, 20, 50, 100, and 200 periods. These averages provide a visual summary of price movements. Depending on whether the price is above or below the moving average, it determines the market direction as either “Bullish” or “Bearish.”
2. **RSI (Relative Strength Index)**:
- The RSI helps identify overbought or oversold market conditions. Here, the RSI is calculated for a 14-period window, and this value is displayed in the table. Additionally, the 14-period moving average of the RSI is also included.
3. **MACD (Moving Average Convergence Divergence)**:
- The MACD indicator is used to determine trend strength and potential reversals. This script calculates the MACD line, signal line, and histogram. The MACD condition (“Bullish,” “Bearish,” or “Neutral”) is displayed alongside the MACD and signal line values.
4. **Stochastic RSI**:
- Stochastic RSI is used to identify momentum changes in the market. The %K and %D lines are calculated to determine the market condition (“Bullish” or “Bearish”), which is displayed along with the calculated values for %K and %D.
### Table Layout and Presentation
The dashboard is presented in a vertical table format in the top-right corner of the chart. The table contains two columns: “Indicator” and “Status,” summarizing the condition of each technical indicator.
- **Indicator Column**: Lists each of the indicators being tracked, such as SMA values, RSI, MACD, etc.
- **Status Column**: Displays the current status of each indicator, such as “Bullish,” “Bearish,” or specific values like the RSI or MACD.
The table also includes rounded indicator values for easier interpretation. This helps traders quickly assess market conditions and make informed decisions based on multiple indicators presented in a single location.
### Detailed Indicator Status Calculations
1. **SMA Status**: For each moving average (5, 14, 20, 50, 100, 200), the script checks if the current price is above or below the SMA. The status is determined as “Bullish” if the price is above the SMA and “Bearish” if below, with the value of the SMA also displayed.
2. **RSI and RSI Average**: The RSI value for a 14-period is displayed along with its 14-period SMA, which provides an average reading of the RSI to smooth out volatility.
3. **MACD Indicator**: The MACD line, signal line, and histogram are calculated using standard parameters (12, 26, 9). The status is shown as “Bullish” when the MACD line is above the signal line, and “Bearish” when it is below. The exact values for the MACD line, signal line, and histogram are also included.
4. **Stochastic RSI**: The %K and %D lines of the Stochastic RSI are used to determine the trend condition. If %K is greater than %D, the condition is “Bullish,” otherwise it is “Bearish.” The actual values of %K and %D are also displayed.
### Conclusion
The 'Indicator Dashboard' provides a comprehensive overview of multiple technical indicators in a single, easy-to-read table. This allows traders to quickly gauge market conditions and make more informed decisions. By consolidating key indicators like Moving Averages, RSI, MACD, and Stochastic RSI into one dashboard, it saves time and enhances the efficiency of technical analysis.
This script is particularly useful for traders who prefer a clean and organized overview of their favorite indicators without needing to plot each one individually on the chart. Instead, all the crucial information is available at a glance in a consolidated format.
Sri Yantra MTF - AynetSri Yantra MTF - Aynet Script Overview
This Pine Script generates a Sri Yantra-inspired geometric pattern overlay on price charts. The pattern is dynamically updated based on multi-timeframe (MTF) inputs, utilizing high and low price ranges, and adjusting its size relative to a chosen multiplier.
The Sri Yantra is a sacred geometric figure used in various spiritual and mathematical contexts, symbolizing the interconnectedness of the universe. Here, it is applied to visualize structured price levels.
Scientific and Technical Explanation
Multi-Timeframe Integration:
Base Timeframe (baseRes): This is the primary timeframe for the analysis. The opening price and ATR (Average True Range) are calculated from this timeframe.
Pattern Timeframe (patternRes): Defines the granularity of the pattern. It ensures synchronization with price movements on specific time intervals.
Geometric Construction:
ATR-Based Scaling: The script uses ATR as a volatility measure to dynamically size the geometric pattern. The sizeMult input scales the pattern relative to price volatility.
Pattern Width (barOffset): Defines the horizontal extent of the pattern in terms of bars. This ensures the pattern is aligned with price movements and scales appropriately.
Sri Yantra-Like Geometry:
Outer Square: A bounding box is drawn around the price level.
Triangles: Multiple layers of triangles (primary, secondary, and tertiary) are calculated and drawn to mimic the structure of the Sri Yantra. These triangles converge and diverge based on price levels.
Horizontal Lines: Added at key levels to provide additional structure and aesthetic alignment.
Dynamic Updates:
The pattern recalculates and redraws itself on the last bar of the selected timeframe, ensuring it adapts to real-time price data.
A built-in check identifies new bars in the chosen timeframe (patternRes), ensuring accurate updates.
Information Table:
Displays the selected base and pattern timeframes in a table format on the top-right corner of the chart.
Allows traders to see the active settings for quick adjustments.
Key Inputs
Style Settings:
Pattern Color: Customize the color of the geometric patterns.
Size Multiplier (sizeMult): Adjusts the size of the pattern relative to price movements.
Line Width: Controls the thickness of the geometric lines.
Timeframe Settings:
Base Resolution (baseRes): Timeframe for calculating the pattern's anchor (default: daily).
Pattern Resolution (patternRes): Timeframe granularity for the pattern’s formation.
Geometric Adjustments:
Pattern Width (barOffset): Horizontal width in bars.
ATR Multiplier (rangeSize): Vertical size adjustment based on price volatility.
Scientific Concepts
Volatility Representation:
ATR (Average True Range): A standard measure of market volatility, representing the average range of price movements over a defined period. Here, ATR adjusts the vertical height of the geometric figures.
Geometric Symmetry:
The script emulates symmetry similar to the Sri Yantra, aligning with the principles of sacred geometry, which often appear in nature and mathematical constructs. Symmetry in financial data visualizations can aid in intuitive interpretation of price movements.
Multi-Timeframe Fusion:
Synchronizing patterns with multiple timeframes enhances the relevance of overlays for different trading strategies. For example, daily trends combined with hourly patterns can help traders optimize entries and exits.
Visual Features
Outer Square:
Drawn to encapsulate the geometric structure.
Represents the broader context of price levels.
Triangles:
Three layers of interlocking triangles create a fractal pattern, providing a visual alignment to price dynamics.
Horizontal Lines:
Emphasize critical levels within the pattern, offering visual cues for potential support or resistance areas.
Information Table:
Displays the active timeframe settings, helping traders quickly verify configurations.
Applications
Trend Visualization:
Patterns overlay on price movements provide a clearer view of trend direction and potential reversals.
Volatility Mapping:
ATR-based scaling ensures the pattern adjusts to varying market conditions, making it suitable for different asset classes and trading strategies.
Multi-Timeframe Analysis:
Integrates higher and lower timeframes, enabling traders to spot confluences between short-term and long-term price levels.
Potential Enhancements
Add Fibonacci Levels: Overlay Fibonacci retracements within the pattern for deeper price level insights.
Dynamic Alerts: Include alert conditions when price intersects key geometric lines.
Custom Labels: Add text descriptions for critical intersections or triangle centers.
This script is a unique blend of technical analysis and sacred geometry, providing traders with an innovative way to visualize market dynamics.
Stationarity Test: Dickey-Fuller & KPSS [Pinescriptlabs]
📊 Kwiatkowski-Phillips-Schmidt-Shin Model Indicator & Dickey-Fuller Test 📈
This algorithm performs two statistical tests on the price spread between two selected instruments: the first from the current chart and the second determined in the settings. The purpose is to determine if their relationship is stationary. It then uses this information to generate **visual signals** based on how far the current relationship deviates from its historical average.
⚙️ Key Components:
• 🧪 ADF Test (Augmented Dickey-Fuller):** Checks if the spread between the two instruments is stationary.
• 🔬 KPSS Test (Kwiatkowski-Phillips-Schmidt-Shin):** Another test for stationarity, complementing the ADF test.
• 📏 Z-Score Calculation:** Measures how many standard deviations the current spread is from its historical mean.
• 📊 Dynamic Threshold:** Adjusts the trading signal threshold based on recent market volatility.
🔍 What the Values Mean:
The indicator displays several key values in a table:
• 📈 ADF Stationarity:** Shows "Stationary" or "Non-Stationary" based on the ADF test result.
• 📉 KPSS Stationarity:** Shows "Stationary" or "Non-Stationary" based on the KPSS test result.
• 📏 Current Z-Score:** The current Z-score of the spread.
• 🔗 Hedge Ratio:** The relationship coefficient between the two instruments.
• 🌐 Market State:** Describes the current market condition based on the Z-score.
📊 How to Interpret the Chart:
• The main chart displays the Z-score of the spread over time.
• The green and red lines represent the upper and lower thresholds for trading signals.
• The area between the **Z-score** and the thresholds is filled when a trading signal is active.
• Additional charts show the **statistics of the ADF and KPSS tests** and their critical values.
**📉 Practical Example: NVIDIA Corporation (NVDA)**
Looking at the chart for **NVIDIA Corporation (NVDA)**, we can see how the indicator applies in a real case:
1. **Main Chart (Top):**
• Shows the **historical price** of NVIDIA on a weekly scale.
• A general **uptrend** is observed with periods of consolidation.
2. **KPSS & ADF Indicator (Bottom):**
• The lower chart shows the KPSS & ADF Model indicator applied to NVIDIA.
• The **green line** represents the Z-score of the spread.
• The **green shaded areas** indicate periods where the Z-score exceeded the thresholds, generating trading signals.
3. **📋 Current Values in the Table:**
• **ADF Stationarity:** Non-Stationary
• **KPSS Stationarity:** Non-Stationary
• **Current Z-Score:** 3.45
• **Hedge Ratio:** -164.8557
• **Market State:** Moderate Volatility
4. **🔍 Interpretation:**
• A Z-score of **3.45** suggests that NVIDIA’s price is significantly above its historical average relative to **EURUSD**.
• Both the **ADF** and **KPSS** tests indicate **non-stationarity**, suggesting **caution** when using mean reversion signals at this moment.
• The market state "Moderate Volatility" indicates noticeable deviation, but not extreme.
---
**💡 Usage:**
• **When Both Tests Show Stationarity:**
• **🔼 If Z-score > Upper Threshold:** Consider **buying the first instrument** and **selling the second**.
• **🔽 If Z-score < Lower Threshold:** Consider **selling the first instrument** and **buying the second**.
• **When Either Test Shows Non-Stationarity:**
• Wait for the relationship to become **stationary** before trading.
• **Market State:**
• Use this information to evaluate **general market conditions** and adjust your trading strategy accordingly.
**Mirror Comparison of the Same as Symbol 2 🔄📊**
**📊 Table Values:**
• **Extreme Volatility Threshold:** This value is displayed when the **Z-score** exceeds **100%**, indicating **extreme deviation**. It signals a potential **trading opportunity**, as the spread has reached unusually high or low levels, suggesting a **reversion or correction** in the market.
• **Mean Reversion Threshold:** Appears when the **Z-score** begins returning towards the mean after a period of **high or extreme volatility**. It indicates that the spread between the assets is returning to normal levels, suggesting a phase of **stabilization**.
• **Neutral Zone:** Displayed when the **Z-score** is near **zero**, signaling that the spread between assets is within expected limits. This indicates a **balanced market** with no significant volatility or clear trading opportunities.
• **Low Volatility Threshold:** Appears when the **Z-score** is below **70%** of the dynamic threshold, reflecting a period of **low volatility** and market stability, indicating fewer trading opportunities.
Español:
📊 Indicador del Modelo Kwiatkowski-Phillips-Schmidt-Shin & Prueba de Dickey-Fuller 📈
Este algoritmo realiza dos pruebas estadísticas sobre la diferencia de precios (spread) entre dos instrumentos seleccionados: el primero en el gráfico actual y el segundo determinado en la configuración. El objetivo es determinar si su relación es estacionaria. Luego utiliza esta información para generar señales visuales basadas en cuánto se desvía la relación actual de su promedio histórico.
⚙️ Componentes Clave:
• 🧪 Prueba ADF (Dickey-Fuller Aumentada): Verifica si el spread entre los dos instrumentos es estacionario.
• 🔬 Prueba KPSS (Kwiatkowski-Phillips-Schmidt-Shin): Otra prueba para la estacionariedad, complementando la prueba ADF.
• 📏 Cálculo del Z-Score: Mide cuántas desviaciones estándar se encuentra el spread actual de su media histórica.
• 📊 Umbral Dinámico: Ajusta el umbral de la señal de trading en función de la volatilidad reciente del mercado.
🔍 Qué Significan los Valores:
El indicador muestra varios valores clave en una tabla:
• 📈 Estacionariedad ADF: Muestra "Estacionario" o "No Estacionario" basado en el resultado de la prueba ADF.
• 📉 Estacionariedad KPSS: Muestra "Estacionario" o "No Estacionario" basado en el resultado de la prueba KPSS.
• 📏 Z-Score Actual: El Z-score actual del spread.
• 🔗 Ratio de Cobertura: El coeficiente de relación entre los dos instrumentos.
• 🌐 Estado del Mercado: Describe la condición actual del mercado basado en el Z-score.
📊 Cómo Interpretar el Gráfico:
• El gráfico principal muestra el Z-score del spread a lo largo del tiempo.
• Las líneas verdes y rojas representan los umbrales superior e inferior para las señales de trading.
• El área entre el Z-score y los umbrales se llena cuando una señal de trading está activa.
• Los gráficos adicionales muestran las estadísticas de las pruebas ADF y KPSS y sus valores críticos.
📉 Ejemplo Práctico: NVIDIA Corporation (NVDA)
Observando el gráfico para NVIDIA Corporation (NVDA), podemos ver cómo se aplica el indicador en un caso real:
Gráfico Principal (Superior): • Muestra el precio histórico de NVIDIA en escala semanal. • Se observa una tendencia alcista general con períodos de consolidación.
Indicador KPSS & ADF (Inferior): • El gráfico inferior muestra el indicador Modelo KPSS & ADF aplicado a NVIDIA. • La línea verde representa el Z-score del spread. • Las áreas sombreadas en verde indican períodos donde el Z-score superó los umbrales, generando señales de trading.
📋 Valores Actuales en la Tabla: • Estacionariedad ADF: No Estacionario • Estacionariedad KPSS: No Estacionario • Z-Score Actual: 3.45 • Ratio de Cobertura: -164.8557 • Estado del Mercado: Volatilidad Moderada
🔍 Interpretación: • Un Z-score de 3.45 sugiere que el precio de NVIDIA está significativamente por encima de su promedio histórico en relación con EURUSD. • Tanto la prueba ADF como la KPSS indican no estacionariedad, lo que sugiere precaución al usar señales de reversión a la media en este momento. • El estado del mercado "Volatilidad Moderada" indica una desviación notable, pero no extrema.
💡 Uso:
• Cuando Ambas Pruebas Muestran Estacionariedad:
• 🔼 Si Z-score > Umbral Superior: Considera comprar el primer instrumento y vender el segundo.
• 🔽 Si Z-score < Umbral Inferior: Considera vender el primer instrumento y comprar el segundo.
• Cuando Alguna Prueba Muestra No Estacionariedad:
• Espera a que la relación se vuelva estacionaria antes de operar.
• Estado del Mercado:
• Usa esta información para evaluar las condiciones generales del mercado y ajustar tu estrategia de trading en consecuencia.
Comparativo en Espejo del Mismo Como Símbolo 2 🔄📊
📊 Valores de la Tabla:
• Umbral de Volatilidad Extrema: Este valor se muestra cuando el Z-score supera el 100%, indicando desviación extrema. Señala una posible oportunidad de trading, ya que el spread entre los activos ha alcanzado niveles inusualmente altos o bajos, lo que podría indicar una reversión o corrección en el mercado.
• Umbral de Reversión a la Media: Aparece cuando el Z-score comienza a volver hacia la media tras un período de alta o extrema volatilidad. Indica que el spread entre los activos está regresando a niveles normales, sugiriendo una fase de estabilización.
• Zona Neutral: Se muestra cuando el Z-score está cerca de cero, señalando que el spread entre activos está dentro de lo esperado. Esto indica un mercado equilibrado con ninguna volatilidad significativa ni oportunidades claras de trading.
• Umbral de Baja Volatilidad: Aparece cuando el Z-score está por debajo del 70% del umbral dinámico, reflejando un período de baja volatilidad y estabilidad del mercado, indicando menos oportunidades de trading.
JordanSwindenLibraryLibrary "JordanSwindenLibrary"
TODO: add library description here
getDecimals()
Calculates how many decimals are on the quote price of the current market
Returns: The current decimal places on the market quote price
getPipSize(multiplier)
Calculates the pip size of the current market
Parameters:
multiplier (int) : The mintick point multiplier (1 by default, 10 for FX/Crypto/CFD but can be used to override when certain markets require)
Returns: The pip size for the current market
truncate(number, decimalPlaces)
Truncates (cuts) excess decimal places
Parameters:
number (float) : The number to truncate
decimalPlaces (simple float) : (default=2) The number of decimal places to truncate to
Returns: The given number truncated to the given decimalPlaces
toWhole(number)
Converts pips into whole numbers
Parameters:
number (float) : The pip number to convert into a whole number
Returns: The converted number
toPips(number)
Converts whole numbers back into pips
Parameters:
number (float) : The whole number to convert into pips
Returns: The converted number
getPctChange(value1, value2, lookback)
Gets the percentage change between 2 float values over a given lookback period
Parameters:
value1 (float) : The first value to reference
value2 (float) : The second value to reference
lookback (int) : The lookback period to analyze
Returns: The percent change over the two values and lookback period
random(minRange, maxRange)
Wichmann–Hill Pseudo-Random Number Generator
Parameters:
minRange (float) : The smallest possible number (default: 0)
maxRange (float) : The largest possible number (default: 1)
Returns: A random number between minRange and maxRange
bullFib(priceLow, priceHigh, fibRatio)
Calculates a bullish fibonacci value
Parameters:
priceLow (float) : The lowest price point
priceHigh (float) : The highest price point
fibRatio (float) : The fibonacci % ratio to calculate
Returns: The fibonacci value of the given ratio between the two price points
bearFib(priceLow, priceHigh, fibRatio)
Calculates a bearish fibonacci value
Parameters:
priceLow (float) : The lowest price point
priceHigh (float) : The highest price point
fibRatio (float) : The fibonacci % ratio to calculate
Returns: The fibonacci value of the given ratio between the two price points
getMA(length, maType)
Gets a Moving Average based on type (! MUST BE CALLED ON EVERY TICK TO BE ACCURATE, don't place in scopes)
Parameters:
length (simple int) : The MA period
maType (string) : The type of MA
Returns: A moving average with the given parameters
barsAboveMA(lookback, ma)
Counts how many candles are above the MA
Parameters:
lookback (int) : The lookback period to look back over
ma (float) : The moving average to check
Returns: The bar count of how many recent bars are above the MA
barsBelowMA(lookback, ma)
Counts how many candles are below the MA
Parameters:
lookback (int) : The lookback period to look back over
ma (float) : The moving average to reference
Returns: The bar count of how many recent bars are below the EMA
barsCrossedMA(lookback, ma)
Counts how many times the EMA was crossed recently (based on closing prices)
Parameters:
lookback (int) : The lookback period to look back over
ma (float) : The moving average to reference
Returns: The bar count of how many times price recently crossed the EMA (based on closing prices)
getPullbackBarCount(lookback, direction)
Counts how many green & red bars have printed recently (ie. pullback count)
Parameters:
lookback (int) : The lookback period to look back over
direction (int) : The color of the bar to count (1 = Green, -1 = Red)
Returns: The bar count of how many candles have retraced over the given lookback & direction
getBodySize()
Gets the current candle's body size (in POINTS, divide by 10 to get pips)
Returns: The current candle's body size in POINTS
getTopWickSize()
Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's top wick size in POINTS
getBottomWickSize()
Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's bottom wick size in POINTS
getBodyPercent()
Gets the current candle's body size as a percentage of its entire size including its wicks
Returns: The current candle's body size percentage
isHammer(fib, colorMatch)
Checks if the current bar is a hammer candle based on the given parameters
Parameters:
fib (float) : (default=0.382) The fib to base candle body on
colorMatch (bool) : (default=false) Does the candle need to be green? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a hammer candle
isStar(fib, colorMatch)
Checks if the current bar is a shooting star candle based on the given parameters
Parameters:
fib (float) : (default=0.382) The fib to base candle body on
colorMatch (bool) : (default=false) Does the candle need to be red? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a shooting star candle
isDoji(wickSize, bodySize)
Checks if the current bar is a doji candle based on the given parameters
Parameters:
wickSize (float) : (default=2) The maximum top wick size compared to the bottom (and vice versa)
bodySize (float) : (default=0.05) The maximum body size as a percentage compared to the entire candle size
Returns: A boolean - true if the current bar matches the requirements of a doji candle
isBullishEC(allowance, rejectionWickSize, engulfWick)
Checks if the current bar is a bullish engulfing candle
Parameters:
allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)
rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage
engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?
Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle
isBearishEC(allowance, rejectionWickSize, engulfWick)
Checks if the current bar is a bearish engulfing candle
Parameters:
allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)
rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage
engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?
Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle
isInsideBar()
Detects inside bars
Returns: Returns true if the current bar is an inside bar
isOutsideBar()
Detects outside bars
Returns: Returns true if the current bar is an outside bar
barInSession(sess, useFilter)
Determines if the current price bar falls inside the specified session
Parameters:
sess (simple string) : The session to check
useFilter (bool) : (default=true) Whether or not to actually use this filter
Returns: A boolean - true if the current bar falls within the given time session
barOutSession(sess, useFilter)
Determines if the current price bar falls outside the specified session
Parameters:
sess (simple string) : The session to check
useFilter (bool) : (default=true) Whether or not to actually use this filter
Returns: A boolean - true if the current bar falls outside the given time session
dateFilter(startTime, endTime)
Determines if this bar's time falls within date filter range
Parameters:
startTime (int) : The UNIX date timestamp to begin searching from
endTime (int) : the UNIX date timestamp to stop searching from
Returns: A boolean - true if the current bar falls within the given dates
dayFilter(monday, tuesday, wednesday, thursday, friday, saturday, sunday)
Checks if the current bar's day is in the list of given days to analyze
Parameters:
monday (bool) : Should the script analyze this day? (true/false)
tuesday (bool) : Should the script analyze this day? (true/false)
wednesday (bool) : Should the script analyze this day? (true/false)
thursday (bool) : Should the script analyze this day? (true/false)
friday (bool) : Should the script analyze this day? (true/false)
saturday (bool) : Should the script analyze this day? (true/false)
sunday (bool) : Should the script analyze this day? (true/false)
Returns: A boolean - true if the current bar's day is one of the given days
atrFilter(atrValue, maxSize)
Parameters:
atrValue (float)
maxSize (float)
tradeCount()
Calculate total trade count
Returns: Total closed trade count
isLong()
Check if we're currently in a long trade
Returns: True if our position size is positive
isShort()
Check if we're currently in a short trade
Returns: True if our position size is negative
isFlat()
Check if we're currentlyflat
Returns: True if our position size is zero
wonTrade()
Check if this bar falls after a winning trade
Returns: True if we just won a trade
lostTrade()
Check if this bar falls after a losing trade
Returns: True if we just lost a trade
maxDrawdownRealized()
Gets the max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized).
Returns: The max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized).
totalPipReturn()
Gets the total amount of pips won/lost (as a whole number)
Returns: Total amount of pips won/lost (as a whole number)
longWinCount()
Count how many winning long trades we've had
Returns: Long win count
shortWinCount()
Count how many winning short trades we've had
Returns: Short win count
longLossCount()
Count how many losing long trades we've had
Returns: Long loss count
shortLossCount()
Count how many losing short trades we've had
Returns: Short loss count
breakEvenCount(allowanceTicks)
Count how many break-even trades we've had
Parameters:
allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)
Returns: Break-even count
longCount()
Count how many long trades we've taken
Returns: Long trade count
shortCount()
Count how many short trades we've taken
Returns: Short trade count
longWinPercent()
Calculate win rate of long trades
Returns: Long win rate (0-100)
shortWinPercent()
Calculate win rate of short trades
Returns: Short win rate (0-100)
breakEvenPercent(allowanceTicks)
Calculate break even rate of all trades
Parameters:
allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)
Returns: Break-even win rate (0-100)
averageRR()
Calculate average risk:reward
Returns: Average winning trade divided by average losing trade
unitsToLots(units)
(Forex) Convert the given unit count to lots (multiples of 100,000)
Parameters:
units (float) : The units to convert into lots
Returns: Units converted to nearest lot size (as float)
getFxPositionSize(balance, risk, stopLossPips, fxRate, lots)
(Forex) Calculate fixed-fractional position size based on given parameters
Parameters:
balance (float) : The account balance
risk (float) : The % risk (whole number)
stopLossPips (float) : Pip distance to base risk on
fxRate (float) : The conversion currency rate (more info below in library documentation)
lots (bool) : Whether or not to return the position size in lots rather than units (true by default)
Returns: Units/lots to enter into "qty=" parameter of strategy entry function
EXAMPLE USAGE:
string conversionCurrencyPair = (strategy.account_currency == syminfo.currency ? syminfo.tickerid : strategy.account_currency + syminfo.currency)
float fx_rate = request.security(conversionCurrencyPair, timeframe.period, close )
if (longCondition)
strategy.entry("Long", strategy.long, qty=zen.getFxPositionSize(strategy.equity, 1, stopLossPipsWholeNumber, fx_rate, true))
skipTradeMonteCarlo(chance, debug)
Checks to see if trade should be skipped to emulate rudimentary Monte Carlo simulation
Parameters:
chance (float) : The chance to skip a trade (0-1 or 0-100, function will normalize to 0-1)
debug (bool) : Whether or not to display a label informing of the trade skip
Returns: True if the trade is skipped, false if it's not skipped (idea being to include this function in entry condition validation checks)
fillCell(tableID, column, row, title, value, bgcolor, txtcolor, tooltip)
This updates the given table's cell with the given values
Parameters:
tableID (table) : The table ID to update
column (int) : The column to update
row (int) : The row to update
title (string) : The title of this cell
value (string) : The value of this cell
bgcolor (color) : The background color of this cell
txtcolor (color) : The text color of this cell
tooltip (string)
Returns: Nothing.
MarkdownUtilsLibrary "MarkdownUtils"
This library shows all of CommonMark's formatting elements that are currently (2024-03-30)
available in Pine Script® and gives some hints on how to use them.
The documentation will be in the tooltip of each of the following functions. It is also
logged into Pine Logs by default if it is called. We can disable the logging by setting `pLog = false`.
mediumMathematicalSpace()
Medium mathematical space that can be used in e.g. the library names like `Markdown Utils`.
Returns: The medium mathematical space character U+205F between those double quotes " ".
zeroWidthSpace()
Zero-width space.
Returns: The zero-width character U+200B between those double quotes "".
stableSpace(pCount)
Consecutive space characters in Pine Script® are replaced by a single space character on output.
Therefore we require a "stable" space to properly indent text e.g. in Pine Logs. To use it in code blocks
of a description like this one, we have to copy the 2(!) characters between the following reverse brackets instead:
# > <
Those are the zero-width character U+200B and a space.
Of course, this can also be used within a text to add some extra spaces.
Parameters:
pCount (simple int)
Returns: A zero-width space combined with a space character.
headers(pLog)
Headers
```
# H1
## H2
### H3
#### H4
##### H5
###### H6
```
*results in*
# H1
## H2
### H3
#### H4
##### H5
###### H6
*Best practices*: Add blank line before and after each header.
Parameters:
pLog (bool)
paragrahps(pLog)
Paragraphs
```
First paragraph
Second paragraph
```
*results in*
First paragraph
Second paragraph
Parameters:
pLog (bool)
lineBreaks(pLog)
Line breaks
```
First row
Second row
```
*results in*
First row\
Second row
Parameters:
pLog (bool)
emphasis(pLog)
Emphasis
With surrounding `*` and `~` we can emphasize text as follows. All emphasis can be arbitrarily combined.
```
*Italics*, **Bold**, ***Bold italics***, ~~Scratch~~
```
*results in*
*Italics*, **Bold**, ***Bold italics***, ~~Scratch~~
Parameters:
pLog (bool)
blockquotes(pLog)
Blockquotes
Lines starting with at least one `>` followed by a space and text build block quotes.
```
Text before blockquotes.
> 1st main blockquote
>
> 1st main blockquote
>
>> 1st 1-nested blockquote
>
>>> 1st 2-nested blockquote
>
>>>> 1st 3-nested blockquote
>
>>>>> 1st 4-nested blockquote
>
>>>>>> 1st 5-nested blockquote
>
>>>>>>> 1st 6-nested blockquote
>
>>>>>>>> 1st 7-nested blockquote
>
> 2nd main blockquote, 1st paragraph, 1st row\
> 2nd main blockquote, 1st paragraph, 2nd row
>
> 2nd main blockquote, 2nd paragraph, 1st row\
> 2nd main blockquote, 2nd paragraph, 2nd row
>
>> 2nd nested blockquote, 1st paragraph, 1st row\
>> 2nd nested blockquote, 1st paragraph, 2nd row
>
>> 2nd nested blockquote, 2nd paragraph, 1st row\
>> 2nd nested blockquote, 2nd paragraph, 2nd row
Text after blockquotes.
```
*results in*
Text before blockquotes.
> 1st main blockquote
>
>> 1st 1-nested blockquote
>
>>> 1st 2-nested blockquote
>
>>>> 1st 3-nested blockquote
>
>>>>> 1st 4-nested blockquote
>
>>>>>> 1st 5-nested blockquote
>
>>>>>>> 1st 6-nested blockquote
>
>>>>>>>> 1st 7-nested blockquote
>
> 2nd main blockquote, 1st paragraph, 1st row\
> 2nd main blockquote, 1st paragraph, 2nd row
>
> 2nd main blockquote, 2nd paragraph, 1st row\
> 2nd main blockquote, 2nd paragraph, 2nd row
>
>> 2nd nested blockquote, 1st paragraph, 1st row\
>> 2nd nested blockquote, 1st paragraph, 2nd row
>
>> 2nd nested blockquote, 2nd paragraph, 1st row\
>> 2nd nested blockquote, 2nd paragraph, 2nd row
Text after blockquotes.
*Best practices*: Add blank line before and after each (nested) blockquote.
Parameters:
pLog (bool)
lists(pLog)
Paragraphs
#### Ordered lists
The first line starting with a number combined with a delimiter `.` or `)` starts an ordered
list. The list's numbering starts with the given number. All following lines that also start
with whatever number and the same delimiter add items to the list.
#### Unordered lists
A line starting with a `-`, `*` or `+` becomes an unordered list item. All consecutive items with
the same start symbol build a separate list. Therefore every list can only have a single symbol.
#### General information
To start a new list either use the other delimiter or add some non-list text between.
List items in Pine Script® allow line breaks but cannot have paragraphs or blockquotes.
Lists Pine Script® cannot be nested.
```
1) 1st list, 1st item, 1st row\
1st list, 1st item, 2nd row
1) 1st list, 2nd item, 1st row\
1st list, 2nd item, 2nd row
1) 1st list, 2nd item, 1st row\
1st list, 2nd item, 2nd row
1. 2nd list, 1st item, 1st row\
2nd list, 1st item, 2nd row
Intermediary text.
1. 3rd list
Intermediary text (sorry, unfortunately without proper spacing).
8. 4th list, 8th item
8. 4th list, 9th item
Intermediary text.
- 1st list, 1st item
- 1st list, 2nd item
* 2nd list, 1st item
* 2nd list, 2nd item
Intermediary text.
+ 3rd list, 1st item
+ 3rd list, 2nd item
```
*results in*
1) 1st list, 1st item, 1st row\
1st list, 1st item, 2nd row
1) 1st list, 2nd item, 1st row\
1st list, 2nd item, 2nd row
1) 1st list, 2nd item, 1st row\
1st list, 2nd item, 2nd row
1. 2nd list, 1st item, 1st row\
2nd list, 1st item, 2nd row
Intermediary text.
1. 3rd list
Intermediary text (sorry, unfortunately without proper spacing).
8. 4th list, 8th item
8. 4th list, 9th item
Intermediary text.
- 1st list, 1st item
- 1st list, 2nd item
* 2nd list, 1st item
* 2nd list, 2nd item
Intermediary text.
+ 3rd list, 1st item
+ 3rd list, 2nd item
Parameters:
pLog (bool)
code(pLog)
### Code
`` `Inline code` `` is formatted like this.
To write above line we wrote `` `` `Inline code` `` ``.
And to write that line we added another pair of `` `` `` around that code and
a zero-width space of function between the inner `` `` ``.
### Code blocks
can be formatted like that:
~~~
```
export method codeBlock() =>
"code block"
```
~~~
Or like that:
```
~~~
export method codeBlock() =>
"code block"
~~~
```
To write ````` within a code block we can either surround it with `~~~`.
Or we "escape" those ````` by only the zero-width space of function (stableSpace) in between.
To escape \` within a text we use `` \` ``.
Parameters:
pLog (bool)
horizontalRules(pLog)
Horizontal rules
At least three connected `*`, `-` or `_` in a separate line build a horizontal rule.
```
Intermediary text.
---
Intermediary text.
***
Intermediary text.
___
Intermediary text.
```
*results in*
Intermediary text.
---
Intermediary text.
***
Intermediary text.
___
Intermediary text.
*Best practices*: Add blank line before and after each horizontal rule.
Parameters:
pLog (bool)
tables(pLog)
Tables
A table consists of a single header line with columns separated by `|`
and followed by a row of alignment indicators for either left (`---`, `:---`), centered (`:---:`) and right (`---:`)
A table can contain several rows of data.
The table can be written as follows but hasn't to be formatte like that. By adding (stableSpace)
on the correct side of the header we could even adjust the spacing if we don't like it as it is. Only around
the column separator we should only use a usual space on each side.
```
Header 1 | Header 1 | Header 2 | Header 3
--- | :--- | :----: | ---:
Left (Default) | Left | Centered | Right
Left (Default) | Left | Centered | Right
```
*results in*
Header 1 | Header 1 | Header 2 | Header 3
--- | :--- | :----: | ---:
Left (Default) | Left | Centered | Right
Left (Default) | Left | Centered | Right
Parameters:
pLog (bool)
links(pLog)
## Links.
### Inline-style
` (Here should be the link to the TradingView homepage)`\
results in (Here should be the link to the TradingView homepage)
` (Here should be the link to the TradingView homepage "Trading View tooltip")`\
results in (Here should be the link to the TradingView homepage "Trading View tooltip")
### Reference-style
One can also collect all links e.g. at the end of a description and use a reference to that as follows.
` `\
results in .
` `\
results in .
` `\
results in .
` (../tradingview/scripts/readme)`\
results in (../tradingview/scripts/readme).
### URLs and email
URLs are also identified by the protocol identifier, email addresses by `@`. They can also be surrounded by `<` and `>`.
Input | Result
--- | ---
`Here should be the link to the TradingView homepage` | Here should be the link to the TradingView homepage
`` |
`support@tradingview.com` | support@tradingview.com
`` |
## Images
We can display gif, jp(e)g and png files in our documentation, if we add `!` before a link.
### Inline-style:
`! (Here should be the link to the favicon of the TradingView homepage "Trading View icon")`
results in
! (Here should be the link to the favicon of the TradingView homepage "Trading View icon")\
### Reference-style:
`! `
results in
!
## References for reference-style links
Even though only the formatted references are visible here in the output, this text is also followed
by the following references with links in the style
` : Referenced link`
```
: Here should be the link to the TradingView homepage "Trading view text-reference tooltip"
: Here should be the link to the TradingView homepage "Trading view number-reference tooltip"
: Here should be the link to the TradingView homepage "Trading view self-reference tooltip"
: Here should be the link to the favicon of the TradingView homepage "Trading View icon (reference)"
```
: Here should be the link to the TradingView homepage "Trading view text-reference tooltip"
: Here should be the link to the TradingView homepage "Trading view number-reference tooltip"
: Here should be the link to the TradingView homepage "Trading view self-reference tooltip"
: Here should be the link to the favicon of the TradingView homepage "Trading View icon (reference)"
Parameters:
pLog (bool)
taskLists(pLog)
Task lists.
Other Markdown implementations can also display task lists for list items like `- ` respective `- `.
This can only be simulated by inline code `` ´ ` ``.
Make sure to either add a line-break `\` at the end of the line or a new paragraph by a blank line.
### Task lists
` ` Finish library
` ` Finish library
Parameters:
pLog (bool)
escapeMd(pLog)
Escaping Markdown syntax
To write and display Markdown syntax in regular text, we have to escape it. This can be done
by adding `\` before the Markdown syntax. If the Markdown syntax consists of more than one character
in some cases also the character of function can be helpful if a command consists of
more than one character if it is placed between the separate characters of the command.
Parameters:
pLog (bool)
test()
Calls all functions of above script.
Index Generator [By MUQWISHI]▋ INTRODUCTION :
The “Index Generator” simplifies the process of building a custom market index, allowing investors to enter a list of preferred holdings from global securities. It aims to serve as an approach for tracking performance, conducting research, and analyzing specific aspects of the global market. The output will include an index value, a table of holdings, and chart plotting, providing a deeper understanding of historical movement.
_______________________
▋ OVERVIEW:
The image can be taken as an example of building a custom index. I created this index and named it “My Oil & Gas Index”. The index comprises several global energy companies. Essentially, the indicator weights each company by collecting the number of shares and then computes the market capitalization before sorting them as seen in the table.
_______________________
▋ OUTPUTS:
The output can be divided into 3 sections:
1. Index Title (Name & Value).
2. Index Holdings.
3. Index Chart.
1. Index Title , displays the index name at the top, and at the bottom, it shows the index value, along with the daily change in points and percentage.
2. Index Holdings , displays list the holding securities inside a table that contains the ticker, price, daily change %, market cap, and weight %. Additionally, a tooltip appears when the user passes the cursor over a ticker's cell, showing brief information about the company, such as the company's name, exchange market, country, sector, and industry.
3. Index Chart , display a plot of the historical movement of the index in the form of a bar, candle, or line chart.
_______________________
▋ INDICATOR SETTINGS:
(1) Naming the index.
(2) Entering a currency. To unite all securities in one currency.
(3) Table location on the chart.
(4) Table’s cells size.
(5) Table’s colors.
(6) Sorting table. By securities’ (Market Cap, Change%, Price, or Ticker Alphabetical) order.
(7) Plotting formation (Candle, Bar, or Line)
(8) To show/hide any indicator’s components.
(9) There are 34 fields where user can fill them with symbols.
Please let me know if you have any questions.
IDX Financials v2This indicator adds financial data, ratios, and valuations to your chart. The main objective is to present financial overview that can be glanced quickly to add to your considerations.
The visualization of the indicator consists of two parts:
A. Plots (lines alongside the candlestick)
B. Financial table on the right. Drag your candlestick to the left to provide blank area for the table.
Programatically, the financial data is obtained by using these Pine API:
request.earnings(...) API for the EPS values that are used by the price at average PER line , and
request.financial(..) API for the rest of financial data required by the indicator.
See What financial data is available in Pine for more info on getting financial data in Pine.
A. THE PLOTS
The plots produces two lines, price at average PER in blue and price at average PBV line in pink, calculated over some adjustable time period (the default is one year). By default, only price at average PER line is shown.
Note that PER stands for Price to Earning Ratio.
The price at average PER line shows the price level at the average PER. It is calculated using formula as follows:
line = AVGPER * EPSTTM
where AVGPER is the average PER over some time period (default is one year, adjustable) and EPSTTM is the standardized EPS TTM.
Note that the EPS is updated at the actual time of earning report publication , and not at standard quarter dates such as March 31st, Dec 31st, etc.. This approach is chosen to represent the actual PE at the time.
The price at average PBV line (PBV stands for Price to Book Value), which can be enabled in settings, shows the price at average PBV. It is calculated using formula as follows:
line = AVGPBV * BVPS
where AVGPBV is the average PBV over some period of time (default is one year, adjustable) and BVPS is the book value per share. Note that the PBV is clipped to range to avoid values that are too small/large.
Also note that unlike PER, the BVPS is updated at each quarterly date (such as March 31st, Dec 31st, etc.).
Apart from those lines, some values are written to the status line (i.e. the numbers next to indicator name), which represent the corresponding value at the currently hovered bar:
PER TTM
Average PER
Std value (zvalue) of PER TTM (equal to = (PERTTM - AVGPER)/STDPER)
PBV
The meaning for these abbreviations should be straightforward.
Using the price at average PER line
There are several ways to use the price at average PER line .
You can quickly get the sense of current valuation by seeing the price relative to the price at average PER line . If the price is above the line, the valuation is higher than the average valuation, and vice versa if the price is lower.
The distance between the price and the average is measured in unit of standard deviation. This is represented by the third number in the status line. Value zero indicates the price is exactly at the average PER line. Positive value indicates price is higher than average, and negative if price is lower than average. Usually people use value +2 and -2 to indicate extreme positions.
The second way to use the line is to see how the line jumps up or down at the earning report date . If the line jumps up, this indicates the increase of EPSTTM. And vice versa when the line jumps down.
When EPSTTM is trending up over several quarters, or if EPSTTM is expected to go up, usually the price is also trending up and the valuation is over the average. And vice versa when EPSTTM is trending down or expected to go down. Deviation from this pattern may present some buying or selling opportunity.
B. THE FINANCIAL TABLE
The second visual part is the financial table. The financial table contains financial information at the last bar . It has four sections:
1. Revenue
2. Income
3. Valuations
4. Ratios
Let's discuss them in detail.
1. Revenue and income sections
The revenue and income table are organized into rows and columns.
Each row shows the data at the specified time frame, as follows:
The first four rows shows quarterly revenue/income of the last four quarters.
Then followed by TTM data.
Then followed by forecast of next quarter revenue/income, if such forecast exists. Note the "(F)" notation next to the quarter name.
Then followed by forecast of TTM data of next quarter (only for income), if such forecast exists. Note the "(F)" notation next to the TTM name.
The columns of revenue and income sections show the following:
The time frame information (such as quarter name, TTM, etc.)
The revenue/income value, in billions or millions (configurable).
YoY (year on year) growth, i.e. comparing the value with the value one year earlier, if any.
QoQ (quarter on quarter) growth, i.e. comparing the value with previous quarter value, if any.
GPM/NPM (gross profit margin or net profit margin), i.e. the margin on the specified time period.
Using the Revenue and Income table
The table provides quick way to see the revenue and income trend. You can see the YoY growth as well as QoQ, if that is applicable (non seasonal stocks). You can also see how the margins change over the periods.
The values are also presented with relevant background color . Green indicates "good" value and red indicates "bad" value. The intensity represents how good/bad the value is. The limits of the good and bad values are currently hardcoded in the script.
2. Valuations section
The valuation shows current stock valuation. The section is organized in rows and columns. Each row contains one type of valuation criteria, as follows:
PER (Price Earning Ratio)
Next quarter PER forecast (marked by "(F)" notation) when available
PBV (Price to Book value)
For each valuation criteria, several values are presented as columns:
The current value of the criteria. By current, it means the value at the last bar.
The one year standard deviation position
The three years standard deviation position
3. Ratios Section
The ratios section contains the following useful financial ratios:
ROA (Return on Asset), equal to: NET_INCOME_TTM / TOTAL_ASSETS
ROE (Return on Equity), equal to: NET_INCOME_TTM / BOOK_VALUE_PER_SHARE
PEG (PER to Growth Ratio), equal to PER_TTM / (INCOME_TTM_GROWTH*100)
DER (Debt to Equity Ratio), taken from request.financial(syminfo.tickerid, "DEBT_TO_EQUITY", "FQ")
DPR (Dividend Payout Ratio), taken from request.financial(syminfo.tickerid, "DIVIDEND_PAYOUT_RATIO", "FY")
Dividend yield, equal to (DPR * (NET_INCOME_TTM / TOTAL_SHARES_OUTSTANDING)) / close
KNOWN BUGS
Currently does not handle when the financial quarter contains gap, i.e. there is missing quarter. This usually happens on newly IPO stocks.
arraysLibrary "arraymethods"
Supplementary array methods.
delete(arr, index)
remove int object from array of integers at specific index
Parameters:
arr : int array
index : index at which int object need to be removed
Returns: void
delete(arr, index)
remove float object from array of float at specific index
Parameters:
arr : float array
index : index at which float object need to be removed
Returns: float
delete(arr, index)
remove bool object from array of bool at specific index
Parameters:
arr : bool array
index : index at which bool object need to be removed
Returns: bool
delete(arr, index)
remove string object from array of string at specific index
Parameters:
arr : string array
index : index at which string object need to be removed
Returns: string
delete(arr, index)
remove color object from array of color at specific index
Parameters:
arr : color array
index : index at which color object need to be removed
Returns: color
delete(arr, index)
remove line object from array of lines at specific index and deletes the line
Parameters:
arr : line array
index : index at which line object need to be removed and deleted
Returns: void
delete(arr, index)
remove label object from array of labels at specific index and deletes the label
Parameters:
arr : label array
index : index at which label object need to be removed and deleted
Returns: void
delete(arr, index)
remove box object from array of boxes at specific index and deletes the box
Parameters:
arr : box array
index : index at which box object need to be removed and deleted
Returns: void
delete(arr, index)
remove table object from array of tables at specific index and deletes the table
Parameters:
arr : table array
index : index at which table object need to be removed and deleted
Returns: void
delete(arr, index)
remove linefill object from array of linefills at specific index and deletes the linefill
Parameters:
arr : linefill array
index : index at which linefill object need to be removed and deleted
Returns: void
popr(arr)
remove last int object from array
Parameters:
arr : int array
Returns: int
popr(arr)
remove last float object from array
Parameters:
arr : float array
Returns: float
popr(arr)
remove last bool object from array
Parameters:
arr : bool array
Returns: bool
popr(arr)
remove last string object from array
Parameters:
arr : string array
Returns: string
popr(arr)
remove last color object from array
Parameters:
arr : color array
Returns: color
popr(arr)
remove and delete last line object from array
Parameters:
arr : line array
Returns: void
popr(arr)
remove and delete last label object from array
Parameters:
arr : label array
Returns: void
popr(arr)
remove and delete last box object from array
Parameters:
arr : box array
Returns: void
popr(arr)
remove and delete last table object from array
Parameters:
arr : table array
Returns: void
popr(arr)
remove and delete last linefill object from array
Parameters:
arr : linefill array
Returns: void
shiftr(arr)
remove first int object from array
Parameters:
arr : int array
Returns: int
shiftr(arr)
remove first float object from array
Parameters:
arr : float array
Returns: float
shiftr(arr)
remove first bool object from array
Parameters:
arr : bool array
Returns: bool
shiftr(arr)
remove first string object from array
Parameters:
arr : string array
Returns: string
shiftr(arr)
remove first color object from array
Parameters:
arr : color array
Returns: color
shiftr(arr)
remove and delete first line object from array
Parameters:
arr : line array
Returns: void
shiftr(arr)
remove and delete first label object from array
Parameters:
arr : label array
Returns: void
shiftr(arr)
remove and delete first box object from array
Parameters:
arr : box array
Returns: void
shiftr(arr)
remove and delete first table object from array
Parameters:
arr : table array
Returns: void
shiftr(arr)
remove and delete first linefill object from array
Parameters:
arr : linefill array
Returns: void
push(arr, val, maxItems)
add int to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : int array
val : int object to be pushed
maxItems : max number of items array can hold
Returns: int
push(arr, val, maxItems)
add float to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : float array
val : float object to be pushed
maxItems : max number of items array can hold
Returns: float
push(arr, val, maxItems)
add bool to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : bool array
val : bool object to be pushed
maxItems : max number of items array can hold
Returns: bool
push(arr, val, maxItems)
add string to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : string array
val : string object to be pushed
maxItems : max number of items array can hold
Returns: string
push(arr, val, maxItems)
add color to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : color array
val : color object to be pushed
maxItems : max number of items array can hold
Returns: color
push(arr, val, maxItems)
add line to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : line array
val : line object to be pushed
maxItems : max number of items array can hold
Returns: line
push(arr, val, maxItems)
add label to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : label array
val : label object to be pushed
maxItems : max number of items array can hold
Returns: label
push(arr, val, maxItems)
add box to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : box array
val : box object to be pushed
maxItems : max number of items array can hold
Returns: box
push(arr, val, maxItems)
add table to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : table array
val : table object to be pushed
maxItems : max number of items array can hold
Returns: table
push(arr, val, maxItems)
add linefill to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : linefill array
val : linefill object to be pushed
maxItems : max number of items array can hold
Returns: linefill
unshift(arr, val, maxItems)
add int to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : int array
val : int object to be unshift
maxItems : max number of items array can hold
Returns: int
unshift(arr, val, maxItems)
add float to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : float array
val : float object to be unshift
maxItems : max number of items array can hold
Returns: float
unshift(arr, val, maxItems)
add bool to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : bool array
val : bool object to be unshift
maxItems : max number of items array can hold
Returns: bool
unshift(arr, val, maxItems)
add string to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : string array
val : string object to be unshift
maxItems : max number of items array can hold
Returns: string
unshift(arr, val, maxItems)
add color to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : color array
val : color object to be unshift
maxItems : max number of items array can hold
Returns: color
unshift(arr, val, maxItems)
add line to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : line array
val : line object to be unshift
maxItems : max number of items array can hold
Returns: line
unshift(arr, val, maxItems)
add label to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : label array
val : label object to be unshift
maxItems : max number of items array can hold
Returns: label
unshift(arr, val, maxItems)
add box to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : box array
val : box object to be unshift
maxItems : max number of items array can hold
Returns: box
unshift(arr, val, maxItems)
add table to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : table array
val : table object to be unshift
maxItems : max number of items array can hold
Returns: table
unshift(arr, val, maxItems)
add linefill to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : linefill array
val : linefill object to be unshift
maxItems : max number of items array can hold
Returns: linefill
flush(arr)
remove all int objects in an array
Parameters:
arr : int array
Returns: int
flush(arr)
remove all float objects in an array
Parameters:
arr : float array
Returns: float
flush(arr)
remove all bool objects in an array
Parameters:
arr : bool array
Returns: bool
flush(arr)
remove all string objects in an array
Parameters:
arr : string array
Returns: string
flush(arr)
remove all color objects in an array
Parameters:
arr : color array
Returns: color
flush(arr)
remove and delete all line objects in an array
Parameters:
arr : line array
Returns: line
flush(arr)
remove and delete all label objects in an array
Parameters:
arr : label array
Returns: label
flush(arr)
remove and delete all box objects in an array
Parameters:
arr : box array
Returns: box
flush(arr)
remove and delete all table objects in an array
Parameters:
arr : table array
Returns: table
flush(arr)
remove and delete all linefill objects in an array
Parameters:
arr : linefill array
Returns: linefill
Price Legs: Average Heights; 'Smart ATR'Price Legs: Average Heights; 'Smart ATR'. Consol Range Gauge
~~ Indicator to show small and large price legs (based on short and long input pivot lengths), and calculating the average heights of these price legs; counting legs from user-input start time ~~
//Premise: Wanted to use this as something like a 'Smart ATR': where the average/typical range of a distinct & dynamic price leg could be calculated based on a user-input time interval (as opposed to standard ATR, which is simply the average range over a consistent repeating period, with no regard to market structure). My instinct is that this would be most useful for consolidated periods & range trading: giving the trader an idea of what the typical size of a price leg might be in the current market state (hence in the title, Consol Range gauge)
//Features & User inputs:
-Start time: confirm input when loading indicator by clicking on the chart. Then drag the vertical line to change start time easily.
-Large Legs (toggle on/off) and user-input pivot lookback/lookforward length (larger => larger legs)
-Small Legs (toggle on/off) and user-input pivot lookback/lookforward length (smaller => smaller legs)
-Display Stats table: toggle on/off: simple view- shows the averages of large (up & down), small (up & down), and combined (for each).
-Extended stats table: toggle on/off option to show the averages of the last 3 legs of each category (up/down/large/small/combined)
-Toggle on/off Time & Price chart text labels of price legs (time in mins/hours/days; price in $ or pips; auto assigned based on asset)
-Table position: user choice.
//Notes & tips:
-Using custom start time along with replay mode, you can select any arbitrary chunk of price for the purpose of backtesting.
-Play around with the pivot lookback lengths to find price legs most suitable to the current market regime (consolidating/trending; high volatility/ low volatility)
-Single bar price legs will never be counted: they must be at least 2 bars from H>>L or L>>H.
//Credits: Thanks to @crypto_juju for the idea of applying statistics to this simple price leg indicator.
Simple View: showing only the full averages (counting from Start time):
View showing ONLY the large legs, with Time & Price labels toggled ON:
arraymethodsLibrary "arraymethods"
Supplementary array methods.
delete(arr, index)
remove int object from array of integers at specific index
Parameters:
arr : int array
index : index at which int object need to be removed
Returns: void
delete(arr, index)
remove float object from array of float at specific index
Parameters:
arr : float array
index : index at which float object need to be removed
Returns: float
delete(arr, index)
remove bool object from array of bool at specific index
Parameters:
arr : bool array
index : index at which bool object need to be removed
Returns: bool
delete(arr, index)
remove string object from array of string at specific index
Parameters:
arr : string array
index : index at which string object need to be removed
Returns: string
delete(arr, index)
remove color object from array of color at specific index
Parameters:
arr : color array
index : index at which color object need to be removed
Returns: color
delete(arr, index)
remove line object from array of lines at specific index and deletes the line
Parameters:
arr : line array
index : index at which line object need to be removed and deleted
Returns: void
delete(arr, index)
remove label object from array of labels at specific index and deletes the label
Parameters:
arr : label array
index : index at which label object need to be removed and deleted
Returns: void
delete(arr, index)
remove box object from array of boxes at specific index and deletes the box
Parameters:
arr : box array
index : index at which box object need to be removed and deleted
Returns: void
delete(arr, index)
remove table object from array of tables at specific index and deletes the table
Parameters:
arr : table array
index : index at which table object need to be removed and deleted
Returns: void
delete(arr, index)
remove linefill object from array of linefills at specific index and deletes the linefill
Parameters:
arr : linefill array
index : index at which linefill object need to be removed and deleted
Returns: void
popr(arr)
remove last int object from array
Parameters:
arr : int array
Returns: int
popr(arr)
remove last float object from array
Parameters:
arr : float array
Returns: float
popr(arr)
remove last bool object from array
Parameters:
arr : bool array
Returns: bool
popr(arr)
remove last string object from array
Parameters:
arr : string array
Returns: string
popr(arr)
remove last color object from array
Parameters:
arr : color array
Returns: color
popr(arr)
remove and delete last line object from array
Parameters:
arr : line array
Returns: void
popr(arr)
remove and delete last label object from array
Parameters:
arr : label array
Returns: void
popr(arr)
remove and delete last box object from array
Parameters:
arr : box array
Returns: void
popr(arr)
remove and delete last table object from array
Parameters:
arr : table array
Returns: void
popr(arr)
remove and delete last linefill object from array
Parameters:
arr : linefill array
Returns: void
shiftr(arr)
remove first int object from array
Parameters:
arr : int array
Returns: int
shiftr(arr)
remove first float object from array
Parameters:
arr : float array
Returns: float
shiftr(arr)
remove first bool object from array
Parameters:
arr : bool array
Returns: bool
shiftr(arr)
remove first string object from array
Parameters:
arr : string array
Returns: string
shiftr(arr)
remove first color object from array
Parameters:
arr : color array
Returns: color
shiftr(arr)
remove and delete first line object from array
Parameters:
arr : line array
Returns: void
shiftr(arr)
remove and delete first label object from array
Parameters:
arr : label array
Returns: void
shiftr(arr)
remove and delete first box object from array
Parameters:
arr : box array
Returns: void
shiftr(arr)
remove and delete first table object from array
Parameters:
arr : table array
Returns: void
shiftr(arr)
remove and delete first linefill object from array
Parameters:
arr : linefill array
Returns: void
push(arr, val, maxItems)
add int to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : int array
val : int object to be pushed
maxItems : max number of items array can hold
Returns: int
push(arr, val, maxItems)
add float to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : float array
val : float object to be pushed
maxItems : max number of items array can hold
Returns: float
push(arr, val, maxItems)
add bool to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : bool array
val : bool object to be pushed
maxItems : max number of items array can hold
Returns: bool
push(arr, val, maxItems)
add string to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : string array
val : string object to be pushed
maxItems : max number of items array can hold
Returns: string
push(arr, val, maxItems)
add color to the end of an array with max items cap. Objects are removed from start to maintain max items cap
Parameters:
arr : color array
val : color object to be pushed
maxItems : max number of items array can hold
Returns: color
push(arr, val, maxItems)
add line to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : line array
val : line object to be pushed
maxItems : max number of items array can hold
Returns: line
push(arr, val, maxItems)
add label to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : label array
val : label object to be pushed
maxItems : max number of items array can hold
Returns: label
push(arr, val, maxItems)
add box to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : box array
val : box object to be pushed
maxItems : max number of items array can hold
Returns: box
push(arr, val, maxItems)
add table to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : table array
val : table object to be pushed
maxItems : max number of items array can hold
Returns: table
push(arr, val, maxItems)
add linefill to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap
Parameters:
arr : linefill array
val : linefill object to be pushed
maxItems : max number of items array can hold
Returns: linefill
unshift(arr, val, maxItems)
add int to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : int array
val : int object to be unshift
maxItems : max number of items array can hold
Returns: int
unshift(arr, val, maxItems)
add float to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : float array
val : float object to be unshift
maxItems : max number of items array can hold
Returns: float
unshift(arr, val, maxItems)
add bool to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : bool array
val : bool object to be unshift
maxItems : max number of items array can hold
Returns: bool
unshift(arr, val, maxItems)
add string to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : string array
val : string object to be unshift
maxItems : max number of items array can hold
Returns: string
unshift(arr, val, maxItems)
add color to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap
Parameters:
arr : color array
val : color object to be unshift
maxItems : max number of items array can hold
Returns: color
unshift(arr, val, maxItems)
add line to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : line array
val : line object to be unshift
maxItems : max number of items array can hold
Returns: line
unshift(arr, val, maxItems)
add label to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : label array
val : label object to be unshift
maxItems : max number of items array can hold
Returns: label
unshift(arr, val, maxItems)
add box to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : box array
val : box object to be unshift
maxItems : max number of items array can hold
Returns: box
unshift(arr, val, maxItems)
add table to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : table array
val : table object to be unshift
maxItems : max number of items array can hold
Returns: table
unshift(arr, val, maxItems)
add linefill to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap
Parameters:
arr : linefill array
val : linefill object to be unshift
maxItems : max number of items array can hold
Returns: linefill
flush(arr)
remove all int objects in an array
Parameters:
arr : int array
Returns: int
flush(arr)
remove all float objects in an array
Parameters:
arr : float array
Returns: float
flush(arr)
remove all bool objects in an array
Parameters:
arr : bool array
Returns: bool
flush(arr)
remove all string objects in an array
Parameters:
arr : string array
Returns: string
flush(arr)
remove all color objects in an array
Parameters:
arr : color array
Returns: color
flush(arr)
remove and delete all line objects in an array
Parameters:
arr : line array
Returns: line
flush(arr)
remove and delete all label objects in an array
Parameters:
arr : label array
Returns: label
flush(arr)
remove and delete all box objects in an array
Parameters:
arr : box array
Returns: box
flush(arr)
remove and delete all table objects in an array
Parameters:
arr : table array
Returns: table
flush(arr)
remove and delete all linefill objects in an array
Parameters:
arr : linefill array
Returns: linefill
SUPERTREND MIXED ICHI-DMI-DONCHIAN-VOL-GAP-HLBox@RLSUPERTREND MIXED ICHI-DMI-VOL-GAP-HLBox@RL
by RegisL76
This script is based on several trend indicators.
* ICHIMOKU (KINKO HYO)
* DMI (Directional Movement Index)
* SUPERTREND ICHIMOKU + SUPERTREND DMI
* DONCHIAN CANAL Optimized with Colored Bars
* HMA Hull
* Fair Value GAP
* VOLUME/ MA Volume
* PRICE / MA Price
* HHLL BOXES
All these indications are visible simultaneously on a single graph. A data table summarizes all the important information to make a good trade decision.
ICHIMOKU Indicator:
The ICHIMOKU indicator is visualized in the traditional way.
ICHIMOKU standard setting values are respected but modifiable. (Traditional defaults = .
An oriented visual symbol, near the last value, indicates the progression (Ascending, Descending or neutral) of the TENKAN-SEN and the KIJUN-SEN as well as the period used.
The CLOUD (KUMO) and the CHIKOU-SPAN are present and are essential for the complete analysis of the ICHIMOKU.
At the top of the graph are visually represented the crossings of the TENKAN and the KIJUN.
Vertical lines, accompanied by labels, make it possible to quickly visualize the particularities of the ICHIMOKU.
A line displays the current bar.
A line visualizes the end of the CLOUD (KUMO) which is shifted 25 bars into the future.
A line visualizes the end of the chikou-span, which is shifted 25 bars in the past.
DIRECTIONAL MOVEMENT INDEX (DMI) : Treated conventionally : DI+, DI-, ADX and associated with a SUPERTREND DMI.
A visual symbol at the bottom of the graph indicates DI+ and DI- crossings
A line of oriented and colored symbols (DMI Line) at the top of the chart indicates the direction and strength of the trend.
SUPERTREND ICHIMOKU + SUPERTREND DMI :
Trend following by SUPERTREND calculation.
DONCHIAN CHANNEL: Treated conventionally. (And optimized by colored bars when overshooting either up or down.
The lines, high and low of the last values of the channel are represented to quickly visualize the level of the RANGE.
SUPERTREND HMA (HULL) Treated conventionally.
The HMA line visually indicates, according to color and direction, the market trend.
A visual symbol at the bottom of the chart indicates opportunities to sell and buy.
VOLUME:
Calculation of the MOBILE AVERAGE of the volume with comparison of the volume compared to the moving average of the volume.
The indications are colored and commented according to the comparison.
PRICE: Calculation of the MOBILE AVERAGE of the price with comparison of the price compared to the moving average of the price.
The indications are colored and commented according to the comparison.
HHLL BOXES:
Visualizes in the form of a box, for a given period, the max high and min low values of the price.
The configuration allows taking into account the high and low wicks of the price or the opening and closing values.
FAIR VALUE GAP :
This indicator displays 'GAP' levels over the current time period and an optional higher time period.
The script takes into account the high/low values of the current bar and compares with the 2 previous bars.
The "gap" is generated from the lack of overlap between these bars. Bearish or bullish gaps are determined by whether the gap is above or below HmaPrice, as they tend to fill, and can be used as targets.
NOTE: FAIR VALUE GAP has no values displayed in the table and/or label.
Important information (DATA) relating to each indicator is displayed in real time in a table and/or a label.
Each information is commented and colored according to direction, value, comparison etc.
Each piece of information indicates the values of the current bar and the previous value (in "FULL" mode).
The other possible modes for viewing the table and/or the label allow a more synthetic view of the information ("CONDENSED" and "MINIMAL" modes).
In order not to overload the vision of the chart too much, the visualization box of the RANGE DONCHIAN, the vertical lines of the shifted marks of the ICHIMOKU, as well as the boxes of the HHLL Boxes indicator are only visualized intermittently (managed by an adjustable time delay ).
The "HISTORICAL INFO READING" configuration parameter set to zero (by default) makes it possible to read all the information of the current bar in progress (Bar #0). All other values allow to read the information of a historical bar. The value 1 reads the information of the bar preceding the current bar (-1). The value 10 makes it possible to read the information of the tenth bar behind (-10) compared to the current bar, etc.
At the bottom of the DATAS table and label, lights, red, green or white indicate quickly summarize the trend from the various indicators.
Each light represents the number of indicators with the same trend at a given time.
Green for a bullish trend, red for a bearish trend and white for a neutral trend.
The conditions for determining a trend are for each indicator:
SUPERTREND ICHIMOHU + DMI: the 2 Super trends together are either bullish or bearish.
Otherwise the signal is neutral.
DMI: 2 main conditions:
BULLISH if DI+ >= DI- and ADX >25.
BEARISH if DI+ < DI- and ADX >25.
NEUTRAL if the 2 conditions are not met.
ICHIMOKU: 3 main conditions:
BULLISH if PRICE above the cloud and TENKAN > KIJUN and GREEN CLOUD AHEAD.
BEARISH if PRICE below the cloud and TENKAN < KIJUN and RED CLOUD AHEAD.
The other additional conditions (Data) complete the analysis and are present for informational purposes of the trend and depend on the context.
DONCHIAN CHANNEL: 1 main condition:
BULLISH: the price has crossed above the HIGH DC line.
BEARISH: the price has gone below the LOW DC line.
NEUTRAL if the price is between the HIGH DC and LOW DC lines
The 2 other complementary conditions (Datas) complete the analysis:
HIGH DC and LOW DC are increasing, falling or stable.
SUPERTREND HMA HULL: The script determines several trend levels:
STRONG BUY, BUY, STRONG SELL, SELL AND NEUTRAL.
VOLUME: 3 trend levels:
VOLUME > MOVING AVERAGE,
VOLUME < MOVING AVERAGE,
VOLUME = MOVING AVERAGE.
PRICE: 3 trend levels:
PRICE > MOVING AVERAGE,
PRICE < MOVING AVERAGE,
PRICE = MOVING AVERAGE.
If you are using this indicator/strategy and you are satisfied with the results, you can possibly make a donation (a coffee, a pizza or more...) via paypal to: lebourg.regis@free.fr.
Thanks in advance !!!
Have good winning Trades.
**************************************************************************************************************************
SUPERTREND MIXED ICHI-DMI-VOL-GAP-HLBox@RL
by RegisL76
Ce script est basé sur plusieurs indicateurs de tendance.
* ICHIMOKU (KINKO HYO)
* DMI (Directional Movement Index)
* SUPERTREND ICHIMOKU + SUPERTREND DMI
* DONCHIAN CANAL Optimized with Colored Bars
* HMA Hull
* Fair Value GAP
* VOLUME/ MA Volume
* PRIX / MA Prix
* HHLL BOXES
Toutes ces indications sont visibles simultanément sur un seul et même graphique.
Un tableau de données récapitule toutes les informations importantes pour prendre une bonne décision de Trade.
I- Indicateur ICHIMOKU :
L’indicateur ICHIMOKU est visualisé de manière traditionnelle
Les valeurs de réglage standard ICHIMOKU sont respectées mais modifiables. (Valeurs traditionnelles par défaut =
Un symbole visuel orienté, à proximité de la dernière valeur, indique la progression (Montant, Descendant ou neutre) de la TENKAN-SEN et de la KIJUN-SEN ainsi que la période utilisée.
Le NUAGE (KUMO) et la CHIKOU-SPAN sont bien présents et sont primordiaux pour l'analyse complète de l'ICHIMOKU.
En haut du graphique sont représentés visuellement les croisements de la TENKAN et de la KIJUN.
Des lignes verticales, accompagnées d'étiquettes, permettent de visualiser rapidement les particularités de l'ICHIMOKU.
Une ligne visualise la barre en cours.
Une ligne visualise l'extrémité du NUAGE (KUMO) qui est décalé de 25 barres dans le futur.
Une ligne visualise l'extrémité de la chikou-span, qui est décalée de 25 barres dans le passé.
II-DIRECTIONAL MOVEMENT INDEX (DMI)
Traité de manière conventionnelle : DI+, DI-, ADX et associé à un SUPERTREND DMI
Un symbole visuel en bas du graphique indique les croisements DI+ et DI-
Une ligne de symboles orientés et colorés (DMI Line) en haut du graphique, indique la direction et la puissance de la tendance.
III SUPERTREND ICHIMOKU + SUPERTREND DMI
Suivi de tendance par calcul SUPERTREND
IV- DONCHIAN CANAL :
Traité de manière conventionnelle.
(Et optimisé par des barres colorées en cas de dépassement soit vers le haut, soit vers le bas.
Les lignes, haute et basse des dernières valeurs du canal sont représentées pour visualiser rapidement la fourchette du RANGE.
V- SUPERTREND HMA (HULL)
Traité de manière conventionnelle.
La ligne HMA indique visuellement, selon la couleur et l'orientation, la tendance du marché.
Un symbole visuel en bas du graphique indique les opportunités de vente et d'achat.
*VI VOLUME :
Calcul de la MOYENNE MOBILE du volume avec comparaison du volume par rapport à la moyenne mobile du volume.
Les indications sont colorées et commentées en fonction de la comparaison.
*VII PRIX :
Calcul de la MOYENNE MOBILE du prix avec comparaison du prix par rapport à la moyenne mobile du prix.
Les indications sont colorées et commentées en fonction de la comparaison.
*VIII HHLL BOXES :
Visualise sous forme de boite, pour une période donnée, les valeurs max hautes et min basses du prix.
La configuration permet de prendre en compte les mèches hautes et basses du prix ou bien les valeurs d'ouverture et de fermeture.
IX - FAIR VALUE GAP
Cet indicateur affiche les niveaux de 'GAP' sur la période temporelle actuelle ET une période temporelle facultative supérieure.
Le script prend en compte les valeurs haut/bas de la barre actuelle et compare avec les 2 barres précédentes.
Le "gap" est généré à partir du manque de recouvrement entre ces barres.
Les écarts baissiers ou haussiers sont déterminés selon que l'écart est supérieurs ou inférieur à HmaPrice, car ils ont tendance à être comblés, et peuvent être utilisés comme cibles.
NOTA : FAIR VALUE GAP n'a pas de valeurs affichées dans la table et/ou l'étiquette.
Les informations importantes (DATAS) relatives à chaque indicateur sont visualisées en temps réel dans une table et/ou une étiquette.
Chaque information est commentée et colorée en fonction de la direction, de la valeur, de la comparaison etc.
Chaque information indique la valeurs de la barre en cours et la valeur précédente ( en mode "COMPLET").
Les autres modes possibles pour visualiser la table et/ou l'étiquette, permettent une vue plus synthétique des informations (modes "CONDENSÉ" et "MINIMAL").
Afin de ne pas trop surcharger la vision du graphique, la boite de visualisation du RANGE DONCHIAN, les lignes verticales des marques décalées de l'ICHIMOKU, ainsi que les boites de l'indicateur HHLL Boxes ne sont visualisées que de manière intermittente (géré par une temporisation réglable ).
Le paramètre de configuration "HISTORICAL INFO READING" réglé sur zéro (par défaut) permet de lire toutes les informations de la barre actuelle en cours (Barre #0).
Toutes autres valeurs permet de lire les informations d'une barre historique. La valeur 1 permet de lire les informations de la barre précédant la barre en cours (-1).
La valeur 10 permet de lire les information de la dixième barre en arrière (-10) par rapport à la barre en cours, etc.
Dans le bas de la table et de l'étiquette de DATAS, des voyants, rouge, vert ou blanc indique de manière rapide la synthèse de la tendance issue des différents indicateurs.
Chaque voyant représente le nombre d'indicateur ayant la même tendance à un instant donné. Vert pour une tendance Bullish, rouge pour une tendance Bearish et blanc pour une tendance neutre.
Les conditions pour déterminer une tendance sont pour chaque indicateur :
SUPERTREND ICHIMOHU + DMI : les 2 Super trends sont ensemble soit bullish soit Bearish. Sinon le signal est neutre.
DMI : 2 conditions principales :
BULLISH si DI+ >= DI- et ADX >25.
BEARISH si DI+ < DI- et ADX >25.
NEUTRE si les 2 conditions ne sont pas remplies.
ICHIMOKU : 3 conditions principales :
BULLISH si PRIX au dessus du nuage et TENKAN > KIJUN et NUAGE VERT DEVANT.
BEARISH si PRIX en dessous du nuage et TENKAN < KIJUN et NUAGE ROUGE DEVANT.
Les autres conditions complémentaires (Datas) complètent l'analyse et sont présents à titre informatif de la tendance et dépendent du contexte.
CANAL DONCHIAN : 1 condition principale :
BULLISH : le prix est passé au dessus de la ligne HIGH DC.
BEARISH : le prix est passé au dessous de la ligne LOW DC.
NEUTRE si le prix se situe entre les lignes HIGH DC et LOW DC
Les 2 autres conditions complémentaires (Datas) complètent l'analyse : HIGH DC et LOW DC sont croissants, descendants ou stables.
SUPERTREND HMA HULL :
Le script détermine plusieurs niveaux de tendance :
STRONG BUY, BUY, STRONG SELL, SELL ET NEUTRE.
VOLUME : 3 niveaux de tendance :
VOLUME > MOYENNE MOBILE, VOLUME < MOYENNE MOBILE, VOLUME = MOYENNE MOBILE.
PRIX : 3 niveaux de tendance :
PRIX > MOYENNE MOBILE, PRIX < MOYENNE MOBILE, PRIX = MOYENNE MOBILE.
Si vous utilisez cet indicateur/ stratégie et que vous êtes satisfait des résultats,
vous pouvez éventuellement me faire un don (un café, une pizza ou plus ...) via paypal à : lebourg.regis@free.fr.
Merci d'avance !!!
Ayez de bons Trades gagnants.
OrderFlow Sentiment SwiftEdgeOrderFlow Sentiment SwiftEdge
Overview
OrderFlow Sentiment SwiftEdge is a visual indicator designed to help traders analyze market dynamics through a simulated orderbook and market sentiment display. It breaks down the current candlestick into 10 price bins, estimating buy and sell volumes, and presents this data in an orderbook table alongside a sentiment row showing the buy vs. sell bias. This tool provides a quick and intuitive way to assess orderflow activity and market sentiment directly on your chart.
How It Works
The indicator consists of two main components: an Orderbook Table and a Market Sentiment Row.
Orderbook Table:
Simulates buy and sell volumes for the current candlestick by distributing total volume into 10 price bins based on price movement and proximity to open/close levels.
Displays the price bins in a table with columns for Price, Buy Volume, and Sell Volume, sorted from highest to lowest price.
Highlights the current price level in orange for easy identification, while buy and sell dominance is indicated with green (buy) or red (sell) backgrounds.
Market Sentiment Row:
Calculates the overall buy and sell sentiment (as a percentage) for the current candlestick based on the simulated orderflow data.
Displays the sentiment above the orderbook table, with the background colored green if buyers dominate or red if sellers dominate.
Features
Customizable Colors: Choose colors for buy (default: green), sell (default: red), and current price (default: orange) levels.
Lot Scaling Factor: Adjust the volume scaling factor (default: 0.1 lots per volume unit) to simulate realistic lot sizes.
Table Position: Select the table position on the chart (Top, Middle, or Bottom; default: Middle).
Default Properties
Positive Color: Green
Negative Color: Red
Current Price Color: Orange
Lot Scaling Factor: 0.1
Table Position: Middle
Usage
This indicator is ideal for traders who want to visualize orderflow dynamics and market sentiment in real-time. The orderbook table provides a snapshot of buy and sell activity at different price levels within the current candlestick, helping you identify areas of high buying or selling pressure. The sentiment row offers a quick overview of market bias, allowing you to gauge whether buyers or sellers are currently dominating. Use this information to complement your trading decisions, such as identifying potential breakout levels or confirming trend direction.
Limitations
This indicator simulates orderflow data based on candlestick price movement and volume, as TradingView does not provide tick-by-tick data. The volume distribution is an approximation and should be used as a visual aid rather than a definitive measure of market activity.
The indicator operates on the chart's current timeframe and does not incorporate higher timeframe data.
The simulated volumes are scaled using a user-defined lot scaling factor, which may not reflect actual market lot sizes.
Disclaimer
This indicator is for informational purposes only and does not guarantee trading results. Always conduct your own analysis and manage risk appropriately. The simulated orderflow data is an estimation and may not reflect real market conditions.
Uptrick Signal Density Cloud🟪 Introduction
The Uptrick Signal Density Cloud is designed to track market direction and highlight potential reversals or shifts in momentum. It plots two smoothed lines on the chart and fills the space between them (often called a “cloud”). The bars on the chart change color depending on bullish or bearish conditions, and small triangles appear when certain reversal criteria are met. A metrics table displays real-time values for easy reference.
🟩 Why These Features Have Been Linked Together
1) Dual-Line Structure
Two separate lines represent shorter- and longer-term market tendencies. Linking them in one tool allows traders to view both near-term changes and the broader directional bias in a single glance.
2) Smoothed Averages
The script offers multiple smoothing methods—exponential, simple, hull, and an optimized approach—to reduce noise. Using more than one type of moving average can help balance responsiveness with stability.
3) Density Cloud Concept
Shading the region between the two lines highlights the gap or “thickness.” A wider gap typically signals stronger momentum, while a narrower gap could indicate a weakening trend or potential market indecision. When the cloud is too wide and crosses a certain threshold defined by the user, it indicates a possible reversal. When the cloud is too narrow it may indicate a potential breakout.
🟪 Why Use This Indicator
• Trend Visibility: The color-coded lines and bars make it easier to distinguish bullish from bearish conditions.
• Momentum Tracking: Thicker cloud regions suggest stronger separation between the faster and slower lines, potentially indicating robust momentum.
• Possible Reversal Alerts: Small triangles appear within thick zones when the indicator detects a crossover, drawing attention to key moments of potential trend change.
• Quick Reference Table: A metrics table shows line values, bullish or bearish status, and cloud thickness without needing to hover over chart elements.
🟩 Inputs
1) First Smoothing Length (length1)
Default: 14
Defines the lookback period for the faster line. Lower values make the line respond more quickly to price changes.
2) Second Smoothing Length (length2)
Default: 28
Defines the lookback period for the slower line or one of the moving averages in optimized mode. It generally responds more slowly than the faster line.
3) Extra Smoothing Length (extraLength)
Default: 50
A medium-term period commonly seen in technical analysis. In optimized mode, it helps add broader perspective to the combined lines.
4) Source (source)
Default: close
Specifies the price data (for example, open, high, low, or a custom source) used in the calculations.
5) Cloud Type (cloudType)
Options: Optimized, EMA, SMA, HMA
Determines the smoothing method used for the lines. “Optimized” blends multiple exponential averages at different lengths.
6) Cloud Thickness Threshold (thicknessThreshold)
Default: 0.5
Sets the minimum separation between the two lines to qualify as a “thick” zone, indicating potentially stronger momentum.
🟪 Core Components
1) Faster and Slower Lines
Each line is smoothed according to user preferences or the optimized technique. The faster line typically reacts more quickly, while the slower line provides a broader overview.
2) Filled Density Cloud
The space between the two lines is filled to visualize in which direction the market is trending.
3) Color-Coded Bars
Price bars adopt bullish or bearish colors based on which line is on top, providing an immediate sense of trend direction.
4) Reversal Triangles
When the cloud is thick (exceeding the threshold) and the lines cross in the opposite direction, small triangles appear, signaling a possible market shift.
5) Metrics Table
A compact table shows the current values of both lines, their bullish/bearish statuses, the cloud thickness, and whether the cloud is in a “reversal zone.”
🟩 Calculation Process
1) Raw Averages
Depending on the mode, standard exponential, simple, hull, or “optimized” exponential blends are calculated.
2) Optimized Averages (if selected)
The faster line is the average of three exponential moving averages using length1, length2, and extraLength.
The slower line similarly uses those same lengths multiplied by 1.5, then averages them together for broader smoothing.
3) Difference and Threshold
The absolute gap between the two lines is measured. When it exceeds thicknessThreshold, the cloud is considered thick.
4) Bullish or Bearish Determination
If sma1 (the faster line) is above sma2 (the slower line), conditions are deemed bullish; otherwise, they are bearish. This distinction is reflected in both bar colors and cloud shading.
5) Reversal Markers
In thick zones, a crossover triggers a triangle at the point of potential reversal, alerting traders to a possible trend change.
🟪 Smoothing Methods
1) Exponential (EMA)
Prioritizes recent data for quicker responsiveness.
2) Simple (SMA)
Takes a straightforward average of the chosen period, smoothing price action but often lagging more in volatile markets.
3) Hull (HMA)
Employs a specialized formula to reduce lag while maintaining smoothness.
4) Optimized (Blended Exponential)
Combines multiple EMA calculations to strike a balance between responsiveness and noise reduction.
🟩 Cloud Logic and Reversal Zones
Cloud thickness above the defined threshold typically signals exceeding momentum and can lead to a quick reversal. During these thick periods, if the width exceeds the defined threshold, small triangles mark potential reversal points. In order for the reversal shape to show, the color of the cloud has to be the opposite. So, for example, if the cloud is bearish, and exceeds momentum, defined by the user, a bullish signal appears. The opposite conditions for a bullish signal. This approach can help traders focus on notable changes rather than minor oscillations.
🟪 Bar Coloring and Layered Lines
Bars take on bullish or bearish tints, matching the faster line’s position relative to the slower line. The lines themselves are plotted multiple times with varying opacities, creating a layered, glowing look that enhances visibility without affecting calculations.
🟩 The Metrics Table
Located in the top-right corner of the chart, this table displays:
• SMA1 and SMA2 current values.
• Bullish or bearish alignment for each line.
• Cloud thickness.
• Reversal zone status (in or out of zone).
This numeric readout allows for a quick data check without hovering over the chart.
🟪 Why These Specific Moving Average Lengths Are Used
Default lengths of 14, 28, and 50 are common in technical analysis. Fourteen captures near-term price movement without overreacting. Twenty-eight, roughly double 14, provides a moderate smoothing level. Fifty is widely regarded as a medium-term benchmark. Multiplying each length by 1.5 for the slower line enhances separation when combined with the faster line.
🟩 Originality and Usefulness
• Multi-Layered Smoothing. The user can select from several moving average modes, including a unique “optimized” blend, possibly reducing random fluctuations in the market data.
• Combined Visual and Numeric Clarity. Bars, clouds, and a real-time table merge into a single interface, enabling efficient trend analysis.
• Focus on Significant Shifts. Thick cloud zones and triangles draw attention to potentially stronger momentum changes and plausible reversals.
• Flexible Across Markets. The adjustable lengths and threshold can be tuned to different asset classes (stocks, forex, commodities, crypto) and timeframes.
By integrating multiple technical concepts—cloud-based trend detection, color coding, reversal markers, and an immediate reference table—the Uptrick Signal Density Cloud aims to streamline chart reading and decision-making.
🟪 Additional Considerations
• Timeframes. Intraday, daily, and weekly charts each yield different signals. Adjust the smoothing lengths and threshold to suit specific trading horizons.
• Market Types. Though applicable across asset classes, parameters might need tweaking to address the volatility of commodities, forex pairs, or cryptocurrencies.
• Confirmation Tools. Pairing this indicator with volume studies or support/resistance analysis can improve the reliability of signals.
• Potential Limitations. No indicator is foolproof; sudden market shifts or choppy conditions may reduce accuracy. Cautious position sizing and risk management remain essential.
🟩 Disclaimers
The Uptrick Signal Density Cloud relies on historical price data and may lag sudden moves or provide false positives in ranging conditions. Always combine it with other analytical techniques and sound risk management. This script is offered for educational purposes only and should not be considered financial advice.
🟪 Conclusion
The Uptrick Signal Density Cloud blends trend identification, momentum assessment, and potential reversal alerts in a single, user-friendly tool. With customizable smoothing methods and a focus on cloud thickness, it visually highlights important market conditions. While it cannot guarantee predictive accuracy, it can serve as a comprehensive reference for traders seeking both a quick snapshot of the current trend and deeper insights into market dynamics.
Dynamic Intensity Transition Oscillator (DITO)The Dynamic Intensity Transition Oscillator (DITO) is a comprehensive indicator designed to identify and visualize the slope of price action normalized by volatility, enabling consistent comparisons across different assets. This indicator calculates and categorizes the intensity of price movement into six states—three positive and three negative—while providing visual cues and alerts for state transitions.
Components and Functionality
1. Slope Calculation
- The slope represents the rate of change in price action over a specified period (Slope Calculation Period).
- It is calculated as the difference between the current price and the simple moving average (SMA) of the price, divided by the length of the period.
2. Normalization Using ATR
- To standardize the slope across assets with different price scales and volatilities, the slope is divided by the Average True Range (ATR).
- The ATR ensures that the slope is comparable across assets with varying price levels and volatility.
3. Intensity Levels
- The normalized slope is categorized into six distinct intensity levels:
High Positive: Strong upward momentum.
Medium Positive: Moderate upward momentum.
Low Positive: Weak upward movement or consolidation.
Low Negative: Weak downward movement or consolidation.
Medium Negative: Moderate downward momentum.
High Negative: Strong downward momentum.
4. Visual Representation
- The oscillator is displayed as a histogram, with each intensity level represented by a unique color:
High Positive: Lime green.
Medium Positive: Aqua.
Low Positive: Blue.
Low Negative: Yellow.
Medium Negative: Purple.
High Negative: Fuchsia.
Threshold levels (Low Intensity, Medium Intensity) are plotted as horizontal dotted lines for visual reference, with separate colors for positive and negative thresholds.
5. Intensity Table
- A dynamic table is displayed on the chart to show the current intensity level.
- The table's text color matches the intensity level color for easy interpretation, and its size and position are customizable.
6. Alerts for State Transitions
- The indicator includes a robust alerting system that triggers when the intensity level transitions from one state to another (e.g., from "Medium Positive" to "High Positive").
- The alert includes both the previous and current states for clarity.
Inputs and Customization
The DITO indicator offers a variety of customizable settings:
Indicator Parameters
Slope Calculation Period: Defines the period over which the slope is calculated.
ATR Calculation Period: Defines the period for the ATR used in normalization.
Low Intensity Threshold: Threshold for categorizing weak momentum.
Medium Intensity Threshold: Threshold for categorizing moderate momentum.
Intensity Table Settings
Table Position: Allows you to position the intensity table anywhere on the chart (e.g., "Bottom Right," "Top Left").
Table Size: Enables customization of table text size (e.g., "Small," "Large").
Use Cases
Trend Identification:
- Quickly assess the strength and direction of price movement with color-coded intensity levels.
Cross-Asset Comparisons:
- Use the normalized slope to compare momentum across different assets, regardless of price scale or volatility.
Dynamic Alerts:
- Receive timely alerts when the intensity transitions, helping you act on significant momentum changes.
Consolidation Detection:
- Identify periods of low intensity, signaling potential reversals or breakout opportunities.
How to Use
- Add the indicator to your chart.
- Configure the input parameters to align with your trading strategy.
Observe:
The Oscillator: Use the color-coded histogram to monitor price action intensity.
The Intensity Table: Track the current intensity level dynamically.
Alerts: Respond to state transitions as notified by the alerts.
Final Notes
The Dynamic Intensity Transition Oscillator (DITO) combines trend strength detection, cross-asset comparability, and real-time alerts to offer traders an insightful tool for analyzing market conditions. Its user-friendly visualization and comprehensive alerting make it suitable for both novice and advanced traders.
Disclaimer: This indicator is for educational purposes and is not financial advice. Always perform your own analysis before making trading decisions.
Burst PowerThe Burst Power indicator is to be used for Indian markets where most stocks have a maximum price band limit of 20%.
This indicator is intended to identify stocks with high potential for significant price movements. By analysing historical price action over a user-defined lookback period, it calculates a Burst Power score that reflects the stock's propensity for rapid and substantial moves. This can be helpful for stock selection in strategies involving momentum bursts, swing trading, or identifying stocks with explosive potential.
Key Components
____________________
Significant Move Counts:
5% Moves: Counts the number of days within the lookback period where the stock had a positive close-to-close move between 5% and 10%.
10% Moves: Counts the number of days with a positive close-to-close move between 10% and 19%.
19% Moves: Counts the number of days with a positive close-to-close move of 19% or more.
Maximum Price Move (%):
Identifies the largest positive close-to-close percentage move within the lookback period, along with the date it occurred.
Burst Power Score:
A composite score calculated using the counts of significant moves: Burst Power =(Count5%/5) +(Count10%/2) + (Count19%/0.5)
The score is then rounded to the nearest whole number.
A higher Burst Power score indicates a higher frequency of significant price bursts.
Visual Indicators:
Table Display: Presents all the calculated data in a customisable table on the chart.
Markers on Chart: Plots markers on the chart where significant moves occurred, aiding visual analysis.
Using the Lookback Period
____________________________
The lookback period determines how much historical data the indicator analyses. Users can select from predefined options:
3 Months
6 Months
1 Year
3 Years
5 Years
A shorter lookback period focuses on recent price action, which may be more relevant for short-term trading strategies. A longer lookback period provides a broader historical context, useful for identifying long-term patterns and behaviors.
Interpreting the Burst Power Score
__________________________________
High Burst Power Score (≥15):
Indicates the stock frequently experiences significant price moves.
Suitable for traders seeking quick momentum bursts and swing trading opportunities.
Stocks with high scores may be more volatile but offer potential for rapid gains.
Moderate Burst Power Score (10 to 14):
Suggests occasional significant price movements.
May suit traders looking for a balance between volatility and stability.
Low Burst Power Score (<10):
Reflects fewer significant price bursts.
Stocks are more likely to exhibit longer, sustainable, but slower price trends.
May be preferred by traders focusing on steady growth or longer-term investments.
Note: Trading involves uncertainties, and the Burst Power score should be considered as one of many factors in a comprehensive trading strategy. It is essential to incorporate broader market analysis and risk management practices.
Customisation Options
_________________________
The indicator offers several customisation settings to tailor the display and functionality to individual preferences:
Display Mode:
Full Mode: Shows the detailed table with all components, including significant move counts, maximum price move, and the Burst Power score.
Mini Mode: Displays only the Burst Power score and its corresponding indicator (green, orange, or red circle).
Show Latest Date Column:
Toggle the display of the "Latest Date" column in the table, which shows the most recent occurrence of each significant move category.
Theme (Dark Mode):
Switch between Dark Mode and Light Mode for better visual integration with your chart's color scheme.
Table Position and Size:
Position: Place the table at various locations on the chart (top, middle, bottom; left, center, right).
Size: Adjust the table's text size (tiny, small, normal, large, huge, auto) for optimal readability.
Header Size: Customise the font size of the table headers (Small, Medium, Large).
Color Settings:
Disable Colors in Table: Option to display the table without background colors, which can be useful for printing or if colors are distracting.
Bullish Closing Filter:
Another customisation here is to count a move only when the closing for the day is strong. For this, we have an additional filter to see if close is within the chosen % of the range of the day. Closing within the top 1/3, for instance, indicates a way more bullish day tha, say, closing within the bottom 25%.
Move Markers on chart:
The indicator also marks out days with significant moves. You can choose to hide or show the markers on the candles/bars.
Practical Applications
________________________
Momentum Trading: High Burst Power scores can help identify stocks that are likely to experience rapid price movements, suitable for momentum traders.
Swing Trading: Traders looking for short- to medium-term opportunities may focus on stocks with moderate to high Burst Power scores.
Positional Trading: Lower Burst Power scores may indicate steadier stocks that are less prone to volatility, aligning with long-term investment strategies.
Risk Management: Understanding a stock's propensity for significant moves can aid in setting appropriate stop-loss and take-profit levels.
Disclaimer: Trading involves significant risk, and past performance is not indicative of future results. The Burst Power indicator is intended for educational purposes and should not be construed as financial advice. Always conduct thorough research and consult with a qualified financial professional before making investment decisions.
Uptrick: TimeFrame Trends: Performance & Sentiment Indicator### **Uptrick: TimeFrame Trends: Performance & Sentiment Indicator (TFT) - In-Depth Explanation**
#### **Overview**
The **Uptrick: TimeFrame Trends: Performance & Sentiment Indicator (TFT)** is a sophisticated trading tool designed to provide traders with a comprehensive view of market trends across multiple timeframes, combined with a sentiment gauge through the Relative Strength Index (RSI). This indicator offers a unique blend of performance analysis, sentiment evaluation, and visual signal generation, making it an invaluable resource for traders who seek to understand both the macro and micro trends within a financial instrument.
#### **Purpose**
The primary purpose of the TFT indicator is to empower traders with the ability to assess the performance of an asset over various timeframes while simultaneously gauging market sentiment through the RSI. By analyzing price changes over periods ranging from one week to one year, and complementing this with sentiment signals, TFT enables traders to make informed decisions based on a well-rounded analysis of historical price performance and current market conditions.
#### **Key Components and Features**
1. **Multi-Timeframe Performance Analysis:**
- **Performance Lookback Periods:**
- The TFT indicator calculates the percentage price change over several predefined timeframes: 7 days (1 week), 14 days (2 weeks), 30 days (1 month), 180 days (6 months), and 365 days (1 year). These timeframes provide a layered view of how an asset has performed over short, medium, and long-term periods.
- **Percentage Change Calculation:**
- The indicator computes the percentage change for each timeframe by comparing the current closing price to the closing price at the start of each period. This gives traders insight into the strength and direction of the trend over different periods, helping them identify consistent trends or potential reversals.
2. **Sentiment Analysis Using RSI:**
- **Relative Strength Index (RSI):**
- RSI is a widely-used momentum oscillator that measures the speed and change of price movements. It oscillates between 0 and 100 and is typically used to identify overbought or oversold conditions. In TFT, the RSI is calculated using a 14-period lookback, which is standard for most RSI implementations.
- **RSI Smoothing with EMA:**
- To refine the RSI signal and reduce noise, TFT applies a 10-period Exponential Moving Average (EMA) to the RSI values. This smoothed RSI is then used to generate buy, sell, and neutral signals based on its position relative to the 50 level:
- **Buy Signal:** Triggered when the smoothed RSI crosses above 50, indicating bullish sentiment.
- **Sell Signal:** Triggered when the smoothed RSI crosses below 50, indicating bearish sentiment.
- **Neutral Signal:** Triggered when the smoothed RSI equals 50, suggesting indecision or a balanced market.
3. **Visual Signal Generation:**
- **Signal Plots:**
- TFT provides clear visual cues directly on the price chart by plotting shapes at the points where buy, sell, or neutral signals are generated. These shapes are color-coded (green for buy, red for sell, yellow for neutral) and are positioned below or above the price bars for easy identification.
- **First Occurrence Trigger:**
- To avoid clutter and focus on significant market shifts, TFT only triggers the first occurrence of each signal type. This feature helps traders concentrate on the most relevant signals without being overwhelmed by repeated alerts.
4. **Customizable Performance & Sentiment Table:**
- **Table Display:**
- The TFT indicator includes a customizable table that displays the calculated percentage changes for each timeframe. This table is positioned on the chart according to user preference (top-left, top-right, bottom-left, bottom-right) and provides a quick reference to the asset’s performance across multiple periods.
- **Dynamic Text Color:**
- To enhance readability and provide immediate visual feedback, the text color in the table changes based on the direction of the percentage change: green for positive (upward movement) and red for negative (downward movement). This color-coding helps traders quickly assess whether the asset is in an uptrend or downtrend for each period.
- **Customizable Font Size:**
- Traders can adjust the font size of the table to fit their chart layout and personal preferences, ensuring that the information is accessible without being intrusive.
5. **Flexibility and Customization:**
- **Lookback Period Customization:**
- While the default lookback periods are set for common trading intervals (7 days, 14 days, etc.), these can be adjusted to match different trading strategies or market conditions. This flexibility allows traders to tailor the indicator to focus on the timeframes most relevant to their analysis.
- **RSI and EMA Settings:**
- The length of the RSI calculation and the smoothing EMA can also be customized. This is particularly useful for traders who prefer shorter or longer periods for their momentum analysis, allowing them to fine-tune the sensitivity of the indicator.
- **Table Position and Appearance:**
- The table’s position on the chart, along with its font size and colors, is fully customizable. This ensures that the indicator can be integrated seamlessly into any chart setup without obstructing key price data.
#### **Use Cases and Applications**
1. **Trend Identification and Confirmation:**
- **Short-Term Traders:**
- Traders focused on short-term movements can use the 7-day and 14-day performance metrics to identify recent trends and momentum shifts. The RSI signals provide additional confirmation, helping traders enter or exit positions based on the latest market sentiment.
- **Swing Traders:**
- For those holding positions over days to weeks, the 30-day and 180-day performance data are particularly useful. These metrics highlight medium-term trends, and when combined with RSI signals, they provide a robust framework for swing trading strategies.
- **Long-Term Investors:**
- Long-term investors can benefit from the 1-year performance data to gauge the overall health and direction of an asset. The indicator’s ability to track performance across different periods helps in identifying long-term trends and potential reversal points.
2. **Sentiment Analysis and Market Timing:**
- **Market Sentiment Tracking:**
- By using RSI in conjunction with performance metrics, TFT provides a clear picture of market sentiment. Traders can use this information to time their entries and exits more effectively, aligning their trades with periods of strong bullish or bearish sentiment.
- **Avoiding False Signals:**
- The smoothing of RSI helps reduce noise and avoid false signals that are common in volatile markets. This makes the TFT indicator a reliable tool for identifying true market trends and avoiding whipsaws that can lead to losses.
3. **Comprehensive Market Analysis:**
- **Multi-Timeframe Analysis:**
- TFT’s ability to analyze multiple timeframes simultaneously makes it an excellent tool for comprehensive market analysis. Traders can compare short-term and long-term performance to understand the broader market context, making it easier to align their trading strategies with the overall trend.
- **Performance Benchmarking:**
- The percentage change metrics provide a clear benchmark for an asset’s performance over time. This information can be used to compare the asset against broader market indices or other assets, helping traders make more informed decisions about where to allocate their capital.
4. **Custom Strategy Development:**
- **Tailoring to Specific Markets:**
- TFT can be customized to suit different markets, whether it’s stocks, forex, commodities, or cryptocurrencies. For instance, traders in volatile markets may opt for shorter lookback periods and more sensitive RSI settings, while those in stable markets may prefer longer periods for a smoother analysis.
- **Integrating with Other Indicators:**
- TFT can be used alongside other technical indicators to create a more comprehensive trading strategy. For example, combining TFT with moving averages, Bollinger Bands, or MACD can provide additional layers of confirmation and reduce the likelihood of false signals.
#### **Best Practices for Using TFT**
- **Regularly Adjust Lookback Periods:**
- Depending on the market conditions and the asset being traded, it’s important to regularly review and adjust the lookback periods for the performance metrics. This ensures that the indicator remains relevant and responsive to current market trends.
- **Combine with Volume Analysis:**
- While TFT provides a solid foundation for trend and sentiment analysis, combining it with volume indicators can further enhance its effectiveness. Volume can confirm the strength of a trend or signal potential reversals when divergences occur.
- **Use RSI with Other Momentum Indicators:**
- Although RSI is a powerful tool on its own, using it alongside other momentum indicators like Stochastic Oscillator or MACD can provide additional confirmation and help refine entry and exit points.
- **Customize Table Settings for Clarity:**
- Ensure that the performance table is positioned and sized appropriately on the chart. It should be easily readable without obstructing important price data. Adjust the text size and colors as needed to maintain clarity.
- **Monitor Multiple Timeframes:**
- Utilize the multi-timeframe analysis feature of TFT to monitor trends across different periods. This helps in identifying the dominant trend and avoiding trades that go against the broader market direction.
#### **Conclusion**
The **Uptrick: TimeFrame Trends: Performance & Sentiment Indicator (TFT)** is a comprehensive and versatile tool that combines the power of multi-timeframe performance analysis with sentiment gauging through RSI. Its ability to customize and adapt to various trading strategies and markets makes it a valuable asset for traders at all levels. By offering a clear visual representation of trends and market sentiment, TFT empowers traders to make more informed and confident trading decisions, whether they are focusing on short-term price movements or long-term investment opportunities. With its deep integration of performance metrics and sentiment analysis, TFT stands out as a must-have indicator for any trader looking to gain a holistic understanding of market dynamics.
Uptrick: Volume-Weighted EMA Signal### **Uptrick: Volume-Weighted EMA Signal (UVES) Indicator - Comprehensive Description**
#### **Overview**
The **Uptrick: Volume-Weighted EMA Signal (UVES)** is an advanced, multifaceted trading indicator meticulously designed to provide traders with a holistic view of market trends by integrating Exponential Moving Averages (EMA) with volume analysis. This indicator not only identifies the direction of market trends through dynamic EMAs but also evaluates the underlying strength of these trends using real-time volume data. UVES is a versatile tool suitable for various trading styles and markets, offering a high degree of customization to meet the specific needs of individual traders.
#### **Purpose**
The UVES indicator aims to enhance traditional trend-following strategies by incorporating a critical yet often overlooked component: volume. Volume is a powerful indicator of market strength, providing insights into the conviction behind price movements. By merging EMA-based trend signals with detailed volume analysis, UVES offers a more nuanced and reliable approach to identifying trading opportunities. This dual-layer analysis allows traders to differentiate between strong trends supported by significant volume and weaker trends that may be prone to reversals.
#### **Key Features and Functions**
1. **Dynamic Exponential Moving Average (EMA):**
- The core of the UVES indicator is its dynamic EMA, calculated over a customizable period. The EMA is a widely used technical indicator that smooths price data to identify the underlying trend. In UVES, the EMA is dynamically colored—green when the current EMA value is above the previous value, indicating an uptrend, and red when below, signaling a downtrend. This visual cue helps traders quickly assess the trend direction without manually calculating or interpreting raw data.
2. **Comprehensive Moving Average Customization:**
- While the EMA is the default moving average in UVES, traders can select from various other moving average types, including Simple Moving Average (SMA), Smoothed Moving Average (SMMA), Weighted Moving Average (WMA), and Volume-Weighted Moving Average (VWMA). Each type offers unique characteristics:
- **SMA:** Provides a simple average of prices over a specified period, suitable for identifying long-term trends.
- **EMA:** Gives more weight to recent prices, making it more responsive to recent market movements.
- **SMMA (RMA):** A slower-moving average that reduces noise, ideal for capturing smoother trends.
- **WMA:** Weighs prices based on their order in the dataset, making recent prices more influential.
- **VWMA:** Integrates volume data, emphasizing price movements that occur with higher volume, making it particularly useful in volume-sensitive markets.
3. **Signal Line for Trend Confirmation:**
- UVES includes an optional signal line, which applies a secondary moving average to the primary EMA. This signal line can be used to smooth out the EMA and confirm trend changes. The signal line’s color changes based on its slope—green for an upward slope and red for a downward slope—providing a clear visual confirmation of trend direction. Traders can adjust the length and type of this signal line, allowing them to tailor the indicator’s responsiveness to their trading strategy.
4. **Buy and Sell Signal Generation:**
- UVES generates explicit buy and sell signals based on the interaction between the EMA and the signal line. A **buy signal** is triggered when the EMA transitions from a red (downtrend) to a green (uptrend), indicating a potential entry point. Conversely, a **sell signal** is triggered when the EMA shifts from green to red, suggesting an exit or shorting opportunity. These signals are displayed directly on the chart as upward or downward arrows, making them easily identifiable even during fast market conditions.
5. **Volume Analysis with Real-Time Buy/Sell Volume Table:**
- One of the standout features of UVES is its integration of volume analysis, which calculates and displays the volume attributed to buying and selling activities. This analysis includes:
- **Buy Volume:** The portion of the total volume associated with price increases (close higher than open).
- **Sell Volume:** The portion of the total volume associated with price decreases (close lower than open).
- **Buy/Sell Ratio:** A ratio of buy volume to sell volume, providing a quick snapshot of market sentiment.
- These metrics are presented in a real-time table positioned in the top-right corner of the chart, with customizable colors and formatting. The table updates with each new bar, offering continuous feedback on the strength and direction of the market trend based on volume data.
6. **Customizable Settings and User Control:**
- **EMA Length and Source:** Traders can specify the lookback period for the EMA, adjusting its sensitivity to price changes. The source for EMA calculations can also be customized, with options such as close, open, high, low, or other custom price series.
- **Signal Line Customization:** The signal line’s length, type, and width can be adjusted to suit different trading strategies, allowing traders to optimize the balance between trend detection and noise reduction.
- **Offset Adjustment:** The offset feature allows users to shift the EMA and signal line forward or backward on the chart. This can help align the indicator with specific price action or adjust for latency in decision-making processes.
- **Volume Table Positioning and Formatting:** The position, size, and color scheme of the volume table are fully customizable, enabling traders to integrate the table seamlessly into their chart setup without cluttering the visual workspace.
7. **Versatility Across Markets and Trading Styles:**
- UVES is designed to be effective across a wide range of financial markets, including Forex, stocks, cryptocurrencies, commodities, and indices. Its adaptability to different markets is supported by its comprehensive customization options and the inclusion of volume analysis, which is particularly valuable in markets where volume plays a crucial role in price movement.
#### **How Different Traders Can Benefit from UVES**
1. **Trend Followers:**
- Trend-following traders will find UVES particularly beneficial for identifying and riding trends. The dynamic EMA and signal line provide clear visual cues for trend direction, while the volume analysis helps confirm the strength of these trends. This combination allows trend followers to stay in profitable trades longer and exit when the trend shows signs of weakening.
2. **Volume-Based Traders:**
- Traders who focus on volume as a key indicator of market strength can leverage the UVES volume table to gain insights into the buying and selling pressure behind price movements. By monitoring the buy/sell ratio, these traders can identify periods of strong conviction (high buy volume) or potential reversals (high sell volume) with greater accuracy.
3. **Scalpers and Day Traders:**
- For traders operating on shorter time frames, UVES provides quick and reliable signals that are essential for making rapid trading decisions. The ability to customize the EMA length and type allows scalpers to fine-tune the indicator for responsiveness, while the volume analysis offers an additional layer of confirmation to avoid false signals.
4. **Swing Traders:**
- Swing traders, who typically hold positions for several days to weeks, can use UVES to identify medium-term trends and potential entry and exit points. The indicator’s ability to filter out market noise through the signal line and volume analysis makes it ideal for capturing significant price movements without being misled by short-term volatility.
5. **Position Traders and Long-Term Investors:**
- Even long-term investors can benefit from UVES by using it to identify major trend reversals or confirm the strength of long-term trends. The flexibility to adjust the EMA and signal line to longer periods ensures that the indicator remains relevant for detecting shifts in market sentiment over extended time frames.
#### **Optimal Settings for Different Markets**
- **Forex Markets:**
- **EMA Length:** 9 to 14 periods.
- **Signal Line:** Use VWMA or WMA for the signal line to incorporate volume data, which is crucial in the highly liquid Forex markets.
- **Best Use:** Short-term trend following, with an emphasis on identifying rapid changes in market sentiment.
- **Stock Markets:**
- **EMA Length:** 20 to 50 periods.
- **Signal Line:** SMA or EMA with a slightly longer length (e.g., 50 periods) to capture broader market trends.
- **Best Use:** Medium to long-term trend identification, with volume analysis confirming the strength of institutional buying or selling.
- **Cryptocurrency Markets:**
- **EMA Length:** 9 to 12 periods, due to the high volatility in crypto markets.
- **Signal Line:** SMMA or EMA for smoothing out extreme price fluctuations.
- **Best Use:** Identifying entry and exit points in volatile markets, with the volume table providing insights into market manipulation or sudden shifts in trader sentiment.
- **Commodity Markets:**
- **EMA Length:** 14 to 21 periods.
- **Signal Line:** WMA or VWMA, considering the impact of trading volume on commodity prices.
- **Best Use:** Capturing medium-term price movements and confirming trend strength with volume data.
#### **Customization for Advanced Users**
- **Advanced Offset Usage:** Traders can experiment with different offset values to see how shifting the EMA and signal line impacts the timing of buy/sell signals. This can be particularly useful in markets with known latency or for strategies that require a delayed confirmation of trend changes.
- **Volume Table Integration:** The position, size, and colors of the volume table can be adjusted to fit seamlessly into any trading setup. For example, a trader might choose to position the table in the bottom-right corner and use a smaller size to keep the focus on price action while still having access to volume data.
- **Signal Filtering:** By combining the signal line with the primary EMA, traders can filter out false signals during periods of low volatility or when the market is range-bound. Adjusting the length of the signal line allows for greater control over the sensitivity of the trend detection.
#### **Conclusion**
The **Uptrick: Volume-Weighted EMA Signal (UVES)** is a powerful and adaptable indicator designed for traders who demand more from their technical analysis tools. By integrating dynamic EMA trend signals with real-time volume analysis, UVES offers a comprehensive view of market conditions, making it an invaluable resource for identifying trends, confirming signals, and understanding market sentiment. Whether you are a day trader, swing trader, or long-term investor, UVES provides the versatility, precision, and customization needed to make more informed and profitable trading decisions. With its ability to adapt to various markets and trading styles, UVES is not just an indicator but a complete trend analysis solution.
ChartUtilsLibrary "ChartUtils"
Library for chart utilities, including managing tables
initTable(rows, cols, bgcolor)
Initializes a table with specific dimensions and color
Parameters:
rows (int) : (int) Number of rows in the table
cols (int) : (int) Number of columns in the table
bgcolor (color) : (color) Background color of the table
Returns: (table) The initialized table
updateTable(tbl, is_price_below_avg, current_investment_USD, strategy_position_size, strategy_position_avg_price, strategy_openprofit, strategy_opentrades, isBullishRate, isBearishRate, mlRSIOverSold, mlRSIOverBought)
Updates the trading table
Parameters:
tbl (table) : (table) The table to update
is_price_below_avg (bool) : (bool) If the current price is below the average price
current_investment_USD (float) : (float) The current investment in USD
strategy_position_size (float) : (float) The size of the current position
strategy_position_avg_price (float) : (float) The average price of the current position
strategy_openprofit (float) : (float) The current open profit
strategy_opentrades (int) : (int) The number of open trades
isBullishRate (bool) : (bool) If the current rate is bullish
isBearishRate (bool) : (bool) If the current rate is bearish
mlRSIOverSold (bool) : (bool) If the ML RSI is oversold
mlRSIOverBought (bool) : (bool) If the ML RSI is overbought
updateTableNoPosition(tbl)
Updates the table when there is no position
Parameters:
tbl (table) : (table) The table to update
Price Cross Time Custom Range Interactive█ OVERVIEW
This indicator was a time-based indicator and intended as educational purpose only based on pine script v5 functions for ta.cross() , ta.crossover() and ta.crossunder() .
I realised that there is some overlap price with the cross functions, hence I integrate them into Custom Range Interactive with value variance and overlap displayed into table.
This was my submission for Pinefest #1 , I decided to share this as public, I may accidentally delete this as long as i keep as private.
█ INSPIRATION
Inspired by design, code and usage of CAGR. Basic usage of custom range / interactive, pretty much explained here . Credits to TradingView.
█ FEATURES
1. Custom Range Interactive
2. Label can be resize and change color.
3. Label show tooltip for price and time.
4. Label can be offset to improve readability.
5. Table can show price variance when any cross is true.
6. Table can show overlap if found crosss is overlap either with crossover and crossunder.
7. Table text color automatically change based on chart background (light / dark mode).
8. Source 2 is drawn as straight line, while Source 1 will draw as label either above line for crossover, below line for crossunder and marked 'X' if crossing with Source 2's line.
9. Cross 'X' label can be offset to improve readability.
10. Both Source 1 and Source 2 can select Open, Close, High and Low, which can be displayed into table.
█ LIMITATIONS
1. Table is limited to intraday timeframe only as time format is not accurate for daily timeframe and above. Example daily timeframe will give result less 1 day from actual date.
2. I did not include other sources such external source or any built in sources such as hl2, hlc3, ohlc4 and hlcc4.
█ CODE EXPLAINATION
I pretty much create custom function with method which returns tuple value.
method crossVariant(float price = na, chart.point ref = na) =>
cross = ta.cross( price, ref.price)
over = ta.crossover( price, ref.price)
under = ta.crossunder(price, ref.price)
Unfortunately, I unable make the labels into array which i plan to return string value by getting the text value from array label, hence i use label.all and add incremental int value as reference.
series label labelCross = na, labelCross.delete()
var int num = 0
if over
num += 1
labelCross := label.new()
if under
num += 1
labelCross := label.new()
if cross
num += 1
labelCross := label.new()
I realised cross value can be overlap with crossover and crossunder, hence I add bool to enable force overlap and add additional bools.
series label labelCross = na, labelCross.delete()
var int num = 0
if forceOverlap
if over
num += 1
labelCross := label.new()
if under
num += 1
labelCross := label.new()
if cross
num += 1
labelCross := label.new()
else
if cross and over
num += 1
labelCross := label.new()
if cross and under
num += 1
labelCross := label.new()
if cross and not over and not under
num += 1
labelCross := label.new()
█ USAGE / EXAMPLES
Major and Minor Trend Indicator by Nikhil34a V 2.2Title: Major and Minor Trend Indicator by Nikhil34a V 2.2
Description:
The Major and Minor Trend Indicator v2.2 is a comprehensive technical analysis script designed for use with the TradingView platform. This powerful tool is developed in Pine Script version 5 and helps traders identify potential buying and selling opportunities in the stock market.
Features:
SMA Trend Analysis: The script calculates two Simple Moving Averages (SMAs) with user-defined lengths for major and minor trends. It displays these SMAs on the chart, allowing traders to visualize the prevailing trends easily.
Surge Detection: The indicator can detect buying and selling surges based on specific conditions, such as volume, RSI, MACD, and stochastic indicators. Both Buying and Selling surges are marked in black on the chart.
Option Buy Zone Detection: The script identifies the option buy zone based on SMA crossovers, RSI, and MACD values. The buy zone is categorized as "CE Zone" or "PE Zone" and displayed in the table along with the trigger time.
Two-Day High and Low Range: The script calculates the highest high and lowest low of the previous two trading days and plots them on the chart. The area between these points is shaded in semi-transparent green and red colors.
Crossover Analysis: The script analyzes moving average crossovers on multiple timeframes (2-minute, 3-minute, and 5-minute) and displays buy and sell signals accordingly.
Trend Identification: The script identifies the major and minor trends as either bullish or bearish, providing valuable insights into the overall market sentiment.
Usage:
Customize Major and Minor SMA Periods: Adjust the lengths of major and minor SMAs through input parameters to suit your trading preferences.
Enable/Disable Moving Averages: Choose which SMAs to display on the chart by toggling the "showXMA" input options.
Set Surge and Option Buy Zone Thresholds: Modify the surgeThreshold, volumeThreshold, RSIThreshold, and StochThreshold inputs to refine the surge and buy zone detection.
Analyze Crossover Signals: Monitor the crossover signals in the table, categorized by timeframes (2-minute, 3-minute, and 5-minute).
Explore Market Bias and Distance to 2-Day High/Low: The table provides information on market bias, current price movement relative to the previous two-day high and low, and the option buy zone status.
Additional Use Cases:
Surge Indicator:
The script includes a Surge Indicator that detects sudden buying or selling surges in the market. When a buying surge is identified, the "BSurge" label will appear below the corresponding candle with black text on a white background. Similarly, a selling surge will display the "SSurge" label in white text on a black background. These indicators help traders quickly spot strong buying or selling activities that may influence their trading decisions. These surges can be used to identify sudden premium dump zones.
Option Buy Zone:
The Option Buy Zone is an essential feature that identifies potential zones for buying call options (CE Zone) or put options (PE Zone) based on specific technical conditions. The indicator evaluates SMA crossovers, RSI, and MACD values to determine the current market sentiment. When the option buy zone is triggered, the script will display the respective zone ("CE Zone" or "PE Zone") in the table, highlighted with a white background. Additionally, the time when the buy zone was triggered will be shown under the "Option Buy Zone Trigger Time" column.
Price Movement Relative to 2-Day High/Low:
The script calculates the highest high and lowest low of the previous two trading days (high2DaysAgo and low2DaysAgo) and plots these points on the chart. The area between these two points is shaded in semi-transparent green and red colors. The green region indicates the price range between the highpricetoconsider (highest high of the previous two days) and the lower value between highPreviousDay and high2DaysAgo. Similarly, the red region represents the price range between the lowpricetoconsider (lowest low of the previous two days) and the higher value between lowPreviousDay and low2DaysAgo.
Entry Time and Current Zone:
The script identifies potential entry times for trades within the option buy zone. When a valid buy zone trigger occurs, the script calculates the entryTime by adding the durationInMinutes (user-defined) to the startTime. The entryTime will be displayed in the "Entry Time" column of the table. Depending on the comparison between optionbuyzonetriggertime and entryTime, the background color of the entry time will change. If optionbuyzonetriggertime is greater than entryTime, the background color will be yellow, indicating that a new trigger has occurred before the specified duration. Otherwise, the background color will be green, suggesting that the entry time is still within the defined duration.
Current Zone Indicator:
The script further categorizes the current zone as either "CE Zone" (call option zone) or "PE Zone" (put option zone). When the market is trending upwards and the minor SMA is above the major SMA, the currentZone will be set to "CE Zone." Conversely, when the market is trending downwards and the minor SMA is below the major SMA, the currentZone will be "PE Zone." This information is displayed in the "Current Zone" column of the table.
These additional use cases empower traders with valuable insights into market trends, buying and selling surges, option buy zones, and potential entry times. Traders can combine this information with their analysis and risk management strategies to make informed and confident trading decisions.
Note:
The script is optimized for identifying trends and potential trade opportunities. It is crucial to perform additional analysis and risk management before executing any trades based on the provided signals.
Happy Trading!
