SMT Divergences [OutOfOptions]Smart Money Technique (SMT) Divergence is designed to identify discrepancies between correlated assets within the same timeframe. It occurs when two related assets exhibit opposing signals, such as one forming a higher low while the other forms a lower low. This technique is particularly useful for anticipating market shifts or reversals before they become evident through other Premium Discount (PD) Arrays.
This indicator works by identifying the highs and lows that have formed for an asset on the current chart and the correlated symbol defined in the settings. Once a pivot on either asset is formed, it checks if the pivot has taken liquidity as identified by the previous pivot in the same direction (i.e., a new high taking out a previous high). If this is the case and the corresponding asset has not taken a similar pivot, the condition is determined to be a potential valid divergence. The indicator will then filter out SMTs formed by adjacent candles, requiring at least one candle difference between the candles forming the SMT.
If the “Candle Direction Validation” setting is enabled, the indicator will further check both assets to ensure that for bullish SMTs, the last high on both assets was formed by down candle, and for bearish SMTs, the low was formed by an up candle. This check can often eliminate low-probability SMTs that are frequently broken.
The referenced chart shows divergence between Nasdaq (NQ) and S&P 500 (ES) futures, which are normally closely correlated assets that move in the same direction. The lines shown represent bullish and bearish divergences between the two when they are formed. As you can see from the chart, SMT Divergences may not always indicate a reversal, or a reversal might be just a short-term retrace. Therefore, SMT Divergences should not be used independently. However, in conjunction with other PD arrays, they can provide strong confirmation of a change in market direction.
Configurability:
Pivot strength - Indicates how many bars to the left/right of a high for pivot to be considered, recommended to keep at 1 for maximum detection speed
Candle Direction Validation - Additional SMT validation to filter out weak/low-probability SMTs be examining candle direction
Line Styling for Bullish/Bearish SMTs - Ability to customize line style, color & width for bullish/bearish SMTs
Label Control - Whether or not to show SMT label and if shown what font size & color should be used
What makes this indicator different:
Unlike other SMT indicators, this indicators has additional built-in controls to remove low-probability SMTs
Buscar en scripts para "ha溢价率"
Liquidity Pools [LuxAlgo]The Liquidity Pools indicator identifies and displays estimated liquidity pools on the chart by analyzing high and low wicked price areas, along with the amount, and frequency of visits to each zone.
🔶 USAGE
Liquidity Pools are areas where smaller participants are likely to place stop-limit orders to manage risks at reasonable swing points. These zones attract institutional traders who use the pending orders as liquidity to enter larger positions, aiming to influence price movements. By monitoring these zones, traders can anticipate market movements and potentially benefit from these dynamics.
Beyond general liquidity theory, identifying zones consistently visited by price aids in using them as support and resistance zones. By analyzing these areas, we can assess how effectively participants enter or exit these zones, helping to gauge their importance.
In the screenshots below, we will explore both sides of the same chart in more detail to display how each zone could be viewed from a bullish and bearish perspective.
Bullish Zones Example:
Bearish Zones Example:
🔶 DETAILS
The method behind this indicator focuses on identifying a swing point and tracking future interactions with it. It adaptively identifies high and low "potential zones". These zones are monitored over time; if a zone meets the user-defined criteria, the script marks and displays these zones on the chart.
🔹 Identification
The method to identify Liquidity Pools in this indicator revolves around 3 main parameters. By utilizing these settings, the indicator can be tailored to produce zones that fit the specific strategic needs of each trader.
Zone Identification Parameters
Zone Contact Amount: This setting determines the number of times each zone must be in contact with the price (and bought or sold out of) before being identified by the indicator as a Liquidity Pool.
For example: When a zone is first displayed, it is considered as having been reached 1 time. When the zone is re-tested for the first time, this is considered the 2nd contact, since the price has seen the zone a total of 2 times.
Bars Required Between Each Contact: This is used to rule out (or in) consecutive candles reaching each zone from the calculation, adding a separation length between zone contact points to refine the zones produced.
For example: When set to "2", the first contact point (first re-test) will be ignored by the script if it is not at least 2 bars away from the initial zone proposal point.
Confirmation Bars: After a zone has reached the desired Contact Amount, this setting will cause the script to wait a specified number of bars before identifying a zone. While this might initially seem counterintuitive, by waiting, we are able to watch the market's reaction to the proposed zone and respond accordingly. If the price were to continue through the potential liquidity zone Immediately, it would not be logical to consider this area as a valid Liquidity Pool.
Displayed in this screenshot, you will see the specific points we are looking for in order to identify these zones.
🔹 Display
After a Liquidity Pool is identified, its boundary line is extended to the current price to keep it in view for reference. This extension will continue until the zone is mitigated (price has closed above or below the zone), after which it will stop extending.
Candles can optionally be colored when returning to the most recent Liquidity Pool if it is still unmitigated, and will only color after the zone is displayed on the chart. Because of this, if a candle is colored within a zone, then its color comes from being inside a previously unmitigated zone.
🔹 Volume
Each time a candle overlaps an Unmitigated Zone, a percentage of its volume will be accumulated to the total for each specific zone. The volume total is displayed on the right end of the extended boundary lines.
This volume data could help to determine the importance of specific zones based on the amount of volume traded within.
Note: This volume is fractional to the percentage of candles that are contained within the zone. If a candle is 50% within a zone, The zone will receive 50% of the candle's volume added to its current total.
🔶 SETTINGS
See above for a more detailed explanation of the "Zone Identification" parameters.
Zone Contact Amount: The number of times the price must bounce from this zone before considering it as a liquidity pool.
Bars Required Between Each Contact: The number of bars to wait before checking for another zone contact.
Confirmation Bars: The number of bars to wait before identifying a zone to confirm validity.
Display Volume Labels: Toggles the display for the volume readout for each Liquidity Pool.
Fill Candles Inside Zones: Toggles the display of colored candles within Liquidity Pools.
HTF LQ SweepThe following script recognises QL sweeps in the desired time frame with alarm function!
Theory:
There is liquidity above highs and below lows. If this is tapped and the market reacts strongly immediately, the probability of a reversal is greatly increased! In the chart, this is defined in such a way that a candle has its wicks BELOW the old low, but the close is ABOVE the old low. the same applies to the high, of course!
In such a case we have an "LQ Sweep"
How does the script work?
Williams 3 fractals are used as a basis. These are meaningful as lows or highs. Whenever a fractal is created, the price level is saved.
This means that not only the last fractal is relevant, but all historical fractals as long as they have not been reached!
If a candle reaches the level, but shows a rejection and closes within the level again, we have our "LQ Sweep" setup.
In the script you can select the timeframe in which the market has to be analysed. When the QL sweep occurs, an alert is triggered. This saves a lot of time because you can analyse different markets in different timeframes at the same time!
Each QL Sweep is marked in the chart when we are in the selected timeframe. These can also be deactivated so that only the last sweep is displayed.
Benefits for the trader:
An LQ sweep is a nice confirmation for a reversal.
If we have such an LQ sweep, we can wait in the lower timeframe for further confirmation, such as a structural break, to position our entries there.
The alarm function saves us a lot of time and we only go to the chart when a potential setup has been created.
You can set different time frames in the script: The selected time frame is then scanned and sends a signal when the event occurs.
Universal Ratio Trend Matrix [InvestorUnknown]The Universal Ratio Trend Matrix is designed for trend analysis on asset/asset ratios, supporting up to 40 different assets. Its primary purpose is to help identify which assets are outperforming others within a selection, providing a broad overview of market trends through a matrix of ratios. The indicator automatically expands the matrix based on the number of assets chosen, simplifying the process of comparing multiple assets in terms of performance.
Key features include the ability to choose from a narrow selection of indicators to perform the ratio trend analysis, allowing users to apply well-defined metrics to their comparison.
Drawback: Due to the computational intensity involved in calculating ratios across many assets, the indicator has a limitation related to loading speed. TradingView has time limits for calculations, and for users on the basic (free) plan, this could result in frequent errors due to exceeded time limits. To use the indicator effectively, users with any paid plans should run it on timeframes higher than 8h (the lowest timeframe on which it managed to load with 40 assets), as lower timeframes may not reliably load.
Indicators:
RSI_raw: Simple function to calculate the Relative Strength Index (RSI) of a source (asset price).
RSI_sma: Calculates RSI followed by a Simple Moving Average (SMA).
RSI_ema: Calculates RSI followed by an Exponential Moving Average (EMA).
CCI: Calculates the Commodity Channel Index (CCI).
Fisher: Implements the Fisher Transform to normalize prices.
Utility Functions:
f_remove_exchange_name: Strips the exchange name from asset tickers (e.g., "INDEX:BTCUSD" to "BTCUSD").
f_remove_exchange_name(simple string name) =>
string parts = str.split(name, ":")
string result = array.size(parts) > 1 ? array.get(parts, 1) : name
result
f_get_price: Retrieves the closing price of a given asset ticker using request.security().
f_constant_src: Checks if the source data is constant by comparing multiple consecutive values.
Inputs:
General settings allow users to select the number of tickers for analysis (used_assets) and choose the trend indicator (RSI, CCI, Fisher, etc.).
Table settings customize how trend scores are displayed in terms of text size, header visibility, highlighting options, and top-performing asset identification.
The script includes inputs for up to 40 assets, allowing the user to select various cryptocurrencies (e.g., BTCUSD, ETHUSD, SOLUSD) or other assets for trend analysis.
Price Arrays:
Price values for each asset are stored in variables (price_a1 to price_a40) initialized as na. These prices are updated only for the number of assets specified by the user (used_assets).
Trend scores for each asset are stored in separate arrays
// declare price variables as "na"
var float price_a1 = na, var float price_a2 = na, var float price_a3 = na, var float price_a4 = na, var float price_a5 = na
var float price_a6 = na, var float price_a7 = na, var float price_a8 = na, var float price_a9 = na, var float price_a10 = na
var float price_a11 = na, var float price_a12 = na, var float price_a13 = na, var float price_a14 = na, var float price_a15 = na
var float price_a16 = na, var float price_a17 = na, var float price_a18 = na, var float price_a19 = na, var float price_a20 = na
var float price_a21 = na, var float price_a22 = na, var float price_a23 = na, var float price_a24 = na, var float price_a25 = na
var float price_a26 = na, var float price_a27 = na, var float price_a28 = na, var float price_a29 = na, var float price_a30 = na
var float price_a31 = na, var float price_a32 = na, var float price_a33 = na, var float price_a34 = na, var float price_a35 = na
var float price_a36 = na, var float price_a37 = na, var float price_a38 = na, var float price_a39 = na, var float price_a40 = na
// create "empty" arrays to store trend scores
var a1_array = array.new_int(40, 0), var a2_array = array.new_int(40, 0), var a3_array = array.new_int(40, 0), var a4_array = array.new_int(40, 0)
var a5_array = array.new_int(40, 0), var a6_array = array.new_int(40, 0), var a7_array = array.new_int(40, 0), var a8_array = array.new_int(40, 0)
var a9_array = array.new_int(40, 0), var a10_array = array.new_int(40, 0), var a11_array = array.new_int(40, 0), var a12_array = array.new_int(40, 0)
var a13_array = array.new_int(40, 0), var a14_array = array.new_int(40, 0), var a15_array = array.new_int(40, 0), var a16_array = array.new_int(40, 0)
var a17_array = array.new_int(40, 0), var a18_array = array.new_int(40, 0), var a19_array = array.new_int(40, 0), var a20_array = array.new_int(40, 0)
var a21_array = array.new_int(40, 0), var a22_array = array.new_int(40, 0), var a23_array = array.new_int(40, 0), var a24_array = array.new_int(40, 0)
var a25_array = array.new_int(40, 0), var a26_array = array.new_int(40, 0), var a27_array = array.new_int(40, 0), var a28_array = array.new_int(40, 0)
var a29_array = array.new_int(40, 0), var a30_array = array.new_int(40, 0), var a31_array = array.new_int(40, 0), var a32_array = array.new_int(40, 0)
var a33_array = array.new_int(40, 0), var a34_array = array.new_int(40, 0), var a35_array = array.new_int(40, 0), var a36_array = array.new_int(40, 0)
var a37_array = array.new_int(40, 0), var a38_array = array.new_int(40, 0), var a39_array = array.new_int(40, 0), var a40_array = array.new_int(40, 0)
f_get_price(simple string ticker) =>
request.security(ticker, "", close)
// Prices for each USED asset
f_get_asset_price(asset_number, ticker) =>
if (used_assets >= asset_number)
f_get_price(ticker)
else
na
// overwrite empty variables with the prices if "used_assets" is greater or equal to the asset number
if barstate.isconfirmed // use barstate.isconfirmed to avoid "na prices" and calculation errors that result in empty cells in the table
price_a1 := f_get_asset_price(1, asset1), price_a2 := f_get_asset_price(2, asset2), price_a3 := f_get_asset_price(3, asset3), price_a4 := f_get_asset_price(4, asset4)
price_a5 := f_get_asset_price(5, asset5), price_a6 := f_get_asset_price(6, asset6), price_a7 := f_get_asset_price(7, asset7), price_a8 := f_get_asset_price(8, asset8)
price_a9 := f_get_asset_price(9, asset9), price_a10 := f_get_asset_price(10, asset10), price_a11 := f_get_asset_price(11, asset11), price_a12 := f_get_asset_price(12, asset12)
price_a13 := f_get_asset_price(13, asset13), price_a14 := f_get_asset_price(14, asset14), price_a15 := f_get_asset_price(15, asset15), price_a16 := f_get_asset_price(16, asset16)
price_a17 := f_get_asset_price(17, asset17), price_a18 := f_get_asset_price(18, asset18), price_a19 := f_get_asset_price(19, asset19), price_a20 := f_get_asset_price(20, asset20)
price_a21 := f_get_asset_price(21, asset21), price_a22 := f_get_asset_price(22, asset22), price_a23 := f_get_asset_price(23, asset23), price_a24 := f_get_asset_price(24, asset24)
price_a25 := f_get_asset_price(25, asset25), price_a26 := f_get_asset_price(26, asset26), price_a27 := f_get_asset_price(27, asset27), price_a28 := f_get_asset_price(28, asset28)
price_a29 := f_get_asset_price(29, asset29), price_a30 := f_get_asset_price(30, asset30), price_a31 := f_get_asset_price(31, asset31), price_a32 := f_get_asset_price(32, asset32)
price_a33 := f_get_asset_price(33, asset33), price_a34 := f_get_asset_price(34, asset34), price_a35 := f_get_asset_price(35, asset35), price_a36 := f_get_asset_price(36, asset36)
price_a37 := f_get_asset_price(37, asset37), price_a38 := f_get_asset_price(38, asset38), price_a39 := f_get_asset_price(39, asset39), price_a40 := f_get_asset_price(40, asset40)
Universal Indicator Calculation (f_calc_score):
This function allows switching between different trend indicators (RSI, CCI, Fisher) for flexibility.
It uses a switch-case structure to calculate the indicator score, where a positive trend is denoted by 1 and a negative trend by 0. Each indicator has its own logic to determine whether the asset is trending up or down.
// use switch to allow "universality" in indicator selection
f_calc_score(source, trend_indicator, int_1, int_2) =>
int score = na
if (not f_constant_src(source)) and source > 0.0 // Skip if you are using the same assets for ratio (for example BTC/BTC)
x = switch trend_indicator
"RSI (Raw)" => RSI_raw(source, int_1)
"RSI (SMA)" => RSI_sma(source, int_1, int_2)
"RSI (EMA)" => RSI_ema(source, int_1, int_2)
"CCI" => CCI(source, int_1)
"Fisher" => Fisher(source, int_1)
y = switch trend_indicator
"RSI (Raw)" => x > 50 ? 1 : 0
"RSI (SMA)" => x > 50 ? 1 : 0
"RSI (EMA)" => x > 50 ? 1 : 0
"CCI" => x > 0 ? 1 : 0
"Fisher" => x > x ? 1 : 0
score := y
else
score := 0
score
Array Setting Function (f_array_set):
This function populates an array with scores calculated for each asset based on a base price (p_base) divided by the prices of the individual assets.
It processes multiple assets (up to 40), calling the f_calc_score function for each.
// function to set values into the arrays
f_array_set(a_array, p_base) =>
array.set(a_array, 0, f_calc_score(p_base / price_a1, trend_indicator, int_1, int_2))
array.set(a_array, 1, f_calc_score(p_base / price_a2, trend_indicator, int_1, int_2))
array.set(a_array, 2, f_calc_score(p_base / price_a3, trend_indicator, int_1, int_2))
array.set(a_array, 3, f_calc_score(p_base / price_a4, trend_indicator, int_1, int_2))
array.set(a_array, 4, f_calc_score(p_base / price_a5, trend_indicator, int_1, int_2))
array.set(a_array, 5, f_calc_score(p_base / price_a6, trend_indicator, int_1, int_2))
array.set(a_array, 6, f_calc_score(p_base / price_a7, trend_indicator, int_1, int_2))
array.set(a_array, 7, f_calc_score(p_base / price_a8, trend_indicator, int_1, int_2))
array.set(a_array, 8, f_calc_score(p_base / price_a9, trend_indicator, int_1, int_2))
array.set(a_array, 9, f_calc_score(p_base / price_a10, trend_indicator, int_1, int_2))
array.set(a_array, 10, f_calc_score(p_base / price_a11, trend_indicator, int_1, int_2))
array.set(a_array, 11, f_calc_score(p_base / price_a12, trend_indicator, int_1, int_2))
array.set(a_array, 12, f_calc_score(p_base / price_a13, trend_indicator, int_1, int_2))
array.set(a_array, 13, f_calc_score(p_base / price_a14, trend_indicator, int_1, int_2))
array.set(a_array, 14, f_calc_score(p_base / price_a15, trend_indicator, int_1, int_2))
array.set(a_array, 15, f_calc_score(p_base / price_a16, trend_indicator, int_1, int_2))
array.set(a_array, 16, f_calc_score(p_base / price_a17, trend_indicator, int_1, int_2))
array.set(a_array, 17, f_calc_score(p_base / price_a18, trend_indicator, int_1, int_2))
array.set(a_array, 18, f_calc_score(p_base / price_a19, trend_indicator, int_1, int_2))
array.set(a_array, 19, f_calc_score(p_base / price_a20, trend_indicator, int_1, int_2))
array.set(a_array, 20, f_calc_score(p_base / price_a21, trend_indicator, int_1, int_2))
array.set(a_array, 21, f_calc_score(p_base / price_a22, trend_indicator, int_1, int_2))
array.set(a_array, 22, f_calc_score(p_base / price_a23, trend_indicator, int_1, int_2))
array.set(a_array, 23, f_calc_score(p_base / price_a24, trend_indicator, int_1, int_2))
array.set(a_array, 24, f_calc_score(p_base / price_a25, trend_indicator, int_1, int_2))
array.set(a_array, 25, f_calc_score(p_base / price_a26, trend_indicator, int_1, int_2))
array.set(a_array, 26, f_calc_score(p_base / price_a27, trend_indicator, int_1, int_2))
array.set(a_array, 27, f_calc_score(p_base / price_a28, trend_indicator, int_1, int_2))
array.set(a_array, 28, f_calc_score(p_base / price_a29, trend_indicator, int_1, int_2))
array.set(a_array, 29, f_calc_score(p_base / price_a30, trend_indicator, int_1, int_2))
array.set(a_array, 30, f_calc_score(p_base / price_a31, trend_indicator, int_1, int_2))
array.set(a_array, 31, f_calc_score(p_base / price_a32, trend_indicator, int_1, int_2))
array.set(a_array, 32, f_calc_score(p_base / price_a33, trend_indicator, int_1, int_2))
array.set(a_array, 33, f_calc_score(p_base / price_a34, trend_indicator, int_1, int_2))
array.set(a_array, 34, f_calc_score(p_base / price_a35, trend_indicator, int_1, int_2))
array.set(a_array, 35, f_calc_score(p_base / price_a36, trend_indicator, int_1, int_2))
array.set(a_array, 36, f_calc_score(p_base / price_a37, trend_indicator, int_1, int_2))
array.set(a_array, 37, f_calc_score(p_base / price_a38, trend_indicator, int_1, int_2))
array.set(a_array, 38, f_calc_score(p_base / price_a39, trend_indicator, int_1, int_2))
array.set(a_array, 39, f_calc_score(p_base / price_a40, trend_indicator, int_1, int_2))
a_array
Conditional Array Setting (f_arrayset):
This function checks if the number of used assets is greater than or equal to a specified number before populating the arrays.
// only set values into arrays for USED assets
f_arrayset(asset_number, a_array, p_base) =>
if (used_assets >= asset_number)
f_array_set(a_array, p_base)
else
na
Main Logic
The main logic initializes arrays to store scores for each asset. Each array corresponds to one asset's performance score.
Setting Trend Values: The code calls f_arrayset for each asset, populating the respective arrays with calculated scores based on the asset prices.
Combining Arrays: A combined_array is created to hold all the scores from individual asset arrays. This array facilitates further analysis, allowing for an overview of the performance scores of all assets at once.
// create a combined array (work-around since pinescript doesn't support having array of arrays)
var combined_array = array.new_int(40 * 40, 0)
if barstate.islast
for i = 0 to 39
array.set(combined_array, i, array.get(a1_array, i))
array.set(combined_array, i + (40 * 1), array.get(a2_array, i))
array.set(combined_array, i + (40 * 2), array.get(a3_array, i))
array.set(combined_array, i + (40 * 3), array.get(a4_array, i))
array.set(combined_array, i + (40 * 4), array.get(a5_array, i))
array.set(combined_array, i + (40 * 5), array.get(a6_array, i))
array.set(combined_array, i + (40 * 6), array.get(a7_array, i))
array.set(combined_array, i + (40 * 7), array.get(a8_array, i))
array.set(combined_array, i + (40 * 8), array.get(a9_array, i))
array.set(combined_array, i + (40 * 9), array.get(a10_array, i))
array.set(combined_array, i + (40 * 10), array.get(a11_array, i))
array.set(combined_array, i + (40 * 11), array.get(a12_array, i))
array.set(combined_array, i + (40 * 12), array.get(a13_array, i))
array.set(combined_array, i + (40 * 13), array.get(a14_array, i))
array.set(combined_array, i + (40 * 14), array.get(a15_array, i))
array.set(combined_array, i + (40 * 15), array.get(a16_array, i))
array.set(combined_array, i + (40 * 16), array.get(a17_array, i))
array.set(combined_array, i + (40 * 17), array.get(a18_array, i))
array.set(combined_array, i + (40 * 18), array.get(a19_array, i))
array.set(combined_array, i + (40 * 19), array.get(a20_array, i))
array.set(combined_array, i + (40 * 20), array.get(a21_array, i))
array.set(combined_array, i + (40 * 21), array.get(a22_array, i))
array.set(combined_array, i + (40 * 22), array.get(a23_array, i))
array.set(combined_array, i + (40 * 23), array.get(a24_array, i))
array.set(combined_array, i + (40 * 24), array.get(a25_array, i))
array.set(combined_array, i + (40 * 25), array.get(a26_array, i))
array.set(combined_array, i + (40 * 26), array.get(a27_array, i))
array.set(combined_array, i + (40 * 27), array.get(a28_array, i))
array.set(combined_array, i + (40 * 28), array.get(a29_array, i))
array.set(combined_array, i + (40 * 29), array.get(a30_array, i))
array.set(combined_array, i + (40 * 30), array.get(a31_array, i))
array.set(combined_array, i + (40 * 31), array.get(a32_array, i))
array.set(combined_array, i + (40 * 32), array.get(a33_array, i))
array.set(combined_array, i + (40 * 33), array.get(a34_array, i))
array.set(combined_array, i + (40 * 34), array.get(a35_array, i))
array.set(combined_array, i + (40 * 35), array.get(a36_array, i))
array.set(combined_array, i + (40 * 36), array.get(a37_array, i))
array.set(combined_array, i + (40 * 37), array.get(a38_array, i))
array.set(combined_array, i + (40 * 38), array.get(a39_array, i))
array.set(combined_array, i + (40 * 39), array.get(a40_array, i))
Calculating Sums: A separate array_sums is created to store the total score for each asset by summing the values of their respective score arrays. This allows for easy comparison of overall performance.
Ranking Assets: The final part of the code ranks the assets based on their total scores stored in array_sums. It assigns a rank to each asset, where the asset with the highest score receives the highest rank.
// create array for asset RANK based on array.sum
var ranks = array.new_int(used_assets, 0)
// for loop that calculates the rank of each asset
if barstate.islast
for i = 0 to (used_assets - 1)
int rank = 1
for x = 0 to (used_assets - 1)
if i != x
if array.get(array_sums, i) < array.get(array_sums, x)
rank := rank + 1
array.set(ranks, i, rank)
Dynamic Table Creation
Initialization: The table is initialized with a base structure that includes headers for asset names, scores, and ranks. The headers are set to remain constant, ensuring clarity for users as they interpret the displayed data.
Data Population: As scores are calculated for each asset, the corresponding values are dynamically inserted into the table. This is achieved through a loop that iterates over the scores and ranks stored in the combined_array and array_sums, respectively.
Automatic Extending Mechanism
Variable Asset Count: The code checks the number of assets defined by the user. Instead of hardcoding the number of rows in the table, it uses a variable to determine the extent of the data that needs to be displayed. This allows the table to expand or contract based on the number of assets being analyzed.
Dynamic Row Generation: Within the loop that populates the table, the code appends new rows for each asset based on the current asset count. The structure of each row includes the asset name, its score, and its rank, ensuring that the table remains consistent regardless of how many assets are involved.
// Automatically extending table based on the number of used assets
var table table = table.new(position.bottom_center, 50, 50, color.new(color.black, 100), color.white, 3, color.white, 1)
if barstate.islast
if not hide_head
table.cell(table, 0, 0, "Universal Ratio Trend Matrix", text_color = color.white, bgcolor = #010c3b, text_size = fontSize)
table.merge_cells(table, 0, 0, used_assets + 3, 0)
if not hide_inps
table.cell(table, 0, 1,
text = "Inputs: You are using " + str.tostring(trend_indicator) + ", which takes: " + str.tostring(f_get_input(trend_indicator)),
text_color = color.white, text_size = fontSize), table.merge_cells(table, 0, 1, used_assets + 3, 1)
table.cell(table, 0, 2, "Assets", text_color = color.white, text_size = fontSize, bgcolor = #010c3b)
for x = 0 to (used_assets - 1)
table.cell(table, x + 1, 2, text = str.tostring(array.get(assets, x)), text_color = color.white, bgcolor = #010c3b, text_size = fontSize)
table.cell(table, 0, x + 3, text = str.tostring(array.get(assets, x)), text_color = color.white, bgcolor = f_asset_col(array.get(ranks, x)), text_size = fontSize)
for r = 0 to (used_assets - 1)
for c = 0 to (used_assets - 1)
table.cell(table, c + 1, r + 3, text = str.tostring(array.get(combined_array, c + (r * 40))),
text_color = hl_type == "Text" ? f_get_col(array.get(combined_array, c + (r * 40))) : color.white, text_size = fontSize,
bgcolor = hl_type == "Background" ? f_get_col(array.get(combined_array, c + (r * 40))) : na)
for x = 0 to (used_assets - 1)
table.cell(table, x + 1, x + 3, "", bgcolor = #010c3b)
table.cell(table, used_assets + 1, 2, "", bgcolor = #010c3b)
for x = 0 to (used_assets - 1)
table.cell(table, used_assets + 1, x + 3, "==>", text_color = color.white)
table.cell(table, used_assets + 2, 2, "SUM", text_color = color.white, text_size = fontSize, bgcolor = #010c3b)
table.cell(table, used_assets + 3, 2, "RANK", text_color = color.white, text_size = fontSize, bgcolor = #010c3b)
for x = 0 to (used_assets - 1)
table.cell(table, used_assets + 2, x + 3,
text = str.tostring(array.get(array_sums, x)),
text_color = color.white, text_size = fontSize,
bgcolor = f_highlight_sum(array.get(array_sums, x), array.get(ranks, x)))
table.cell(table, used_assets + 3, x + 3,
text = str.tostring(array.get(ranks, x)),
text_color = color.white, text_size = fontSize,
bgcolor = f_highlight_rank(array.get(ranks, x)))
Multiple ATR Lines with Current Price PercentageThis indicator plots multiple lines based on the Average True Range (ATR) on the chart, helping traders identify potential support and resistance levels. Specifically, it draws three lines above the price and three lines below the price at different multiples of the ATR. Additionally, it plots a dynamic line at the current price level, which shows how much percentage of the ATR the current price has traveled from a specific point.
How it works:
ATR-Based Lines: The indicator calculates three upper and three lower levels based on the ATR of the selected period. These levels represent 1x, 2x, and 3x ATR above and below the current price.
Current Price Line: A dotted line follows the current price, displaying the percentage of the ATR that the price has moved.
Labels: Each line is labeled with its respective ATR multiple (1x ATR, 2x ATR, 3x ATR), and the current price line shows the percentage of the ATR traveled.
Use Cases:
Identifying Market Volatility: Traders can use this indicator to see how far the price has moved relative to its average volatility.
Support and Resistance Levels: The ATR lines can be treated as potential support and resistance zones, providing insight into price targets or stop-loss placement.
Dynamic Tracking: The percentage of ATR traveled helps traders understand the market momentum relative to its historical volatility.
Settings:
ATR Length: The user can adjust the length of the ATR calculation period.
ATR Multiplier: A multiplier to adjust the distance of the lines relative to the ATR.
Advantages:
Clear visualization of market volatility through ATR-based levels.
Real-time tracking of the price’s movement relative to ATR, giving traders a better understanding of price action.
Customizable settings for different trading styles.
Autotable█ OVERVIEW
The library allows to automatically draw a table based on a string or float matrix (or both) controlling all of the parameters of the table (including merging cells) with parameter matrices (like, e.g. matrix of cell colors).
All things you would normally do with table.new() and table.cell() are now possible using respective parameters of library's main function, autotable() (as explained further below).
Headers can be supplied as arrays.
Merging of the cells is controlled with a special matrix of "L" and "U" values which instruct a cell to merged with the cell to the left or upwards (please see examples in the script and in this description).
█ USAGE EXAMPLES
The simplest and most straightforward:
mxF = matrix.new(3,3, 3.14)
mxF.autotable(bgcolor = color.rgb(249, 209, 29)) // displays float matrix as a table in the top right corner with defalult settings
mxS = matrix.new(3,3,"PI")
// displays string matrix as a table in the top right corner with defalult settings
mxS.autotable(Ypos = "bottom", Xpos = "right", bgcolor = #b4d400)
// displays matrix displaying a string value over a float value in each cell
mxS.autotable(mxF, Ypos = "middle", Xpos = "center", bgcolor = color.gray, text_color = #86f62a)
Draws this:
Tables with headers:
if barstate.islast
mxF = matrix.new(3,3, 3.14)
mxS = matrix.new(3,3,"PI")
arColHeaders = array.from("Col1", "Col2", "Col3")
arRowHeaders = array.from("Row1", "Row2", "Row3")
// float matrix with col headers
mxF.autotable(
bgcolor = #fdfd6b
, arColHeaders = arColHeaders
)
// string matrix with row headers
mxS.autotable(arRowHeaders = arRowHeaders, Ypos = "bottom", Xpos = "right", bgcolor = #b4d400)
// string/float matrix with both row and column headers
mxS.autotable(mxF
, Ypos = "middle", Xpos = "center"
, arRowHeaders = arRowHeaders
, arColHeaders = arColHeaders
, cornerBgClr = #707070, cornerTitle = "Corner\ncell", cornerTxtClr = #ffdc13
, bgcolor = color.gray, text_color = #86f62a
)
Draws this:
█ FUNCTIONS
One main function is autotable() which has only one required argument mxValS, a string matrix.
Please see below the description of all of the function parameters:
The table:
tbl (table) (Optional) If supplied, this table will be deleted.
The data:
mxValS (matrix ) (Required) Cell text values
mxValF (matrix) (Optional) Numerical part of cell text values. Is concatenated to the mxValS values via `string_float_separator` string (default "\n")
Table properties, have same effect as in table.new() :
defaultBgColor (color) (Optional) bgcolor to be used if mxBgColor is not supplied
Ypos (string) (Optional) "top", "bottom" or "center"
Xpos (string) (Optional) "left", "right", or "center"
frame_color (color) (Optional) frame_color like in table.new()
frame_width (int) (Optional) frame_width like in table.new()
border_color (color) (Optional) border_color like in table.new()
border_width (int) (Optional) border_width like in table.new()
force_overlay (simple bool) (Optional) If true draws table on main pane.
Cell parameters, have same effect as in table.cell() ):
mxBgColor (matrix) (Optional) like bgcolor argument in table.cell()
mxTextColor (matrix) (Optional) like text_color argument in table.cell()
mxTt (matrix) (Optional) like tooltip argument in table.cell()
mxWidth (matrix) (Optional) like width argument in table.cell()
mxHeight (matrix) (Optional) like height argument in table.cell()
mxHalign (matrix) (Optional) like text_halign argument in table.cell()
mxValign (matrix) (Optional) like text_valign argument in table.cell()
mxTextSize (matrix) (Optional) like text_size argument in table.cell()
mxFontFamily (matrix) (Optional) like text_font_family argument in table.cell()
Other table properties:
tableWidth (float) (Optional) Overrides table width if cell widths are non zero. E.g. if there are four columns and cell widths are 20 (either as set via cellW or via mxWidth) then if tableWidth is set to e.g. 50 then cell widths will be 50 * (20 / 80), where 80 is 20*4 = total width of all cells. Works simialar for widths set via mxWidth - determines max sum of widths across all cloumns of mxWidth and adjusts cell widths proportionally to it. If cell widths are 0 (i.e. auto-adjust) tableWidth has no effect.
tableHeight (float) (Optional) Overrides table height if cell heights are non zero. E.g. if there are four rows and cell heights are 20 (either as set via cellH or via mxHeight) then if tableHeigh is set to e.g. 50 then cell heights will be 50 * (20 / 80), where 80 is 20*4 = total height of all cells. Works simialar for heights set via mxHeight - determines max sum of heights across all cloumns of mxHeight and adjusts cell heights proportionally to it. If cell heights are 0 (i.e. auto-adjust) tableHeight has no effect.
defaultTxtColor (color) (Optional) text_color to be used if mxTextColor is not supplied
text_size (string) (Optional) text_size to be used if mxTextSize is not supplied
font_family (string) (Optional) cell text_font_family value to be used if a value in mxFontFamily is no supplied
cellW (float) (Optional) cell width to be used if a value in mxWidth is no supplied
cellH (float) (Optional) cell height to be used if a value in mxHeight is no supplied
halign (string) (Optional) cell text_halign value to be used if a value in mxHalign is no supplied
valign (string) (Optional) cell text_valign value to be used if a value in mxValign is no supplied
Headers parameters:
arColTitles (array) (Optional) Array of column titles. If not na a header row is added.
arRowTitles (array) (Optional) Array of row titles. If not na a header column is added.
cornerTitle (string) (Optional) If both row and column titles are supplied allows to set the value of the corner cell.
colTitlesBgColor (color) (Optional) bgcolor for header row
colTitlesTxtColor (color) (Optional) text_color for header row
rowTitlesBgColor (color) (Optional) bgcolor for header column
rowTitlesTxtColor (color) (Optional) text_color for header column
cornerBgClr (color) (Optional) bgcolor for the corner cell
cornerTxtClr (color) (Optional) text_color for the corner cell
Cell merge parameters:
mxMerge (matrix) (Optional) A matrix determining how cells will be merged. "L" - cell merges to the left, "U" - upwards.
mergeAllColTitles (bool) (Optional) Allows to print a table title instead of column headers, merging all header row cells and leaving just the value of the first cell. For more flexible options use matrix arguments leaving header/row arguments na.
mergeAllRowTitles (bool) (Optional) Allows to print one text value merging all header row cells and leaving just the value of the first cell. For more flexible options use matrix arguments leaving header/row arguments na.
Format:
string_float_separator (string) (Optional) A string used to separate string and float parts of cell values (mxValS and mxValF). Default is "\n"
format (string) (Optional) format string like in str.format() used to format numerical values
nz (string) (Optional) Determines how na numerical values are displayed.
The only other available function is autotable(string,... ) with a string parameter instead of string and float matrices which draws a one cell table.
█ SAMPLE USE
E.g., CSVParser library demo uses Autotable's for generating complex tables with merged cells.
█ CREDITS
The library was inspired by @kaigouthro's matrixautotable . A true master. Many thanks to him for his creative, beautiful and very helpful libraries.
Support and Resistance HeatmapThe "Support and Resistance Heatmap" indicator is designed to identify key support and resistance levels in the price action by using pivots and ATR (Average True Range) to define the sensitivity of zone detection. The zones are plotted as horizontal lines on the chart, representing areas where the price has shown significant interaction. The indicator features a customizable heatmap to visualize the intensity of these zones, making it a powerful tool for technical analysis.
Features:
Dynamic Support and Resistance Zones:
Identifies potential support and resistance areas based on price pivots.
Zones are defined by ATR-based thresholds, making them adaptive to market volatility.
Customization Options:
Heatmap Visualization: Toggle the heatmap on/off to view the strength of each zone.
Sensitivity Control: Modify the zone sensitivity with the ATR Multiplier to increase or decrease zone detection precision.
Confirmations: Set how many touches a level needs before it is confirmed as a zone.
Extended Zone Visualization:
Option to extend the zones for better long-term visibility.
Ability to limit the number of zones displayed to avoid clutter on the chart.
Color-Coded Zones:
Color-coded zones help differentiate between bullish (support) and bearish (resistance) levels, providing visual clarity for traders.
Heatmap Integration:
Gradient-based color changes on levels show the intensity of touches, helping traders understand which zones are more reliable.
Inputs and Settings:
1. Settings Group:
Length:
Determines the number of bars used for the pivot lookback. This directly affects how frequently new zones are formed.
Sensitivity:
Controls the sensitivity of the zone calculation using ATR (Average True Range). A higher value will result in fewer, larger zones, while a lower value increases the number of detected zones.
Confirmations:
Sets the number of price touches needed before a level is confirmed as a support/resistance zone. Lower values will result in more zones.
2. Visual Group:
Extend Zones:
Option to extend the support and resistance lines across the chart for better visibility over time.
Max Zones to Display (maxZonesToShow):
Limits the maximum number of zones shown on the chart to avoid clutter.
3. Heatmap Group:
Show Heatmap:
Toggle the heatmap display on/off. When enabled, the script visualizes the strength of the zones using color intensity.
Core Logic:
Pivot Calculation:
The script identifies support and resistance zones by using the pivotHigh and pivotLow functions. These pivots are calculated using a lookback period, which defines the number of candles to the left and right of the pivot point.
ATR-Based Threshold:
ATR (Average True Range) is used to create dynamic zones based on volatility. The ATR acts as a buffer around the identified pivot points, creating zones that are more flexible and adaptable to market conditions.
Merging Zones:
If two zones are close to each other (within a certain threshold), they are merged into a single zone. This reduces overlapping zones and gives a cleaner visual representation of significant price levels.
Confirmation Mechanism:
Each time the price touches a zone, the confirmation counter for that zone increases. The more confirmations a zone has, the more reliable it is. Zones are only displayed if they meet the required number of confirmations as specified by the user.
Color Gradient:
Zones are color-coded based on the number of confirmations. A gradient is used to visually represent the strength of each zone, with stronger zones being more vividly colored.
Heatmap Visualization:
When the heatmap is enabled, the color intensity of the zones is adjusted based on the proximity of the price to the zone and the number of touches the zone has received. This helps traders quickly identify which zones are more critical.
How to Use:
Identifying Support and Resistance Zones:
After adding the indicator to your chart, you will see horizontal lines representing key support (bullish) and resistance (bearish) levels. These zones are dynamically updated based on price action and pivots.
Adjusting Zone Sensitivity:
Use the "ATR Multiplier" to fine-tune how sensitive the indicator is to price fluctuations. A higher multiplier will reduce the number of zones, focusing on more significant levels.
Using Confirmations:
The more times a price interacts with a zone, the stronger that zone becomes. Use the "Confirmations" input to filter out weaker zones. This ensures that only zones with enough interaction (touches) are plotted.
Activating the Heatmap:
Enabling the heatmap will provide a color-coded visual representation of the strength of the zones. Zones with more price interactions will appear more vividly, helping you focus on the most significant areas.
Best Practices:
Combine with Other Indicators:
This support and resistance indicator works well when combined with other technical analysis tools, such as oscillators (e.g., RSI, MACD) or moving averages, for better trade confirmations.
Adjust Sensitivity Based on Market Conditions:
In volatile markets, you may want to increase the ATR multiplier to focus on more significant support and resistance zones. In calmer markets, decreasing the multiplier can help you spot smaller, but relevant, levels.
Use in Different Time Frames:
This indicator can be used effectively across different time frames, from intraday charts (e.g., 1-minute or 5-minute charts) to longer-term analysis on daily or weekly charts.
Look for Confluences:
Zones that overlap with other indicators, such as Fibonacci retracements or key moving averages, tend to be more reliable. Use the zones in conjunction with other forms of analysis to increase your confidence in trade setups.
Limitations and Considerations:
False Breakouts:
In highly volatile markets, there may be false breakouts where the price briefly moves through a zone without a sustained trend. Consider combining this indicator with momentum-based tools to avoid false signals.
Sensitivity to ATR Settings:
The ATR multiplier is a key component of this indicator. Adjusting it too high or too low may result in too few or too many zones, respectively. It is important to fine-tune this setting based on your specific trading style and market conditions.
RSI 30-50-70 moving averageDescription:
The RSI 30-50-70 Moving Average indicator plots three distinct moving averages based on different RSI ranges (30%, 50%, and 70%). Each moving average corresponds to different market conditions and provides potential entry and exit signals. Here's how it works:
• RSI_30 Range (25%-35%): The moving average of closing prices when the RSI is between 25% and 35%, representing potential oversold conditions.
• RSI_50 Range (45%-55%): The moving average of closing prices when the RSI is between 45% and 55%, providing a balanced perspective for trend-following strategies.
• RSI_70 Range (65%-75%): The moving average of closing prices when the RSI is between 65% and 75%, representing potential overbought conditions.
This indicator offers flexibility, as users can adjust key parameters such as RSI ranges, periods, and time frames to fine-tune the signals for their trading strategies.
How it Works:
Like traditional moving averages, the RSI 30-50-70 Moving Averages can highlight dynamic levels of support and resistance. They offer additional insight by focusing on specific RSI ranges, providing early signals for trend reversals or continuation. The default settings can be used across various assets but should be optimized via backtesting.
Default Settings:
• RSI_30: 25% to 35% (Oversold Zone, yellow line)
• RSI_50: 45% to 55% (Neutral/Trend Zone, green line)
• RSI_70: 65% to 75% (Overbought Zone, red line)
• RSI Period: 14
Buy Conditions:
• Use the 5- or 15-minute time frame.
• Wait for the price to move below the RSI_30 line, indicating potential oversold conditions.
• Enter a buy order when the price closes above the RSI_30 line, signaling a recovery from the oversold zone.
• For a more conservative approach, use the RSI_50 line as the buy signal to confirm a trend reversal.
• Important: Before entering, ensure that the RSI_30 moving average has flattened or started to level off, signaling that the oversold momentum has slowed.
Sell Conditions:
• Use the 5- or 15-minute time frame.
• Wait for the price to close above the RSI_70 line, indicating potential overbought conditions.
• Enter a sell order when the price closes below the RSI_70 line, signaling a decline from the overbought zone.
• Important: Similar to buying, wait for the RSI_70 moving average to flatten or level off before selling, indicating the overbought conditions are stalling.
Key Features:
1. Dynamic Range Customization: The indicator allows users to modify the RSI ranges and periods, tailoring the moving averages to fit different market conditions or asset classes.
2. Trend-Following and Reversal Signals: The RSI 30-50-70 moving averages provide both reversal and trend-following signals, making it a versatile tool for short-term traders.
3. Visual Representation of Market Strength: By plotting moving averages based on RSI levels, traders can visually interpret the market’s strength and potential turning points.
4. Risk Management: The built-in flexibility allows traders to choose lower-risk entries by adjusting which RSI level (e.g., RSI_30 vs. RSI_50) they rely on for signals.
Practical Use:
Different assets respond uniquely to RSI-based moving averages, so it's recommended to backtest and adjust ranges for specific instruments. For example, volatile assets may require wider RSI ranges, while more stable assets could benefit from tighter ranges.
Checking for Buy conditions:
1st: Wait for current price to go below the RSI_30 (yellow line)
2nd: Wait and observe for bullish divergence
3rd: RSI_30 has flattened indicating potential gain of momentum after a bullish divergence.
4th: Enter a buy order when the price closed above the RSI_30, preferably when a green candle appeared.
Bitcoin Cycle Master [InvestorUnknown]The "Bitcoin Cycle Master" indicator is designed for in-depth, long-term analysis of Bitcoin's price cycles, using several key metrics to track market behavior and forecast potential price tops and bottoms. The indicator integrates multiple moving averages and on-chain metrics, offering a comprehensive view of Bitcoin’s historical and projected performance. Each of its components plays a crucial role in identifying critical cycle points:
Top Cap: This is a multiple of the Average Cap, which is calculated as the cumulative sum of Bitcoin’s price (price has a longer history than Market Cap) divided by its age in days. Top Cap serves as an upper boundary for speculative price peaks, multiplied by a factor of 35.
Time_dif() =>
date = ta.valuewhen(bar_index == 0, time, 0)
sec_r = math.floor(date / 1000)
min_r = math.floor(sec_r / 60)
h_r = math.floor(min_r / 60)
d_r = math.floor(h_r / 24)
// Launch of BTC
start = timestamp(2009, 1, 3, 00, 00)
sec_rb = math.floor(start / 1000)
min_rb = math.floor(sec_rb / 60)
h_rb = math.floor(min_rb / 60)
d_rb = math.floor(h_rb / 24)
difference = d_r - d_rb
AverageCap() =>
ta.cum(btc_price) / (Time_dif() + btc_age)
TopCap() =>
// To calculate Top Cap, it is first necessary to calculate Average Cap, which is the cumulative sum of Market Cap divided by the age of the market in days.
// This creates a constant time-based moving average of market cap.
// Once Average cap is calculated, those values are multiplied by 35. The result is Top Cap.
// For AverageCap the BTC price was used instead of the MC because it has more history
// (the result should have minimal if any deviation since MC would have to be divided by Supply)
AverageCap() * 35
Delta Top: Defined as the difference between the Realized Cap and the Average Cap, this metric is further multiplied by a factor of 7. Delta Top provides a historically reliable signal for Bitcoin market cycle tops.
DeltaTop() =>
// Delta Cap = Realized Cap - Average Cap
// Average Cap is explained in the Top Cap section above.
// Once Delta Cap is calculated, its values over time are then multiplied by 7. The result is Delta Top.
(RealizedPrice() - AverageCap()) * 7
Terminal Price: Derived from Coin Days Destroyed, Terminal Price normalizes Bitcoin’s historical price behavior by its finite supply (21 million bitcoins), offering an adjusted price forecast as all bitcoins approach being mined. The original formula for Terminal Price didn’t produce expected results, hence the calculation was adjusted slightly.
CVDD() =>
// CVDD stands for Cumulative Value Coin Days Destroyed.
// Coin Days Destroyed is a term used for bitcoin to identify a value of sorts to UTXO’s (unspent transaction outputs). They can be thought of as coins moving between wallets.
(MCR - TV) / 21000000
TerminalPrice() =>
// Theory:
// Before Terminal price is calculated, it is first necessary to calculate Transferred Price.
// Transferred price takes the sum of > Coin Days Destroyed and divides it by the existing supply of bitcoin and the time it has been in circulation.
// The value of Transferred Price is then multiplied by 21. Remember that there can only ever be 21 million bitcoin mined.
// This creates a 'terminal' value as the supply is all mined, a kind of reverse supply adjustment.
// Instead of heavily weighting later behavior, it normalizes historical behavior to today. By normalizing by 21, a terminal value is created
// Unfortunately the theoretical calculation didn't produce results it should, in pinescript.
// Therefore the calculation was slightly adjusted/improvised
TransferredPrice = CVDD() / (Supply * math.log(btc_age))
tp = TransferredPrice * 210000000 * 3
Realized Price: Calculated as the Market Cap Realized divided by the current supply of Bitcoin, this metric shows the average value of Bitcoin based on the price at which coins last moved, giving a market consensus price for long-term holders.
CVDD (Cumulative Value Coin Days Destroyed): This on-chain metric analyzes Bitcoin’s UTXOs (unspent transaction outputs) and the velocity of coins moving between wallets. It highlights key market dynamics during prolonged accumulation or distribution phases.
Balanced Price: The Balanced Price is the difference between the Realized Price and the Terminal Price, adjusted by Bitcoin's supply constraints. This metric provides a useful signal for identifying oversold market conditions during bear markets.
BalancedPrice() =>
// It is calculated by subtracting Transferred Price from Realized Price
RealizedPrice() - (TerminalPrice() / (21 * 3))
Each component can be toggled individually, allowing users to focus on specific aspects of Bitcoin’s price cycle and derive meaningful insights from its long-term behavior. The combination of these models provides a well-rounded view of both speculative peaks and long-term value trends.
Important consideration:
Top Cap did historically provide reliable signals for cycle peaks, however it may not be a relevant indication of peaks in the future.
Mean Reversion Cloud (Ornstein-Uhlenbeck) // AlgoFyreThe Mean Reversion Cloud (Ornstein-Uhlenbeck) indicator detects mean-reversion opportunities by applying the Ornstein-Uhlenbeck process. It calculates a dynamic mean using an Exponential Weighted Moving Average, surrounded by volatility bands, signaling potential buy/sell points when prices deviate.
TABLE OF CONTENTS
🔶 ORIGINALITY
🔸Adaptive Mean Calculation
🔸Volatility-Based Cloud
🔸Speed of Reversion (θ)
🔶 FUNCTIONALITY
🔸Dynamic Mean and Volatility Bands
🞘 How it works
🞘 How to calculate
🞘 Code extract
🔸Visualization via Table and Plotshapes
🞘 Table Overview
🞘 Plotshapes Explanation
🞘 Code extract
🔶 INSTRUCTIONS
🔸Step-by-Step Guidelines
🞘 Setting Up the Indicator
🞘 Understanding What to Look For on the Chart
🞘 Possible Entry Signals
🞘 Possible Take Profit Strategies
🞘 Possible Stop-Loss Levels
🞘 Additional Tips
🔸Customize settings
🔶 CONCLUSION
▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅
🔶 ORIGINALITY The Mean Reversion Cloud (Ornstein-Uhlenbeck) is a unique indicator that applies the Ornstein-Uhlenbeck stochastic process to identify mean-reverting behavior in asset prices. Unlike traditional moving average-based indicators, this model uses an Exponentially Weighted Moving Average (EWMA) to calculate the long-term mean, dynamically adjusting to recent price movements while still considering all historical data. It also incorporates volatility bands, providing a "cloud" that visually highlights overbought or oversold conditions. By calculating the speed of mean reversion (θ) through the autocorrelation of log returns, this indicator offers traders a more nuanced and mathematically robust tool for identifying mean-reversion opportunities. These innovations make it especially useful for markets that exhibit range-bound characteristics, offering timely buy and sell signals based on statistical deviations from the mean.
🔸Adaptive Mean Calculation Traditional MA indicators use fixed lengths, which can lead to lagging signals or over-sensitivity in volatile markets. The Mean Reversion Cloud uses an Exponentially Weighted Moving Average (EWMA), which adapts to price movements by dynamically adjusting its calculation, offering a more responsive mean.
🔸Volatility-Based Cloud Unlike simple moving averages that only plot a single line, the Mean Reversion Cloud surrounds the dynamic mean with volatility bands. These bands, based on standard deviations, provide traders with a visual cue of when prices are statistically likely to revert, highlighting potential reversal zones.
🔸Speed of Reversion (θ) The indicator goes beyond price averages by calculating the speed at which the price reverts to the mean (θ), using the autocorrelation of log returns. This gives traders an additional tool for estimating the likelihood and timing of mean reversion, making the signals more reliable in practice.
🔶 FUNCTIONALITY The Mean Reversion Cloud (Ornstein-Uhlenbeck) indicator is designed to detect potential mean-reversion opportunities in asset prices by applying the Ornstein-Uhlenbeck stochastic process. It calculates a dynamic mean through the Exponentially Weighted Moving Average (EWMA) and plots volatility bands based on the standard deviation of the asset's price over a specified period. These bands create a "cloud" that represents expected price fluctuations, helping traders to identify overbought or oversold conditions. By calculating the speed of reversion (θ) from the autocorrelation of log returns, the indicator offers a more refined way of assessing how quickly prices may revert to the mean. Additionally, the inclusion of volatility provides a comprehensive view of market conditions, allowing for more accurate buy and sell signals.
Let's dive into the details:
🔸Dynamic Mean and Volatility Bands The dynamic mean (μ) is calculated using the EWMA, giving more weight to recent prices but considering all historical data. This process closely resembles the Ornstein-Uhlenbeck (OU) process, which models the tendency of a stochastic variable (such as price) to revert to its mean over time. Volatility bands are plotted around the mean using standard deviation, forming the "cloud" that signals overbought or oversold conditions. The cloud adapts dynamically to price fluctuations and market volatility, making it a versatile tool for mean-reversion strategies. 🞘 How it works Step one: Calculate the dynamic mean (μ) The Ornstein-Uhlenbeck process describes how a variable, such as an asset's price, tends to revert to a long-term mean while subject to random fluctuations. In this indicator, the EWMA is used to compute the dynamic mean (μ), mimicking the mean-reverting behavior of the OU process. Use the EWMA formula to compute a weighted mean that adjusts to recent price movements. Assign exponentially decreasing weights to older data while giving more emphasis to current prices. Step two: Plot volatility bands Calculate the standard deviation of the price over a user-defined period to determine market volatility. Position the upper and lower bands around the mean by adding and subtracting a multiple of the standard deviation. 🞘 How to calculate Exponential Weighted Moving Average (EWMA)
The EWMA dynamically adjusts to recent price movements:
mu_t = lambda * mu_{t-1} + (1 - lambda) * P_t
Where mu_t is the mean at time t, lambda is the decay factor, and P_t is the price at time t. The higher the decay factor, the more weight is given to recent data.
Autocorrelation (ρ) and Standard Deviation (σ)
To measure mean reversion speed and volatility: rho = correlation(log(close), log(close ), length) Where rho is the autocorrelation of log returns over a specified period.
To calculate volatility:
sigma = stdev(close, length)
Where sigma is the standard deviation of the asset's closing price over a specified length.
Upper and Lower Bands
The upper and lower bands are calculated as follows:
upper_band = mu + (threshold * sigma)
lower_band = mu - (threshold * sigma)
Where threshold is a multiplier for the standard deviation, usually set to 2. These bands represent the range within which the price is expected to fluctuate, based on current volatility and the mean.
🞘 Code extract // Calculate Returns
returns = math.log(close / close )
// Calculate Long-Term Mean (μ) using EWMA over the entire dataset
var float ewma_mu = na // Initialize ewma_mu as 'na'
ewma_mu := na(ewma_mu ) ? close : decay_factor * ewma_mu + (1 - decay_factor) * close
mu = ewma_mu
// Calculate Autocorrelation at Lag 1
rho1 = ta.correlation(returns, returns , corr_length)
// Ensure rho1 is within valid range to avoid errors
rho1 := na(rho1) or rho1 <= 0 ? 0.0001 : rho1
// Calculate Speed of Mean Reversion (θ)
theta = -math.log(rho1)
// Calculate Volatility (σ)
sigma = ta.stdev(close, corr_length)
// Calculate Upper and Lower Bands
upper_band = mu + threshold * sigma
lower_band = mu - threshold * sigma
🔸Visualization via Table and Plotshapes
The table shows key statistics such as the current value of the dynamic mean (μ), the number of times the price has crossed the upper or lower bands, and the consecutive number of bars that the price has remained in an overbought or oversold state.
Plotshapes (diamonds) are used to signal buy and sell opportunities. A green diamond below the price suggests a buy signal when the price crosses below the lower band, and a red diamond above the price indicates a sell signal when the price crosses above the upper band.
The table and plotshapes provide a comprehensive visualization, combining both statistical and actionable information to aid decision-making.
🞘 Code extract // Reset consecutive_bars when price crosses the mean
var consecutive_bars = 0
if (close < mu and close >= mu) or (close > mu and close <= mu)
consecutive_bars := 0
else if math.abs(deviation) > 0
consecutive_bars := math.min(consecutive_bars + 1, dev_length)
transparency = math.max(0, math.min(100, 100 - (consecutive_bars * 100 / dev_length)))
🔶 INSTRUCTIONS
The Mean Reversion Cloud (Ornstein-Uhlenbeck) indicator can be set up by adding it to your TradingView chart and configuring parameters such as the decay factor, autocorrelation length, and volatility threshold to suit current market conditions. Look for price crossovers and deviations from the calculated mean for potential entry signals. Use the upper and lower bands as dynamic support/resistance levels for setting take profit and stop-loss orders. Combining this indicator with additional trend-following or momentum-based indicators can improve signal accuracy. Adjust settings for better mean-reversion detection and risk management.
🔸Step-by-Step Guidelines
🞘 Setting Up the Indicator
Adding the Indicator to the Chart:
Go to your TradingView chart.
Click on the "Indicators" button at the top.
Search for "Mean Reversion Cloud (Ornstein-Uhlenbeck)" in the indicators list.
Click on the indicator to add it to your chart.
Configuring the Indicator:
Open the indicator settings by clicking on the gear icon next to its name on the chart.
Decay Factor: Adjust the decay factor (λ) to control the responsiveness of the mean calculation. A higher value prioritizes recent data.
Autocorrelation Length: Set the autocorrelation length (θ) for calculating the speed of mean reversion. Longer lengths consider more historical data.
Threshold: Define the number of standard deviations for the upper and lower bands to determine how far price must deviate to trigger a signal.
Chart Setup:
Select the appropriate timeframe (e.g., 1-hour, daily) based on your trading strategy.
Consider using other indicators such as RSI or MACD to confirm buy and sell signals.
🞘 Understanding What to Look For on the Chart
Indicator Behavior:
Observe how the price interacts with the dynamic mean and volatility bands. The price staying within the bands suggests mean-reverting behavior, while crossing the bands signals potential entry points.
The indicator calculates overbought/oversold conditions based on deviation from the mean, highlighted by color-coded cloud areas on the chart.
Crossovers and Deviation:
Look for crossovers between the price and the mean (μ) or the bands. A bullish crossover occurs when the price crosses below the lower band, signaling a potential buying opportunity.
A bearish crossover occurs when the price crosses above the upper band, suggesting a potential sell signal.
Deviations from the mean indicate market extremes. A large deviation indicates that the price is far from the mean, suggesting a potential reversal.
Slope and Direction:
Pay attention to the slope of the mean (μ). A rising slope suggests bullish market conditions, while a declining slope signals a bearish market.
The steepness of the slope can indicate the strength of the mean-reversion trend.
🞘 Possible Entry Signals
Bullish Entry:
Crossover Entry: Enter a long position when the price crosses below the lower band with a positive deviation from the mean.
Confirmation Entry: Use additional indicators like RSI (above 50) or increasing volume to confirm the bullish signal.
Bearish Entry:
Crossover Entry: Enter a short position when the price crosses above the upper band with a negative deviation from the mean.
Confirmation Entry: Look for RSI (below 50) or decreasing volume to confirm the bearish signal.
Deviation Confirmation:
Enter trades when the deviation from the mean is significant, indicating that the price has strayed far from its expected value and is likely to revert.
🞘 Possible Take Profit Strategies
Static Take Profit Levels:
Set predefined take profit levels based on historical volatility, using the upper and lower bands as guides.
Place take profit orders near recent support/resistance levels, ensuring you're capitalizing on the mean-reversion behavior.
Trailing Stop Loss:
Use a trailing stop based on a percentage of the price deviation from the mean to lock in profits as the trend progresses.
Adjust the trailing stop dynamically along the calculated bands to protect profits as the price returns to the mean.
Deviation-Based Exits:
Exit when the deviation from the mean starts to decrease, signaling that the price is returning to its equilibrium.
🞘 Possible Stop-Loss Levels
Initial Stop Loss:
Place an initial stop loss outside the lower band (for long positions) or above the upper band (for short positions) to protect against excessive deviations.
Use a volatility-based buffer to avoid getting stopped out during normal price fluctuations.
Dynamic Stop Loss:
Move the stop loss closer to the mean as the price converges back towards equilibrium, reducing risk.
Adjust the stop loss dynamically along the bands to account for sudden market movements.
🞘 Additional Tips
Combine with Other Indicators:
Enhance your strategy by combining the Mean Reversion Cloud with momentum indicators like MACD, RSI, or Bollinger Bands to confirm market conditions.
Backtesting and Practice:
Backtest the indicator on historical data to understand how it performs in various market environments.
Practice using the indicator on a demo account before implementing it in live trading.
Market Awareness:
Keep an eye on market news and events that might cause extreme price movements. The indicator reacts to price data and might not account for news-driven events that can cause large deviations.
🔸Customize settings 🞘 Decay Factor (λ): Defines the weight assigned to recent price data in the calculation of the mean. A value closer to 1 places more emphasis on recent prices, while lower values create a smoother, more lagging mean.
🞘 Autocorrelation Length (θ): Sets the period for calculating the speed of mean reversion and volatility. Longer lengths capture more historical data, providing smoother calculations, while shorter lengths make the indicator more responsive.
🞘 Threshold (σ): Specifies the number of standard deviations used to create the upper and lower bands. Higher thresholds widen the bands, producing fewer signals, while lower thresholds tighten the bands for more frequent signals.
🞘 Max Gradient Length (γ): Determines the maximum number of consecutive bars for calculating the deviation gradient. This setting impacts the transparency of the plotted bands based on the length of deviation from the mean.
🔶 CONCLUSION
The Mean Reversion Cloud (Ornstein-Uhlenbeck) indicator offers a sophisticated approach to identifying mean-reversion opportunities by applying the Ornstein-Uhlenbeck stochastic process. This dynamic indicator calculates a responsive mean using an Exponentially Weighted Moving Average (EWMA) and plots volatility-based bands to highlight overbought and oversold conditions. By incorporating advanced statistical measures like autocorrelation and standard deviation, traders can better assess market extremes and potential reversals. The indicator’s ability to adapt to price behavior makes it a versatile tool for traders focused on both short-term price deviations and longer-term mean-reversion strategies. With its unique blend of statistical rigor and visual clarity, the Mean Reversion Cloud provides an invaluable tool for understanding and capitalizing on market inefficiencies.
Uptrick: Market MoodsThe "Uptrick: Market Moods" indicator is an advanced technical analysis tool designed for the TradingView platform. It combines three powerful indicators—Relative Strength Index (RSI), Average True Range (ATR), and Bollinger Bands—into one cohesive framework, aimed at helping traders better understand and interpret market sentiment. By capturing shifts in the emotional climate of the market, it provides a holistic view of market conditions, which can range from calm to stressed or even highly excited. This multi-dimensional analysis tool stands apart from traditional single-indicator approaches by offering a more complete picture of market dynamics, making it a valuable resource for traders looking to anticipate and react to changes in market behavior.
The RSI in the "Uptrick: Market Moods" indicator is used to measure momentum. RSI is an essential component of many technical analysis strategies, and in this tool, it is used to identify potential market extremes. When RSI values are high, they indicate an overbought condition, meaning the market may be approaching a peak. Conversely, low RSI values suggest an oversold condition, signaling that the market could be nearing a bottom. These extremes provide crucial clues about shifts in market sentiment, helping traders gauge whether the current emotional state of the market is likely to result in a reversal. This understanding is pivotal in predicting whether the market is transitioning from calm to stressed or from excited to overbought.
The Average True Range adds another layer to this analysis by offering insights into market volatility. Volatility is a key factor in understanding the mood of the market, as periods of high volatility often reflect high levels of excitement or stress, while low volatility typically indicates a calm, steady market. ATR is calculated based on the range of price movements over a given period, and the higher the value, the more volatile the market is. The "Uptrick: Market Moods" indicator uses ATR to dynamically gauge volatility levels, helping traders understand whether the market is currently moving in a way that aligns with its emotional mood. For example, an increase in ATR accompanied by an RSI value that indicates overbought conditions could suggest that the market is in a highly excited state, with the potential for either strong momentum continuation or a sharp reversal.
Bollinger Bands complement these tools by providing visual cues about price volatility and the range within which the market is likely to move. Bollinger Bands plot two standard deviations away from a simple moving average of the price. This banding technique helps traders visualize how far the price is likely to deviate from its average over a certain period. The "Uptrick: Market Moods" indicator uses Bollinger Bands to establish price boundaries and identify breakout conditions. When prices break above the upper band or below the lower band, it often signals that the market is either highly stressed or excited. This breakout condition serves as a visual representation of the market mood, alerting traders to moments when prices are moving beyond typical ranges and when significant emotional shifts are occurring in the market.
Technically, the "Uptrick: Market Moods" indicator has been developed using TradingView’s Pine Script language, a highly efficient language for building custom indicators. It employs functions like ta.rsi, ta.atr, and ta.sma to perform the necessary calculations. The use of these built-in functions ensures that the calculations are both accurate and efficient, allowing the indicator to operate in real-time without lagging, even in volatile market conditions. The ta.rsi function is used to compute the Relative Strength Index, while ta.atr calculates the Average True Range, and ta.sma is used to smooth out price data for the Bollinger Bands. These functions are applied dynamically within the script, allowing the "Uptrick: Market Moods" indicator to respond to changes in market conditions in real time.
The user interface of the "Uptrick: Market Moods" indicator is designed to provide a visually intuitive experience. The market mood is color-coded on the chart, making it easy for traders to identify whether the market is calm, stressed, or excited at a glance. This feature is especially useful for traders who need to make quick decisions in fast-moving markets. Additionally, the indicator includes an interactive table that updates in real-time, showing the most recent mood state and its frequency. This provides valuable statistical insights into market behavior over specific time frames, helping traders track the dominant emotional state of the market. Whether the market is in a prolonged calm state or rapidly transitioning through moods, this real-time feedback offers actionable data that can help traders adjust their strategies accordingly.
The RSI component of the "Uptrick: Market Moods" indicator helps detect the speed and direction of price movements, offering insight into whether the market is approaching extreme conditions. By providing signals based on overbought and oversold levels, the RSI helps traders decide whether to enter or exit positions. The ATR element acts as a volatility gauge, dynamically adjusting traders’ expectations in response to changes in market volatility. Meanwhile, the Bollinger Bands help identify trends and potential breakout conditions, serving as an additional confirmation tool that highlights when the price has moved beyond normal boundaries, indicating heightened market excitement or stress.
Despite the robust capabilities of the "Uptrick: Market Moods" indicator, it does have limitations. In markets affected by sudden shifts, such as those driven by major news events or external economic factors, the indicator’s performance may not always be reliable. These external factors can cause rapid mood swings that are difficult for any technical analysis tool to fully anticipate. Additionally, the indicator’s complexity may pose a learning curve for novice traders, particularly those who are unfamiliar with the concepts of RSI, ATR, and Bollinger Bands. However, with practice, traders can become proficient in using the tool to its full potential, leveraging the insights it provides to better navigate market shifts.
For traders seeking a deeper understanding of market sentiment, the "Uptrick: Market Moods" indicator is an invaluable resource. It is recommended for those dealing with medium to high volatility instruments, where understanding emotional shifts can offer a strategic advantage. While it can be used on its own, integrating it with other forms of analysis, such as fundamental analysis and additional technical indicators, can enhance its effectiveness. By confirming signals with other tools, traders can reduce the likelihood of false signals and improve their overall trading strategy.
To further enhance the accuracy of the "Uptrick: Market Moods" indicator, it can be integrated with volume-based tools like Volume Profile or On-Balance Volume (OBV). This combination allows traders to confirm the moods identified by the indicator with volume data, providing additional confirmation of market sentiment. For example, when the market is in an excited mood, an increase in trading volume could reinforce the reliability of that signal. Conversely, if the market is stressed but volume remains low, traders may want to proceed with caution. Using multiple indicators together creates a more comprehensive trading approach, helping traders better manage risk and make informed decisions based on multiple data points.
In conclusion, the "Uptrick: Market Moods" indicator is a powerful and unique addition to the suite of technical analysis tools available on TradingView. It provides traders with a multi-dimensional view of market sentiment by combining the analytical strengths of RSI, ATR, and Bollinger Bands into a single tool. Its ability to capture and interpret the emotional mood of the market makes it an essential tool for traders seeking to gain an edge in understanding market behavior. While the indicator has certain limitations, particularly in rapidly shifting markets, its ability to provide real-time insights into market sentiment is a valuable asset for traders of all experience levels. Used in conjunction with other tools and sound trading practices, the "Uptrick: Market Moods" indicator offers a comprehensive solution for navigating the complexities of financial markets.
Support and ResistanceThis indicator, titled "Support and Resistance," is designed to identify and display key price levels based on volume and pivot points. It's a versatile tool that can be adapted for different market views and timeframes.
Key Features
Market View Options
The indicator offers three market view settings:
Short term
Standard
Long term
These settings affect the lookback periods used in calculations, allowing users to adjust the indicator's sensitivity to market movements.
Volume-Based Levels
The indicator calculates support and resistance levels using a rolling Point of Control (POC) derived from volume data. This approach helps identify price levels where the most trading activity has occurred.
Pivot Points
In addition to volume-based levels, the indicator incorporates pivot points to identify potential support and resistance areas.
Customizable Appearance
Users can adjust:
Number of lines to display (1-8)
Colors for support and resistance levels
Line thickness based on level importance
Calculation Methods
Rolling POC
The indicator uses a custom function f_rolling_poc to calculate the rolling Point of Control. This function analyzes volume distribution across price levels within a specified lookback period.
Pivot Points
Both standard and quick pivot points are calculated using the rolling POC as input, rather than traditional price data.
Level Importance
The indicator assigns importance to each level based on:
Number of touches (how often price has interacted with the level)
Duration (how long the level has been relevant)
This importance score determines the thickness of the displayed lines.
Unique Aspects
Dynamic Line Thickness: Lines become thicker when levels overlap, highlighting potentially stronger support/resistance areas.
Adaptive Coloring: The color of each line changes dynamically based on whether the current price is above or below the level, indicating whether it's acting as support or resistance.
Flexible Time Frames: The market view options allow the indicator to be easily adapted for different trading styles and timeframes.
Potential Uses
This indicator could be valuable for:
Identifying key price levels for entry and exit points
Recognizing potential breakout or breakdown levels
Understanding the strength of support and resistance based on line thickness
Adapting analysis to different market conditions and timeframes
Overall, this "Support and Resistance" indicator offers a sophisticated approach to identifying key price levels, combining volume analysis with pivot points and providing visual cues for level importance and current market position.
This Support and Resistance indicator is provided for informational and educational purposes only. It should not be considered as financial advice or a recommendation to buy or sell any security. The indicator's calculations are based on historical data and may not accurately predict future market movements. Trading decisions should be made after thorough research and consultation with a licensed financial advisor. The creator of this indicator is not responsible for any losses incurred from its use. Past performance does not guarantee future results. Use at your own risk.
RSI (Kernel Optimized) | Flux Charts💎 GENERAL OVERVIEW
Introducing our new KDE Optimized RSI Indicator! This indicator adds a new aspect to the well-known RSI indicator, with the help of the KDE (Kernel Density Estimation) algorithm, estimates the probability of a candlestick will be a pivot or not. For more information about the process, please check the "HOW DOES IT WORK ?" section.
Features of the new KDE Optimized RSI Indicator :
A New Approach To Pivot Detection
Customizable KDE Algorithm
Realtime RSI & KDE Dashboard
Alerts For Possible Pivots
Customizable Visuals
❓ HOW TO INTERPRET THE KDE %
The KDE % is a critical metric that reflects how closely the current RSI aligns with the KDE (Kernel Density Estimation) array. In simple terms, it represents the likelihood that the current candlestick is forming a pivot point based on historical data patterns. a low percentage suggests a lower probability of the current candlestick being a pivot point. In these cases, price action is less likely to reverse, and existing trends may continue. At moderate levels, the possibility of a pivot increases, indicating potential trend shifts or consolidations.Traders should start monitoring closely for confirmation signals. An even higher KDE % suggests a strong likelihood that the current candlestick could form a pivot point, which could lead to a reversal or significant price movement. These points often align with overbought or oversold conditions in traditional RSI analysis, making them key moments for potential trade entry or exit.
📌 HOW DOES IT WORK ?
The RSI (Relative Strength Index) is a widely used oscillator among traders. It outputs a value between 0 - 100 and gives a glimpse about the current momentum of the price action. This indicator then calculates the RSI for each candlesticks, and saves them into an array if the candlestick is a pivot. The low & high pivot RSIs' are inserted into two different arrays. Then the a KDE array is calculated for both of the low & high pivot RSI arrays. Explaining the KDE might be too much for this write-up, but for a brief explanation, here are the steps :
1. Define the necessary options for the KDE function. These are : Bandwidth & Nº Steps, Array Range (Array Max - Array Min)
2. After that, create a density range array. The array has (steps * 2 - 1) elements and they are calculated by (arrMin + i * stepCount), i being the index.
3. Then, define a kernel function. This indicator has 3 different kernel distribution modes : Uniform, Gaussian and Sigmoid
4. Then, define a temporary value for the current element of KDE array.
5. For each element E in the pivot RSI array, add "kernel(densityRange.get(i) - E, 1.0 / bandwidth)" to the temporary value.
6. Add 1.0 / arrSize * to the KDE array.
Then the prefix sum array of the KDE array is calculated. For each candlestick, the index closest to it's RSI value in the KDE array is found using binary search. Then for the low pivot KDE calculation, the sum of KDE values from found index to max index is calculated. For the high pivot KDE, the sum of 0 to found index is used. Then if high or low KDE value is greater than the activation threshold determined in the settings, a bearish or bullish arrow is plotted after bar confirmation respectively. The arrows are drawn as long as the KDE value of current candlestick is greater than the threshold. When the KDE value is out of the threshold, a less transparent arrow is drawn, indicating a possible pivot point.
🚩 UNIQUENESS
This indicator combines RSI & KDE Algorithm to get a foresight of possible pivot points. Pivot points are important entry, confirmation and exit points for traders. But to their nature, they can be only detected after more candlesticks are rendered after them. The purpose of this indicator is to alert the traders of possible pivot points using KDE algorithm right away when they are confirmed. The indicator also has a dashboard for realtime view of the current RSI & Bullish or Bearish KDE value. You can fully customize the KDE algorithm and set up alerts for pivot detection.
⚙️ SETTINGS
1. RSI Settings
RSI Length -> The amount of bars taken into account for RSI calculation.
Source -> The source value for RSI calculation.
2. Pivots
Pivot Lengths -> Pivot lengths for both high & low pivots. For example, if this value is set to 21; 21 bars before AND 21 bars after a candlestick must be higher for a candlestick to be a low pivot.
3. KDE
Activation Threshold -> This setting determines the amount of arrows shown. Higher options will result in more arrows being rendered.
Kernel -> The kernel function as explained in the upper section.
Bandwidth -> The bandwidth variable as explained in the upper section. The smoothness of the KDE function is tied to this setting.
Nº Bins -> The Nº Steps variable as explained in the upper section. It determines the precision of the KDE algorithm.
Liquidity Zones [BigBeluga]This indicator is designed to detect liquidity zones on the chart by identifying significant pivot highs and lows filtered by volume strength. It plots these zones as boxes, highlighting areas where liquidity is likely to accumulate. The indicator also draws lines extending from these boxes, marking the levels where price may "grab" this liquidity. The size of these boxes can be dynamic, adjusting based on the volume size, offering a visual representation of market areas where traders might expect significant price reactions.
🔵 IDEA
The idea behind the Liquidity Zones indicator is to help traders identify key market levels where liquidity accumulates. Liquidity zones are areas where there are enough buy or sell orders that can potentially lead to significant price movements. By focusing on pivot points filtered by volume strength, the indicator aims to provide a clearer picture of where large players may have positioned their orders. This insight allows traders to anticipate potential market reactions, such as reversals or breakouts, when the price reaches these zones. The option for dynamic box height further refines the visualization, showing the extent of liquidity based on the volume's intensity.
🔵 KEY FEATURES & USAGE
◉ Volume-Filtered Pivot Highs and Lows:
The indicator scans for pivot highs and lows on the chart, filtering these points based on the volume strength setting (Low, Mid, High). This ensures that only the most significant liquidity zones, backed by notable trading volume, are highlighted. Traders can adjust the filter to focus on different levels of market activity, from small fluctuations to major volume spikes.
Low:
Mid:
High:
◉ Dynamic and Static Liquidity Zones:
Liquidity zones are plotted as boxes around pivot points, with an optional dynamic mode that adjusts the box height based on the normalized volume. This dynamic adjustment reflects the liquidity carried by the volume, making it easier to gauge the significance of each zone. In static mode, the boxes have a fixed height, providing a consistent visual reference for the zones.
◉ Color Intensity Based on Volume:
The indicator adjusts the color intensity of the liquidity zones based on the volume strength. Higher volume zones will be displayed with more intense colors, giving a visual cue to the strength of the liquidity present in that area. This makes it easier to differentiate between zones of varying importance at a glance, allowing traders to quickly identify where the market has the highest concentration of liquidity.
◉ Liquidity Grab Detection and Red Circles:
When the price interacts with a liquidity zone, the indicator detects whether liquidity has been "grabbed" at these levels. If the price moves into a zone and crosses a level, the box label changes to "Liquidity Grabbed," and the line marking the level becomes dashed.
Reversal Points:
The beginning of a trend:
Additionally marks these "liquidity grabs" with red circles, indicating both recent and past liquidity grabs. This feature helps traders identify areas where liquidity has been absorbed by the market, which may signal potential reversals or shifts in market direction.
◉ Dashboard Display:
A dashboard in the upper right corner of the chart provides an overview of the indicator's settings and status. It shows the number of plotted zones, as set in the input settings, and whether the dynamic mode is active. This quick reference helps traders stay informed about the indicator's configuration without needing to open the settings panel.
🔵 CUSTOMIZATION
Length & Zones Amount: Set the length for pivot detection and the maximum number of zones to be displayed on the chart. This allows you to control how many liquidity zones you want to monitor at any given time.
Volume Strength Filter: Adjust the filter to Low, Mid, or High to control the strength of volume required for a pivot to be considered a significant liquidity zone. Higher settings focus on zones with greater volume, indicating stronger liquidity.
Dynamic Distance Mode: Enable or disable the dynamic mode, which adjusts the box height based on the volume size. When dynamic mode is off, the boxes have a fixed height based on the ATR, offering a consistent visualization regardless of the volume size.
The Liquidity Zones indicator is a versatile tool for identifying areas of significant market activity, offering a clear view of where liquidity is likely to reside. By filtering these zones through volume strength and providing dynamic or static visualization options, it equips traders with insights into potential market reaction points, enhancing their ability to anticipate and respond to market movements. The varying color intensity based on volume further aids in quickly recognizing the most critical liquidity zones on the chart.
Delta Dashboard with Custom Candle Count "Delta Dashboard with Custom Candle Count," creates a dynamic table on a chart that shows Buying Delta, Selling Delta, and Cumulative Delta for a user-defined number of candles. It is designed to give traders an easy-to-read visual dashboard for analyzing volume-based deltas, potentially helping to identify bullish or bearish trends.
Script Overview:
Custom Timeframe Input: The user has the option to enable a custom lower timeframe (useCustomTimeframeInput). If enabled, the script uses the lowerTimeframeInput (default is 1 minute) to request data from a lower timeframe. If not enabled, the script automatically selects a timeframe based on the chart’s current settings.
Candle Count Input: The script allows the user to specify the number of candles (numCandlesInput) for which they want to track volume deltas. This input determines how many columns are included in the delta dashboard.
Proportional Buy/Sell Volume Calculation: The script calculates the buy and sell volume for each candle. The buy volume is based on how much the price has moved up from the low, while the sell volume is based on how much the price has moved down from the high. The total volume is then split between buyers and sellers for a more accurate volume-based analysis.
Lower Timeframe Volume Data: The script requests volume data from the lower timeframe and uses it to calculate the positive (buying) and negative (selling) volume arrays over the specified number of candles.
Cumulative Delta: The cumulative delta is calculated as the difference between buying volume (positiveVolume) and selling volume (negativeVolume). The delta is accumulated over the day, and it resets at the start of each new day.
Dashboard Creation: The script creates a table (deltaTable) that is displayed on the chart, showing the following for each candle:
Buying Delta: The volume of buy orders.
Selling Delta: The volume of sell orders.
Cumulative Delta: The net difference between buying and selling volumes over the course of the day.
Dynamic Table Updating: The table updates with each new candle. The current candle's data is dynamically added to the table, and older candles shift to the left. When the maximum number of candles (as defined by numCandlesInput) is reached, the table wraps around, continuously updating with the latest data.
Abnormal Volume Detection: The script highlights candles where abnormal volume is detected. If the buying or selling volume for a particular candle is greater than twice the 50-period moving average volume, it highlights the respective cells in the table with shaded background colors:
Green: Indicates abnormal buying volume.
Red: Indicates abnormal selling volume.
Blue: Highlights abnormal cumulative delta spikes.
Daily Reset: The script automatically clears the table at the start of each new day, ensuring that the dashboard only reflects data from the current trading day.
How to Use:
Adding to Chart: To use this script, apply it to your TradingView chart. The dashboard will automatically appear in the upper left corner of the chart, showing volume-based delta data for each candle.
Customizing Timeframe: If you want to use a different timeframe for delta calculation (e.g., 1-second or 1-minute chart data), enable the Use Custom Timeframe option and specify the desired timeframe in the input section.
Adjusting the Number of Candles: You can adjust the number of candles shown in the delta dashboard by changing the Number of Candles input. The script will track the volume deltas for this number of candles, displaying them in the dashboard.
Interpreting the Dashboard:
Buying Delta: A higher positive value indicates stronger buying pressure in that candle.
Selling Delta: A higher negative value indicates stronger selling pressure in that candle.
Cumulative Delta: This value gives the net result of buying versus selling pressure across the trading day. Positive cumulative delta suggests buying dominance, while negative cumulative delta suggests selling dominance.
Abnormal Volume Detection: When abnormal volume spikes occur, pay attention to highlighted rows:
Green cells show that buying volume is unusually high.
Red cells indicate unusually high selling volume.
Blue cells mark large spikes in cumulative delta.
This script can be particularly useful for traders who want to gauge market sentiment based on volume distribution and detect abnormal trading activity, which could precede significant price movements.
The Vet [TFO]In collaboration with @mickey1984 , "The Vet" was created to showcase various statistical measures of price.
The first core measurement utilizes the Defining Range (DR) concept on a weekly basis. For example, we might track the session from 09:30-10:30 on Mondays to get the DR high, DR low, IDR high, and IDR low. The DR high and low are the highest high and lowest low of the session, respectively, whereas the IDR high and low would be the highest candle body level (open or close) and lowest candle body level, respectively, during this window of time.
From this data, we use the IDR range (from IDR high to IDR low) to extrapolate several, custom projections of this range from its high and low so that we can collect data on how often these levels are hit, from the close of one DR session to the open of the next one.
This information is displayed in the Range Projection Table with a few main columns of information:
- The leftmost column indicates each level that is projected from the IDR range, where (+) indicates a projection above the range high, and (-) indicates a projection below the range low
- The "First Touch" column indicates how often price has reached these levels in the past at any point until the next weekly DR session
- The "Other Side Touch" column indicates how often price has reached a given level, then reversed to hit the opposing level of the same magnitude. For example, the above chart shows that if price hit the +1 projection, ~33% of instances also hit the -1 projection before the next weekly DR session. For this reason, the probabilities will be the same for projection levels of the same but opposite magnitude (+1 would be the same as -1, +3 would be the same as -3, etc.)
- The "Next Level Touch" column provides insight into how often price reaches the next greatest projection level. For example, in the above chart, the red box in the projection table is highlighting that once price hits the -2 projection, ~86% of instances reached the -3 projection before the next weekly DR session
- The last columns, "Within ADR" and "Within AWR" show if any of the projection levels are within the current Average Daily Range, or Average Weekly Range, respectively, which can both be enabled from the Average Range section
The next section, Distributions, primarily measures and displays the average price movements from specified intraday time windows. The option to Show Distribution Boxes will overlay a box showing each respective session's average range, while adjusting itself to encapsulate the price action of that session until the average range is met/exceeded. Users can choose to display the range average by Day of Week, or the Total average from all days. Values for average ranges can either be shown as point or percent values. We can also show a table to display this information about price's average ranges for each given session, and show labels displaying the current range vs its average.
The final section, Average Range, simply offers the ability to plot the Average Daily Range (ADR) and Average Weekly Range (AWR) of a specified length. An ADR of 10 for example would take the average of the last 10 days, from high to low, while an AWR of 10 would take the average of the last 10 weeks (if the current chart provides enough data to support this). Similarly, we can also show the Average Range Table to indicate what these ADR/AWR values are, what our current range is and how it compares to those values, as well as some simple statistics on how often these levels are hit. As an example, "Hit +/- ADR: 40%/35%" in this table would indicate that price has hit the upper ADR limit 40% of the time, and the lower limit 35% of the time, for the amount of data available on the current chart.
[DarkTrader] Pivot Point HeatmapThe indicator calculates pivot points using price data from different timeframes such as 12M, 1M, 1W, 3D, and 1D. For each timeframe, it retrieves the high, low, open, and close prices of the previous bar. The pivot point is calculated as the average of the high, low, and close prices, which provides a central level where market sentiment may shift. This calculation is repeated for each timeframe, ensuring a multi-dimensional view of potential interest zones.
Importance of Pivot Points :
Pivot points are essential tools in technical analysis, providing traders with levels that act as potential support and resistance zones. These zones help identify price levels where reversals or breakouts are more likely to occur.
Visual Representation :
The core feature of this indicator is its ability to visualize pivot points as a heatmap on the chart. Instead of showing just the latest pivot points, it tracks the historical pivot swipe, providing a dynamic view of how price interacts with these key levels. Each pivot point is represented by a line, color-coded based on its position relative to other points, creating a gradient effect that highlights the most critical price areas.
Customization Options :
Traders can customize various aspects of the heatmap to suit their preferences. The indicator offers options to toggle pivot swipe history, enabling traders to either focus on the most recent price interactions or consider how price has behaved over time. The background color and pivot line colors are fully customizable, making it easy to match the heatmap with your chart's theme or emphasize certain price levels.
Detecting Sweeps and Price Interaction :
Another important feature is the detection of price interactions with pivot levels. If the current bar's high and low cross a pivot point, it signals that the pivot level has been "swept" by price action, potentially indicating a change in market sentiment. The indicator either extends the line if the pivot point remains relevant or deletes it if price has broken through. This dynamic adjustment helps traders stay updated on which pivot levels are still valid.
Larry Conners Vix Reversal II Strategy (approx.)This Pine Script™ strategy is a modified version of the original Larry Connors VIX Reversal II Strategy, designed for short-term trading in market indices like the S&P 500. The strategy utilizes the Relative Strength Index (RSI) of the VIX (Volatility Index) to identify potential overbought or oversold market conditions. The logic is based on the assumption that extreme levels of market volatility often precede reversals in price.
How the Strategy Works
The strategy calculates the RSI of the VIX using a 25-period lookback window. The RSI is a momentum oscillator that measures the speed and change of price movements. It ranges from 0 to 100 and is often used to identify overbought and oversold conditions in assets.
Overbought Signal: When the RSI of the VIX rises above 61, it signals a potential overbought condition in the market. The strategy looks for a RSI downtick (i.e., when RSI starts to fall after reaching this level) as a trigger to enter a long position.
Oversold Signal: Conversely, when the RSI of the VIX drops below 42, the market is considered oversold. A RSI uptick (i.e., when RSI starts to rise after hitting this level) serves as a signal to enter a short position.
The strategy holds the position for a minimum of 7 days and a maximum of 12 days, after which it exits automatically.
Larry Connors: Background
Larry Connors is a prominent figure in quantitative trading, specializing in short-term market strategies. He is the co-author of several influential books on trading, such as Street Smarts (1995), co-written with Linda Raschke, and How Markets Really Work. Connors' work focuses on developing rules-based systems using volatility indicators like the VIX and oscillators such as RSI to exploit mean-reversion patterns in financial markets.
Risks of the Strategy
While the Larry Connors VIX Reversal II Strategy can capture reversals in volatile market environments, it also carries significant risks:
Over-Optimization: This modified version adjusts RSI levels and holding periods to fit recent market data. If market conditions change, the strategy might no longer be effective, leading to false signals.
Drawdowns in Trending Markets: This is a mean-reversion strategy, designed to profit when markets return to a previous mean. However, in strongly trending markets, especially during extended bull or bear phases, the strategy might generate losses due to early entries or exits.
Volatility Risk: Since this strategy is linked to the VIX, an instrument that reflects market volatility, large spikes in volatility can lead to unexpected, fast-moving market conditions, potentially leading to larger-than-expected losses.
Scientific Literature and Supporting Research
The use of RSI and VIX in trading strategies has been widely discussed in academic research. RSI is one of the most studied momentum oscillators, and numerous studies show that it can capture mean-reversion effects in various markets, including equities and derivatives.
Wong et al. (2003) investigated the effectiveness of technical trading rules such as RSI, finding that it has predictive power in certain market conditions, particularly in mean-reverting markets .
The VIX, often referred to as the “fear index,” reflects market expectations of volatility and has been a focal point in research exploring volatility-based strategies. Whaley (2000) extensively reviewed the predictive power of VIX, noting that extreme VIX readings often correlate with turning points in the stock market .
Modified Version of Original Strategy
This script is a modified version of Larry Connors' original VIX Reversal II strategy. The key differences include:
Adjusted RSI period to 25 (instead of 2 or 4 commonly used in Connors’ other work).
Overbought and oversold levels modified to 61 and 42, respectively.
Specific holding period (7 to 12 days) is predefined to reduce holding risk.
These modifications aim to adapt the strategy to different market environments, potentially enhancing performance under specific volatility conditions. However, as with any system, constant evaluation and testing in live markets are crucial.
References
Wong, W. K., Manzur, M., & Chew, B. K. (2003). How rewarding is technical analysis? Evidence from Singapore stock market. Applied Financial Economics, 13(7), 543-551.
Whaley, R. E. (2000). The investor fear gauge. Journal of Portfolio Management, 26(3), 12-17.
ICT HTF FVGs v2 (fadi)NOTICE: Instead of updating the existing ICT HTF FVGs indicator, this indicator is being published separately due to the requests to keep the original by some traders and because of the drastic change in behavior/configurations. If the original v1 version is more appropriate for your style of trading, feel free to continue to use it.
ICT HTF FVGs v2
In trading, Fair Value Gaps (FVGs) refer to market inefficiencies or imbalances that occur when buying and selling activities are not equal. These gaps can be identified on various timeframes and are used in different trading strategies.
FVGs are crucial in price action trading as they highlight the difference between the current market price of an asset and its fair value. Traders use these gaps to identify potential trading opportunities, as they often indicate areas where the market may correct itself
This indicator will overlap the higher timeframe (HTF) FVGS over the current timeframe to help traders anticipate and plan their trades.
Features
Up to 6 higher timeframes (HTF) can be overlayed on a chart
Traders can limit the number of HTF FVGs to preset number of HTFs
Lower and current timeframes can be included
Configurable spacing of HTF FVGs to prevent overlapping
Configurable Smart Expansion of FVGs based on proximity to current price
Traders can decide what constitutes a Mitigated FVG
Show or hide mitigated FVGs to declutter the chart
Flexible display settings that controls how the FVGs are displayed
Flexible labeling of the FVG levels and content
Higher Timeframes Display Settings
This indicator provides the ability to select up to 6 HTF intervals. These intervals are based on the trader's timeframes including any custom timeframes.
Timeframe Configurations
Enable or Disable a Timeframe
The Timeframe to Display
Bullish / BISI FVG Color
Bearish / SIBI FVG Color
The number of FVGs For The Selected Timeframe
Limit to the next HTFs only can be used to display the selected number of HTF FVGs. For example, if the trader selects 3 then only 3 HTF FVGs will be displayed.
Note: If either of the next two options is selected, they will take up spots from this count.
Hide lower Timeframes restricts the FVGs to higher timeframes only. If this option is disabled, it will show lower timeframes FVGs as well.
Hide Current Timeframe removes current timeframe from the selected list of HTF FVGs. If this option is disabled, it will show current timeframe FVGs as well.
Background Transparency Enable or disable the background color (shaded area) of the FVG. If it is enabled, it will set the transparency amount. The higher the value, the more transparent the background.
Extend lines controls when and how to extend the FVG levels. There are three options:
Extension Only extends the FVGs by the specified number provided below only.
Current Candle Plus Extension extends all the FVGs beyond the current candle by the number provided below.
When in Range will only extend the FVGs near current price based on the advanced settings below. This setting will use Average True Range multiplier to calculate the range (shows FVGs that are higher or lower by the average candle size multiplied by the number in Advanced section).
Mitigated shows or hides the mitigated HTF FVGs. A FVG is considered mitigated based on one of the following options:
None will ignore mitigation and show all FVGs.
Touched when a HTF FVG is touched regardless of how deep the price get inside the FVG.
Wick filled the FVG is closed by a wick or body of a candle.
Body filled the FVG is closed by the body of a candle
Wick filled half a candle's wick or body has reached the C.E. of the FVG
Body filled half a candle body has reached the C.E. of the FVG
Extend mitigated lines sets the number of candles to extend the mitigated FVG levels by for better visibility.
Important Note: Mitigation is calculated based on the timeframe of the FVG, not current timeframe.
Display
Display settings focus on how the FVGs will be displayed. The trader is in total control and there are multiple ways to overlay FVGs on the chart.
Open / Close / C.E. / Link controls the borders. Traders can enable or disable any of them as well as set the thickness and style. Link is the right border.
C.E. also offers the option of setting the bullish (BISI) and bearish (SIBI) colors of the C.E. level
Labeling controls if the labels should be displayed next to the FVG, their color, background, and font size.
Label levels to display controls which levels to show. Open, High. or the C.E.
Label display content controls what to show in the labels, the timeframe of the label, is it a BISI or a SIBI, and a label to indicate if it is the Open or the Close.
Note: if the distance between the open and close has the potential of overlapping the labels, then the indicator will only show the C.E. label for visual clarity.
Advanced Settings
Advanced settings controls some internal calculations:
Proximity factor based on daily range used to calculate possible range of FVGs within a day's range to keep the chart clean. The higher the value, the more FVGs will be shown.
Combine labels factor for visibility used to calculate the distance between the open and close and if all the labels or only the C.E. should be displayed. The higher the value, the bigger the distance for combination (smaller numbers will show more labels).
Range should be within X candles used when "When in Range" option is selected. This is the ATR multiplier used to extend the FVGs. The higher the number, the more FVGs will be extended.
Once desired settings have been achieved, the settings can be saved as default from the bottom left of the indicator settings page for future use.
Relative Rating Index (RRI)The technical rating is one of the most perfect indicators. The reason is that this indicator is based on a majority vote of multiple indicators. It is logical that the judgment based on a majority vote of multiple indicators would not be inferior to the judgment made using only a single indicator. However, just as any indicator has its shortcomings, the technical rating also has weaknesses. The most significant issue is that it primarily provides only a momentary evaluation of the current situation.
Let's consider this in more detail. In the technical rating, an evaluation of 1.0 by the majority vote of indicators is considered a strong buy. However, in the market, there are naturally varying levels of strength. For example, would a market that only once reached an evaluation of 1.0 within a given period be considered the same as a market that consistently maintains an evaluation of 1.0? The latter clearly shows a stronger trend, but the technical rating does not provide an objective criterion for such differentiation. While it is possible to check the histogram to see how long the buy or sell rating has continued, there is no objective standard for judgment.
The indicator I have created this time compensates for this weakness by using the concept of RSI. As is well known, RSI is an indicator that shows the momentum of the market. RSI typically calculates the strength of the price increase during a 14-period by dividing the total upward movement by the total movement range. Similarly, I thought that if we divide the positive evaluations of the technical rating during a given period by the total evaluations, we could calculate the "momentum of the technical rating," which shows how often positive ratings have appeared during that period.
Below is the calculation formula.
1. Setting the Evaluation Period
Decide the period to calculate (e.g., 14 periods). This is denoted as `n`.
2. Total Positive Ratings of the Technical Rating
Calculate the total number of times the technical rating is evaluated as "strong buy" or "buy" during each period. This is called `positive_sum`.
3. Total Ratings
Count the total number of ratings (including buy, sell, and neutral) during the period. This is called `total_sum`.
4. Calculating the Upward Strength
Divide `positive_sum` by `total_sum` to calculate the ratio of positive ratings in the technical rating. This is called the "ratio of positive ratings."
The ratio of positive ratings, denoted as `P`, is calculated as follows:
P = positive_sum / total_sum
5. Calculating RRI
Following the calculation method of RSI, RRI is calculated by the following formula:
RRI = 100 - (100 / (1 + (P / (1 - P))))
As you can see, the calculation method is similar to that of RSI. Therefore, initially, I intended to name this indicator the Technical Rating RSI. However, RSI calculates based on the difference between the previous bar's price and the current bar's price, whereas this indicator calculates by summing the values of the technical ratings themselves. In the case of prices, if the difference between bars is zero, it indicates a flat market, but in the case of technical rating values, if 1.0 continues for two consecutive periods, it signifies an extremely strong buy rather than a flat market. For this reason, I decided that the calculation method could no longer be considered the same as the traditional RSI, and to avoid confusion, I chose to give this new indicator the name "Relative Rating Index" (RRI), as it provides a new type of numerical evaluation.
The information provided by this indicator is simple. When RRI exceeds 50, it means that more than 50% of the technical rating evaluations during the set period (I recommend 50 periods, but please determine the optimal value based on your timeframe) are buy evaluations. However, since there may be many false signals around exactly 50, I define it as buy-dominant when the value exceeds 60 and sell-dominant when it falls below 40. Additionally, if the graph itself is rising, it indicates that the buying momentum is strengthening, and if it is falling, it indicates that the selling momentum is increasing.
Furthermore, there are lines drawn at 90 and 10, but please note that unlike RSI, these do not indicate overbought or oversold conditions. When RRI exceeds 90, it means that over 90% of the technical rating evaluations during the specified period are buy evaluations, indicating an ongoing extremely strong buy trend. Until the RRI graph turns downward and falls below 90, it should rather be considered a buying opportunity.
With this new indicator, the technical rating becomes an indicator with depth, providing evaluations not only for the moment but over a specified period. I hope you find it helpful in your market analysis.
RSI Trend Following StrategyOverview
The RSI Trend Following Strategy utilizes Relative Strength Index (RSI) to enter the trade for the potential trend continuation. It uses Stochastic indicator to check is the price is not in overbought territory and the MACD to measure the current price momentum. Moreover, it uses the 200-period EMA to filter the counter trend trades with the higher probability. The strategy opens only long trades.
Unique Features
Dynamic stop-loss system: Instead of fixed stop-loss level strategy utilizes average true range (ATR) multiplied by user given number subtracted from the position entry price as a dynamic stop loss level.
Configurable Trading Periods: Users can tailor the strategy to specific market windows, adapting to different market conditions.
Two layers trade filtering system: Strategy utilizes MACD and Stochastic indicators measure the current momentum and overbought condition and use 200-period EMA to filter trades against major trend.
Trailing take profit level: After reaching the trailing profit activation level script activates the trailing of long trade using EMA. More information in methodology.
Wide opportunities for strategy optimization: Flexible strategy settings allows users to optimize the strategy entries and exits for chosen trading pair and time frame.
Methodology
The strategy opens long trade when the following price met the conditions:
RSI is above 50 level.
MACD line shall be above the signal line
Both lines of Stochastic shall be not higher than 80 (overbought territory)
Candle’s low shall be above the 200 period EMA
When long trade is executed, strategy set the stop-loss level at the price ATR multiplied by user-given value below the entry price. This level is recalculated on every next candle close, adjusting to the current market volatility.
At the same time strategy set up the trailing stop validation level. When the price crosses the level equals entry price plus ATR multiplied by user-given value script starts to trail the price with trailing EMA(by default = 20 period). If price closes below EMA long trade is closed. When the trailing starts, script prints the label “Trailing Activated”.
Strategy settings
In the inputs window user can setup the following strategy settings:
ATR Stop Loss (by default = 1.75)
ATR Trailing Profit Activation Level (by default = 2.25)
MACD Fast Length (by default = 12, period of averaging fast MACD line)
MACD Fast Length (by default = 26, period of averaging slow MACD line)
MACD Signal Smoothing (by default = 9, period of smoothing MACD signal line)
Oscillator MA Type (by default = EMA, available options: SMA, EMA)
Signal Line MA Type (by default = EMA, available options: SMA, EMA)
RSI Length (by default = 14, period for RSI calculation)
Trailing EMA Length (by default = 20, period for EMA, which shall be broken close the trade after trailing profit activation)
Justification of Methodology
This trading strategy is designed to leverage a combination of technical indicators—Relative Strength Index (RSI), Moving Average Convergence Divergence (MACD), Stochastic Oscillator, and the 200-period Exponential Moving Average (EMA)—to determine optimal entry points for long trades. Additionally, the strategy uses the Average True Range (ATR) for dynamic risk management to adapt to varying market conditions. Let's look in details for which purpose each indicator is used for and why it is used in this combination.
Relative Strength Index (RSI) is a momentum indicator used in technical analysis to measure the speed and change of price movements in a financial market. It helps traders identify whether an asset is potentially overbought (overvalued) or oversold (undervalued), which can indicate a potential reversal or continuation of the current trend.
How RSI Works? RSI tracks the strength of recent price changes. It compares the average gains and losses over a specific period (usually 14 periods) to assess the momentum of an asset. Average gain is the average of all positive price changes over the chosen period. It reflects how much the price has typically increased during upward movements. Average loss is the average of all negative price changes over the same period. It reflects how much the price has typically decreased during downward movements.
RSI calculates these average gains and losses and compares them to create a value between 0 and 100. If the RSI value is above 70, the asset is generally considered overbought, meaning it might be due for a price correction or reversal downward. Conversely, if the RSI value is below 30, the asset is considered oversold, suggesting it could be poised for an upward reversal or recovery. RSI is a useful tool for traders to determine market conditions and make informed decisions about entering or exiting trades based on the perceived strength or weakness of an asset's price movements.
This strategy uses RSI as a short-term trend approximation. If RSI crosses over 50 it means that there is a high probability of short-term trend change from downtrend to uptrend. Therefore RSI above 50 is our first trend filter to look for a long position.
The MACD (Moving Average Convergence Divergence) is a popular momentum and trend-following indicator used in technical analysis. It helps traders identify changes in the strength, direction, momentum, and duration of a trend in an asset's price.
The MACD consists of three components:
MACD Line: This is the difference between a short-term Exponential Moving Average (EMA) and a long-term EMA, typically calculated as: MACD Line = 12 period EMA − 26 period EMA
Signal Line: This is a 9-period EMA of the MACD Line, which helps to identify buy or sell signals. When the MACD Line crosses above the Signal Line, it can be a bullish signal (suggesting a buy); when it crosses below, it can be a bearish signal (suggesting a sell).
Histogram: The histogram shows the difference between the MACD Line and the Signal Line, visually representing the momentum of the trend. Positive histogram values indicate increasing bullish momentum, while negative values indicate increasing bearish momentum.
This strategy uses MACD as a second short-term trend filter. When MACD line crossed over the signal line there is a high probability that uptrend has been started. Therefore MACD line above signal line is our additional short-term trend filter. In conjunction with RSI it decreases probability of following false trend change signals.
The Stochastic Indicator is a momentum oscillator that compares a security's closing price to its price range over a specific period. It's used to identify overbought and oversold conditions. The indicator ranges from 0 to 100, with readings above 80 indicating overbought conditions and readings below 20 indicating oversold conditions.
It consists of two lines:
%K: The main line, calculated using the formula (CurrentClose−LowestLow)/(HighestHigh−LowestLow)×100 . Highest and lowest price taken for 14 periods.
%D: A smoothed moving average of %K, often used as a signal line.
This strategy uses stochastic to define the overbought conditions. The logic here is the following: we want to avoid long trades in the overbought territory, because when indicator reaches it there is a high probability that the potential move is gonna be restricted.
The 200-period EMA is a widely recognized indicator for identifying the long-term trend direction. The strategy only trades in the direction of this primary trend to increase the probability of successful trades. For instance, when the price is above the 200 EMA, only long trades are considered, aligning with the overarching trend direction.
Therefore, strategy uses combination of RSI and MACD to increase the probability that price now is in short-term uptrend, Stochastic helps to avoid the trades in the overbought (>80) territory. To increase the probability of opening long trades in the direction of a main trend and avoid local bounces we use 200 period EMA.
ATR is used to adjust the strategy risk management to the current market volatility. If volatility is low, we don’t need the large stop loss to understand the there is a high probability that we made a mistake opening the trade. User can setup the settings ATR Stop Loss and ATR Trailing Profit Activation Level to realize his own risk to reward preferences, but the unique feature of a strategy is that after reaching trailing profit activation level strategy is trying to follow the trend until it is likely to be finished instead of using fixed risk management settings. It allows sometimes to be involved in the large movements.
Backtest Results
Operating window: Date range of backtests is 2023.01.01 - 2024.08.01. It is chosen to let the strategy to close all opened positions.
Commission and Slippage: Includes a standard Binance commission of 0.1% and accounts for possible slippage over 5 ticks.
Initial capital: 10000 USDT
Percent of capital used in every trade: 30%
Maximum Single Position Loss: -3.94%
Maximum Single Profit: +15.78%
Net Profit: +1359.21 USDT (+13.59%)
Total Trades: 111 (36.04% win rate)
Profit Factor: 1.413
Maximum Accumulated Loss: 625.02 USDT (-5.85%)
Average Profit per Trade: 12.25 USDT (+0.40%)
Average Trade Duration: 40 hours
These results are obtained with realistic parameters representing trading conditions observed at major exchanges such as Binance and with realistic trading portfolio usage parameters.
How to Use
Add the script to favorites for easy access.
Apply to the desired timeframe and chart (optimal performance observed on 2h BTC/USDT).
Configure settings using the dropdown choice list in the built-in menu.
Set up alerts to automate strategy positions through web hook with the text: {{strategy.order.alert_message}}
Disclaimer:
Educational and informational tool reflecting Skyrex commitment to informed trading. Past performance does not guarantee future results. Test strategies in a simulated environment before live implementation
Points of InterestIndicator for displaying a timed, intraday Range of Price as a Point of Interest (POI) that you may want to track when trading as a potential magnet for price. Quite often you will see Price return to prior days price range before continuing to move. This enables you to track specific portions of a Days Trading session to see what has been revisited and what has not yet been re traded to.
The range is tracked for each trading day between the times that you specify in the Inputs ‘POI Time’ parameter You can also set the Time zone of the Range.
It will mark the Range High and Low for the timed range with lines that can be optionally extended and can be customised in terms of colour, style and width.
It will also Plot a line showing the Equilibrium of the range which is 50% from the High to the Low point of price during the time window that you specified in the ‘POI Time’ Parameter. This can also be customised in terms of visibility, colour, style and width.
You can control an optional Label for the POI Equilibrium Line to include a combination of a user defined prefix, the Date that the POI Equilibrium Line’s range is from and the Price Level of the Equilibrium Line. The colour and size of the label is also configurable
This indicator will also track when a POI Equilibrium Line has been traded to or ‘Tapped’. The tracking can be started after a configurable number of minutes have elapsed from the end of the POI Time window. This can also be customised in terms of visibility, colour, style, extended toggle and width.
Optionally Taps of the POI Equilibrium Level can be counted as valid during specific time windows or session of the day - for example only count taps during New York Morning Trading session.
The indicator uses Lower Time Frame data to compute the Range and 50% / Equilibrium Level so will work accurately on Chart Timeframes up to and including Daily with The POI Time specified down to a Minute resolution.
Theta Shield | Flux Charts💎 GENERAL OVERVIEW
Introducing our new Theta Shield indicator! Theta is the options risk factor concerning how fast there is a decline in the value of an option over time. This indicator aims to help the trader avoid sideways market phases in the current ticker, to minimize the risk of theta decay. For more information, please check the "How Does It Work" section.
Features of the new Theta Shield Indicator :
Foresight Of Accumulation Zones
Decrease Risk Of Theta Decay
Clear "Valid" & "Non-Valid" Signals
Validness Trail
Alerts
📌 HOW DOES IT WORK ?
In options trading, theta is defined as the rate of decline in the value of an option due to the passage of time. Traders want to avoid this kind of decay in the value of an option. One of the best ways to avoid it is not holding an option contract when the market is going sideways. This indicator uses a stochastic oscillator to try to get a foresight of sideways markets, warning the trader to not hold an option contract while the price is in a range.
The indicator starts by calculating the stochastic value using close, high & low prices of the candlesticks. Then a stoch threshold & a theta length are determined depending on the option contract type defined by the user in the settings of the indicator. Each candlestick that falls above or below the stoch threshold value is counted, and a "theta valid strength" is calculated using the counted candlesticks, which has a value between -100 & 100. Here is the formula of the "theta valid strength" value :
f_lin_interpolate(float x0, float x1, float y0, float y1, float x) =>
y0 + (x - x0) * (y1 - y0) / (x1 - x0)
thetaValid = Total Candlesticks That Fall Above & Below The Threshold In Last "Theta Length" bars.
thetaValidStrength = f_lin_interpolate(0, thetaLength, -100, 100, thetaValid)
Then a trail is rendered, and "Valid" & "Non-Valid" signals are given using this freshly calculated strength value. Valid means that the indicator currently thinks that no accumulation will happen in the near future, so the option positions in the current ticker are protected from the theta decay. Non-Valid means that the indicator thinks the ticker has entered the accumulation phase, so holding any option position is not recommended, as they may be affected by the theta decay.
🚩 UNIQUENESS
This indicator offers a unique way to avoid theta decay in options trading. It uses a stochastic oscillator and thresholds to calculate a "theta strength" value, which is used for rendering validness signals and a trail. Traders can follow the valid & non-valid signals when deciding to hold their options position or not. The indicator also has an alerts feature, so you can get notified when a ticker is about to enter a range, or when it's about to get out of it.
⚙️ SETTINGS
1. General Configuration
Contract Type -> You can set the option contract type here. The indicator will adjust itself to get a better foresight depending on the contract length.
2. Style
Fill Validness -> Will render a trail based on "theta strength" value.