Ultra Trade JournalThe Ultra Trade Journal is a powerful TradingView indicator designed to help traders meticulously document and analyze their trades. Whether you're a novice or an experienced trader, this tool offers a clear and organized way to visualize your trading strategy, monitor performance, and make informed decisions based on detailed trade metrics.
Detailed Description
The Ultra Trade Journal indicator allows users to input and visualize critical trade information directly on their TradingView charts.
.........
User Inputs
Traders can specify entry and exit prices , stop loss levels, and up to four take profit targets.
.....
Dynamic Plotting
Once the input values are set, the indicator automatically plots horizontal lines for entry, exit, stop loss, and each take profit level on the chart. These lines are visually distinct, using different colors and styles (solid, dashed, dotted) to represent each element clearly.
.....
Live Position Tracking
If enabled, the indicator can adjust the exit price in real-time based on the current market price, allowing traders to monitor live positions effectively.
.....
Tick Calculations
The script calculates the number of ticks between the entry price and each exit point (stop loss and take profits). This helps in understanding the movement required for each target and assessing the potential risk and reward.
.....
Risk-Reward Ratios
For each take profit level, the indicator computes the risk-reward (RR) ratio by comparing the ticks at each target against the stop loss ticks. This provides a quick view of the potential profitability versus the risk taken.
.....
Comprehensive Table Display
A customizable table is displayed on the chart, summarizing all key trade details. This includes the entry and exit prices, stop loss and take profit levels, tick counts, and their respective RR ratios.
Users can adjust the table's Position and text color to suit their preferences.
.....
Visual Enhancements
The indicator uses adjustable background shading between entry and stop loss/take profit lines to visually represent potential trade outcomes. This shading adjusts based on whether the trade is long or short, providing an intuitive understanding of trade performance.
.........
Overall, the Ultra Trade Journal combines visual clarity with detailed analytics, enabling traders to keep a well-organized record of their trades and enhance their trading strategies through insightful data.
المؤشرات والاستراتيجيات
AI Moving Average Crossover BotA bot that gives signals using MA(Moving average)
s a strategy rather than just an indicator. A strategy allows for backtesting and automating trades.
made with pinescript v6
ForecastPro by BinhMyco1. Overview:
This Pine Script implements a custom forecasting tool on TradingView, labeled "BinhMyco." It provides a method to predict future price movements based on historical data and a comparison with similar historical patterns. The script supports two types of forecasts: **Prediction** and **Replication**, where the forecasted price can be either based on price peaks/troughs or an average direction. The script also calculates a confidence probability, showing how closely the forecasted data aligns with historical trends.
2. Inputs:
- Source (`src`): The input data source for forecasting, which defaults to `open`.
- Length (`len`): The length of the training data used for analysis (fixed at 200).
- Reference Length (`leng`): A fixed reference length for comparing similar historical patterns (set to 70).
- Forecast Length (`length`): The length of the forecast period (fixed at 60).
- Multiplier (`mult`): A constant multiplier for the forecast confidence cone (set to 4.0).
- Forecast Type (`typ`): Type of forecast, either **Prediction** or **Replication**.
- Direction Type (`dirtyp`): Defines how the forecast is calculated — either based on price **peaks/troughs** or an **average direction**.
- Forecast Divergence Cone (`divcone`): A boolean option to enable the display of a confidence cone around the forecast.
3. Color Constants:
- Green (`#00ffbb`): Color used for upward price movements.
- Red (`#ff0000`): Color used for downward price movements.
- Reference Data Color (`refcol`): Blue color for the reference data.
- Similar Data Color (`simcol`): Orange color for the most similar data.
- Forecast Data Color (`forcol`): Yellow color for forecasted data.
4. Error Checking:
- The script checks if the reference length is greater than half the training data length, and if the forecast length exceeds the reference length, raising errors if either condition is true.
5. Arrays for Calculation:
- Correlation Array (`c`): Holds the correlation values between the data source (`src`) and historical data points.
- Index Array (`index`): Stores the indices of the historical data for comparison.
6. Forecasting Logic:
- Correlation Calculation: The script calculates the correlation between the historical data (`src`) and the reference data over the given reference length. It then identifies the point in history most similar to the current data.
- Forecast Price Calculation: Based on the type of forecast (Prediction or Replication), the script calculates future prices either by predicting based on similar bars or by replicating past data. The forecasted prices are stored in the `forecastPrices` array.
- Forecast Line Drawing: The script draws lines to represent the forecasted price movements. These lines are color-coded based on whether the forecasted price is higher or lower than the current price.
7. Divergence Cone (Optional):
- If the **divcone** option is enabled, the script calculates and draws a confidence cone around the forecasted prices. The upper and lower bounds of the cone are calculated using a standard deviation factor, providing a visual representation of forecast uncertainty.
8. Probability Table:
- A table is displayed on the chart, showing the probability of the forecast being accurate. This probability is calculated using the correlation between the current data and the most similar historical pattern. If the probability is positive, the table background turns green; if negative, it turns red. The probability is presented as a percentage.
9. Key Functions:
- `highest_range` and `lowest_range`: Functions to find the highest and lowest price within a range of bars.
- `ftype`: Determines the forecast type (Prediction or Replication) and adjusts the forecasting logic accordingly.
- `ftypediff`: Computes the difference between the forecasted and actual prices based on the selected forecast type.
- `ftypelim`, `ftypeleft`, `ftyperight`: Additional functions to adjust the calculation of the forecast based on the forecast type.
10. Conclusion:
The "ForecastPro" script is a unique tool for forecasting future price movements on TradingView. It compares historical price data with similar historical trends to generate predictions. The script also offers a customizable confidence cone and displays the probability of the forecast's accuracy. This tool provides traders with valuable insights into future price action, potentially enhancing decision-making in trading strategies.
---
This script provides advanced functionality for traders who wish to explore price forecasting, and can be customized to fit various trading styles.
Support and Resistance Trading IndicatorИндикатор Support and Resistance Trading Indicator разработан для эффективной торговли на уровнях поддержки и сопротивления. Он автоматически определяет ключевые уровни, анализирует экстремумы цены за заданный период и отображает сигналы для входа в рынок на основе популярных разворотных паттернов.
Основные функции
Автоматическое определение уровней поддержки и сопротивления:
Анализ экстремумов цены за заданный пользователем период.
Игнорирование мелких рыночных движений и шума для отображения только значимых уровней.
Сигналы для входа в рынок:
Покупка: При формировании разворотного паттерна (пин-бар с длинной нижней тенью или бычье поглощение) на уровне поддержки, подтвержденного увеличением объема.
Продажа: При формировании разворотного паттерна (молот с длинной верхней тенью или медвежье поглощение) на уровне сопротивления, также подтвержденного объемом.
Отображение ключевой информации на графике:
Уровни поддержки и сопротивления в виде линий с гибкими настройками стиля и цвета.
Стрелки и метки для сигналов входа с указанием текущей цены.
Рекомендуемые уровни стоп-лосса (SL) и тейк-профита (TP) с соответствующими ценами.
Гибкие настройки:
Период для анализа уровней.
Настройка стоп-лосса: в процентах от цены.
Выбор типа тейк-профита: фиксированный (по соотношению риск/прибыль) или динамический (следующий уровень).
Параметры паттернов (например, минимальная длина тени для пин-бара).
Режимы отображения:
Минималистичный: Только уровни и сигналы для входа.
Расширенный: Дополнительная информация, включая визуализацию стоп-лосса, тейк-профита и выделение паттернов.
Кому подойдет этот индикатор?
Этот индикатор полезен для:
Трейдеров, которые торгуют от уровней поддержки и сопротивления.
Любителей паттернов Price Action.
Начинающих и опытных трейдеров, желающих автоматизировать поиск точек входа.
Как использовать?
Настройте параметры индикатора (период анализа, стиль уровней, параметры стоп-лосса и тейк-профита).
Следите за сигналами на покупку и продажу, которые отображаются стрелками и метками на графике.
Используйте рекомендуемые уровни стоп-лосса и тейк-профита для управления рисками.
Примечание
Индикатор не является торговой стратегией. Перед использованием обязательно протестируйте его на исторических данных и применяйте в сочетании с другими инструментами анализа.
//@version=6
indicator("Support and Resistance Trading Indicator", overlay=true)
// === Входные параметры ===
period = input.int(20, title="Период для расчета уровней")
support_color = input.color(color.green, title="Цвет уровня поддержки")
resistance_color = input.color(color.red, title="Цвет уровня сопротивления")
line_style = input.string("solid", title="Стиль линий", options= )
show_patterns = input.bool(true, title="Отображать паттерны на графике")
stop_loss_percent = input.float(1.0, title="Стоп-лосс (%)", step=0.1)
risk_reward_ratio = input.float(2.0, title="Соотношение риск/прибыль")
pattern_min_shadow = input.float(2.0, title="Мин. длина тени для пин-бара (%)")
mode = input.string("expanded", title="Режим отображения", options= )
// === Расчет уровней поддержки и сопротивления ===
var support_levels = array.new_float(0)
var resistance_levels = array.new_float(0)
highest_high = ta.highest(high, period)
lowest_low = ta.lowest(low, period)
is_support = low == lowest_low
is_resistance = high == highest_high
if is_support
array.push(support_levels, low)
if is_resistance
array.push(resistance_levels, high)
// Удаление старых уровней для оптимизации
if array.size(support_levels) > 10
array.shift(support_levels)
if array.size(resistance_levels) > 10
array.shift(resistance_levels)
// === Функция для отрисовки линий ===
draw_levels(levels, color, style) =>
for i = 0 to array.size(levels) - 1
line.new(x1=bar_index ,
x2=bar_index + period,
y1=array.get(levels, i),
y2=array.get(levels, i),
color=color, width=1, style=style)
// Отрисовка уровней
draw_levels(support_levels, support_color, line_style)
draw_levels(resistance_levels, resistance_color, line_style)
// === Проверка паттернов ===
is_pinbar_bullish = (close > open) and ((low / close) * 100 > pattern_min_shadow)
is_engulfing_bullish = close < open and close > open and close > open
is_pinbar_bearish = (close < open) and ((high / close) * 100 > pattern_min_shadow)
is_engulfing_bearish = close > open and close < open and close < open
is_volume_high = volume > ta.sma(volume, period)
// Сигналы для покупки и продажи
buy_signal = is_support and (is_pinbar_bullish or is_engulfing_bullish) and is_volume_high
sell_signal = is_resistance and (is_pinbar_bearish or is_engulfing_bearish) and is_volume_high
// === Отображение сигналов на графике ===
if buy_signal
label.new(bar_index, low,
str.tostring(close, "#.##") + " BUY",
style=label.style_label_up,
color=color.green,
textcolor=color.white)
if sell_signal
label.new(bar_index, high,
str.tostring(close, "#.##") + " SELL",
style=label.style_label_down,
color=color.red,
textcolor=color.white)
// === Расчет стоп-лосса и тейк-профита ===
stop_loss = buy_signal ? low * (1 - stop_loss_percent / 100) : sell_signal ? high * (1 + stop_loss_percent / 100) : na
take_profit = buy_signal ? close + (close - stop_loss) * risk_reward_ratio : sell_signal ? close - (stop_loss - close) * risk_reward_ratio : na
// Отображение стоп-лосса с ценой
if not na(stop_loss)
label.new(bar_index, stop_loss,
"SL: " + str.tostring(stop_loss, "#.##"),
style=label.style_label_left,
color=color.orange,
textcolor=color.black)
// === Визуализация сигналов через цветные линии ===
plotshape(series=buy_signal, style=shape.triangleup, location=location.belowbar, color=color.new(color.green, 0), size=size.small)
plotshape(series=sell_signal, style=shape.triangledown, location=location.abovebar, color=color.new(color.red, 0), size=size.small)
// === Дополнительное отображение ===
plot(stop_loss, title="Stop Loss", color=color.orange, style=plot.style_circles)
plot(take_profit, title="Take Profit", color=color.blue, style=plot.style_circles)
Enhanced SMA Signal Box With TargetsOverview
The Enhanced SMA Signal Box With Targets is a versatile trading indicator designed for scalping any asset or instrument across markets. Combining a 20-period Simple Moving Average (SMA) with ATR-based target levels and advanced filtering options, it provides a streamlined approach to identifying high-probability setups. This tool caters to traders seeking clear signals and adaptive profit targets for fast-paced, disciplined trades.
Key Features
Scalping Focus: Tailored for quick trades on any asset, including indices, forex, commodities, and crypto.
20 SMA-Based Signals: Generates buy/sell signals based on price-SMA crossovers for trend clarity.
Signal Boxes: Highlights entry opportunities with visually distinct yellow boxes.
Adaptive Targets: Plots three ATR-based profit-taking levels for dynamic trade management.
Custom Filters: Refine signals using MACD, RSI, and volume to enhance precision.
Real-Time Alerts: Stay informed with alerts for buy and sell signals.
How It Works
Buy Signal: Triggered when the closing price crosses above the SMA.
Sell Signal: Triggered when the price drops below the SMA.
Profit Targets: Three ATR-based levels guide trade exits dynamically:
Target 1: 1:1 risk-reward based on the signal candle size.
Target 2 & 3: Expanded targets based on ATR.
Customization Options
Adjust SMA settings, colors, and signal visuals for any trading style.
Enable or disable MACD, RSI, and volume filters to suit market conditions.
Personalize target line extensions and colors for improved clarity.
Disclaimer
This indicator is intended for educational purposes only. Trading involves significant risk, including potential loss of capital. Past performance is not indicative of future results. Users should test the indicator and seek advice from licensed professionals before live trading. The author is not liable for any losses incurred. Always trade responsibly.
Enhanced Zigzag & Pivot Levels### Description of the Script
This TradingView Pine Script combines **Zigzag Channels**, **Pivot Points**, **Missed Levels**, and a **Trend Filter** to provide a comprehensive market analysis tool. It is designed to help traders identify key market levels, trends, and potential reversals while maintaining clarity and simplicity.
### Components of the Script
1. **Zigzag Channels**:
- **Purpose**: Highlights significant price swings by connecting pivot highs and lows.
- **How It Works**:
- Uses a specified length (`zigzag_length`) to calculate significant highs and lows.
- Draws dynamic lines between consecutive highs and lows, helping visualize market structure and directional moves.
- **Visuals**: Zigzag lines in **orange** (or your chosen color).
2. **Pivot Points**:
- **Purpose**: Marks key turning points in the market (local highs and lows).
- **How It Works**:
- Identifies pivot highs and lows using `ta.pivothigh` and `ta.pivotlow` with the input `length`.
- Labels these points on the chart using upward (`▲`) or downward (`▼`) arrows.
- **Visuals**:
- Pivot highs are marked with **red labels**.
- Pivot lows are marked with **green labels**.
3. **Missed Levels**:
- **Purpose**: Highlights missed highs and lows that are lower than previous highs or higher than previous lows, which may signal missed opportunities or market inefficiencies.
- **How It Works**:
- Compares the current pivot point to the last zigzag extreme.
- If the current high is below the last high or the current low is above the last low, it labels the missed levels.
- **Visuals**: Missed levels are marked with **gray labels** labeled "Missed High" or "Missed Low."
4. **Trend Filter (SMA)**:
- **Purpose**: Provides a simple context for market direction based on a moving average.
- **How It Works**:
- Computes a Simple Moving Average (SMA) of the `close` price over a user-defined period (`sma_length`).
- Indicates an **uptrend** when the price is above the SMA and a **downtrend** when below.
- **Visuals**: SMA is plotted as a **blue line**.
### Inputs
- **Pivot Length** (`length`): Number of bars to the left and right used to identify pivot highs and lows.
- **Zigzag Length** (`zigzag_length`): Period for calculating zigzag channel points.
- **SMA Length** (`sma_length`): Period for the trend filter.
- Toggle options to show/hide:
- Pivot points
- Zigzag channels
- Missed levels
- Labels
- Customizable colors for:
- Pivot highs and lows
- Zigzag lines
- Missed levels
- Trend filter (SMA)
### How It Works
1. **Pivot Points Detection**:
- The script calculates pivot points using the specified `length`.
- If a new high or low is detected, it places a label at the bar corresponding to the pivot.
2. **Zigzag Line Plotting**:
- Lines are drawn dynamically to connect the most recent pivot points.
- These lines represent swings and give a clear view of market structure.
3. **Missed Levels Detection**:
- Compares each pivot high/low to the previous zigzag extreme.
- Labels missed levels with tooltips that show their exact values.
4. **Trend Confirmation**:
- Uses the SMA to provide context for the overall trend.
- Traders can use this to decide whether to prioritize long or short opportunities.
### Example Use Cases
1. **Trend Confirmation**:
- Use the SMA to identify the prevailing market trend.
- Trade in the direction of the trend (e.g., look for buying opportunities above the SMA).
2. **Swing Trading**:
- Use the zigzag lines to identify key swing points for entry or exit.
3. **Missed Opportunities**:
- Look for missed highs or lows to spot market inefficiencies or reversal zones.
4. **Support and Resistance**:
- Pivot points can act as potential support or resistance levels.
### Visual Example
- **Uptrend**:
- Price above the SMA (blue line).
- Zigzag lines showing higher highs and higher lows.
- Pivot highs and lows aligning with the trend.
- **Downtrend**:
- Price below the SMA.
- Zigzag lines showing lower highs and lower lows.
- Pivot points reinforcing the bearish structure.
Protected Highs & Lows [TFO] OLD + notificationsЭто код старого TFO с добавленными оповещениями о новых точках пивот и смене цвета горизонтальной линии.
Сделано Азаматом.
The Final CountdownDescription:
The Final Countdown is a multi-timeframe candle countdown tool with the following features:
Dynamic Color-Coded Countdowns: Easily track candle closings with green, yellow, and red colors based on remaining time. Fully customizable thresholds.
Customizable Timeframes: Monitor up to 8 timeframes simultaneously, from 1-minute to weekly candles.
Alerts for Candle Closures: Get notified when a candle is about to close (red zone).
Flexible Display Options: Choose between vertical or horizontal layouts, adjust table size, and enable/disable individual timeframes.
Real-Time Updates: Seamlessly integrates with live charts to ensure accurate countdowns.
User-Friendly Settings: Modify colors, alert thresholds, and other parameters directly from the settings menu.
---------------------------------------------------------------
Dynamic Color-Coded Countdowns (In-Depth)
The countdown changes color based on how much time remains before a candle closes:
Green: Ample time remains.
Yellow: A warning that the candle is nearing its close.
Red: The candle is about to close imminently, requiring immediate attention.
Default Settings:
Green to Yellow: When 50% of the time has elapsed.
Yellow to Red: When only 10% of the time remains.
These percentages can be easily adjusted in the indicator settings to fit your trading needs. For example, you can set the transition to yellow at 70% elapsed time or adjust the red zone to begin with 5% time remaining for more urgency.
Stay prepared, stay informed, and never miss an important candle close with The Final Countdown!
Uptrick: Smart BoundariesThis script is designed to help traders identify potential turning points in the market by combining RSI (Relative Strength Index) signals and Bollinger Bands. It also includes a built-in mechanism to manage the number of consecutive buy and sell entries, often referred to as pyramiding. Below you will find a detailed explanation of how the script works, how it was designed, and some suggestions on using it effectively in your trading workflow.
Overview
The script calculates RSI using a user-defined length and identifies when the RSI is in overbought or oversold territory based on user-selected threshold levels (default values for RSI overbought and oversold are 70 and 30, respectively). Additionally, it plots Bollinger Bands, which can provide context on potential price volatility. A Bollinger Band uses a moving average of the closing price plus and minus a configurable multiplier of the standard deviation. When price closes below the lower band, it may suggest a temporary oversold condition. Conversely, when price closes above the upper band, it may suggest an overbought condition.
Combining RSI and Bollinger Bands
The buy condition is triggered when the RSI is below the defined oversold level and the closing price is below the lower Bollinger Band. The idea behind this is that both momentum (as indicated by RSI) and volatility (as indicated by Bollinger Bands) are pointing to a potential undervaluation of price. The sell condition is the mirror image of that logic: it is triggered when the RSI is above the defined overbought level and the closing price is above the upper Bollinger Band. These signals aim to highlight points in the market where there could be a momentum shift or a mean reversion.
Pyramiding Logic
A unique aspect of this script is how it manages pyramiding, which is the practice of taking multiple entries in the same direction. For example, if you already have a buy entry and the conditions remain bullish, you might want to add an additional position. However, controlling how often you add those positions can be crucial in risk management. The script includes a variable that counts the number of buys and sells currently triggered. Once the maximum allowed number of entries per side (defined as maxPyramiding) is reached, no more entries of that type are plotted.
There is an optional feature (enablePyramiding) that allows you to reduce pyramiding by disabling it if you prefer to take only one entry per signal. When disabled, the script will not allow additional positions in the same direction until a reset occurs, which happens when the condition for that side is not met.
Labels and Visuals
Every time a buy or sell condition is triggered, the script plots a small label on the chart at the bar index. A buy label appears underneath the price to visually mark the entry, while a sell label appears above the price. These labels make it easy to see on the chart exactly when both conditions coincide (RSI condition and Bollinger Band condition). This visual reference helps traders quickly spot patterns and potential entry or exit points.
Alongside these signals, you can also see the Bollinger Bands plotted in real time. The upper band is shown in red, and the lower band is shown in green. Having these bands on the chart allows you to see when price is trading near the extremes of its recent average range.
Alerts
Alerts can be set to notify you when a buy or sell condition appears. This means that even if you are not actively watching the chart, you can receive a notification (through TradingView's alert system) whenever RSI crosses into oversold or overbought territory in conjunction with price closing outside the Bollinger Bands.
Potential Uses
Traders might use this tool for a range of styles, from scalping to swing trading. Since the signals are based on RSI and Bollinger Bands, it can help highlight points of possible mean reversion, but it does not guarantee future performance. It may be beneficial to combine it with other forms of technical analysis, such as volume studies or support/resistance levels, to help filter out weaker signals.
Customization
One of the main strengths of this script is its flexibility. All key parameters can be tuned to fit your personal trading style and risk tolerance. You can adjust:
• The RSI length and threshold levels for overbought/oversold.
• Bollinger Band length and multiplier to catch wider or narrower volatility bands.
• The maximum allowed pyramiding entries per side.
• Whether to enable or disable pyramiding logic altogether.
Uniqueness of This Script
A distinctive aspect of this script is its combination of a classic momentum indicator (RSI) with Bollinger Bands, plus an intelligent pyramiding component. While many indicators simply plot RSI or Bollinger Bands, this script synchronizes the two to highlight oversold and overbought conditions more precisely. At the same time, the built-in pyramiding counter allows you to manage how many times you enter on the same signal direction, giving you a dynamic scaling feature not commonly seen in standalone RSI or Bollinger Band scripts. This approach helps traders maintain consistent risk management by preventing excessive stacking of positions when signals continue to appear, which can be beneficial for those who like to scale into trades gradually. All these factors contribute to the script's uniqueness and potential usefulness for a wide range of trading styles, from cautious single-entry traders to those who prefer incremental position building.
Conclusion
This script is a helpful tool for traders interested in combining momentum and volatility indicators. By integrating RSI signals with Bollinger Band breakouts, it tries to uncover moments when price might be at an extreme. It further offers pyramiding control, which can be appealing to traders who like to scale into positions. As with any technical indicator or script, it is important to do additional research and not rely solely on these signals. Always consider using proper risk management, and keep in mind that no tool can accurately predict future prices every time.
BACKTESTED RESULTS
The script has proven to be the most profitable on the 3 mins timeframe with these settings:
RSI Length: 17
Overbought Level: 70
Oversold Level: 33
Bollinger Bands Length: 19
Bollinger Bands Multiplier: 2
As of 22nd December 2024
Pyramiding was set to 10
Not financial advice
TOTAL WINNING RATE: 75.04%
Socrate's Bottom Finder - Free editionENGLISH :
Hi everybody,
This indicator will give you the market bottoms with remarkable accuracy.
/!\ Be aware that the indicator cannot know the current economic situation and that in the event of a major crisis, it can signal a market bottom despite the decline not being over. /!\
How to read it ?
It is composed of two visual sections:
- The first section materialized by the white line is a "treshhold" which gives the current trend of the week. It is used to filter most of the "fake signals"
- The second section, materialized by a green and red band, gives the strength of the price trend. If for example the trend is rather bullish, this bar will turn green, the opposit will produce red. An "opportunity" signal will appear when the optimal conditions are met to define a market bottom. Before an opportunity signal there will always be an "Surrender" signal, wich means the trend has weakened and the bottom is near in time.
Special Recommandation :
- The best results are on 1W, 3D, 1D. The indicator work on lower TF but it's not his purpose and you may drop significantly your W/L rate.
- Avoid stocks/crypto with poor stability in the very long time, a good hint is to look after thoses who mostly are above SMA200 on weekly TF.
- Avoid cyclical stock, as they tend to bounce up and down way to often.
Please do your own diligence. Trading may conduct you to loose capital.
Apply your own trading strategy :)
-----------------------------------------------------------------------------------------------------------------------------
FRANCAIS :
Salut tout le monde,
Cet indicateur vous donnera les creux du marché avec une précision remarquable.
/!\ Sachez que l'indicateur ne peut pas connaître la situation économique actuelle et qu'en cas de crise majeure, il peut signaler un creux de marché même si la baisse n'est pas terminée. /!\
Comment le lire ?
Il est composé de deux sections visuelles :
- La première section matérialisée par la ligne blanche est un « seuil » qui donne la tendance actuelle de la semaine. Il est utilisé pour filtrer la plupart des "faux signaux"
- La deuxième section, matérialisée par une bande verte et rouge, donne la force de la tendance des prix. Si par exemple la tendance est plutôt haussière, cette barre deviendra verte, l'inverse produira du rouge. Un signal "d'opportunité" apparaîtra lorsque les conditions optimales seront réunies pour définir un creux de marché. Avant un signal d'opportunité, il y aura toujours un signal "Abandon", ce qui signifie que la tendance s'est affaiblie et que le creux est proche dans le temps.
Recommandations spéciales :
- Les meilleurs résultats sont sur 1W, 3D, 1D. L'indicateur fonctionne sur des TF plus faibles mais ce n'est pas son but et vous risquez de faire chuter considérablement votre ratio de W/L.
- Évitez les stocks/crypto avec une faible stabilité sur le long terme, un bon indice est de cibler ceux qui sont majoritairement (dans leur historique) au-dessus de leur SMA200 en TF hebdomadaire.
- Prioriser les actifs de type "HyperGrowth", l'indicateur fonctionne moins bien avec les cycliques
Veuillez faire vos propres recherches en parallèle. Le trading pouvant vous conduire à perdre du capital.
Appliquez à cet indicateur votre propre stratégie :)
Ryuk Desviations(NÃO USAR DE FORMA ISOLADA)
Este é um indicador baseado em Open interest e análise de candles. Seu principal objetivo é nos mostrar rastros de desvios no comportamento do ativo. Nele, será mostrado:
- Filtro de força para abertura de contratos futuros, destacando o candle do open interest de verde ou vermelho e nos dando possíveis sinais para entrada caso esteja alinhado com o ICT e ao contexto maior;
- Divergência entre o OI e o preço, destacando o candle de branco, nos mostrando incongruência, absorção ou contratos stopados/liquidados; (apenas considerar candles grandes ou HTF)
- Divergência entre o preço do ativo e o preço do bitcoin, destacando o candle de laranja no gráfico do preço, nos mostrando a performançe da Altcoin em relação ao par Bitcoin. (Funciona apenas para Altcoins)
Observações: Usar com contexto; não usar de forma isolada; ter cuidado com os ruídos de pequenas divergências.
Christmas EMA with Advent Calendar [SS]Hey everyone!
As Tradingview is looking for Christmas themed indicators, I thought I would throw one out this year!
I understand they don't need to be useful, but if you know me, you know that's just not an option, so I went ahead and did a semi useful Christmas themed indicator!
It will calculate the EMA and put the EMA in a Christmas theme, you can select custom EMA theme:
Or you can select "Random" and it will random generate the Emoji and change each day (the advent aspect of the indicator).
In addition to that, of course the EMA is customizable, you can select whichever length you want, and you can toggle on or off the Christmas Countdown!
Thanks for everyone who followed me this year and for a longtime!
And thank you to the Tradingview and Pinecoder community for an awesome platform!
Hopefully we can all approach the new year with an optimistic outlook and be well prepared for whatever comes, both within the market and within our lives.
Safe trades, safe holidays and thoughts and wishes with you all.
[Linus] VWAO DeviationThe VWAP (Volume Weighted Average Price) Deviation Script is a sophisticated tool designed to help traders analyze the interplay between price and volume. By calculating deviations from the VWAP, it identifies critical support and resistance levels, enabling more informed trading decisions.
This script computes the VWAP based on a selected data source (defaulting to the closing price) and determines deviations above and below it using either the Average Deviation or Standard Deviation method. Users can customize their preference through the script's input settings. These deviations are visually plotted as bands on the chart, offering clear insights into areas where price may revert or break out.
A standout feature of the script is its Cross Count Monitor, which tracks how often the price crosses above the Upper Deviation Level 2 and below the Lower Deviation Level 2 within a user-defined lookback period. This data is displayed in a table at the bottom-right corner of the chart and can be toggled on or off via an input setting.
The Cross Count Monitor provides traders with valuable historical insights into the frequency of price interactions with deviation levels, helping to identify potential trading opportunities based on established price behaviors. This functionality makes the script an indispensable tool for traders seeking to enhance their market analysis and strategy development.
Double Bottom[DBBUY]/Top[DTSELL] WITH KILLZONES [Dante123456]Indicator Overview**
The Double Top/Bottom indicator is a technical analysis tool designed to detect and label potential **Double Top** and **Double Bottom** patterns. These chart patterns are widely recognized as reversal signals, indicating a possible trend change.
- Double Top : This pattern forms after an uptrend and suggests a potential trend reversal to the downside. It occurs when the price reaches a peak (resistance level), pulls back, rises again to the same level, and then declines.
- Double Bottom : This pattern forms after a downtrend and suggests a potential trend reversal to the upside. It occurs when the price hits a low (support level), rallies, then drops again to the same level, and then rises.
How to Use the Indicator
1. Signals and Labels :
- The indicator will automatically label potential Double Bottom (Buy) signals with DBBUY and potential Double Top (Sell) signals with DTSELL. These labels will appear on the chart where the pattern is detected.
- The signals are calculated based on price action and pivot points, with additional confirmation using a Smoothed Moving Average (SMA). The price's interaction with the SMA is used as an additional support/resistance check.
2. Entry Strategy :
- Double Bottom (DBBUY) : If the indicator labels a potential ** Double Bottom **, you might consider opening a **Buy** position when the price breaks above the middle of the pattern (the neckline).
- ** Double Top (DTSELL) **: If the indicator labels a potential ** Double Top **, you might consider opening a **Sell** position when the price breaks below the middle of the pattern (the neckline).
3. Cooldown:
- To avoid overtrading and too many signals in a short time, a **cooldown period** is implemented. This ensures that after a confirmed signal, the indicator will not trigger another signal for a certain number of bars (set by the user).
4. SMA (Smoothed Moving Average):
- The indicator also displays a 200-period **SMA**, which acts as a reference for price trends. A bounce off the SMA could indicate support (for buy signals) or resistance (for sell signals).
5. Alerts
- Alerts are set up to notify the user when potential Double Bottom (Buy) or Double Top(Sell) patterns are detected. These alerts can be configured to trigger once per bar.
---
Risk and Rewards
Rewards:
- Trend Reversal Potential : Double Top and Double Bottom patterns are significant as they indicate potential reversals after a strong price movement. If the market is correctly identified, these patterns offer the possibility of entering a trend at a critical turning point.
- **Versatile Use**: The indicator can be used across multiple timeframes, allowing for short-term and long-term trading strategies.
- **SMA Confirmation**: The interaction with the **200 SMA** helps confirm the validity of support and resistance zones, improving the accuracy of the trade signals.
**Risks**:
- **False Signals**: Like any technical indicator, this tool is not foolproof. Price action can sometimes form patterns that appear to be Double Tops/Bottoms but do not lead to reversals. Therefore, it's essential to consider other factors and not rely solely on the pattern.
- **Market Conditions**: The indicator works best in markets with clear trends and when the price respects key levels (like support and resistance). In volatile or range-bound markets, the pattern signals may produce less reliable results.
- **Delay in Confirmation**: The confirmation of the pattern can sometimes occur too late, meaning the ideal entry point could have already passed. This is typical with any pattern-based strategy, as price confirmation is required before taking action.
**Managing Risk**:
- **Stop-Loss and Take-Profit**: Always use appropriate risk management techniques such as stop-loss and take-profit orders to protect against unexpected price movements. A good practice is to set the stop-loss just outside the pattern's key levels (above resistance for sell signals, below support for buy signals).
- **Avoid Overtrading**: The cooldown period feature helps reduce the risk of taking multiple trades in quick succession, which can be detrimental to your account.
---
### **Conditions for Using the Indicator**
1. **Market Conditions**: The Double Top and Double Bottom patterns are most effective in trending markets. In sideways or choppy markets, the patterns may lead to false signals, so it's essential to avoid using the indicator in such conditions.
2. **Pattern Confirmation**: The indicator relies on pivot points to detect the patterns. For greater accuracy, ensure that other technical analysis tools (such as volume analysis, RSI, MACD, or other trend-following indicators) are used to confirm the signals.
3. **Time Horizon**: The indicator allows you to adjust the look-back period (Time Horizon) to find both short-term and long-term patterns. Larger values are suitable for longer-term trend reversal patterns, while smaller values are better for more immediate reversal signals.
4. **SMA Support/Resistance**: The 200-period **SMA** acts as a filter for identifying strong support and resistance zones. If the price is above the SMA, bullish signals (Double Bottom) are prioritized, and if the price is below the SMA, bearish signals (Double Top) are favored.
5. KILLZONE SESSIONS AND FVG,BB,OB :
- I included the session killzones and fvg,odb,bb to aid you during your drading session
Conclusion
The **Double Top/Bottom ** indicator is a useful tool for identifying potential trend reversal patterns. It works by detecting key price pivots and labeling them with **"DBBUY"** or **"DTSELL"** to highlight entry points. However, as with all indicators, it should be used in conjunction with proper risk management and other forms of analysis to ensure the best chances of success.
Always be aware of the risks, such as false signals and the potential for overtrading. Properly manage your trades, set stop-loss and take-profit levels, and consider using additional confirmation tools for higher accuracy.
Happy trading!
PS
HELP ME REFINE IT IF YOU CAN
Market Profile with TPO by DaRealsVision25Key Components of TPO Charts:
TPO Blocks: Each letter or symbol represents a specific time period during which the price traded at a particular level. For example, in a 30-minute timeframe, each TPO block might represent 30 minutes of trading at that price level.
Point of Control (POC): The price level where the most TPO blocks are concentrated, indicating the price at which the market spent the most time during the session. This level is often considered the fairest price.
Value Area: The range of prices where a significant portion of trading occurred, typically encompassing 70% of the total trading volume. This area helps identify the price range where the market found consensus.
Benefits of Using TPO Charts:
Market Structure Analysis: TPO charts help traders understand market structure by identifying areas of balance and imbalance, which can indicate potential support and resistance levels.
Trend Identification: By observing the distribution of TPO blocks, traders can identify trends and reversals, aiding in making informed trading decisions.
Enhanced Decision-Making: The visual representation of time spent at various price levels allows traders to assess market sentiment and potential price movements more effectively.
[EmreKb] Santa Clause🎅 Ho Ho Ho! Santa Claus on Your Chart! 🎅
Bring the holiday spirit to your charts with this special Pine Script indicator! Add a cheerful Santa Claus drawing to your charts and celebrate the most wonderful time of the year. 🎄✨
This indicator is purely for fun and designed to spread joy and festive vibes within the Pine Script community. Whether you’re a charting enthusiast or just looking to embrace the holiday cheer, this indicator brings the magic of Santa Claus directly to your charts.
luusang//@version=5
indicator('Swing', shorttitle='GoodLuck', overlay=true, max_lines_count=500)
//-----Input-------
customTF = input.timeframe(defval="",title = "Show Other TimeFrame")
GroupGann = "Gann"
showGann = input.bool(false, 'Show Gann/Color/Width', group = GroupGann, inline = "Gann1")
colorGann = input.color(color.aqua, '', group = GroupGann,inline = "Gann1")
widthGann = input.int(defval=1,title = "",minval=1,step=1, group = GroupGann,inline = "Gann1")
GroupSGann = "Swing of Gann"
showSGann = input.bool(true, 'Show Swing/Color/Width', group = GroupSGann,inline = "Swing1")
colorSGann = input.color(color.blue, '', group = GroupSGann,inline = "Swing1")
widthSGann = input.int(defval=1,title = "",minval=1,step=1, group = GroupSGann,inline = "Swing1")
showChoCh = input.bool(false, 'Show ChoCh/Color/Width', group = GroupSGann,inline = "Choch")
colorChoch = input.color(color.red, '', group = GroupSGann,inline = "Choch")
widthChoch = input.int(defval=1,title = "",minval=1,step=1, group = GroupSGann,inline = "Choch")
show2ChoCh = input.bool(false, 'Show 2Choch/Color/Width', group = GroupSGann,inline = "2Choch")
color2Choch = input.color(color.purple, '', group = GroupSGann,inline = "2Choch")
width2Choch = input.int(defval=1,title = "",minval=1,step=1, group = GroupSGann,inline = "2Choch")
showtargetOTL = input.bool(true, 'Show Target OTL/Color/Width',group = GroupSGann, inline = "target")
colortargetOTL = input.color(color.purple, '', group = GroupSGann, inline = "target")
widthtargetOTL = input.int(defval=1,title = "",minval=1,step=1, group = GroupSGann,inline = "target")
showLabel = input.bool(false, 'Show Label TimeFrame',group = GroupSGann)
//showLinePrice = input.bool(true, 'Show LinePrice/Color/Width', group = GroupSGann,inline = "LinePrice")
//colorLinePrice = input.color(color.blue, '', group = GroupSGann,inline = "LinePrice")
//widthLinePrice = input.int(defval=1,title = "",minval=1,step=1, group = GroupSGann,inline = "LinePrice")
///tùy chọn line//
lineGann = input.string(title="",options= ,defval='(╌)', group = GroupGann, inline = "Gann1")
lineStyleGann = lineGann == "(┈)" ? line.style_dotted : lineGann == "(╌)" ? line.style_dashed : line.style_solid
lineSGann = input.string(title="",options= ,defval="(─)", group = GroupSGann, inline = "Swing1")
lineStyleSGann = lineSGann == "(┈)" ? line.style_dotted : lineSGann == "(╌)" ? line.style_dashed : line.style_solid
line2Choch = input.string(title="",options= ,defval="(╌)", group = GroupSGann, inline = "2Choch")
lineStyle2Choch = line2Choch == "(┈)" ? line.style_dotted : line2Choch == "(╌)" ? line.style_dashed : line.style_dashed
lineChoch = input.string(title="",options= ,defval="(─)", group = GroupSGann, inline = "Choch")
lineStyleChoch = lineChoch == "(┈)" ? line.style_dotted : lineChoch == "(╌)" ? line.style_dashed : lineChoch == "(←)" ? line.style_arrow_left : lineChoch == "(→)" ? line.style_arrow_right : lineChoch == "(↔)" ? line.style_arrow_both : line.style_solid
linetargetOTL = input.string(title="",options= ,defval="(→)", group = GroupSGann, inline = "target")
lineStyletargetOTL = linetargetOTL == "(┈)" ? line.style_dotted : linetargetOTL == "(╌)" ? line.style_dashed : linetargetOTL == "(←)" ? line.style_arrow_left : linetargetOTL == "(→)" ? line.style_arrow_right : linetargetOTL == "(↔)" ? line.style_arrow_both : line.style_arrow_both
//in out side bar//
OSB_up_down ="Ousidebar up down"
//////////////////////////Global//////////////////////////
var arrayLineTemp = array.new_line()
// Funtion
f_resInMinutes() =>
_resInMinutes = timeframe.multiplier * (
timeframe.isseconds ? 1. / 60. :
timeframe.isminutes ? 1. :
timeframe.isdaily ? 1440. :
timeframe.isweekly ? 10080. :
timeframe.ismonthly ? 43800. : na)
// Converts a resolution expressed in minutes into a string usable by "security()"
f_resFromMinutes(_minutes) =>
_minutes < 1 ? str.tostring(math.round(_minutes*60)) + "S" :
_minutes < 60 ? str.tostring(math.round(_minutes)) + "m" :
_minutes < 1440 ? str.tostring(math.round(_minutes/60)) + "H" :
_minutes < 10080 ? str.tostring(math.round(math.min(_minutes / 1440, 7))) + "D" :
_minutes < 43800 ? str.tostring(math.round(math.min(_minutes / 10080, 4))) + "W" :
str.tostring(math.round(math.min(_minutes / 43800, 12))) + "M"
f_tfRes(_res,_exp) =>
request.security(syminfo.tickerid,_res,_exp,lookahead=barmerge.lookahead_on)
var arrayLineChoCh = array.new_line()
var label labelTF = label.new(time, close, text = "",color = color.new(showSGann ? colorSGann : colorGann,95), textcolor = showSGann ? colorSGann : colorGann,xloc = xloc.bar_time, textalign = text.align_left)
var line lineChoChOTLTarget = line.new(x1= time , y1=close,x2=time, y2= close,color = showSGann ? colortargetOTL : colorGann,xloc = xloc.bar_time,style = lineStyletargetOTL,width = widthtargetOTL)
var line lineBosOTLTarget = line.new(x1= time , y1=close,x2=time, y2= close,color = showSGann ? colortargetOTL : colorGann,xloc = xloc.bar_time,style = lineStyletargetOTL, width = widthtargetOTL)
//var line line_Price = line.new(x1= time , y1=close,x2=time, y2= close,color = showSGann ? colorLinePrice : colorGann,xloc = xloc.bar_time,style = lineStyleLinePrice, width = widthLinePrice)
styleGann = showSGann ? line.style_dashed : line.style_solid
var arrayXGann = array.new_int(5,time)
var arrayYGann = array.new_float(5,close)
var arrayLineGann = array.new_line()
int drawLineGann = 0
_high = high
_low = low
_close = close
_open = open
if(customTF != timeframe.period)
_high := f_tfRes(customTF,high)
_low := f_tfRes(customTF,low)
_close := f_tfRes(customTF,close)
_open := f_tfRes(customTF,open)
highPrev = _high
lowPrev = _low
// drawLineGann => 2:Tiếp tục 1:Đảo chiều; // Outsidebar 2:Tiếp tục 3:Tiếp tục và Đảo chiều 4 : Đảo chiều 2 lần
drawLineGann := 0
if(_high > highPrev and _low > lowPrev )
if(array.get(arrayYGann,0) > array.get(arrayYGann,1))
if(_high <= high)
array.set(arrayXGann, 0, time)
array.set(arrayYGann, 0, _high )
drawLineGann := 2
else
array.unshift(arrayXGann,time)
array.unshift(arrayYGann,_high )
drawLineGann := 1
else if(_high < highPrev and _low < lowPrev )
if(array.get(arrayYGann,0) > array.get(arrayYGann,1))
array.unshift(arrayXGann,time)
array.unshift(arrayYGann,_low )
drawLineGann := 1
else
if(_low >= low)
array.set(arrayXGann, 0, time)
array.set(arrayYGann, 0, _low )
drawLineGann := 2
else if(_high >= highPrev and _low < lowPrev or _high > highPrev and _low <= lowPrev )
if(array.get(arrayYGann,0) > array.get(arrayYGann,1))
if(_high >= array.get(arrayYGann,0) and array.get(arrayYGann,1) < _low )
if(_high <= high)
array.set(arrayXGann, 0, time)
array.set(arrayYGann, 0, _high )
drawLineGann := 2
else if(_high >= array.get(arrayYGann,0) and array.get(arrayYGann,1) > _low )
if(_close < _open)
if(_high <= high)
array.set(arrayXGann, 0, time)
array.set(arrayYGann, 0, _high )
array.unshift(arrayXGann,time)
array.unshift(arrayYGann,_low )
drawLineGann := 3
else
array.unshift(arrayXGann,time)
array.unshift(arrayYGann,_low )
array.unshift(arrayXGann,time)
array.unshift(arrayYGann,_high )
drawLineGann := 4
else if(array.get(arrayYGann,0) < array.get(arrayYGann,1))
if(_low <= array.get(arrayYGann,0) and _high < array.get(arrayYGann,1))
if(_low >= low)
array.set(arrayXGann, 0, time)
array.set(arrayYGann, 0, _low )
drawLineGann := 2
else if(_low <= array.get(arrayYGann,0) and _high > array.get(arrayYGann,1))
if(_close > _open)
if(_low >= low)
array.set(arrayXGann, 0, time)
array.set(arrayYGann, 0, _low )
array.unshift(arrayXGann,time)
array.unshift(arrayYGann,_high )
drawLineGann := 3
else
array.unshift(arrayXGann,time)
array.unshift(arrayYGann,_high )
array.unshift(arrayXGann,time)
array.unshift(arrayYGann,_low )
drawLineGann := 4
else if((_high <= highPrev and _low >= lowPrev ))
highPrev := highPrev
lowPrev := lowPrev
if(f_resInMinutes() < f_tfRes(customTF,f_resInMinutes()) and drawLineGann == 0)
if(array.get(arrayYGann,0) > array.get(arrayYGann,1))
if(array.get(arrayYGann,0) <= high)
array.set(arrayXGann, 0, time)
drawLineGann := 2
else
if(array.get(arrayYGann,0) >= low)
array.set(arrayXGann, 0, time)
drawLineGann := 2
if(showGann and f_resInMinutes() <= f_tfRes(customTF,f_resInMinutes()))
if(drawLineGann == 2)
if(array.size(arrayLineGann) >0)
line.set_xy2(array.get(arrayLineGann,0),array.get(arrayXGann,0),array.get(arrayYGann,0))
else
array.unshift(arrayLineGann,line.new(array.get(arrayXGann,1),array.get(arrayYGann,1),array.get(arrayXGann,0),array.get(arrayYGann,0), color = colorGann,xloc = xloc.bar_time, style = lineStyleGann,width = widthGann))
else if(drawLineGann == 1)
array.unshift(arrayLineGann,line.new(array.get(arrayXGann,1),array.get(arrayYGann,1),array.get(arrayXGann,0),array.get(arrayYGann,0), color = colorGann,xloc = xloc.bar_time, style = lineStyleGann,width = widthGann))
else if(drawLineGann == 3)
if(array.size(arrayLineGann) >0)
line.set_xy2(array.get(arrayLineGann,0),array.get(arrayXGann,1),array.get(arrayYGann,1))
else
array.unshift(arrayLineGann,line.new(array.get(arrayXGann,2),array.get(arrayYGann,2),array.get(arrayXGann,1),array.get(arrayYGann,1), color = colorGann,xloc = xloc.bar_time, style = lineStyleGann,width = widthGann))
array.unshift(arrayLineGann,line.new(array.get(arrayXGann,1),array.get(arrayYGann,1),array.get(arrayXGann,0),array.get(arrayYGann,0), color = colorGann,xloc = xloc.bar_time, style = lineStyleGann,width = widthGann))
else if(drawLineGann == 4)
array.unshift(arrayLineGann,line.new(array.get(arrayXGann,2),array.get(arrayYGann,2),array.get(arrayXGann,1),array.get(arrayYGann,1), color = colorGann,xloc = xloc.bar_time, style = lineStyleGann,width = widthGann))
array.unshift(arrayLineGann,line.new(array.get(arrayXGann,1),array.get(arrayYGann,1),array.get(arrayXGann,0),array.get(arrayYGann,0), color = colorGann,xloc = xloc.bar_time, style = lineStyleGann,width = widthGann))
//////////////////////////Swing Gann//////////////////////////
var arrayXSGann = array.new_int(5,time)
var arrayYSGann = array.new_float(5,close)
var arrayLineSGann = array.new_line()
int drawLineSGann = 0
int drawLineSGann1 = 0
bool runCheckChoChSGann = false
runCheckChoChSGann := runCheckChoChSGann
if(showSGann)
if(math.max(array.get(arrayYSGann,0),array.get(arrayYSGann,1)) < math.min(array.get(arrayYGann,0),array.get(arrayYGann,1)) or math.min(array.get(arrayYSGann,0),array.get(arrayYSGann,1)) > math.max(array.get(arrayYGann,0),array.get(arrayYGann,1)))
//Khởi tạo bắt đầu
drawLineSGann1 := 5
array.set(arrayXSGann, 0, array.get(arrayXGann,1))
array.set(arrayYSGann, 0, array.get(arrayYGann,1))
array.unshift(arrayXSGann,array.get(arrayXGann,0))
array.unshift(arrayYSGann,array.get(arrayYGann,0))
// drawLineSGann kiểm tra điểm 1 => 13:Tiếp tục có sóng hồi // 12|19(reDraw):Tiếp tục không có sóng hồi // 14:Đảo chiều
if(array.get(arrayXGann,0) == array.get(arrayXGann,1))
if(array.get(arrayXSGann,0) >= array.get(arrayXGann,2) and array.get(arrayYSGann,0) != array.get(arrayYGann,1) and ((array.get(arrayYGann,1) > array.get(arrayYGann,2) and array.get(arrayYSGann,0) > array.get(arrayYSGann,1)) or (array.get(arrayYGann,1) < array.get(arrayYGann,2) and array.get(arrayYSGann,0) < array.get(arrayYSGann,1))))
drawLineSGann1 := 12
array.set(arrayXSGann, 0, array.get(arrayXGann,1))
array.set(arrayYSGann, 0, array.get(arrayYGann,1))
else if(array.get(arrayXSGann,0) <= array.get(arrayXGann,2))
if((array.get(arrayYSGann,0) > array.get(arrayYSGann,1) and array.get(arrayYGann,1) < array.get(arrayYSGann,1)) or (array.get(arrayYSGann,0) < array.get(arrayYSGann,1) and array.get(arrayYGann,1) > array.get(arrayYSGann,1)))
drawLineSGann1 := 14
runCheckChoChSGann := true
array.unshift(arrayXSGann,array.get(arrayXGann,1))
array.unshift(arrayYSGann,array.get(arrayYGann,1))
else if((array.get(arrayYSGann,0) > array.get(arrayYSGann,1) and array.get(arrayYGann,1) > array.get(arrayYSGann,0)) or (array.get(arrayYSGann,0) < array.get(arrayYSGann,1) and array.get(arrayYGann,1) < array.get(arrayYSGann,0)))
drawLineSGann1 := 13
_max = math.min(array.get(arrayYSGann,0),array.get(arrayYSGann,1))
_min = math.max(array.get(arrayYSGann,0),array.get(arrayYSGann,1))
_max_idx = 0
_min_idx = 0
for i = 2 to array.size(arrayXGann)
if(array.get(arrayXSGann,0) >= array.get(arrayXGann,i))
break
if(_min > array.get(arrayYGann,i))
_min := array.get(arrayYGann,i)
_min_idx := array.get(arrayXGann,i)
if(_max < array.get(arrayYGann,i))
_max := array.get(arrayYGann,i)
_max_idx := array.get(arrayXGann,i)
if(array.get(arrayYSGann,0) > array.get(arrayYSGann,1))
array.unshift(arrayXSGann,_min_idx)
array.unshift(arrayYSGann,_min)
else if(array.get(arrayYSGann,0) < array.get(arrayYSGann,1))
array.unshift(arrayXSGann,_max_idx)
array.unshift(arrayYSGann,_max)
array.unshift(arrayXSGann,array.get(arrayXGann,1))
array.unshift(arrayYSGann,array.get(arrayYGann,1))
if(f_resInMinutes() < f_tfRes(customTF,f_resInMinutes()))
if(array.get(arrayYSGann,0) == array.get(arrayYGann,1) and array.get(arrayXSGann,0) != array.get(arrayXGann,1))
array.set(arrayXSGann, 0, array.get(arrayXGann,1))
drawLineSGann1 := 19
if(f_resInMinutes() <= f_tfRes(customTF,f_resInMinutes()))
if(drawLineSGann1 == 12 or drawLineSGann1 == 19)
if(array.size(arrayLineSGann) >0)
line.set_xy2(array.get(arrayLineSGann,0),array.get(arrayXSGann,0),array.get(arrayYSGann,0))
else
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,1),array.get(arrayYSGann,1),array.get(arrayXSGann,0),array.get(arrayYSGann,0), color = colorSGann,xloc = xloc.bar_time,width = widthSGann, style = lineStyleSGann))
else if(drawLineSGann1 == 14)
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,1),array.get(arrayYSGann,1),array.get(arrayXSGann,0),array.get(arrayYSGann,0), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
else if(drawLineSGann1 == 13)
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,2),array.get(arrayYSGann,2),array.get(arrayXSGann,1),array.get(arrayYSGann,1), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,1),array.get(arrayYSGann,1),array.get(arrayXSGann,0),array.get(arrayYSGann,0), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
else if(drawLineSGann1 == 15)
if(array.size(arrayLineSGann) >0)
line.set_xy2(array.get(arrayLineSGann,0),array.get(arrayXSGann,1),array.get(arrayYSGann,1))
else
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,2),array.get(arrayYSGann,2),array.get(arrayXSGann,1),array.get(arrayYSGann,1), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,1),array.get(arrayYSGann,1),array.get(arrayXSGann,0),array.get(arrayYSGann,0), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
if(runCheckChoChSGann)
runCheckChoChSGann := false
// ChoCh Trường hợp chữ N ngược, chữ N
if((array.get(arrayYSGann,3) > array.get(arrayYSGann,2) and array.get(arrayYSGann,3) < array.get(arrayYSGann,1) and array.get(arrayYSGann,0) < array.get(arrayYSGann,2)) or (array.get(arrayYSGann,3) < array.get(arrayYSGann,2) and array.get(arrayYSGann,3) > array.get(arrayYSGann,1) and array.get(arrayYSGann,0) > array.get(arrayYSGann,2)))
alert(syminfo.ticker + " : " + timeframe.period + " => Swing of Gann ChoCh" + (array.get(arrayYSGann,0) > array.get(arrayYSGann,1) ? "+ ⇑" : "- ⇓"))
if(showChoCh)
array.unshift(arrayLineChoCh,line.new(x1= array.get(arrayXSGann,2) , y1=array.get(arrayYSGann,2),x2=array.get(arrayXSGann,0), y2=array.get(arrayYSGann,2),color = colorChoch,xloc = xloc.bar_time,style = lineStyleChoch,width = widthChoch))
// ChoCh 2 Đầu Trường hợp chữ N ngược, chữ N
if(show2ChoCh and ((array.get(arrayYSGann,1) > array.get(arrayYSGann,3) and array.get(arrayYSGann,3) > array.get(arrayYSGann,4) and array.get(arrayYSGann,4) > array.get(arrayYSGann,2) and array.get(arrayYSGann,2) > array.get(arrayYSGann,0)) or (array.get(arrayYSGann,0) > array.get(arrayYSGann,2) and array.get(arrayYSGann,2) > array.get(arrayYSGann,4) and array.get(arrayYSGann,4) > array.get(arrayYSGann,3) and array.get(arrayYSGann,3) > array.get(arrayYSGann,1))))
line.set_width(array.get(arrayLineSGann,1),width2Choch)
line.set_style(array.get(arrayLineSGann,1), lineStyle2Choch)
line.set_color(array.get(arrayLineSGann,1),color2Choch)
// drawLineSGann kiểm tra điểm 0 => 3:Tiếp tục có sóng hồi // 2|9(reDraw):Tiếp tục không có sóng hồi // 4:Đảo chiều
if(array.get(arrayXSGann,0) >= array.get(arrayXGann,1) and array.get(arrayYSGann,0) != array.get(arrayYGann,0) and ((array.get(arrayYGann,0) > array.get(arrayYGann,1) and array.get(arrayYSGann,0) > array.get(arrayYSGann,1)) or (array.get(arrayYGann,0) < array.get(arrayYGann,1) and array.get(arrayYSGann,0) < array.get(arrayYSGann,1))))
drawLineSGann := 2
array.set(arrayXSGann, 0, array.get(arrayXGann,0))
array.set(arrayYSGann, 0, array.get(arrayYGann,0))
else if(array.get(arrayXSGann,0) <= array.get(arrayXGann,1))
if((array.get(arrayYSGann,0) > array.get(arrayYSGann,1) and array.get(arrayYGann,0) < array.get(arrayYSGann,1)) or (array.get(arrayYSGann,0) < array.get(arrayYSGann,1) and array.get(arrayYGann,0) > array.get(arrayYSGann,1)))
drawLineSGann := 4
runCheckChoChSGann := true
array.unshift(arrayXSGann,array.get(arrayXGann,0))
array.unshift(arrayYSGann,array.get(arrayYGann,0))
else if((array.get(arrayYSGann,0) > array.get(arrayYSGann,1) and array.get(arrayYGann,0) > array.get(arrayYSGann,0)) or (array.get(arrayYSGann,0) < array.get(arrayYSGann,1) and array.get(arrayYGann,0) < array.get(arrayYSGann,0)))
drawLineSGann := 3
_max = math.min(array.get(arrayYSGann,0),array.get(arrayYSGann,1))
_min = math.max(array.get(arrayYSGann,0),array.get(arrayYSGann,1))
_max_idx = 0
_min_idx = 0
for i = 1 to array.size(arrayXGann)
if(array.get(arrayXSGann,0) >= array.get(arrayXGann,i))
break
if(_min > array.get(arrayYGann,i))
_min := array.get(arrayYGann,i)
_min_idx := array.get(arrayXGann,i)
if(_max < array.get(arrayYGann,i))
_max := array.get(arrayYGann,i)
_max_idx := array.get(arrayXGann,i)
if(array.get(arrayYSGann,0) > array.get(arrayYSGann,1))
array.unshift(arrayXSGann,_min_idx)
array.unshift(arrayYSGann,_min)
else if(array.get(arrayYSGann,0) < array.get(arrayYSGann,1))
array.unshift(arrayXSGann,_max_idx)
array.unshift(arrayYSGann,_max)
array.unshift(arrayXSGann,array.get(arrayXGann,0))
array.unshift(arrayYSGann,array.get(arrayYGann,0))
if(f_resInMinutes() < f_tfRes(customTF,f_resInMinutes()))
if(array.get(arrayYSGann,0) == array.get(arrayYGann,0) and array.get(arrayXSGann,0) != array.get(arrayXGann,0))
array.set(arrayXSGann, 0, array.get(arrayXGann,0))
drawLineSGann := 9
if(f_resInMinutes() <= f_tfRes(customTF,f_resInMinutes()))
if(drawLineSGann == 2 or drawLineSGann == 9)
if(array.size(arrayLineSGann) >0)
line.set_xy2(array.get(arrayLineSGann,0),array.get(arrayXSGann,0),array.get(arrayYSGann,0))
else
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,1),array.get(arrayYSGann,1),array.get(arrayXSGann,0),array.get(arrayYSGann,0), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
else if(drawLineSGann == 4)
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,1),array.get(arrayYSGann,1),array.get(arrayXSGann,0),array.get(arrayYSGann,0), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
else if(drawLineSGann == 3)
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,2),array.get(arrayYSGann,2),array.get(arrayXSGann,1),array.get(arrayYSGann,1), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,1),array.get(arrayYSGann,1),array.get(arrayXSGann,0),array.get(arrayYSGann,0), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
else if(drawLineSGann == 5)
if(array.size(arrayLineSGann) >0)
line.set_xy2(array.get(arrayLineSGann,0),array.get(arrayXSGann,1),array.get(arrayYSGann,1))
else
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,2),array.get(arrayYSGann,2),array.get(arrayXSGann,1),array.get(arrayYSGann,1), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
array.unshift(arrayLineSGann,line.new(array.get(arrayXSGann,1),array.get(arrayYSGann,1),array.get(arrayXSGann,0),array.get(arrayYSGann,0), color = colorSGann,xloc = xloc.bar_time,width = widthSGann,style = lineStyleSGann))
if(runCheckChoChSGann)
runCheckChoChSGann := false
// ChoCh Trường hợp chữ N ngược, chữ N
if((array.get(arrayYSGann,3) > array.get(arrayYSGann,2) and array.get(arrayYSGann,3) < array.get(arrayYSGann,1) and array.get(arrayYSGann,0) < array.get(arrayYSGann,2)) or (array.get(arrayYSGann,3) < array.get(arrayYSGann,2) and array.get(arrayYSGann,3) > array.get(arrayYSGann,1) and array.get(arrayYSGann,0) > array.get(arrayYSGann,2)))
alert(syminfo.ticker + " : " + timeframe.period + " => Swing of Gann ChoCh" + (array.get(arrayYSGann,0) > array.get(arrayYSGann,1) ? "+ ⇑" : "- ⇓"))
if(showChoCh)
array.unshift(arrayLineChoCh,line.new(x1= array.get(arrayXSGann,2) , y1=array.get(arrayYSGann,2),x2=array.get(arrayXSGann,0), y2=array.get(arrayYSGann,2),color = colorChoch,xloc = xloc.bar_time,style = lineStyleChoch,width = widthChoch))
// ChoCh 2 Đầu Trường hợp chữ N ngược, chữ N
if(show2ChoCh and ((array.get(arrayYSGann,1) > array.get(arrayYSGann,3) and array.get(arrayYSGann,3) > array.get(arrayYSGann,4) and array.get(arrayYSGann,4) > array.get(arrayYSGann,2) and array.get(arrayYSGann,2) > array.get(arrayYSGann,0)) or (array.get(arrayYSGann,0) > array.get(arrayYSGann,2) and array.get(arrayYSGann,2) > array.get(arrayYSGann,4) and array.get(arrayYSGann,4) > array.get(arrayYSGann,3) and array.get(arrayYSGann,3) > array.get(arrayYSGann,1))))
line.set_width(array.get(arrayLineSGann,1),width2Choch)
line.set_style(array.get(arrayLineSGann,1),lineStyle2Choch)
line.set_color(array.get(arrayLineSGann,1),color2Choch)
///////////////////////Other//////////////////////////////////
if(f_resInMinutes() <= f_tfRes(customTF,f_resInMinutes()))
if(showSGann)
if(showtargetOTL)
if(drawLineSGann1 == 14)
line.set_xy1(lineChoChOTLTarget,array.get(arrayXSGann,3),array.get(arrayYSGann,3))
line.set_xy2(lineChoChOTLTarget,array.get(arrayXSGann,3),array.get(arrayYSGann,3)*2 - array.get(arrayYSGann,2))
else if(drawLineSGann1 == 13)
line.set_xy1(lineBosOTLTarget,array.get(arrayXSGann,3),array.get(arrayYSGann,3))
line.set_xy2(lineBosOTLTarget,array.get(arrayXSGann,3),array.get(arrayYSGann,3)*2 - array.get(arrayYSGann,2))
if(drawLineSGann == 4)
line.set_xy1(lineChoChOTLTarget,array.get(arrayXSGann,2),array.get(arrayYSGann,2))
line.set_xy2(lineChoChOTLTarget,array.get(arrayXSGann,2),array.get(arrayYSGann,2)*2 - array.get(arrayYSGann,1))
else if(drawLineSGann == 3)
line.set_xy1(lineBosOTLTarget,array.get(arrayXSGann,2),array.get(arrayYSGann,2))
line.set_xy2(lineBosOTLTarget,array.get(arrayXSGann,2),array.get(arrayYSGann,2)*2 - array.get(arrayYSGann,1))
if(showLabel and (barstate.islast or barstate.islastconfirmedhistory))
texLabel = f_resInMinutes() == f_tfRes(customTF,f_resInMinutes()) ? f_resFromMinutes(f_resInMinutes()) : f_resFromMinutes(f_tfRes(customTF,f_resInMinutes()))
label.set_xy(labelTF,array.get(arrayXSGann,0),array.get(arrayYSGann,0))
label.set_text(labelTF,texLabel)
label.set_style(labelTF,array.get(arrayYSGann,0) < array.get(arrayYSGann,1) ? label.style_label_upper_right : label.style_label_lower_right)
else if(showGann)
if(showLabel and (barstate.islast or barstate.islastconfirmedhistory))
texLabel = f_resInMinutes() == f_tfRes(customTF,f_resInMinutes()) ? f_resFromMinutes(f_resInMinutes()) : f_resFromMinutes(f_tfRes(customTF,f_resInMinutes()))
label.set_xy(labelTF,array.get(arrayXGann,0),array.get(arrayYGann,0))
label.set_text(labelTF,texLabel)
label.set_style(labelTF,array.get(arrayYGann,0) < array.get(arrayYGann,1) ? label.style_label_upper_right : label.style_label_lower_right)
///ema///
EMA = "EMA Setting"
len = input.int(21, minval=1, title="EMA Length")
len1= input.int(34, minval=1, title="EMA Length")
len2 = input.int(89, minval=1, title="EMA Length")
len3 = input.int(200, minval=1, title="EMA Length")
src = close
ema = ta.ema(src, len)
ema1 = ta.ema(close,len1) //34
ema2 = ta.ema(close,len2) //89
ema3 = ta.ema (close,len3)//200
up = ema > ema
down = ema < ema
mycolor = up ? #00a7bc : down ? #b91002 : color.blue
plot(ema, title="EMA", color=mycolor, linewidth=1)
//plot(ema1, title="EMA", color=mycolor, linewidth=1,editable = false)
//plot(ema2, title="EMA", color=mycolor, linewidth=1,editable = false)
//plot(ema3, title="EMA", color=mycolor, linewidth=1,editable = false)
table_color_up = color.new(#00a7bc,70)
table_color_down = color.new(#b91002,70)
//vẽ bảng ema + rsi//
t = table.new(position = position.bottom_right, columns = 5, rows = 9, bgcolor = #fde9c9)
table.cell(t, 0, 0, "Time",text_size = size.small)
table.cell(t, 1, 0, "EMA",text_size = size.small)
table.cell(t, 0, 1, "5m",text_size = size.small)
table.cell(t, 0, 2, "15m",text_size = size.small)
table.cell(t, 0, 3, "4h",text_size = size.small)
table.cell(t, 0, 4, "1d",text_size = size.small)
// tính toán giá EMA của các khung thời gian khác nhau
ema5 = request.security(syminfo.tickerid, "5", ta.ema(src, len))
ema15 = request.security(syminfo.tickerid, "15", ta.ema(src, len))
ema4h = request.security(syminfo.tickerid, "240", ta.ema(src, len))
ema1d = request.security(syminfo.tickerid, "D", ta.ema(src, len))
//tô màu cho bảng chứa EMA
ema5_color = ema5 < close ? table_color_up : table_color_down
ema15_color = ema15 < close ? table_color_up :table_color_down
ema4h_color = ema4h < close ? table_color_up : table_color_down
ema1d_color = ema1d < close ? table_color_up : table_color_down
//tính toán ema 123_5
//ema5_1 = request.security(syminfo.tickerid, "5", ta.ema(close, len1))
//ema5_2 = request.security(syminfo.tickerid, "5", ta.ema(close, len2))
//ema5_3 = request.security(syminfo.tickerid, "5", ta.ema(close, len3))
//trend_ema5_color = (ema5_1 > ema5_2 and ema5_2 > ema5_3) ? color.green : (ema5_1 > ema5_2 and ema5_2 < ema5_3)? color.new(color.green,70) : (ema5_1 < ema5_2 and ema5_2 < ema5_3) ? color.red : (ema5_1 < ema5_2 and ema5_2 > ema5_3) ? color.new(color.red,70) : color.orange
//tính toán ema 123_15
ema15_1 = request.security(syminfo.tickerid, "15", ta.ema(close, len1))
ema15_2 = request.security(syminfo.tickerid, "15", ta.ema(close, len2))
ema15_3 = request.security(syminfo.tickerid, "15", ta.ema(close, len3))
trend_ema15_color = (ema15_1 > ema15_2 and ema15_2 > ema15_3) ? color.green : (ema15_1 > ema15_2 and ema15_2 < ema15_3)? color.new(color.green,70) : (ema15_1 < ema15_2 and ema15_2 < ema15_3) ? color.red : (ema15_1 < ema15_2 and ema15_2 > ema15_3) ? color.new(color.red,70) : color.orange
//tính toán ema 123_4h
ema4h_1 = request.security(syminfo.tickerid, "240", ta.ema(close, len1))
ema4h_2 = request.security(syminfo.tickerid, "240", ta.ema(close, len2))
ema4h_3 = request.security(syminfo.tickerid, "240", ta.ema(close, len3))
trend_ema4h_color = (ema4h_1 > ema4h_2 and ema4h_2 > ema4h_3) ? color.green : (ema4h_1 > ema4h_2 and ema4h_2 < ema4h_3)? color.new(color.green,70) : (ema4h_1 < ema4h_2 and ema4h_2 < ema4h_3) ? color.red : (ema4h_1 < ema4h_2 and ema4h_2 > ema4h_3) ? color.new(color.red,70) : color.orange
// tính toán RSI của các khung thời gian khác nhau
rsi5 = request.security(syminfo.tickerid, "5", ta.rsi(src, 14))
rsi15 = request.security(syminfo.tickerid, "15", ta.rsi(src, 14))
rsi4h = request.security(syminfo.tickerid, "240", ta.rsi(src, 14))
rsi1d = request.security(syminfo.tickerid, "D", ta.rsi(src, 14))
//tô màu cho bảng chứa RSI
rsi5_color = rsi5 > 70 ? table_color_down : rsi5 < 30 ? table_color_up : color.orange
rsi15_color = rsi15 > 70 ? table_color_down : rsi15 < 30 ? table_color_up : color.orange
rsi4h_color = rsi4h > 70 ? table_color_down : rsi4h < 30 ? table_color_up : color.orange
rsi1d_color = rsi1d > 70 ? table_color_down : rsi1d < 30 ? table_color_up : color.orange
//tính toán % thay đổi 1d, 7d, 30d
// Lấy giá trị giá đóng cửa của các ngày trước đó
yesterday_close = request.security(syminfo.tickerid, "D", close )
last_week_close = request.security(syminfo.tickerid, "W", close )
last_month_close = request.security(syminfo.tickerid, "M", close )
// Tính toán phần trăm thay đổi giá so với các ngày trước đó
day_change = math.round((close / yesterday_close - 1) * 100,1)
week_change = math.round((close / last_week_close - 1) * 100,1)
month_change = math.round((close / last_month_close - 1) * 100,1)
//tô màu cho bảng chứa % thay đổi
day_change_color = day_change < 0 ? table_color_down : table_color_up
weak_change_color = week_change < 0 ? table_color_down : table_color_up
month_change_color = month_change < 0 ? table_color_down : table_color_up
// tính toán btc.d usdt.d dxy
btc_d = request.security("CRYPTOCAP:BTC.D", timeframe.period, close)
usdt_d = request.security("CRYPTOCAP:USDT.D", timeframe.period, close)
dxy = request.security("TVC:DXY", timeframe.period, close)
yesterday_btc_d = request.security("CRYPTOCAP:BTC.D", timeframe.period, close )
yesterday_usdt_d = request.security("CRYPTOCAP:USDT.D", timeframe.period, close )
yesterday_dxy = request.security("TVC:DXY", timeframe.period, close )
btc_d_color = btc_d < yesterday_btc_d ? table_color_down : table_color_up //too mau
usdt_d_color = usdt_d < yesterday_usdt_d ? table_color_down : table_color_up
dxy_color = dxy < yesterday_dxy ? table_color_down : table_color_up
// điền giá EMA vào bảng
table.cell(t, 1, 1, str.tostring(math.round(ema5, 3)), bgcolor = ema5_color,text_size = size.small)
table.cell(t, 1, 2, str.tostring(math.round(ema15, 3)), bgcolor = ema15_color,text_size = size.small)
table.cell(t, 1, 3, str.tostring(math.round(ema4h, 3)), bgcolor = ema4h_color,text_size = size.small)
table.cell(t, 1, 4, str.tostring(math.round(ema1d, 3)), bgcolor = ema1d_color,text_size = size.small)
// điền rsi vào bảng
show_info_2 = input.bool(title = "Show % RSI",defval = true,group = "Table Setting")
if show_info_2
table.cell(t, 2, 0, "RSI",text_size = size.small)
table.cell(t, 2, 1, str.tostring(math.round(rsi5,0)), bgcolor = rsi5_color,text_size = size.small)
table.cell(t, 2, 2, str.tostring(math.round(rsi15,0)), bgcolor = rsi15_color,text_size = size.small)
table.cell(t, 2, 3, str.tostring(math.round(rsi4h,0)), bgcolor = rsi4h_color,text_size = size.small)
table.cell(t, 2, 4, str.tostring(math.round(rsi1d,0)), bgcolor = rsi1d_color,text_size = size.small)
// điển % change vào bảng
show_info_1 = input.bool(title = "Show % Change 1d, 7d, 30d",defval = true,group = "Table Setting")
if show_info_1
table.cell(t,0,5,"%",text_size = size.small)
table.cell(t,1,5,"1d",text_size = size.small)
table.cell(t,2,5,"7d",text_size = size.small)
table.cell(t,3,5,"30d",text_size = size.small)
table.cell(t, 1, 6, str.tostring(day_change, "#.##") + "%",bgcolor= day_change_color,text_size = size.small)
table.cell(t, 2, 6, str.tostring(week_change, "#.##") + "%",bgcolor = weak_change_color,text_size = size.small)
table.cell(t, 3, 6, str.tostring(month_change,"#.##") + "%", bgcolor = month_change_color,text_size = size.small)
//điện btc.d usdt.d dxy vào bảng
Table_Info = "Table Setting"
show_info = input.bool(title = "Show BTC.D, USSDT, DXY",defval = true,group = "Table Setting")
if show_info
table.cell(t,0,7,"#",text_size = size.small)
table.cell(t,1,7,"BTC.D",text_size = size.small)
table.cell(t,2,7,"USDT.D",text_size = size.small)
table.cell(t,3,7,"DXY",text_size = size.small)
table.cell(t, 1, 8, str.tostring(btc_d, "#.##") + "%",bgcolor= btc_d_color,text_size = size.small)
table.cell(t, 2, 8, str.tostring(usdt_d, "#.##") + "%",bgcolor = usdt_d_color,text_size = size.small)
table.cell(t, 3, 8, str.tostring(dxy,"#.##") + "%", bgcolor = dxy_color,text_size = size.small)
//điền trend ema vào bảng
show_info_3 = input.bool(title = "Show Trend",defval = true,group = "Table Setting")
if show_info_3
table.cell(t,3,0,"Trend",text_size = size.small)
//table.cell(t,3,1,"",bgcolor = trend_ema5_color)
table.cell(t,3,2,"",bgcolor = trend_ema15_color)
table.cell(t,3,3,"",bgcolor = trend_ema4h_color)
//đánh dấu volume với các osb + nến bulish bearish
//indicator("Color Ultra Volume Background", shorttitle = "UV",overlay=true, max_boxes_count=500, max_labels_count=500, max_lines_count=500, max_bars_back=1000)
UltraVol = "Ultra volume background"
colorultravol = input.color(color.new(color.purple,50),"Color UltraVol",group = UltraVol)
//Công thức//
lengthVolumeMA = input.int(20,minval=1,title="Length of MA applied on Volume",group = UltraVol)
ratioUltraVolume = input.float(2.2,minval=1,title="Ultra High Volume Ratio", group = UltraVol)
float volumeMA = 0
volumeMA := nz(volumeMA ) + (volume-nz(volumeMA )) / lengthVolumeMA
ultraHighVolumeMin = volumeMA * ratioUltraVolume
volUltraHigh = volume >= ultraHighVolumeMin? true : false
// Màu volume
color_cande_up_down = input.color(color.new(color.purple,100),"Color UltraVol",group = OSB_up_down)
Candle_body = input.float(0.5, 'Height of Engulfing candle body (%)', group = OSB_up_down)
//scan nến osb-eng - mera mera//
osb_up = high > high and low < low and close > close
osb_down = high > high and low < low and close < close
eng_up = open >= close and close > high and (close - open) >= Candle_body*(high - low)
eng_down = open <= close and close < low and (open - close) >= Candle_body*(high - low)
mm_up = osb_up and close > close and close > close
mm_down = osb_down and close < close and close < close
cande_up = close > close
cande_down = close < close
//tô màu nến//
colorOSB_up = input.color(#0ba4f9,'colorOSB_up',inline = "Up Outside Bar",group = OSB_up_down)
colorOSB_down = input.color(#fd1700,'colorOSB_dowwn',inline = "Down Outside Bar",group = OSB_up_down)
barcolor(osb_up ? colorOSB_up : na, title="Up Outside Bar")
barcolor(osb_down ? colorOSB_down : na, title="Down Outside Bar")
coloreng_up = input.color(#00a7bc,'coloreng_up',inline = "Bullish Bar",group = OSB_up_down)
coloreng_down = input.color(#b91002,'coloreng_dowwn',inline = "Bearlish Bar",group = OSB_up_down)
barcolor(eng_up ? coloreng_up : na, title="Bullish Bar")
barcolor(eng_down ? coloreng_down : na, title="Bearlish Bar")
//đánh dấu vol - mera mera
plotshape(volUltraHigh and cande_up,"Candle_UltraVol_up_shape",style = shape.circle,location = location.belowbar,color = coloreng_up,size = size.tiny)
plotshape(volUltraHigh and cande_down,"Candle_UltraVol_down_shape",style = shape.circle,location = location.abovebar,color = coloreng_down,size = size.tiny)
plotshape(volUltraHigh and osb_up,"Up Outside Bar+ Vol",style = shape.circle,location = location.belowbar,color = color_cande_up_down,size = size.tiny)
plotshape(volUltraHigh and osb_down,"Down Outside Bar+ Vol",style = shape.circle,location = location.abovebar,color = color_cande_up_down,size = size.tiny)
plotshape(volUltraHigh and eng_up,"Bullish Bar + Vol",style = shape.circle,location = location.belowbar,color = color_cande_up_down,size = size.tiny)
plotshape(volUltraHigh and eng_down,"Bearlish + Vol Bar",style = shape.circle,location = location.abovebar,color = color_cande_up_down,size = size.tiny)
plotshape(mm_up ? high : na, style=shape.circle, location=location.belowbar, color=#0ba4f9,title = "Mera UP",size = size.tiny)
plotshape(mm_down ? low : na, style=shape.circle, location=location.abovebar, color=#fd1700, title = "Mera Down", size = size.tiny)
//cảnh báo khi xuất hiện nến/
close_osb_up = close
close_osb_down = close
close_eng_up = close
close_eng_down = close
close_mm_up = close
close_mm_down = close
time_h4 = request.security(syminfo.tickerid, "240",close)
time_D1 = request.security(syminfo.tickerid, "D",close)
if (osb_up and barstate.isconfirmed)
if (close_osb_up > ema)
alert("OSB_UP: Above Ema: " + str.tostring(close_osb_up))
if volUltraHigh
alert("OSB_UP + Volume: Above Ema: " + str.tostring(close_osb_up))
else if (close_osb_up < ema)
alert("OSB_UP: Below Ema: " + str.tostring(close_osb_up))
if volUltraHigh
alert("OSB_UP + Volume: Below Ema: " + str.tostring(close_osb_up))
if (osb_down and barstate.isconfirmed)
if (close_osb_down > ema)
alert("OSB_DOWN: Above Ema: " + str.tostring(close_osb_down))
if volUltraHigh
alert("OSB_DOWN + Volume: Above Ema: " + str.tostring(close_osb_down))
else if (close_osb_down < ema)
alert("OSB_DOWN: Below Ema: " + str.tostring(close_osb_down))
if volUltraHigh
alert("OSB_DOWN + Volume: Below Ema: " + str.tostring(close_osb_down))
if (eng_up and barstate.isconfirmed)
if (close_eng_up > ema)
alert("Bar_UP: Above Ema: " + str.tostring(close_eng_up))
if volUltraHigh
alert("Bar_UP + Volume: Above Ema: " + str.tostring(close_eng_up))
else if (close_eng_up < ema)
alert("Bar_UP: Below Ema: " + str.tostring(close_eng_up))
if volUltraHigh
alert("Bar_UP + Volume: Below Ema: " + str.tostring(close_eng_up))
if (eng_down and barstate.isconfirmed)
if (close_eng_down > ema)
alert("Bar_DOWN: Above Ema: " + str.tostring(close_eng_down))
if volUltraHigh
alert("Bar_DOWN + Volume: Above Ema: " + str.tostring(close_eng_down))
else if (close_eng_down < ema)
alert("Bar_DOWN: Below Ema: " + str.tostring(close_eng_down))
if volUltraHigh
alert("Bar_DOWN + Volume: Below Ema: " + str.tostring(close_eng_down))
if (mm_up and barstate.isconfirmed)
if (close_mm_up > ema)
alert("Mera_UP: Above Ema: " + str.tostring(close_mm_up))
if volUltraHigh
alert("Mera_UP + Volume: Above Ema: " + str.tostring(close_mm_up))
else if (close_mm_up < ema)
alert("Mera_UP: Below Ema: " + str.tostring(close_mm_up))
if volUltraHigh
alert("Mera_UP + Volume: Below Ema: " + str.tostring(close_mm_up))
if (mm_down and barstate.isconfirmed)
if (close_mm_down > ema)
alert("Mera_DOWN: Above Ema: " + str.tostring(close_mm_down))
if volUltraHigh
alert("Mera_DOWN + Volume: Above Ema: " + str.tostring(close_mm_down))
else if (close_mm_down < ema)
alert("Mera_DOWN: Below Ema: " + str.tostring(close_mm_down))
if volUltraHigh
alert("Mera_DOWN + Volume: Below Ema: " + str.tostring(close_mm_down))
//indicator("Initial Balance", shorttitle="Initial Balance", overlay=true, max_bars_back=5000)
ib_session = input.session("2300-0000", title="Initial Balance", group="Calculation period")
show_extra_levels = input.bool(false, "Show extra levels (IBH x2 & IBL x2)", group="Information")
show_intermediate_levels = input.bool(false, "Show intermediate levels (50%)", group="Information")
show_ib_calculation_area = input.bool(false, "Initial balance calculation period coloration", group="Information")
show_labels = input.bool(false, "Show labels", group="Information")
fill_ib_areas = input.bool(false, "Colour IB areas", group="Information")
only_current_levels = input.bool(true, "Only display the current IB Levels", group="Information")
only_current_zone = input.bool(false, "Only display the current IB calculation area", group="Information")
label_size = input.string("Small", title="Label Size", options= , group="Drawings")
lvl_width = input.int(1, "Daily price level width", group="Drawings")
high_col = input.color(color.black, "Initial balance high levels color", group="Drawings")
low_col = input.color(color.black, "Initial balance low levels color", group="Drawings")
middle_col = input.color(#ffa726, "50% initial balance color", group="Drawings")
extend_level = input.string("Right", title="Extend current levels", options= , group="Drawings")
main_levels_style = input.string("Solid" , "Main levels line style", options= , group="Drawings")
ext_levels_style = input.string("Dashed" , "Extended levels line style", options= , group="Drawings")
int_levels_style = input.string("Dotted" , "Intermediate levels line style", options= , group="Drawings")
fill_ib_color= input.color(#b8851faa, "IB area background color", group="Drawings")
ext = extend_level == "Right" ? extend.right : extend_level == "Left" ? extend.left : extend_level == "Both" ? extend.both : extend.none
var delta_history = array.new_float(20)
inSession(sess) => na(time(timeframe.period, sess)) == false
get_line_style(s) =>
s == "Solid" ? line.style_solid : s == "Dotted" ? line.style_dotted : line.style_dashed
get_levels(n) =>
h = high
l = low
for i=1 to n
if low < l
l := low
if high > h
h := high
var line ibh = na
var line ibl = na
var line ibm = na
var line ib_plus = na
var line ib_minus = na
var line ib_plus2 = na
var line ib_minus2 = na
var line ibm_plus = na
var line ibm_minus = na
var label labelh = na
var label labell = na
var label labelm = na
var label label_plus = na
var label label_minus = na
var label label_plus2 = na
var label label_minus2 = na
var label labelm_plus = na
var label labelm_minus = na
var box ib_area = na
labelSize = (label_size == "Huge") ? size.huge :
(label_size == "Large") ? size.large :
(label_size == "Small") ? size.small :
(label_size == "Tiny") ? size.tiny :
(label_size == "Auto") ? size.auto : size.normal
var offset = 0
ins = inSession(ib_session)
bgcolor(show_ib_calculation_area and ins ? #673ab730 : na, title="IB calculation zone")
var float ib_delta = na
if ins
offset += 1
if ins and not ins
= get_levels(offset)
ib_delta := h - l
if array.size(delta_history) >= 20
array.shift(delta_history)
array.push(delta_history, ib_delta)
line.set_extend(ibh, extend.none)
line.set_extend(ibl, extend.none)
if show_intermediate_levels
line.set_extend(ibm, extend.none)
if show_extra_levels
line.set_extend(ib_plus, extend.none)
line.set_extend(ib_minus, extend.none)
line.set_extend(ib_plus2, extend.none)
line.set_extend(ib_minus2, extend.none)
if show_intermediate_levels
line.set_extend(ibm_plus, extend.none)
line.set_extend(ibm_minus, extend.none)
if show_labels
if only_current_levels
label.delete(labelh)
label.delete(labell)
label.delete(labelm)
label.delete(label_plus)
label.delete(label_minus)
label.delete(label_plus2)
label.delete(label_minus2)
label.delete(labelm_plus)
label.delete(labelm_minus)
labelh := label.new(bar_index , h, text="IBH 100%: "+str.tostring(h), style=label.style_none, textcolor=high_col, size=labelSize)
labell := label.new(bar_index , l, text="IBL 0%: "+str.tostring(l), style=label.style_none, textcolor=low_col, size=labelSize)
if show_intermediate_levels
labelm := label.new(bar_index , m, text="IBM 50%: "+str.tostring(m)+" IBΔ: "+str.tostring(h - l), style=label.style_none, textcolor=middle_col, size=labelSize)
if show_extra_levels
label_plus := label.new(bar_index , h + ib_delta, text="IBH x2 - "+str.tostring(h + ib_delta), style=label.style_none, textcolor=high_col, size=labelSize)
label_minus := label.new(bar_index , l - ib_delta, text="IBL x2: "+str.tostring(l - ib_delta), style=label.style_none, textcolor=low_col, size=labelSize)
label_plus2 := label.new(bar_index , h + (ib_delta*2), text="IBH x3 - "+str.tostring(h + (ib_delta*2)), style=label.style_none, textcolor=high_col, size=labelSize)
label_minus2 := label.new(bar_index , l - (ib_delta*2), text="IBL x3: "+str.tostring(l - (ib_delta*2)), style=label.style_none, textcolor=low_col, size=labelSize)
if fill_ib_areas
if only_current_zone
box.delete(ib_area)
ib_area := box.new(bar_index , h, bar_index, l, bgcolor=fill_ib_color, border_color=#00000000)//, extend=ext)
if only_current_levels
line.delete(ibh)
line.delete(ibl)
line.delete(ibm)
line.delete(ib_plus)
line.delete(ib_minus)
line.delete(ib_plus2)
line.delete(ib_minus2)
line.delete(ibm_plus)
line.delete(ibm_minus)
ibh := line.new(bar_index , h, bar_index, h, color=high_col, extend=ext, width=lvl_width, style=get_line_style(main_levels_style))
ibl := line.new(bar_index , l, bar_index, l, color=low_col, extend=ext, width=lvl_width, style=get_line_style(main_levels_style))
if show_intermediate_levels
ibm := line.new(bar_index , m, bar_index, m, color=middle_col, style=get_line_style(int_levels_style), extend=ext, width=lvl_width)
if show_extra_levels
ib_plus := line.new(bar_index , h + ib_delta, bar_index, h + ib_delta, color=high_col, style=get_line_style(ext_levels_style), extend=ext, width=lvl_width)
ib_minus := line.new(bar_index , l - ib_delta, bar_index, l - ib_delta, color=low_col, style=get_line_style(ext_levels_style), extend=ext, width=lvl_width)
ib_plus2 := line.new(bar_index , h + (ib_delta*2), bar_index, h + (ib_delta *2), color=high_col, style=get_line_style(ext_levels_style), extend=ext, width=lvl_width)
ib_minus2 := line.new(bar_index , l - (ib_delta*2), bar_index, l - (ib_delta*2), color=low_col, style=get_line_style(ext_levels_style), extend=ext, width=lvl_width)
if show_intermediate_levels
ibm_plus := line.new(bar_index , h + (ib_delta/2), bar_index, h + (ib_delta/2), color=middle_col, style=get_line_style(int_levels_style), extend=ext, width=lvl_width)
ibm_minus := line.new(bar_index , l - (ib_delta/2), bar_index, l - (ib_delta/2), color=middle_col, style=get_line_style(int_levels_style), extend=ext, width=lvl_width)
offset := 0
if (not ins) and (not ins )
line.set_x2(ibh, bar_index)
line.set_x2(ibl, bar_index)
if show_intermediate_levels
line.set_x2(ibm, bar_index)
if show_extra_levels
line.set_x2(ib_plus, bar_index)
line.set_x2(ib_minus, bar_index)
line.set_x2(ib_plus2, bar_index)
line.set_x2(ib_minus2, bar_index)
if show_intermediate_levels
line.set_x2(ibm_plus, bar_index)
line.set_x2(ibm_minus, bar_index)
var table ib_analytics = table.new(position.bottom_left, 2, 6)
ib_sentiment() =>
h = array.max(delta_history)
l = array.min(delta_history)
a = array.avg(delta_history)
h_comp = ib_delta > h ? ib_delta - h : (ib_delta - h) * -1
l_comp = ib_delta > l ? ib_delta - l : (ib_delta - l) * -1
a_comp = ib_delta > a ? ib_delta - a : (ib_delta - a) * -1
(h_comp < l_comp and h_comp < a_comp) ? "Huge" : (l_comp < h_comp and l_comp < a_comp) ? "Small" : "Medium"
//@version=5
//indicator('Key Levels', overlay=true)
group = 'KEYLVL_SETTINGS'
displaystyle = input.string('Standard', ' Display Style', group = group, inline='onest', options= )
linestyle = input.string('Solid', ' Line Style ', group = group, inline='twost', options= )
fontstyle = input.string('Monospace', ' Font Type ', group = group, inline='trest', options= )
labelpos = input.string('Middle', ' Label Pos ', group = group, inline=' ', options= )
bar_offset = input.int (30, ' Offset ', group = group, inline='onest', minval=0, maxval=450, step = 5)
threshold = input.float (0.1, ' Threshold %', group = group, inline='twost', minval=0, step=0.05, tooltip='Threshold - the distance between the levels after which the labels merge.')
index = input.int (0, ' Index ', group = group, inline='trest', minval=0, step=1, tooltip='Index - Default 0 allows you to see current and past price levels. Changing to 1 will shift the current levels to the previous levels, and the previous levels to the previous levels, etc.')
color_cD = input.color (#2a89c9, ' cD', group = group, inline='cols1')
color_cW = input.color (#b7d123, ' cW', group = group, inline='cols1')
color_cM = input.color (#8056b8, ' cM', group = group, inline='cols1')
color_cQ = input.color (#c23eb0, ' cQ', group = group, inline='cols1')
color_cY = input.color (#d62e28, ' cY', group = group, inline='cols1')
color_pD = input.color (#2a89c9, ' pD', group = group, inline='cols2')
color_pW = input.color (#b7d123, ' pW', group = group, inline='cols2')
color_pM = input.color (#8056b8, ' pM', group = group, inline='cols2')
color_pQ = input.color (#c23eb0, ' pQ', group = group, inline='cols2')
color_pY = input.color (#d62e28, ' pY', group = group, inline='cols2', tooltip="Prefix 'C' = Current/today. Prefix 'P' = Previous/yesterday. Prefix 'D' = Day. Prefix 'W' = Week. Prefix 'M' = Mounth. Prefix 'Q' = Quarterly. Prefix 'Y' = Year.'" )
i_tG = input.bool (true, ' Global Color Text', group = group, inline='colsg')
color_tG = input.color (color.black, ' ', group = group, inline='colsg')
i_lG = input.bool (true, ' Global Color Line', group = group, inline='colsg')
color_lG = input.color (color.black, ' ', group = group, inline='colsg')
fontstyles = switch fontstyle
"Default" => font.family_default
"Monospace" => font.family_monospace
linestyles = switch linestyle
"Solid" => line.style_solid
"Dashed" => line.style_dashed
"Dotted" => line.style_dotted
displaystyles = switch displaystyle
"Standard" => extend.none
"Right" => extend.right
"Both" => extend.both
"Left" => extend.left
getprice(TimeFrame, Index)=> // Get Open, High, Low, Close, Time data
i = Index
tf = TimeFrame
= request.security(syminfo.tickerid, tf, [open , high , low , close , time ], lookahead=barmerge.lookahead_on)
= getprice('D', 0+index) // Get Current Day Open, High, Low, Close, Time
= getprice('W', 0+index) // Get Current Weekly Open, High, Low, Close, Time
= getprice('M', 0+index) // Get Current Mounth Open, High, Low, Close, Time
= getprice('3M', 0+index) // Get Current Quarter Open, High, Low, Close, Time
= getprice('12M', 0+index) // Get Current Year Open, High, Low, Close, Time
= getprice('D', 1+index) // Get Previous Day Open, High, Low, Close, Time
= getprice('W', 1+index) // Get Previous Weekly Open, High, Low, Close, Time
= getprice('M', 1+index) // Get Previous Mounth Open, High, Low, Close, Time
= getprice('3M', 1+index) // Get Previous Quarter Open, High, Low, Close, Time
= getprice('12M', 1+index) // Get Previous Year Open, High, Low, Close, Time
extend(bars) => // Extends the current time by the product of the time difference between elements and the number of bars.
timenow + (time - time ) * bars
getlevel(time, level, txtcolor, linecolor, txtlabel)=> // Get draws a line and a label on the chart
if barstate.islast // The following code doesn't need to be processed on every candle
xindex = displaystyle == 'Standard' ? time : bar_index+bar_offset
xloc = displaystyle == 'Standard' ? xloc.bar_time : xloc.bar_index
xid = displaystyle == 'Standard' ? extend(bar_offset) : bar_index+bar_offset+1
lblpos = labelpos == 'Middle' ? label.style_label_center : label.style_none
lines = line.new (x1=xindex, x2=xid, y1=level, y2=level, xloc=xloc, style=linestyles, extend=displaystyles, color=linecolor)
labels = label.new(x=xid, y=level, text=txtlabel, style=lblpos, xloc=xloc, text_font_family=fontstyles, textcolor=txtcolor, color = #ffffff00)
line.delete(lines ) // remove the previous line when new bar appears
label.delete(labels ) // remove the previous label when new bar appears
// Get Inputs, Lines, Labels
i_cDO = input(false, 'DO ', group = group, inline='D'), = getlevel(cDtime, i_cDO ? cDopen : na, i_tG ? color_tG : color_cD, i_lG ? color_lG : color_cD, 'DO' )
i_cDH = input(false, 'DH ', group = group, inline='D'), = getlevel(cDtime, i_cDH ? cDhigh : na, i_tG ? color_tG : color_cD, i_lG ? color_lG : color_cD, 'DH' )
i_cDL = input(false, 'DL ', group = group, inline='D'), = getlevel(cDtime, i_cDL ? cDlow : na, i_tG ? color_tG : color_cD, i_lG ? color_lG : color_cD, 'DL' )
i_pDO = input(false, 'pDO', group = group, inline='D'), = getlevel(pDtime, i_pDO ? pDopen : na, i_tG ? color_tG : color_pD, i_lG ? color_lG : color_pD, 'pDO' )
i_pDH = input(true, 'pDH', group = group, inline='D'), = getlevel(pDtime, i_pDH ? pDhigh : na, i_tG ? color_tG : color_pD, i_lG ? color_lG : color_pD, 'pDH' )
i_pDL = input(true, 'pDL', group = group, inline='D'), = getlevel(pDtime, i_pDL ? pDlow : na, i_tG ? color_tG : color_pD, i_lG ? color_lG : color_pD, 'pDL' )
i_cWO = input(false, 'WO ', group = group, inline='W'), = getlevel(cWtime, i_cWO ? cWopen : na, i_tG ? color_tG : color_cW, i_lG ? color_lG : color_cW, 'WO' )
i_cWH = input(false, 'WH ', group = group, inline='W'), = getlevel(cWtime, i_cWH ? cWhigh : na, i_tG ? color_tG : color_cW, i_lG ? color_lG : color_cW, 'WH' )
i_cWL = input(false, 'WL ', group = group, inline='W'), = getlevel(cWtime, i_cWL ? cWlow : na, i_tG ? color_tG : color_cW, i_lG ? color_lG : color_cW, 'WL' )
i_pWO = input(false, 'pWO', group = group, inline='W'), = getlevel(pWtime, i_pWO ? pWopen : na, i_tG ? color_tG : color_pW, i_lG ? color_lG : color_pW, 'pWO' )
i_pWH = input(false, 'pWH', group = group, inline='W'), = getlevel(pWtime, i_pWH ? pWhigh : na, i_tG ? color_tG : color_pW, i_lG ? color_lG : color_pW, 'pWH' )
i_pWL = input(false, 'pWL', group = group, inline='W'), = getlevel(pWtime, i_pWL ? pWlow : na, i_tG ? color_tG : color_pW, i_lG ? color_lG : color_pW, 'pWL' )
i_cMO = input(false, 'MO ', group = group, inline='M'), = getlevel(cMtime, i_cMO ? cMopen : na, i_tG ? color_tG : color_cM, i_lG ? color_lG : color_cM, 'MO' )
i_cMH = input(false, 'MH ', group = group, inline='M'), = getlevel(cMtime, i_cMH ? cMhigh : na, i_tG ? color_tG : color_cM, i_lG ? color_lG : color_cM, 'MH' )
i_cML = input(false, 'ML ', group = group, inline='M'), = getlevel(cMtime, i_cML ? cMlow : na, i_tG ? color_tG : color_cM, i_lG ? color_lG : color_cM, 'ML' )
i_pMO = input(false, 'pMO', group = group, inline='M'), = getlevel(pMtime, i_pMO ? pMopen : na, i_tG ? color_tG : color_pM, i_lG ? color_lG : color_pM, 'pMO' )
i_pMH = input(false, 'pMH', group = group, inline='M'), = getlevel(pMtime, i_pMH ? pMhigh : na, i_tG ? color_tG : color_pM, i_lG ? color_lG : color_pM, 'pMH' )
i_pML = input(false, 'pML', group = group, inline='M'), = getlevel(pMtime, i_pML ? pMlow : na, i_tG ? color_tG : color_pM, i_lG ? color_lG : color_pM, 'pML' )
i_cQO = input(false, 'QO ', group = group, inline='Q'), = getlevel(cQtime, i_cQO ? cQopen : na, i_tG ? color_tG : color_cQ, i_lG ? color_lG : color_cQ, 'QO' )
i_cQH = input(false, 'QH ', group = group, inline='Q'), = getlevel(cQtime, i_cQH ? cQhigh : na, i_tG ? color_tG : color_cQ, i_lG ? color_lG : color_cQ, 'QH' )
i_cQL = input(false, 'QL ', group = group, inline='Q'), = getlevel(cQtime, i_cQL ? cQlow : na, i_tG ? color_tG : color_cQ, i_lG ? color_lG : color_cQ, 'QL' )
i_pQO = input(false, 'pQO', group = group, inline='Q'), = getlevel(pQtime, i_pQO ? pQopen : na, i_tG ? color_tG : color_pQ, i_lG ? color_lG : color_pQ, 'pQO' )
i_pQH = input(false, 'pQH', group = group, inline='Q'), = getlevel(pQtime, i_pQH ? pQhigh : na, i_tG ? color_tG : color_pQ, i_lG ? color_lG : color_pQ, 'pQH' )
i_pQL = input(false, 'pQL', group = group, inline='Q'), = getlevel(pQtime, i_pQL ? pQlow : na, i_tG ? color_tG : color_pQ, i_lG ? color_lG : color_pQ, 'pQL' )
i_cYO = input(false, 'YO ', group = group, inline='Y'), = getlevel(cYtime, i_cYO ? cYopen : na, i_tG ? color_tG : color_cY, i_lG ? color_lG : color_cY, 'YO' )
i_cYH = input(false, 'YH ', group = group, inline='Y'), = getlevel(cYtime, i_cYH ? cYhigh : na, i_tG ? color_tG : color_cY, i_lG ? color_lG : color_cY, 'YH' )
i_cYL = input(false, 'YL ', group = group, inline='Y'), = getlevel(cYtime, i_cYL ? cYlow : na, i_tG ? color_tG : color_cY, i_lG ? color_lG : color_cY, 'YL' )
i_pYO = input(false, 'pYO', group = group, inline='Y'), = getlevel(pYtime, i_pYO ? pYopen : na, i_tG ? color_tG : color_pY, i_lG ? color_lG : color_pY, 'pYO' )
i_pYH = input(false, 'pYH', group = group, inline='Y'), = getlevel(pYtime, i_pYH ? pYhigh : na, i_tG ? color_tG : color_pY, i_lG ? color_lG : color_pY, 'pYH' )
i_pYL = input(false, 'pYL', group = group, inline='Y'), = getlevel(pYtime, i_pYL ? pYlow : na, i_tG ? color_tG : color_pY, i_lG ? color_lG : color_pY, 'pYL' )
// Сollecting labels into an array for normalization
labels = array.from(cDOlabel,cDHlabel,cDLlabel,pDOlabel,pDHlabel,pDLlabel,cWOlabel,cWHlabel,cWLlabel,pWOlabel,pWHlabel,pWLlabel,cMOlabel,cMHlabel,cMLlabel,pMOlabel,pMHlabel,pMLlabel,cQOlabel,cQHlabel,cQLlabel,pQOlabel,pQHlabel,pQLlabel,cYOlabel,cYHlabel,cYLlabel,pYOlabel,pYHlabel,pYLlabel)
// This loop merge items in arrays "labels" into a single label if their difference is less than a certain threshold, and updates the label text.
for i = 0 to array.size(labels) - 2 // Loop through all the labels
txt = label.get_text(array.get(labels, i)) // Get the text of the current label
price_i = label.get_y(array.get(labels, i)) // Get the y coordinate of the current label
label_i = array.get(labels, i) // Store the current label
for j = i + 1 to array.size(labels) - 1 // Loop through the remaining labels
price_j = label.get_y(array.get(labels, j)) // Get the y coordinate of the current label
if math.abs(price_i - price_j) < (threshold/100) * price_i // Compare the prices
txt := txt + ' / ' + label.get_text(array.get(labels, j)) // Add the text of the second label
label.delete(array.get(labels, j)) // Delete the second label
label.set_text(label_i, txt) // Set the text of the current label
repeat(str, num) => // Returns a string that is created by repeating the input str num times
res = ""
len = str.length(str)
if num > 0 and len * num <= 4096
for r = 1 to num
res := res + str
res
// Loop to change the position of the Label
if labelpos == 'Middle'
for z = 0 to array.size(labels) - 1
label_z = array.get(labels, z) // Get the label at position z
texts = label.get_text(label_z) // Get the text of the label
spaces = fontstyle=='Default' ? repeat(' ', math.ceil(str.length(texts))*2) : repeat(' ', math.ceil(str.length(texts))) // Calculate the number of spaces needed
label.set_text(label_z, displaystyle=='Right'? texts + spaces + ' ' : spaces+' ' + texts) // Set the label text with the calculated spaces
//
//@version=5
//indicator("Congestion Zone", overlay=true)
Congestion_Zone = "Congestio_Zone"
Show_CZ = input.bool(true, title="On/off Congestion Zone", group="Congestion_Zone")
minbar = input(title="Minimum Bars in Zone", defval=5, group="Congestion_Zone", inline="Box",tooltip = "Số lượng nến tối thiểu để có 1 vùng CZ")
border_width = input.int(title="CZ boder width", defval=1, inline="Box1", group="Congestion_Zone", step=1,tooltip = "Viền CZ")
max_boxes = input.int(title="Max CZ", defval=50, group="Congestion_Zone", minval=1,tooltip = "Số vùng box tối đa muốn hiển thị để tránh rối mắt")
boxcolor_basic = input.color(title="CZ Color Basic", defval=color.new(color.orange, 80), group="Congestion_Zone",tooltip = "Nến thoát khỏi box không có xu hướng rõ ràng")
boxcolor_up = input.color(title="CZ Color Up", defval=color.new(color.green, 80), group="Congestion_Zone",tooltip = "Nến thoát khỏi box có giá đóng cửa > vùng CZ")
boxcolor_down = input.color(title="CZ Color Dowwn", defval=color.new(color.red, 80), group="Congestion_Zone",tooltip = "Nến thoát khỏi box có đóng cửa < vùng CZ")
var boxopen = array.new_float()
var boxclose = array.new_float()
var boxes = array.new_box()
congestion_condition = close >= low and close <= high and open >= low and open <= high
if congestion_condition and Show_CZ
array.push(boxopen, open > close ? open : close)
array.push(boxclose, open > close ? close : open)
else if array.size(boxopen) < minbar
array.clear(boxopen)
array.clear(boxclose)
if not congestion_condition and array.size(boxopen) >= minbar and Show_CZ
box_max = array.max(boxopen)
box_min = array.min(boxclose)
box_color = close >= box_max ? boxcolor_up : close <= box_min ? boxcolor_down : boxcolor_basic
if box_color == boxcolor_basic
alert("CZ basic")
else if box_color == boxcolor_up
alert("CZ UP")
else if box_color == boxcolor_down
alert("CZ DOWN")
// Determine box color based on last candle
new_box = box.new(bar_index - array.size(boxopen), box_max, bar_index - 1, box_min, bgcolor=box_color, border_width=border_width,border_color = box_color)
array.push(boxes, new_box)
array.clear(boxopen)
array.clear(boxclose)
//Remove old boxes if limit is reached
while array.size(boxes) > max_boxes
box.delete(array.shift(boxes))
onder-mam//@version=5
indicator("Basitleştirilmiş Multi-Indicator System (Sadeleştirilmiş Görünürlük)", overlay=true)
// --- Kullanıcı Ayarları ---
macdShortLength = input.int(12, title="MACD Kısa Periyot", minval=1)
macdLongLength = input.int(26, title="MACD Uzun Periyot", minval=1)
macdSignalSmoothing = input.int(9, title="MACD Signal Periyodu", minval=1)
smaLength = input.int(50, title="SMA Periyodu", minval=1)
emaLength = input.int(200, title="EMA Periyodu", minval=1)
atrLength = input.int(14, title="ATR Periyodu", minval=1)
factor = input.float(3.0, title="Supertrend Çarpanı", minval=1.0, step=0.1)
bbLength = input.int(20, title="Bollinger Bands Periyot", minval=1)
bbMultiplier = input.float(2.0, title="Bollinger Band Çarpanı", minval=0.1, step=0.1)
src = close
// --- MACD Hesaplamaları ---
= ta.macd(src, macdShortLength, macdLongLength, macdSignalSmoothing)
macdBuySignal = ta.crossover(macdLine, signalLine)
macdSellSignal = ta.crossunder(macdLine, signalLine)
// --- SMA ve EMA Hesaplamaları ---
smaLine = ta.sma(src, smaLength)
emaLine = ta.ema(src, emaLength)
maBuySignal = ta.crossover(smaLine, emaLine)
maSellSignal = ta.crossunder(smaLine, emaLine)
// --- Supertrend Hesaplamaları ---
atrValue = ta.atr(atrLength)
upperBand = hl2 - factor * atrValue
lowerBand = hl2 + factor * atrValue
var float supertrend = na
if (na(supertrend ))
supertrend := upperBand
else
if (close > supertrend )
supertrend := math.max(upperBand, supertrend )
else
supertrend := math.min(lowerBand, supertrend )
supertrendBuySignal = ta.crossover(close, supertrend)
supertrendSellSignal = ta.crossunder(close, supertrend)
// --- Bollinger Bands Hesaplamaları ---
basis = ta.sma(src, bbLength)
dev = bbMultiplier * ta.stdev(src, bbLength)
bbUpper = basis + dev
bbLower = basis - dev
bbBuySignal = ta.crossover(src, bbLower)
bbSellSignal = ta.crossunder(src, bbUpper)
// --- Çizimler ---
// MACD Çizgileri - sadece sinyal olduğunda gösterilecek
plot(macdLine, title="MACD Line", color=color.blue, linewidth=2)
plot(signalLine, title="Signal Line", color=color.orange, linewidth=2)
// SMA ve EMA Çizgileri - sadece geçerli sinyallerde gösterilecek
plot(smaLine, title="SMA Line", color=color.green, linewidth=2)
plot(emaLine, title="EMA Line", color=color.red, linewidth=2)
// Supertrend Çizgisi - sadece sinyal olduğunda gösterilecek
plot(supertrend, title="Supertrend", color=color.blue, linewidth=2)
// Bollinger Bands Çizgileri - sadece sinyal olduğunda gösterilecek
plot(basis, title="Bollinger Bands Orta Band", color=color.blue, linewidth=2)
plot(bbUpper, title="Bollinger Bands Üst Band", color=color.red, linewidth=2)
plot(bbLower, title="Bollinger Bands Alt Band", color=color.green, linewidth=2)
// --- Sinyaller ve Arka Plan Rengi ---
// Alım ve Satım sinyalleri için şekiller - sadece sinyal olduğunda gösterecek
plotshape(series=macdBuySignal, title="MACD Alım Sinyali", location=location.belowbar, color=color.green, style=shape.triangleup, text="BUY", size=size.small)
plotshape(series=macdSellSignal, title="MACD Satım Sinyali", location=location.abovebar, color=color.red, style=shape.triangledown, text="SELL", size=size.small)
plotshape(series=maBuySignal, title="SMA/EMA Alım Sinyali", location=location.belowbar, color=color.green, style=shape.triangleup, text="BUY", size=size.small)
plotshape(series=maSellSignal, title="SMA/EMA Satım Sinyali", location=location.abovebar, color=color.red, style=shape.triangledown, text="SELL", size=size.small)
plotshape(series=supertrendBuySignal, title="Supertrend Alım Sinyali", location=location.belowbar, color=color.green, style=shape.triangleup, text="BUY", size=size.small)
plotshape(series=supertrendSellSignal, title="Supertrend Satım Sinyali", location=location.abovebar, color=color.red, style=shape.triangledown, text="SELL", size=size.small)
plotshape(series=bbBuySignal, title="Bollinger Bands Alım Sinyali", location=location.belowbar, color=color.green, style=shape.triangleup, text="BUY", size=size.small)
plotshape(series=bbSellSignal, title="Bollinger Bands Satım Sinyali", location=location.abovebar, color=color.red, style=shape.triangledown, text="SELL", size=size.small)
// Arka plan renkleri (trend doğrulama için)
bgcolor(macdBuySignal or maBuySignal or supertrendBuySignal or bbBuySignal ? color.new(color.green, 90) : na, title="Alım Trend Arka Planı")
bgcolor(macdSellSignal or maSellSignal or supertrendSellSignal or bbSellSignal ? color.new(color.red, 90) : na, title="Satım Trend Arka Planı")
// Alerjler (Alert Conditions)
alertcondition(macdBuySignal, title="MACD Alım Sinyali", message="MACD çizgisi, Signal çizgisini yukarıya kesiyor. Alım sinyali!")
alertcondition(macdSellSignal, title="MACD Satım Sinyali", message="MACD çizgisi, Signal çizgisini aşağıya kesiyor. Satım sinyali!")
alertcondition(maBuySignal, title="SMA/EMA Alım Sinyali", message="SMA çizgisi, EMA çizgisini yukarıya doğru kesiyor. Alım sinyali!")
alertcondition(maSellSignal, title="SMA/EMA Satım Sinyali", message="SMA çizgisi, EMA çizgisini aşağıya doğru kesiyor. Satım sinyali!")
alertcondition(supertrendBuySignal, title="Supertrend Alım Sinyali", message="Supertrend çizgisi, fiyatı yukarıya doğru kesiyor. Alım sinyali!")
alertcondition(supertrendSellSignal, title="Supertrend Satım Sinyali", message="Supertrend çizgisi, fiyatı aşağıya doğru kesiyor. Satım sinyali!")
alertcondition(bbBuySignal, title="Bollinger Bands Alım Sinyali", message="Fiyat alt Bollinger Band'ını yukarı kesiyor. Alım sinyali!")
alertcondition(bbSellSignal, title="Bollinger Bands Satım Sinyali", message="Fiyat üst Bollinger Band'ını aşağı kesiyor. Satım sinyali!")
Breakout Master//@version=5
indicator('Breakout Master', overlay=true)
bullishBar = 1
bearishBar = -1
var inside_bar = array.new_int(0)
var inside_bar_high = array.new_float(0)
var inside_bar_low = array.new_float(0)
var motherCandleIndex = 0
var motherCandleHigh = 0.0
var motherCandleLow = 0.0
var motherCandleRange = 0.0
var target1Buy = 0.0
var target2Buy = 0.0
var target1Sell = 0.0
var target2Sell = 0.0
var motherCandleH = line.new(na, na, na, na, extend=extend.right, color=color.green)
var motherCandleL = line.new(na, na, na, na, extend=extend.right, color=color.red)
var motherCandleHLabel = label.new(na, na, style=label.style_label_left, textcolor=color.green, color=color.new(color.green, 80))
var motherCandleLLabel = label.new(na, na, style=label.style_label_left, textcolor=color.red, color=color.new(color.red, 80))
var longT1 = line.new(na, na, na, na, extend=extend.right)
var longT2 = line.new(na, na, na, na, extend=extend.right)
var shortT1 = line.new(na, na, na, na, extend=extend.right)
var shortT2 = line.new(na, na, na, na, extend=extend.right)
var longT1Label = label.new(na, na, textcolor=color.blue, style=label.style_label_left, color=color.new(color.blue, 80))
var longT2Label = label.new(na, na, textcolor=color.blue, style=label.style_label_left, color=color.new(color.blue, 80))
var shortT1Label = label.new(na, na, textcolor=color.blue, style=label.style_label_left, color=color.new(color.blue, 80))
var shortT2Label = label.new(na, na, textcolor=color.blue, style=label.style_label_left, color=color.new(color.blue, 80))
var longT1Line = input.bool(title='Show Long T1', defval=true, group='Long')
var longT2Line = input.bool(title='Show Long T2', defval=true, group='Long')
var shortT1Line = input.bool(title='Show Short T1', defval=true, group='Short')
var shortT2Line = input.bool(title='Show Short T2', defval=true, group='Short')
var longT1Range = input.float(title='Long T1', defval=1, group='Long (x times above range of mother candle)', tooltip='Line will be plotted above high of mother candle. If value entered is 1, then T1 = range of mother candle x 1')
var longT2Range = input.float(title='Long T2', defval=1.5, group='Long (x times above range of mother candle)', tooltip='Line will be plotted above high of mother candle. If value entered is 2, then T2 = range of mother candle x 2')
var shortT1Range = input.float(title='Short T1', defval=1, group='Short (x times below range of mother candle)', tooltip='Line will be plotted below low of mother candle. If value entered is 1, then T1 = range of mother candle x 1')
var shortT2Range = input.float(title='Short T2', defval=1.5, group='Short (x times below range of mother candle)', tooltip='Line will be plotted below low of mother candle. If value entered is 2, then T2 = range of mother candle x 1')
hi = high
lo = low
op = open
cl = close
isInside() =>
previousBar = 1
bodyStatus = cl >= op ? 1 : -1
isInsidePattern = hi < hi and lo > lo
isInsidePattern ? bodyStatus : 0
newDay = ta.change(time('D'))
if newDay
array.clear(inside_bar)
array.clear(inside_bar_high)
array.clear(inside_bar_low)
if isInside() and array.size(inside_bar) <= 0
array.push(inside_bar, bar_index)
array.push(inside_bar_high, hi )
array.push(inside_bar_low, lo )
if barstate.islast and array.size(inside_bar) > 0
motherCandleIndex := array.get(inside_bar, 0) - 1
motherCandleHigh := array.get(inside_bar_high, 0)
motherCandleLow := array.get(inside_bar_low, 0)
motherCandleRange := motherCandleHigh - motherCandleLow
target1Buy := motherCandleHigh + longT1Range * motherCandleRange
target2Buy := motherCandleHigh + longT2Range * motherCandleRange
target1Sell := motherCandleLow - shortT1Range * motherCandleRange
target2Sell := motherCandleLow - shortT2Range * motherCandleRange
// mother candle high
line.set_xy1(motherCandleH, motherCandleIndex, motherCandleHigh)
line.set_xy2(motherCandleH, bar_index, motherCandleHigh)
label.set_xy(motherCandleHLabel, bar_index + 5, motherCandleHigh)
label.set_text(id=motherCandleHLabel, text='Range High - ' + str.tostring(motherCandleHigh))
//mother candle low
line.set_xy1(motherCandleL, motherCandleIndex, motherCandleLow)
line.set_xy2(motherCandleL, bar_index, motherCandleLow)
label.set_xy(motherCandleLLabel, bar_index + 5, motherCandleLow)
label.set_text(id=motherCandleLLabel, text='Range Low - ' + str.tostring(motherCandleLow))
//long target 1
if longT1Line
line.set_xy1(longT1, motherCandleIndex, target1Buy)
line.set_xy2(longT1, bar_index, target1Buy)
label.set_xy(longT1Label, bar_index + 5, target1Buy)
label.set_text(id=longT1Label, text='T1 - ' + str.tostring(target1Buy) + ' (' + str.tostring(longT1Range * motherCandleRange) + ') points')
//long target 2
if longT2Line
line.set_xy1(longT2, motherCandleIndex, target2Buy)
line.set_xy2(longT2, bar_index, target2Buy)
label.set_xy(longT2Label, bar_index + 5, target2Buy)
label.set_text(id=longT2Label, text='T2 - ' + str.tostring(target2Buy) + ' (' + str.tostring(longT2Range * motherCandleRange) + ') points')
//short target 1
if shortT1Line
line.set_xy1(shortT1, motherCandleIndex, target1Sell)
line.set_xy2(shortT1, bar_index, target1Sell)
label.set_xy(shortT1Label, bar_index + 5, target1Sell)
label.set_text(id=shortT1Label, text='T1 - ' + str.tostring(target1Sell) + ' (' + str.tostring(shortT1Range * motherCandleRange) + ') points')
//short target 2
if shortT2Line
line.set_xy1(shortT2, motherCandleIndex, target2Sell)
line.set_xy2(shortT2, bar_index, target2Sell)
label.set_xy(shortT2Label, bar_index + 5, target2Sell)
label.set_text(id=shortT2Label, text='T2 - ' + str.tostring(target2Sell) + ' (' + str.tostring(shortT2Range * motherCandleRange) + ') points')
Pi Cycle Bitcoin High/LowThe theory that a Pi Cycle Top might exist in the Bitcoin price action isn't new, but recently I found someone who had done the math on developing a Pi Cycle Low indicator, also using the crosses of moving averages.
The Pi Cycle Top uses the 2x350 Daily MA and the 111 Daily MA
The Pi Cycle Bottom uses the 0.745x471 Daily MA and the 150 Daily EMA
Note: a Signal of "top" doesn't necessarily mean "THE top" of a Bull Run - in 2013 there were two Top Signals, but in 2017 there was just one. There one in 2021, triggered by Tesla's announcement that they would no longer accept BTC as payment due to the "bad for the environment" narrative. China also announced the 769th ban on Crypto that year, and the TOP signal was triggered. However, BTC rose again 6 months later to actually top at 69K for the Culture, before finally plummeting into a long and bleak Crypto Winter / Bear Market.
There is as much of a chance of two "bottom" indications occurring in a single bear market, as nearly happened in the Liquidity Crisis in March 2020.
On April 19 2024 (UTC) the Fourth Bitcoin Halving took place, as the 840,000th block was completed. It is currently estimated that the 5th halving will take place on March 26, 2028. Godspeed, gentlemen.
Support and Resistance Levels TP/SLSupport and resistance levels are critical concepts in trading, often used to set Take Profit (TP) and Stop Loss (SL) levels. Here's a guide to effectively determine these levels:
1. Identifying Support and Resistance Levels
- Support Level: A price level where demand is strong enough to prevent the price from falling further. Think of it as a floor.
- Resistance Level: A price level where selling pressure is strong enough to prevent the price from rising further. Think of it as a ceiling.
Methods to Identify Levels:
- Horizontal Lines: Use historical price data to find levels where prices frequently reversed.
- **Trendlines**: Draw diagonal lines connecting higher lows (support) or lower highs (resistance).
- Fibonacci Retracement: Calculate levels based on key Fibonacci ratios (e.g., 23.6%, 38.2%, 61.8%).
- Moving Averages: Identify dynamic support and resistance based on moving average levels.
- Volume Profile: Spot areas of high trading activity, which often act as support or resistance.
---
2. Setting Take Profit (TP) Levels
- Conservative Approach: Place the TP level slightly below a resistance level to ensure execution.
- Aggressive Approach: Target higher levels, considering momentum and trend strength.
Example:
- Resistance at $50.
- Set TP at $49.80 to account for slippage or premature reversals.
3. Setting Stop Loss (SL) Levels
- Below Support: For long trades, set the SL slightly below the identified support level.
- Above Resistance: For short trades, set the SL slightly above the resistance.
Example:
- Support at $45.
- Set SL at $44.80 to allow for minor price fluctuations.
4. Risk-Reward Ratio
- Aim for at least a 1:2 risk-reward ratio (e.g., risk $1 to gain $2).
- Calculate TP and SL levels accordingly to maintain this balance.
5. Adjusting for Market Conditions
- Volatile Markets: Widen TP and SL levels to account for larger price swings.
- Stable Markets: Use tighter levels for precise risk management.
6. Automating TP/SL
- Use trading platforms to automate TP/SL placements, ensuring discipline and emotional control.
Would you like help applying this to a specific scenario or chart?
Z-Strike RecoveryThis strategy utilizes the Z-Score of daily changes in the VIX (Volatility Index) to identify moments of extreme market panic and initiate long entries. Scientific research highlights that extreme volatility levels often signal oversold markets, providing opportunities for mean-reversion strategies.
How the Strategy Works
Calculation of Daily VIX Changes:
The difference between today’s and yesterday’s VIX closing prices is calculated.
Z-Score Calculation:
The Z-Score quantifies how far the current change deviates from the mean (average), expressed in standard deviations:
Z-Score=(Daily VIX Change)−MeanStandard Deviation
Z-Score=Standard Deviation(Daily VIX Change)−Mean
The mean and standard deviation are computed over a rolling period of 16 days (default).
Entry Condition:
A long entry is triggered when the Z-Score exceeds a threshold of 1.3 (adjustable).
A high positive Z-Score indicates a strong overreaction in the market (panic).
Exit Condition:
The position is closed after 10 periods (days), regardless of market behavior.
Visualizations:
The Z-Score is plotted to make extreme values visible.
Horizontal threshold lines mark entry signals.
Bars with entry signals are highlighted with a blue background.
This strategy is particularly suitable for mean-reverting markets, such as the S&P 500.
Scientific Background
Volatility and Market Behavior:
Studies like Whaley (2000) demonstrate that the VIX, known as the "fear gauge," is highly correlated with market panic phases. A spike in the VIX is often interpreted as an oversold signal due to excessive hedging by investors.
Source: Whaley, R. E. (2000). The investor fear gauge. Journal of Portfolio Management, 26(3), 12-17.
Z-Score in Financial Strategies:
The Z-Score is a proven method for detecting statistical outliers and is widely used in mean-reversion strategies.
Source: Chan, E. (2009). Quantitative Trading. Wiley Finance.
Mean-Reversion Approach:
The strategy builds on the mean-reversion principle, which assumes that extreme market movements tend to revert to the mean over time.
Source: Jegadeesh, N., & Titman, S. (1993). Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency. Journal of Finance, 48(1), 65-91.
Resistance - Support Level PredictionsThis indicator attempts to estimate potential resistance and support levels based on the previous day's closing, high, and low values, and displays them on the chart.
