Simple RSI stock Strategy [1D] The "Simple RSI Stock Strategy " is designed to long-term traders. Strategy uses a daily time frame to capitalize on signals generated by the Relative Strength Index (RSI) and the Simple Moving Average (SMA). This strategy is suitable for low-leverage trading environments and focuses on identifying potential buy opportunities when the market is oversold, while incorporating strong risk management with both dynamic and static Stop Loss mechanisms.
This strategy is recommended for use with a relatively small amount of capital and is best applied by diversifying across multiple stocks in a strong uptrend, particularly in the S&P 500 stock market. It is specifically designed for equities, and may not perform well in other markets such as commodities, forex, or cryptocurrencies, where different market dynamics and volatility patterns apply.
Indicators Used in the Strategy:
1. RSI (Relative Strength Index):
- The RSI is a momentum oscillator used to identify overbought and oversold conditions in the market.
- This strategy enters long positions when the RSI drops below the oversold level (default: 30), indicating a potential buying opportunity.
- It focuses on oversold conditions but uses a filter (SMA 200) to ensure trades are only made in the context of an overall uptrend.
2. SMA 200 (Simple Moving Average):
- The 200-period SMA serves as a trend filter, ensuring that trades are only executed when the price is above the SMA, signaling a bullish market.
- This filter helps to avoid entering trades in a downtrend, thereby reducing the risk of holding positions in a declining market.
3. ATR (Average True Range):
- The ATR is used to measure market volatility and is instrumental in setting the Stop Loss.
- By multiplying the ATR value by a custom multiplier (default: 1.5), the strategy dynamically adjusts the Stop Loss level based on market volatility, allowing for flexibility in risk management.
How the Strategy Works:
Entry Signals:
The strategy opens long positions when RSI indicates that the market is oversold (below 30), and the price is above the 200-period SMA. This ensures that the strategy buys into potential market bottoms within the context of a long-term uptrend.
Take Profit Levels:
The strategy defines three distinct Take Profit (TP) levels:
TP 1: A 5% from the entry price.
TP 2: A 10% from the entry price.
TP 3: A 15% from the entry price.
As each TP level is reached, the strategy closes portions of the position to secure profits: 33% of the position is closed at TP 1, 66% at TP 2, and 100% at TP 3.
Visualizing Target Points:
The strategy provides visual feedback by plotting plotshapes at each Take Profit level (TP 1, TP 2, TP 3). This allows traders to easily see the target profit levels on the chart, making it easier to monitor and manage positions as they approach key profit-taking areas.
Stop Loss Mechanism:
The strategy uses a dual Stop Loss system to effectively manage risk:
ATR Trailing Stop: This dynamic Stop Loss adjusts based on the ATR value and trails the price as the position moves in the trader’s favor. If a price reversal occurs and the market begins to trend downward, the trailing stop closes the position, locking in gains or minimizing losses.
Basic Stop Loss: Additionally, a fixed Stop Loss is set at 25%, limiting potential losses. This basic Stop Loss serves as a safeguard, automatically closing the position if the price drops 25% from the entry point. This higher Stop Loss is designed specifically for low-leverage trading, allowing more room for market fluctuations without prematurely closing positions.
to determine the level of stop loss and target point I used a piece of code by RafaelZioni, here is the script from which a piece of code was taken
Together, these mechanisms ensure that the strategy dynamically manages risk while offering robust protection against significant losses in case of sharp market downturns.
The position size has been estimated by me at 75% of the total capital. For optimal capital allocation, a recommended value based on the Kelly Criterion, which is calculated to be 59.13% of the total capital per trade, can also be considered.
Enjoy !
ابحث في النصوص البرمجية عن "电脑桌面显示BTC"
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)))
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.
CVD with Moving Average (Trend Colors) [SYNC & TRADE]Yesterday I wrote a simple and easy code for the indicator "Cumulative Delta Volume with a moving average" using AI.
Introduction:
Delta is the difference between buys and sells. If there are more purchases, the delta is positive, if there are more sales, the delta is negative. We look at each candle separately on a particular time frame, which does not give us an overall picture over time.
Cumulative volume delta is in many ways an extension of volume delta, but it covers longer periods of time and provides different trading signals. Like the volume delta indicator, the Cumulative Volume Delta (CVD) indicator measures the relationship between buying and selling pressure, but does not focus on one specific candle (or other chart element), but rather gives a picture over time.
What did you want to get?
I have often seen that they tried to attach RSI and the Ichimoku cloud to the cumulative delta of volume, but I have never seen a cumulative delta of volume with a moving average. A moving average that takes data from the cumulative volume delta will be different from the moving average of the underlying asset. It has been noted that often at the intersection of the cumulative volume delta and the moving average, this is a more accurate signal to buy or sell than the same intersections for the underlying asset.
Initially, 5 moving averages were made with values of 21, 55, 89, 144 and 233, but I realized that this overloads the chart. It is easier to change the length of the moving average depending on the time frame you are using than to overload the chart. The final version with one moving SMA, EMA, RMA, WMA, HMA.
The logic for applying a moving average to a cumulative volume delta:
You choose a moving average, just like you would on your underlying asset. Use the moving average you like and the period you are used to working with. Each TF has its own settings.
What we see on the graph:
This is not an oscillator, but an adapted version for a candlestick chart (line only). Using it, you can clearly see where the market is moving based on the cumulative volume delta. The cool thing is that you can include your moving average applied to the cumulative volume delta. Thanks to this, you can see a trend movement, a return to the moving average to continue the trend.
Opportunities not lost:
The most interesting thing is that it remains possible to observe the divergence of the asset and the cumulative delta of the volume. This gives a great advantage. Those who have not worked with divergence do not rush into it right away. There may be 3 peaks in divergence (as with oversold/overbought), but it works many times more clearly than RSI and MACD.
Here's a good example on the daily chart. The moment we were all waiting for 75,000. The cumulative Delta Volume fell with each peak, while the price chart (tops) were approximately level.
Usually they throw (allow to buy) without volume for sales (delta down, price up) in order to merge at a more interesting price. And they also drain without the volume of purchases for a squeeze (price down / delta up) and again I buy back at a more interesting price. There are more complex estimation options; you can read about the divergence of the cumulative delta of the CVD volume. I just recommend doing a backtest.
Recommendations:
One more moment. Use the indicator on the stock exchange, where there is the most money, by turnover and by asset. Choose Binance, not Bybit. Those. choose the BTC asset, for example, but on the Binance exchange. Not futures, but spot.
The greater the turnover on the exchange for an asset, and the fewer opportunities to enter with leverage, the less volatile the price and the more beautiful and accurate the chart.
Works on all assets. There is a subscription limit (the number of calculated bars) that has little effect on anything. Can be applied to any asset where there is volume (not SPX, but ES1, not MOEX, but MX1!).
Перевод на русский.
Вчера написал с помощью AI простой и легкий код индикатора "Кумулятивная Дельта Объема со скользящей средней".
Введение:
Дельта (Delta) — это разница между покупками и продажами. Если покупок больше — дельта положительная, если больше продаж — дельта отрицательная. Мы смотрим на каждую свечу отдельно на том или ином таймфрейме, что не дает нам общей картины во времени.
Кумулятивная дельта объема — во многом продолжение дельты объёмов, но она включает более длительные периоды времени и дает другие торговые сигналы. Как и индикатор дельты объёма, индикатор кумулятивной дельты объема (Cumulative Volume Delta, CVD) измеряет связь между давлением покупателей и продавцов, но при этом не фокусируется на одной конкретной свече (или другом элементе графика), а дает картину во времени.
Что хотел получить?
Часто видел, что к кумулятивной детьте объема пытались прикрепить RSI и облако ишимоку, но никогда не видел кумулятивную дельту объема со скользящей средней. Скользящая средняя которая берет данные от кумулятивной дельты объема будет отличатся от скользящей средней основного актива. Было замечено, что часто в местах пересечения кумулятивной дельты объема и скользящей средней - это более точный сигнал к покупке или продаже, чем такие же пересечения по основному активу.
Изначально было сделанно 5 скользящих со значениями 21, 55, 89, 144 и 233, но я понял, что это перегружает график. Проще менять длину скользящей средней от используемого таймфрейма, чем перегружать график. Финальный вариант с одной скользящей SMA, EMA, RMA, WMA, HMA.
Логика применения скользящей средней к кумулятивной дельте объема:
Вы выбираете скользящую среднюю, так же как и на основном активе. Применяйте ту скользящую среднюю, которая вам нравится и период, с которым привыкли работать. На каждом TF свои настройки.
Что мы видим на графике:
Это не осциллятор, а адаптированная версия к свечному графику (только линия). С помощью него вы можете наглядно посмотреть куда движется рынок по кумулятивной дельте объема. Самое интересное, что вы можете включить свою скользящую среднюю, применимую к кумулятивной дельте объема. Благодаря этому вы можете видеть трендовое движение, возврат к средней скользящей для продолжения тренда.
Не потерянные возможности:
Самое интересное, что осталась возможность наблюдать за дивергенцией актива и кумулятивной дельтой объема. Это дает большое преимущество. Те кто не работал с дивергенцией не бросайтесь на нее сразу. Может быть и 3 пика в дивергенции (как с перепроданностью / перекупленностью), но работает в разы четче чем RSI и MACD.
Вот хороший пример на дневном графике. Момент когда мы все ждали 75000. Кумулятивная Дельта Объема падала с каждым пиком, в то время как ценовой график (вершины) были примерно на уровне.
Обычно закидывают (разрешают покупать) без объема на продажи (дельта вниз цена вверх), чтобы слить по более интересной цене. И также сливают без объема покупок для сквиза (цена вниз / дельта вверх) и опять откупаю по более интересной цене. Существуют более сложные варианты оценки, можете почитать про дивергенцию кумулятивной дельты объема CVD. Только рекомендую сделать бэктест.
Рекомендации:
Еще момент. Используйте индикатор, на бирже, там где больше всего денег, по обороту и по активу. Выбирайте не Bybit, а Binance. Т.е. выбираете актив BTC, к примеру, но на бирже Binance. Не фьючерс, а спот.
Чем более большие обороты на бирже, по активу, и меньше возможностей заходить с плечами, тем менее волатильная цена и более красивый и точный график.
Работает на всех активах. Есть ограничение по подписке (количество рассчитываемых баров) мало влияет на что. Можно применить к любому активу где есть объем (не SPX, а ES1, не MOEX, а MX1!).
Fibo Level DailyOverview
The "Fibo Level Daily" strategy is designed for trading Bitcoin (BTC) using the 1-hour timeframe. This strategy relies on Fibonacci levels calculated from the previous day's range and determines entry and exit points based on whether the previous daily candle was bullish or bearish.
How It Works
Fibonacci Levels Calculation:
The indicator calculates Fibonacci levels (0.8, 0.5, and 0.2) based on the high and low of the previous day.
The levels are calculated as follows:
0.8: This level is calculated by multiplying the difference between the previous day's high and low by 0.8 and adding the result to the previous day's low.
0.5: This is the midpoint of the previous day's range.
0.2: This level is calculated by multiplying the difference between the previous day's high and low by 0.2 and adding the result to the previous day's low.
Identifying the Previous Day's Trend:
The indicator checks if the previous daily candle closed bullish (close greater than open) or bearish (close less than open).
Setting Entry and Take Profit Levels:
If the previous daily candle was bearish:
Sell Entry: Wait for the price to rise to the 0.5 level (midpoint of the previous day's range) to enter a sell position.
Take Profit: The profit target is set at the 0.2 level.
If the previous daily candle was bullish:
Buy Entry: Wait for the price to drop to the 0.5 level (midpoint of the previous day's range) to enter a buy position.
Take Profit: The profit target is set at the 0.8 level.
Visual Representation on the Chart:
The indicator draws horizontal lines on the chart representing the Fibonacci levels (0.8, 0.5, and 0.2) from the previous day. These lines help visualize entry and exit points clearly.
Additionally, the last 15 minutes of the daily session are highlighted with a light red background to indicate the session's end.
Conditions of Use:
Timeframe: This indicator is specifically designed for use on the 1-hour timeframe.
Assets: While it can be used on any asset, it is optimized for trading Bitcoin (BTC).
Steps to Use the Indicator
Add the Indicator:
Insert the "Fibo Level Daily" indicator script into your trading platform (such as TradingView).
Select Timeframe:
Change the chart timeframe to 1 hour.
Interpret the Levels:
Observe the horizontal lines drawn on the chart representing the Fibonacci levels.
Identify whether the previous daily candle was bullish or bearish.
Wait for the Entry Price:
For a bearish previous daily candle: Wait for the price to rise to the 0.5 level to enter a sell position.
For a bullish previous daily candle: Wait for the price to drop to the 0.5 level to enter a buy position.
Set the Profit Target:
For a sell: Set your profit target at the 0.2 level.
For a buy: Set your profit target at the 0.8 level.
Execute the Trade:
Initiate the trade once the price reaches the entry level and set your take profit according to the identified trend from the previous day.
Conclusion
The "Fibo Level Daily" strategy provides a clear and precise methodology for identifying entry and exit points in Bitcoin using Fibonacci levels. By following this step-by-step guide, any trader can take advantage of market movements based on the previous day's price action, optimizing their trading opportunities on the 1-hour timeframe.
Volume Weighted Average Price Ratio (log) [ilyaQwerty]The VWAP Ratio indicator is a valuable tool for traders aiming to assess market trends and price movements in relation to the Volume Weighted Average Price (VWAP). Volume Weighted Average Price Ratio represents the ratio of the price of the asset compared to total traded volume in US Dollars. In a context of Bitcoin, VWAP ratio helps traders assess the market state, if it is overvalued or undervalued. High values of the indicator can suggest that the market is highly overvalued and low values can indicate a great buying opportunity.
Ratio Calculation: The VWAP Ratio is computed by dividing the current price by the VWAP (Price / VWAP). VWAP represents a ratio between a cumulative sum of a traded value (price multiplied by the volume) and a cumulative traded volume.
BTC-Specific Optimization: Although the indicator can be applied to various assets, the VWAP Ratio indicator is particularly useful for Bitcoin (BTC) due to its significant trading volume and unique market behaviour.
Strategic Multi-Step Supertrend - Strategy [presentTrading]The code is mainly developed for me to stimulate the multi-step taking profit function for strategies. The result shows the drawdown can be reduced but at the same time reduced the profit as well. It can be a heuristic for futures leverage traders.
█ Introduction and How it is Different
The "Strategic Multi-Step Supertrend" is a trading strategy designed to leverage the power of multiple steps to optimize trade entries and exits across the Supertrend indicator. Unlike traditional strategies that rely on single entry and exit points, this strategy employs a multi-step approach to take profit, allowing traders to lock in gains incrementally. Additionally, the strategy is adaptable to both long and short trades, providing a comprehensive solution for dynamic market conditions.
This template strategy lies in its dual Supertrend calculation, which enhances the accuracy of trend detection and provides more reliable signals for trade entries and exits. This approach minimizes false signals and increases the overall profitability of trades by ensuring that positions are entered and exited at optimal points.
BTC 6h L/S Performance
█ Strategy, How It Works: Detailed Explanation
The "Strategic Multi-Step Supertrend Trader" strategy utilizes two Supertrend indicators calculated with different parameters to determine the direction and strength of the market trend. This dual approach increases the robustness of the signals, reducing the likelihood of entering trades based on false signals. Here is a detailed breakdown of how the strategy operates:
🔶 Supertrend Indicator Calculation
The Supertrend indicator is a trend-following overlay on the price chart, typically used to identify the direction of the trend. It is calculated using the Average True Range (ATR) to ensure that the indicator adapts to market volatility. The formula for the Supertrend indicator is:
Upper Band = (High + Low) / 2 + (Factor * ATR)
Lower Band = (High + Low) / 2 - (Factor * ATR)
Where:
- High and Low are the highest and lowest prices of the period.
- Factor is a user-defined multiplier.
- ATR is the Average True Range over a specified period.
The Supertrend changes its direction based on the closing price in relation to these bands.
🔶 Entry-Exit Conditions
The strategy enters long positions when both Supertrend indicators signal an uptrend, and short positions when both indicate a downtrend. Specifically:
- Long Condition: Supertrend1 < 0 and Supertrend2 < 0
- Short Condition: Supertrend1 > 0 and Supertrend2 > 0
- Long Exit Condition: Supertrend1 > 0 and Supertrend2 > 0
- Short Exit Condition: Supertrend1 < 0 and Supertrend2 < 0
🔶 Multi-Step Take Profit Mechanism
The strategy features a multi-step take profit mechanism, which allows traders to lock in profits incrementally. This is achieved through four user-configurable take profit levels. For each level, the strategy specifies a percentage increase (for long trades) or decrease (for short trades) in the entry price at which a portion of the position is exited:
- Step 1: Exit a portion of the trade at Entry Price * (1 + Take Profit Percent1 / 100)
- Step 2: Exit a portion of the trade at Entry Price * (1 + Take Profit Percent2 / 100)
- Step 3: Exit a portion of the trade at Entry Price * (1 + Take Profit Percent3 / 100)
- Step 4: Exit a portion of the trade at Entry Price * (1 + Take Profit Percent4 / 100)
This staggered exit strategy helps in locking profits at multiple levels, thereby reducing risk and increasing the likelihood of capturing the maximum possible profit from a trend.
BTC Local
█ Trade Direction
The strategy is highly flexible, allowing users to specify the trade direction. There are three options available:
- Long Only: The strategy will only enter long trades.
- Short Only: The strategy will only enter short trades.
- Both: The strategy will enter both long and short trades based on the Supertrend signals.
This flexibility allows traders to adapt the strategy to various market conditions and their own trading preferences.
█ Usage
1. Add the strategy to your trading platform and apply it to the desired chart.
2. Configure the take profit settings under the "Take Profit Settings" group.
3. Set the trade direction under the "Trade Direction" group.
4. Adjust the Supertrend settings in the "Supertrend Settings" group to fine-tune the indicator calculations.
5. Monitor the chart for entry and exit signals as indicated by the strategy.
█ Default Settings
- Use Take Profit: True
- Take Profit Percentages: Step 1 - 6%, Step 2 - 12%, Step 3 - 18%, Step 4 - 50%
- Take Profit Amounts: Step 1 - 12%, Step 2 - 8%, Step 3 - 4%, Step 4 - 0%
- Number of Take Profit Steps: 3
- Trade Direction: Both
- Supertrend Settings: ATR Length 1 - 10, Factor 1 - 3.0, ATR Length 2 - 11, Factor 2 - 4.0
These settings provide a balanced starting point, which can be customized further based on individual trading preferences and market conditions.
Volume-Supported Linear Regression Trend Modified StrategyHi everyone, this will be my first published script on Tradingview, maybe more to come.
For quite some time I have been looking for a script that performs no matter if price goes up or down or sideways. I believe this strategy comes pretty close to that. Although nowhere near the so called "buy&hold equity" of BTC, it has produced consistent profits even when price goes down.
It is a strategy which seems to work best on the 1H timeframe for cryptocurrencies.
Just by testing different settings for SL and TP you can customize it for each pair.
THE STRATEGY:
Basically, I used the Volume Supported Linear Regression Trend Model that LonesomeTheBlue has created and modified a few things such as entry and exit conditions. So all credits go to him!
LONG ENTRY: When there is a bullish cross of the short term trend (the histogram/columns), while the long term trend is above 0 and rising.
SHORT ENTRY: When there is a bearish cross (green to red) of the short-term trend (the histogram/columns), while the long term trend is beneath 0 and decreasing.
LONG EXIT: Bearish crossover of short-term trend while long term trend is below 0
SHORT EXIT: Bullish crossover of short-term trend while long term trend is above 0
Combining this with e.g. a SL of 2% and a TP of 20% (as used in my backtesting), combined with pyramiding and correct risk management, it gives pretty consistent results.
Be aware, this is only for educational purpose and in no means financial advise. Past results do not guarantee future results. This strategy can lose money!
Enjoy :)
PS: It works not only on BTC of course, works even better on some other major crypto pairs. I'll leave it to you to find out which ones ;)
Vegas SuperTrend Enhanced - Strategy [presentTrading]█ Introduction and How it is Different
The "Vegas SuperTrend Enhanced - Strategy " trading strategy represents a novel integration of two powerful technical analysis tools: the Vegas Channel and the SuperTrend indicator. This fusion creates a dynamic, adaptable strategy designed for the volatile and fast-paced cryptocurrency markets, particularly focusing on Bitcoin trading.
Unlike traditional trading strategies that rely on a static set of rules, this approach modifies the SuperTrend's sensitivity to market volatility, offering traders the ability to customize their strategy based on current market conditions. This adaptability makes it uniquely suited to navigating the often unpredictable swings in cryptocurrency valuations, providing traders with signals that are both timely and reflective of underlying market dynamics.
BTC 6h LS
█ Strategy, How it Works: Detailed Explanation
This is an innovative approach that combines the volatility-based Vegas Channel with the trend-following SuperTrend indicator to create dynamic trading signals. This section delves deeper into the mechanics and mathematical foundations of the strategy.
Detail picture to show :
🔶 Vegas Channel Calculation
The Vegas Channel serves as the foundation of this strategy, employing a simple moving average (SMA) coupled with standard deviation to define the upper and lower bounds of the trading channel. This channel adapts to price movements, offering a visual representation of potential support and resistance levels based on historical price volatility.
🔶 SuperTrend Indicator Adjustment
Central to the strategy is the SuperTrend indicator, which is adjusted according to the width of the Vegas Channel. This adjustment is achieved by modifying the SuperTrend's multiplier based on the channel's volatility, allowing the indicator to become more sensitive during periods of high volatility and less so during quieter market phases.
🔶 Trend Determination and Signal Generation
The market trend is determined by comparing the current price with the SuperTrend values. A shift from below to above the SuperTrend line signals a potential bullish trend, prompting a "buy" signal, whereas a move from above to below indicates a bearish trend, generating a "sell" signal. This methodology ensures that trades are entered in alignment with the prevailing market direction, enhancing the potential for profitability.
BTC 6h Local
█ Trade Direction
A distinctive feature of this strategy is its configurable trade direction input, allowing traders to specify whether they wish to engage in long positions, short positions, or both. This flexibility enables users to tailor the strategy according to their risk tolerance, trading style, and market outlook, providing a personalized trading experience.
█ Usage
To utilize the "Vegas SuperTrend - Enhanced" strategy effectively, traders should first adjust the input settings to align with their trading preferences and the specific characteristics of the asset being traded. Monitoring the strategy's signals within the context of overall market conditions and combining its insights with other forms of analysis can further enhance its effectiveness.
█ Default Settings
- Trade Direction: Both (allows trading in both directions)
- ATR Period for SuperTrend: 10 (determines the length of the ATR for volatility measurement)
- Vegas Window Length: 100 (sets the length of the SMA for the Vegas Channel)
- SuperTrend Multiplier Base: 5 (base multiplier for SuperTrend calculation)
- Volatility Adjustment Factor: 5.0 (adjusts SuperTrend sensitivity based on Vegas Channel width)
These default settings provide a balanced approach suitable for various market conditions but can be adjusted to meet individual trading needs and objectives.
Bitcoin Regression Price BoundariesTLDR
DCA into BTC at or below the blue line. DCA out of BTC when price approaches the red line. There's a setting to toggle the future extrapolation off/on.
INTRODUCTION
Regression analysis is a fundamental and powerful data science tool, when applied CORRECTLY . All Bitcoin regressions I've seen (Rainbow Log, Stock-to-flow, and non-linear models), have glaring flaws ... Namely, that they have huge drift from one cycle to the next.
Presented here, is a canonical application of this statistical tool. "Canonical" meaning that any trained analyst applying the established methodology, would arrive at the same result. We model 3 lines:
Upper price boundary (red) - Predicted the April 2021 top to within 1%
Lower price boundary (green)- Predicted the Dec 2022 bottom within 10%
Non-bubble best fit line (blue) - Last update was performed on Feb 28 2024.
NOTE: The red/green lines were calculated using solely data from BEFORE 2021.
"I'M INTRUIGED, BUT WHAT EXACTLY IS REGRESSION ANALYSIS?"
Quite simply, it attempts to draw a best-fit line over some set of data. As you can imagine, there are endless forms of equations that we might try. So we need objective means of determining which equations are better than others. This is where statistical rigor is crucial.
We check p-values to ensure that a proposed model is better than chance. When comparing two different equations, we check R-squared and Residual Standard Error, to determine which equation is modeling the data better. We check residuals to ensure the equation is sufficiently complex to model all the available signal. We check adjusted R-squared to ensure the equation is not *overly* complex and merely modeling random noise.
While most people probably won't entirely understand the above paragraph, there's enough key terminology in for the intellectually curious to research.
DIVING DEEPER INTO THE 3 REGRESSION LINES ABOVE
WARNING! THIS IS TECHNICAL, AND VERY ABBREVIATED
We prefer a linear regression, as the statistical checks it allows are convenient and powerful. However, the BTCUSD dataset is decidedly non-linear. Thus, we must log transform both the x-axis and y-axis. At the end of this process, we'll use e^ to transform back to natural scale.
Plotting the log transformed data reveals a crucial visual insight. The best fit line for the blowoff tops is different than for the lower price boundary. This is why other models have failed. They attempt to model ALL the data with just one equation. This causes drift in both the upper and lower boundaries. Here we calculate these boundaries as separate equations.
Upper Boundary (in red) = e^(3.24*ln(x)-15.8)
Lower Boundary (green) = e^(0.602*ln^2(x) - 4.78*ln(x) + 7.17)
Non-Bubble best fit (blue) = e^(0.633*ln^2(x) - 5.09*ln(x) +8.12)
* (x) = The number of days since July 18 2010
Anyone familiar with Bitcoin, knows it goes in cycles where price goes stratospheric, typically measured in months; and then a lengthy cool-off period measured in years. The non-bubble best fit line methodically removes the extreme upward deviations until the residuals have the closest statistical semblance to normal data (bell curve shaped data).
Whereas the upper/lower boundary only gets re-calculated in hindsight (well after a blowoff or capitulation occur), the Non-Bubble line changes ever so slightly with each new datapoint. The last update to this line was made on Feb 28, 2024.
ENOUGH NERD TALK! HOW CAN I APPLY THIS?
In the simplest terms, anything below the blue line is a statistical buying opportunity. The closer you approach the green line (the lower boundary) the more statistically strong that opportunity is. As price approaches the red line, is a growing statistical likelyhood/danger of an imminent blowoff top.
So a wise trader would DCA (dollar cost average) into Bitcoin below the blue line; and would DCA out of Bitcoin as it approaches the red line. Historically, you may or may not have a large time-window during points of maximum opportunity. So be vigilant! Anything within 10-20% of the boundary should be regarded as extreme opportunity.
Note: You can toggle the future extrapolation of these lines in the settings (default on).
CLOSING REMARKS
Keep in mind this is a pure statistical analysis. It's likely that this model is probing a complex, real economic process underlying the Bitcoin price. Statistical models like this are most accurate during steady state conditions, where the prevailing fundamentals are stable. (The astute observer will note, that the regression boundaries held despite the economic disruption of 2020).
Thus, it cannot be understated: Should some drastic fundamental change occur in the underlying economic landscape of cryptocurrency, Bitcoin itself, or the broader economy, this model could drastically deviate, and become significantly less accurate.
Furthermore, the upper/lower boundaries cross in the year 2037. THIS MODEL WILL EVENTUALLY BREAK DOWN. But for now, given that Bitcoin price moves on the order of 2000% from bottom to top, it's truly remarkable that, using SOLELY pre-2021 data, this model was able to nail the top/bottom within 10%.
Donchian Quest Research// =================================
Trend following strategy.
// =================================
Strategy uses two channels. One channel - for opening trades. Second channel - for closing.
Channel is similar to Donchian channel, but uses Close prices (not High/Low). That helps don't react to wicks of volatile candles (“stop hunting”). In most cases openings occur earlier than in Donchian channel. Closings occur only for real breakout.
// =================================
Strategy waits for beginning of trend - when price breakout of channel. Default length of both channels = 50 candles.
Conditions of trading:
- Open Long: If last Close = max Close for 50 closes.
- Close Long: If last Close = min Close for 50 closes.
- Open Short: If last Close = min Close for 50 closes.
- Close Short: If last Close = max Close for 50 closes.
// =================================
Color of lines:
- black - channel for opening trade.
- red - channel for closing trade.
- yellow - entry price.
- fuchsia - stoploss and breakeven.
- vertical green - go Long.
- vertical red - go Short.
- vertical gray - close in end, don't trade anymore.
// =================================
Order size calculated with ATR and volatility.
You can't trade 1 contract in BTC and 1 contract in XRP - for example. They have different price and volatility, so 1 contract BTC not equal 1 contract XRP.
Script uses universal calculation for every market. It is based on:
- Risk - USD sum you ready to loss in one trade. It calculated as percent of Equity.
- ATR indicator - measurement of volatility.
With default setting your stoploss = 0.5 percent of equity:
- If initial capital is 1000 USD and used parameter "Permit stop" - loss will be 5 USD (0.5 % of equity).
- If your Equity rises to 2000 USD and used parameter "Permit stop"- loss will be 10 USD (0.5 % of Equity).
// =================================
This Risk works only if you enable “Permit stop” parameter in Settings.
If this parameter disabled - strategy works as reversal strategy:
⁃ If close Long - channel border works as stoploss and momentarily go Short.
⁃ If close Short - channel border works as stoploss and momentarily go Long.
Channel borders changed dynamically. So sometime your loss will be greater than ‘Risk %’. Sometime - less than ‘Risk %’.
If this parameter enabled - maximum loss always equal to 'Risk %'. This parameter also include breakeven: if profit % = Risk %, then move stoploss to entry price.
// =================================
Like all trend following strategies - it works only in trend conditions. If no trend - slowly bleeding. There is no special additional indicator to filter trend/notrend. You need to trade every signal of strategy.
Strategy gives many losses:
⁃ 30 % of trades will close with profit.
⁃ 70 % of trades will close with loss.
⁃ But profit from 30% will be much greater than loss from 70 %.
Your task - patiently wait for it and don't use risky setting for position sizing.
// =================================
Recommended timeframe - Daily.
// =================================
Trend can vary in lengths. Selecting length of channels determine which trend you will be hunting:
⁃ 20/10 - from several days to several weeks.
⁃ 20/20 or 50/20 - from several weeks to several months.
⁃ 50/50 or 100/50 or 100/100 - from several months to several years.
// =================================
Inputs (Settings):
- Length: length of channel for trade opening/closing. You can choose 20/10, 20/20, 50/20, 50/50, 100/50, 100/100. Default value: 50/50.
- Permit Long / Permit short: Longs are most profitable for this strategy. You can disable Shorts and enable Longs only. Default value: permit all directions.
- Risk % of Equity: for position sizing used Equity percent. Don't use values greater than 5 % - it's risky. Default value: 0.5%.
⁃ ATR multiplier: this multiplier moves stoploss up or down. Big multiplier = small size of order, small profit, stoploss far from entry, low chance of stoploss. Small multiplier = big size of order, big profit, stop near entry, high chance of stoploss. Default value: 2.
- ATR length: number of candles to calculate ATR indicator. It used for order size and stoploss. Default value: 20.
- Close in end - to close active trade in the end (and don't trade anymore) or leave it open. You can see difference in Strategy Tester. Default value: don’t close.
- Permit stop: use stop or go reversal. Default value: without stop, reversal strategy.
// =================================
Properties (Settings):
- Initial capital - 1000 USD.
- Script don't uses 'Order size' - you need to change 'Risk %' in Inputs instead.
- Script don't uses 'Pyramiding'.
- 'Commission' 0.055 % and 'Slippage' 0 - this parameters are for crypto exchanges with perpetual contracts (for example Bybit). If use on other markets - set it accordingly to your exchange parameters.
// =================================
Big dataset used for chart - 'BITCOIN ALL TIME HISTORY INDEX'. It gives enough trades to understand logic of script. It have several good trends.
// =================================
Crypto Market OverviewCrypto Market Overview
The Crypto Market Overview (CMO) indicator is your one-stop tool for keeping tabs on the cryptocurrency market. It provides a comprehensive snapshot of key data and trends, helping you make informed decisions in the fast-paced world of crypto trading. Here's what this indicator offers:
1. Lookback Period Control:
You can customize the lookback period for percentage change calculations, tailoring it to your specific analysis needs.
2. Currency Selection:
Choose your preferred currency to view market data in your desired denomination.
3. Major Market Cap Data:
Real-time information on Bitcoin (BTC) and Ethereum (ETH) market caps.
Total market capitalization data for the entire crypto market.
4. Stablecoin Market Cap Data:
Keep track of stablecoin market caps, including USDT, USDC, DAI, TUSD, and BUSD.
Get a clear picture of the stablecoin segment of the market.
5. Shitcoin Market Cap Data:
An interesting category that represents the market cap of all cryptocurrencies not classified as major or stable.
6. Dominance Data:
Dominance percentages for BTC, ETH, stablecoins and shitcoins.
Total market dominance, allowing you to gauge the influence of major cryptocurrencies.
7. Rate of Change (RoC) Metrics:
Monitor the RoC for market caps and dominance percentages.
Positive or negative trends are clearly highlighted with color-coded indicators.
8. Intuitive Table Layout:
A user-friendly table layout displays all the data.
Key assets such as Bitcoin and Ethereum are listed along with their market caps and dominance.
9. Color Coding:
Upward and downward trends are easily identifiable with color-coded cells.
A white background with bold text ensures readability.
The Crypto Market Overview indicator is an invaluable tool for cryptocurrency traders and enthusiasts, offering a quick and convenient way to stay updated on market dynamics. It's perfect for making data-driven decisions in the ever-changing world of digital assets.
Multi-TF AI SuperTrend with ADX - Strategy [PresentTrading]
## █ Introduction and How it is Different
The trading strategy in question is an enhanced version of the SuperTrend indicator, combined with AI elements and an ADX filter. It's a multi-timeframe strategy that incorporates two SuperTrends from different timeframes and utilizes a k-nearest neighbors (KNN) algorithm for trend prediction. It's different from traditional SuperTrend indicators because of its AI-based predictive capabilities and the addition of the ADX filter for trend strength.
BTC 8hr Performance
ETH 8hr Performance
## █ Strategy, How it Works: Detailed Explanation (Revised)
### Multi-Timeframe Approach
The strategy leverages the power of multiple timeframes by incorporating two SuperTrend indicators, each calculated on a different timeframe. This multi-timeframe approach provides a holistic view of the market's trend. For example, a 8-hour timeframe might capture the medium-term trend, while a daily timeframe could capture the longer-term trend. When both SuperTrends align, the strategy confirms a more robust trend.
### K-Nearest Neighbors (KNN)
The KNN algorithm is used to classify the direction of the trend based on historical SuperTrend values. It uses weighted voting of the 'k' nearest data points. For each point, it looks at its 'k' closest neighbors and takes a weighted average of their labels to predict the current label. The KNN algorithm is applied separately to each timeframe's SuperTrend data.
### SuperTrend Indicators
Two SuperTrend indicators are used, each from a different timeframe. They are calculated using different moving averages and ATR lengths as per user settings. The SuperTrend values are then smoothed to make them suitable for KNN-based prediction.
### ADX and DMI Filters
The ADX filter is used to eliminate weak trends. Only when the ADX is above 20 and the directional movement index (DMI) confirms the trend direction, does the strategy signal a buy or sell.
### Combining Elements
A trade signal is generated only when both SuperTrends and the ADX filter confirm the trend direction. This multi-timeframe, multi-indicator approach reduces false positives and increases the robustness of the strategy.
By considering multiple timeframes and using machine learning for trend classification, the strategy aims to provide more accurate and reliable trade signals.
BTC 8hr Performance (Zoom-in)
## █ Trade Direction
The strategy allows users to specify the trade direction as 'Long', 'Short', or 'Both'. This is useful for traders who have a specific market bias. For instance, in a bullish market, one might choose to only take 'Long' trades.
## █ Usage
Parameters: Adjust the number of neighbors, data points, and moving averages according to the asset and market conditions.
Trade Direction: Choose your preferred trading direction based on your market outlook.
ADX Filter: Optionally, enable the ADX filter to avoid trading in a sideways market.
Risk Management: Use the trailing stop-loss feature to manage risks.
## █ Default Settings
Neighbors (K): 3
Data points for KNN: 12
SuperTrend Length: 10 and 5 for the two different SuperTrends
ATR Multiplier: 3.0 for both
ADX Length: 21
ADX Time Frame: 240
Default trading direction: Both
By customizing these settings, traders can tailor the strategy to fit various trading styles and assets.
Dip & Rip Patterns - The Quant Science🇺🇸
GENERAL OVERVIEW
This indicator detects Dip and Rip patterns by quickly highlighting them on the chart.
These patterns have become popular during the pandemic period mainly in the stock, ETF and cryptocurrency markets on which traders use two interesting strategies:
Buy The Dip
Sell The Rip
Before going into the merits of this technical indicator, let's understand what these two patterns mean and what they identify precisely.
Rip (Rise In Price) : wants to identify a market condition in which the price rises rapidly, for example from $100 to $110 in a few minutes or hours.
Dip (Drop In Price) : wants to identify a market condition in which the price drops rapidly, for example from $100 to $90 in a few minutes or hours.
HOW TO USE
For a better user experience, we recommend choosing a neutral colour for the candles while analysing with this indicator. You can quickly change the colour in Chart Settings > Symbol > Candles .
Depending on the configuration set by the user, the indicator will show Dip (Dip In Price) patterns in red and Rip (Rise In Price) patterns in green.
When the pattern forms, a circle will be displayed and a vertical line will be coloured on the chart along with the body of the candle. The user will then be able to quickly and easily track the configured market conditions.
In this example, we decided to use a 4H timeframe on the BTC/USDT pair (Binance).
Set in the user interface:
Period: 20
Dip (%): -25
Rip (%): 20
Price falls by 25% or more in 80 hours (Dip Pattern).
Price rise by 25% or more in 80 hours (Rip Pattern).
The user can easily configure the parameters via the user interface in the Inputs section (A) and change the indicator design in the Properties section (B).
🇮🇹
PANORAMICA GENERALE
Questo indicatore rileva i Dip e Rip patterns evidenziandoli velocemente sul grafico.
Questi patterns sono diventati famosi durante il periodo pandemico principalmente nel mercato delle azioni, ETF e Criptovalute su cui i trader utilizzano due interessanti strategie:
Buy The Dip
Sell The Rip
Prima di entrare nel merito di questo indicatore tecnico, comprendiamo il significato di questi due pattern e cosa identificano precisamente.
Rip (Rise In Price) : vuole identificare una condizione di mercato in cui il prezzo sale rapidamente, per esempio passando da 100$ a 110$ in pochi minuti o poche ore.
Dip (Drop In Price) : vuole identificare una condizione di mercato in cui il prezzo cala rapidamente, per esempio passando da 100$ a 90$ in pochi minuti o poche ore.
UTILIZZO
Per una migliore esperienza utente consigliamo di scegliere un colore neutro per le candele mentre si analizza con questo indicatore. Puoi cambiare velocemente il colore in Chart Settings > Symbol > Candles .
In base alla configurazione impostata dall'utente l'indicatore mostrerà in rosso i pattern Dip (Dip In Price) e in verde i pattern Rip (Rise In Price).
Quando il pattern si forma verrà visualizzato un cerchio e una linea verticale sul grafico che sarà colorata insieme al corpo della candela. L'utente quindi potrà tracciare facilmente e velocemente le condizioni di mercato configurate.
In questo esempio abbiamo deciso di utilizzare un timeframe 4H con l'obbiettivo di ricercare i patterns sul pair BTC/USDT (Binance).
Impostiamo nell'interfaccia utente:
Period: 20
Dip (%): -25
Rip (%): 20
Il prezzo diminuisce del 25% o più in 80 ore (Dip Pattern).
Il prezzo aumenta del 25% o più in 80 ore (Rip Pattern).
L' utente può configurare facilmente i parametri attraverso l'interfaccia utente nella sezione Inputs (A) e modificare il design dell'indicatore nella sezione Properties (B).
Volume Profile with a few polylinesThe base of "Volume Profile with a few polylines" is another script of mine, Volume Profile (Maps) .
The structure of maps is used to gather the data. However, the drawings is done with polylines.
This enables coders to draw an entire volume profile with just a few polylines, while the range is broader.
This results in the benefit to draw more "lines" than with line.new() / box.new() alone.
🔶 CONCEPTS
🔹 Polylines
polyline.new creates a new polyline instance and displays it on the chart, sequentially connecting all of the points in the `points` array with line segments.
The segments in the drawing can be straight or curved depending on the `curved` parameter.
In this script, points are connected, starting from the bottom. The created line moves up until there is a price level where a volume value needs to be displayed,
at which the line goes to the left to the concerning volume value, coming back at the same price level until the line returns to its initial x-axis,
after which the line will continue to rise until all values are displayed.
A polyline can contain maximum 10000 points (10K).
Since the line has to go back and forth, each price/volume line takes 3 points.
In the case that 20K bars all have a different price, we would need 60K points, or just 6 polylines. A maximum of 100 polylines can be displayed.
The 3 highest volume values are displayed with line.new(), each with their own colour.
🔹 Maps
A map object is a collection that consists of key - value pairs
Each key is unique and can only appear once. When adding a new value with a key that the map already contains, that value replaces the old value associated with the key .
You can change the value of a particular key though, for example adding volume (value) at the same price (key), the latter technique is used in this script.
Volume is added to the map, associated with a particular price (default close, can be set at high, low, open,...)
When the map already contains the same price (key), the value (volume) is added to the existing volume at the associated price.
A map can contain maximum 50K values, which is more than enough to hold 20K bars (Basic 5K - Premium plan 20K), so the whole history can be put into a map.
🔹 Rounding function
This publication contains 2 round functions, which can be used to widen the Volume Profile
Round
• "Round" set at zero -> nothing changes to the source number
• "Round" set below zero -> x digit(s) after the decimal point, starting from the right side, and rounded.
• "Round" set above zero -> x digit(s) before the decimal point, starting from the right side, and rounded.
Example: 123456.789
0->123456.789
1->123456.79
2->123456.8
3->123457
-1->123460
-2->123500
Step
Another option is custom steps.
After setting "Round" to "Step", choose the desired steps in price,
Examples
• 2 -> 1234.00, 1236.00, 1238.00, 1240.00
• 5 -> 1230.00, 1235.00, 1240.00, 1245.00
• 100 -> 1200.00, 1300.00, 1400.00, 1500.00
• 0.05 -> 1234.00, 1234.05, 1234.10, 1234.15
•••
🔶 FEATURES
🔹 Volume * currency
Let's take as example BTCUSD, relative to USD, 10 volume at a price of 100 BTCUSD will be very different than 10 volume at a price of 30000 (1K vs. 300K)
If you want volume to be associated with USD, enable Volume * currency . Volume will then be multiplied by the price:
• 10 volume, 1 BTC = 100 -> 1000
• 10 volume, 1 BTC = 30K -> 300K
Polylines has the attributes curved & closed.
When "curved" is enabled the drawing will connect all points from the `points` array using curved line segments.
When "closed" is enabled the drawing will also connect the first point to the last point from the `points` array, resulting in a closed polyline.
They are default disabled, but can be enabled:
🔶 DETAILS
🔹 Put
When the map doesn't contain a price, it will be added, using map.put(id, key, value)
In our code:
map.put(originalMap, price, volume)
or
originalMap.put(price, volume)
A key (price) is now associated with a value (volume) -> key : value
Since all keys are unique, we don't have to know its position to extract the value, we just need to know the key -> map.get(id, key)
We use map.get() when a certain key already exists in the map, and we want to add volume with that value.
if originalMap.contains(price)
originalMap.put(price, originalMap.get(price) + volume)
-> At the last bar, all prices (source) are now associated with volume.
🔶 SETTINGS
Source : Set source of choice; default close , can be set as high , low , open , ...
Volume & currency : Enable to multiply volume with price (see Features )
Amount of bars : Set amount of bars which you want to include in the Volume Profile
🔹 Round -> ' Round/Step '
Round -> see Concepts
Step -> see Concepts
🔹 Display Volume Profile
Offset: shifts the Volume Profile (max. 500 bars to the right of last bar, see Features )
Max width Volume Profile: largest volume will be x bars wide, the rest is displayed as a ratio against largest volume (see Features )
Colours
Curved: make lines curved
Closed: connect last with first point
🔶 LIMITATIONS
• Lines won't go further than first bar (coded).
• The Volume Profile can be placed maximum 500 bar to the right of last price.
Machine Learning: Optimal RSI [YinYangAlgorithms]This Indicator, will rate multiple different lengths of RSIs to determine which RSI to RSI MA cross produced the highest profit within the lookback span. This ‘Optimal RSI’ is then passed back, and if toggled will then be thrown into a Machine Learning calculation. You have the option to Filter RSI and RSI MA’s within the Machine Learning calculation. What this does is, only other Optimal RSI’s which are in the same bullish or bearish direction (is the RSI above or below the RSI MA) will be added to the calculation.
You can either (by default) use a Simple Average; which is essentially just a Mean of all the Optimal RSI’s with a length of Machine Learning. Or, you can opt to use a k-Nearest Neighbour (KNN) calculation which takes a Fast and Slow Speed. We essentially turn the Optimal RSI into a MA with different lengths and then compare the distance between the two within our KNN Function.
RSI may very well be one of the most used Indicators for identifying crucial Overbought and Oversold locations. Not only that but when it crosses its Moving Average (MA) line it may also indicate good locations to Buy and Sell. Many traders simply use the RSI with the standard length (14), however, does that mean this is the best length?
By using the length of the top performing RSI and then applying some Machine Learning logic to it, we hope to create what may be a more accurate, smooth, optimal, RSI.
Tutorial:
This is a pretty zoomed out Perspective of what the Indicator looks like with its default settings (except with Bollinger Bands and Signals disabled). If you look at the Tables above, you’ll notice, currently the Top Performing RSI Length is 13 with an Optimal Profit % of: 1.00054973. On its default settings, what it does is Scan X amount of RSI Lengths and checks for when the RSI and RSI MA cross each other. It then records the profitability of each cross to identify which length produced the overall highest crossing profitability. Whichever length produces the highest profit is then the RSI length that is used in the plots, until another length takes its place. This may result in what we deem to be the ‘Optimal RSI’ as it is an adaptive RSI which changes based on performance.
In our next example, we changed the ‘Optimal RSI Type’ from ‘All Crossings’ to ‘Extremity Crossings’. If you compare the last two examples to each other, you’ll notice some similarities, but overall they’re quite different. The reason why is, the Optimal RSI is calculated differently. When using ‘All Crossings’ everytime the RSI and RSI MA cross, we evaluate it for profit (short and long). However, with ‘Extremity Crossings’, we only evaluate it when the RSI crosses over the RSI MA and RSI <= 40 or RSI crosses under the RSI MA and RSI >= 60. We conclude the crossing when it crosses back on its opposite of the extremity, and that is how it finds its Optimal RSI.
The way we determine the Optimal RSI is crucial to calculating which length is currently optimal.
In this next example we have zoomed in a bit, and have the full default settings on. Now we have signals (which you can set alerts for), for when the RSI and RSI MA cross (green is bullish and red is bearish). We also have our Optimal RSI Bollinger Bands enabled here too. These bands allow you to see where there may be Support and Resistance within the RSI at levels that aren’t static; such as 30 and 70. The length the RSI Bollinger Bands use is the Optimal RSI Length, allowing it to likewise change in correlation to the Optimal RSI.
In the example above, we’ve zoomed out as far as the Optimal RSI Bollinger Bands go. You’ll notice, the Bollinger Bands may act as Support and Resistance locations within and outside of the RSI Mid zone (30-70). In the next example we will highlight these areas so they may be easier to see.
Circled above, you may see how many times the Optimal RSI faced Support and Resistance locations on the Bollinger Bands. These Bollinger Bands may give a second location for Support and Resistance. The key Support and Resistance may still be the 30/50/70, however the Bollinger Bands allows us to have a more adaptive, moving form of Support and Resistance. This helps to show where it may ‘bounce’ if it surpasses any of the static levels (30/50/70).
Due to the fact that this Indicator may take a long time to execute and it can throw errors for such, we have added a Setting called: Adjust Optimal RSI Lookback and RSI Count. This settings will automatically modify the Optimal RSI Lookback Length and the RSI Count based on the Time Frame you are on and the Bar Indexes that are within. For instance, if we switch to the 1 Hour Time Frame, it will adjust the length from 200->90 and RSI Count from 30->20. If this wasn’t adjusted, the Indicator would Timeout.
You may however, change the Setting ‘Adjust Optimal RSI Lookback and RSI Count’ to ‘Manual’ from ‘Auto’. This will give you control over the ‘Optimal RSI Lookback Length’ and ‘RSI Count’ within the Settings. Please note, it will likely take some “fine tuning” to find working settings without the Indicator timing out, but there are definitely times you can find better settings than our ‘Auto’ will create; especially on higher Time Frames. The Minimum our ‘Auto’ will create is:
Optimal RSI Lookback Length: 90
RSI Count: 20
The Maximum it will create is:
Optimal RSI Lookback Length: 200
RSI Count: 30
If there isn’t much bar index history, for instance, if you’re on the 1 Day and the pair is BTC/USDT you’ll get < 4000 Bar Indexes worth of data. For this reason it is possible to manually increase the settings to say:
Optimal RSI Lookback Length: 500
RSI Count: 50
But, please note, if you make it too high, it may also lead to inaccuracies.
We will conclude our Tutorial here, hopefully this has given you some insight as to how calculating our Optimal RSI and then using it within Machine Learning may create a more adaptive RSI.
Settings:
Optimal RSI:
Show Crossing Signals: Display signals where the RSI and RSI Cross.
Show Tables: Display Information Tables to show information like, Optimal RSI Length, Best Profit, New Optimal RSI Lookback Length and New RSI Count.
Show Bollinger Bands: Show RSI Bollinger Bands. These bands work like the TDI Indicator, except its length changes as it uses the current RSI Optimal Length.
Optimal RSI Type: This is how we calculate our Optimal RSI. Do we use all RSI and RSI MA Crossings or just when it crosses within the Extremities.
Adjust Optimal RSI Lookback and RSI Count: Auto means the script will automatically adjust the Optimal RSI Lookback Length and RSI Count based on the current Time Frame and Bar Index's on chart. This will attempt to stop the script from 'Taking too long to Execute'. Manual means you have full control of the Optimal RSI Lookback Length and RSI Count.
Optimal RSI Lookback Length: How far back are we looking to see which RSI length is optimal? Please note the more bars the lower this needs to be. For instance with BTC/USDT you can use 500 here on 1D but only 200 for 15 Minutes; otherwise it will timeout.
RSI Count: How many lengths are we checking? For instance, if our 'RSI Minimum Length' is 4 and this is 30, the valid RSI lengths we check is 4-34.
RSI Minimum Length: What is the RSI length we start our scans at? We are capped with RSI Count otherwise it will cause the Indicator to timeout, so we don't want to waste any processing power on irrelevant lengths.
RSI MA Length: What length are we using to calculate the optimal RSI cross' and likewise plot our RSI MA with?
Extremity Crossings RSI Backup Length: When there is no Optimal RSI (if using Extremity Crossings), which RSI should we use instead?
Machine Learning:
Use Rational Quadratics: Rationalizing our Close may be beneficial for usage within ML calculations.
Filter RSI and RSI MA: Should we filter the RSI's before usage in ML calculations? Essentially should we only use RSI data that are of the same type as our Optimal RSI? For instance if our Optimal RSI is Bullish (RSI > RSI MA), should we only use ML RSI's that are likewise bullish?
Machine Learning Type: Are we using a Simple ML Average, KNN Mean Average, KNN Exponential Average or None?
KNN Distance Type: We need to check if distance is within the KNN Min/Max distance, which distance checks are we using.
Machine Learning Length: How far back is our Machine Learning going to keep data for.
k-Nearest Neighbour (KNN) Length: How many k-Nearest Neighbours will we account for?
Fast ML Data Length: What is our Fast ML Length? This is used with our Slow Length to create our KNN Distance.
Slow ML Data Length: What is our Slow ML Length? This is used with our Fast Length to create our KNN Distance.
If you have any questions, comments, ideas or concerns please don't hesitate to contact us.
HAPPY TRADING!
Crypto Daily WatchList And Screener [M]
Hi, this is a watchlist and screener indicator designed for traders in the field of cryptocurrencies who want to monitor developments in other currency pairs and indices.
The indicator consists of two tables. One of them is the table containing indices such as BTC dominance, total, total2, which allows you to track market developments and changes. In this table, you will find price information, daily change, stochastic, and trend information.
The other table includes cryptocurrencies like BTC/USDT, ETH/USDT, DOT/USDT, and more. In this table, you will see real-time prices, daily volume, daily change, stochastic, the correlation coefficient between the pair and Bitcoin, and the trend value calculated based on MACD.
The "Customize" section in the settings enables you to personalize the appearance of the tables according to your preferences.
Cycles: 4x dual inputs: Swing / Time Cycles projected forward//Purpose/Premise:
To project forward vertical 'cycle' lines based on user-input anchor points, and to search for confluence.
The idea being that if several well-anchored cycles agree (i.e. we see multiple bunched vertical line confluence in the future), then this may add support to an already existing trade idea, or may indicate an increased likelihood of a shift in direction.
//Usage & notes:
~In the above chart I've anchored to obvious swing lows and swing highs in Btc/Usd from 2020-2022. You could also use fixed time-based cycles from a favored start anchor point. Bars per cycle are printed at the top of each cycle box if your're interested in time cycles. I.e. for 1, 2, 3 month cycles: for BTC you could use 30, 60, 90 bars on daily; for S&P you could use 20, 40, 60 bars on daily.
~On first loading the indicator you will be asked select 'start date', and 'end date' for each of 4 sessions (8x clicks on chart). After this you can easily reset points by clicking the indicator display line three dots>> reset points. Or you can simply drag the vertical box edges (purple lines) to change your cycle anchor points.
~Be sure the start anchor point is before the end anchor point or box/lines won't appear.
~When you drop down to low timeframes you might get bar_index error due to history available: you need then to click the three dots on indicator display line >> reset points >> 8x clicks on the chart.
~Vertical projected lines will match the color of the cycle box they origninate from.
~Lines will project into the future as far as is allowed by tradingview (500 bars max)
//Inputs:
~Time start and end dates for each cycle (change these as described above, or input manually)
~Show/hide each cycle (default is show all 4)
~Formatting options: color of forward projected lines, line width, line style, line / box / text color.
~Box transparancy: Set to 100 to make boxes invisible & declutter the chart. Set to 0 for maximum opacity. Default is 80.
thanks to @Sathyamurthie for his ideas on cycle confluence which caused me to write this.
Blackrock Spot ETF Premium BTCUSD (COINBASE) V1I created an indicator that takes the spot BTC/USD pair from major exchanges and compares it to the Spot BTC/USD pair on Coinbase that institutions will use for their Spot ETFs.
Blackrock Spot ETF Premium BTCUSD (COINBASE)
I suspect we will see a new "Kimchi Premium" where the Spot ETF pressures from institutions will raise the Coinbase Bitcoin price by a factor of 10-50% premium to the other exchanges.
Naturally excess coins from other exchanges will flow into Coinbase to capture this.
This indicator should be good for some time until one of the other exchanges delist or stop using BTCUSD "spot" If it breaks it I will update it if I remember.
FederalXBT,
Crypto/DXY ScoringHi!
This indicator "Crypto/DXY Scoring", a multi-purpose script, consists of various comparison statistics (including an alternative RS/RSMOM model) to show the strength of a currency against the DXY.
Features
"Contrived" RS/RSMOM alternative model
Compare the strength of the crypto currency on your chart to any asset (DXY default)
Glass's ∆
Z-comparison
Hedges' g
Cliff's Delta
Z-score for log returns
RRG graph (with adjusted dimensions) Traditional RRG graph coming soon (:
Let's go over some simplified interpretations of what's shown on the chart!
The image above provides generalized interpretations for the three of the data series plotted by the indicator.
The image above further explains the other plots for the indicator!
The image above shows the final result!
Underlying Theory
"When the dollar is strong as indicated by the DXY, it usually means that investors are seeking safety in traditional assets. Bitcoin (crypto) is often considered a "risk-on" asset, meaning investors might sell BTC in favor of holding dollars, thus driving BTC prices down."
Given the complexities associated with this relationship, including its contentious implications and a variable correlation between crypto and the DXY, this theory is one within a plethora.
That said, regardless of accuracy, this indicator adheres to the theory outlined above (:
The image above shows the purpose of the red/lime columns and the corresponding red/green lines.
Should the crypto on your chart and the DXY (or comparison symbol) exhibit negative correlation, and should the performance of DXY (or comparison symbol) hold any predictive utility for the subsequent performance of the crypto on your chart, the red columns violating the red line might indicate an upcoming "dump" for the crypto on your chart.
Lime green columns violating the green line may indicator an inverse response.
Alternative Relative Rotation Graph
In its current state, the alternated dimensions for the Relative Rotation Graph cause it to function more as a "Relative Performance Graph".
Fear not; a traditional RRG graph is coming soon!
The image above shows our alternative RRG!
Interpretation
With this model, you can quickly/intuitively assess the relative performance of the display cryptos against an index of their performance.
The image above shows generalized interpretations of the model!
That's it for this indicator! Thank you for checking it out; more to come (:
Volume Profile (Maps) [LuxAlgo]The Pine Script® developers have unleashed "maps"!
Volume Profile (Maps) displays volume, associated with price, above and below the latest price, by using maps
The largest and second-largest volume is highlighted.
🔶 USAGE
The proposed script can highlight more frequent closing prices/prices with the highest volume, potentially highlighting more liquid areas. The prices with the highest associated volume (in red and orange in the indicator) can eventually be used as support/resistance levels.
Voids within the volume profile can highlight large price displacements (volatile variations).
🔶 CONCEPTS
🔹 Maps
A map object is a collection that consists of key - value pairs
Each key is unique and can only appear once. When adding a new value with a key that the map already contains, that value replaces the old value associated with the key .
You can change the value of a particular key though, for example adding volume (value) at the same price (key), the latter technique is used in this script.
Volume is added to the map, associated with a particular price (default close, can be set at high, low, open,...)
When the map already contains the same price (key), the value (volume) is added to the existing volume at the associated price.
A map can contain maximum 50K values, which is more than enough to hold 20K bars (Basic 5K - Premium plan 20K), so the whole history can be put into a map.
🔹 Visible line/box limit
We can only display maximum 500 line.new() though.
The code locates the current (last) close, and displays volume values around this price, using lines, for example 250 lines above and 250 lines below current price.
If one side contains fewer values, the other side can show more lines, taking the maximum out of the 500 visible line limitation.
Example (max. 500 lines visible)
• 100 values below close
• 2000 values above close
-> 100 values will be displayed below close
-> 400 remaining -> 400 values will be displayed above close
Pushing the limits even further, when ' Amount of bars ' is set higher than 500, boxes - box.new() - will be used as well.
These have a limit of 500 as well, bringing the total limit to 1000.
Note that there are visual differences when boxes overlap against lines.
If this is confusing, please keep ' Amount of bars ' at max. 500 (then only lines will be used).
🔹 Rounding function
This publication contains 2 round functions, which can be used to widen the Volume Profile
Round
• "Round" set at zero -> nothing changes to the source number
• "Round" set below zero -> x digit(s) after the decimal point, starting from the right side, and rounded.
• "Round" set above zero -> x digit(s) before the decimal point, starting from the right side, and rounded.
Example: 123456.789
0->123456.789
1->123456.79
2->123456.8
3->123457
-1->123460
-2->123500
Step
Another option is custom steps.
After setting "Round" to "Step", choose the desired steps in price,
Examples
• 2 -> 1234.00, 1236.00, 1238.00, 1240.00
• 5 -> 1230.00, 1235.00, 1240.00, 1245.00
• 100 -> 1200.00, 1300.00, 1400.00, 1500.00
• 0.05 -> 1234.00, 1234.05, 1234.10, 1234.15
•••
🔶 FEATURES
🔹 Adjust position & width
🔹 Table
The table shows the details:
• Size originalMap : amount of elements in original map
• # higher: amount of elements, higher than last "close" (source)
• index "close" : index of last "close" (source), or # element, lower than source
• Size newMap : amount of elements in new map (used for display lines)
• # higher : amount of elements in newMap, higher than last "close" (source)
• # lower : amount of elements in newMap, lower than last "close" (source)
🔹 Volume * currency
Let's take as example BTCUSD, relative to USD, 10 volume at a price of 100 BTCUSD will be very different than 10 volume at a price of 30000 (1K vs. 300K)
If you want volume to be associated with USD, enable Volume * currency . Volume will then be multiplied by the price:
• 10 volume, 1 BTC = 100 -> 1000
• 10 volume, 1 BTC = 30K -> 300K
Disabled
Enabled
🔶 DETAILS
🔹 Put
When the map doesn't contain a price, it will be added, using map.put(id, key, value)
In our code:
map.put(originalMap, price, volume)
or
originalMap.put(price, volume)
A key (price) is now associated with a value (volume) -> key : value
Since all keys are unique, we don't have to know its position to extract the value, we just need to know the key -> map.get(id, key)
We use map.get() when a certain key already exists in the map, and we want to add volume with that value.
if originalMap.contains(price)
originalMap.put(price, originalMap.get(price) + volume)
-> At the last bar, all prices (source) are now associated with volume.
🔹 Copy & sort
Next, every key of the map is copied and sorted (array of keys), after which the index (idx) is retrieved of last (current) price.
copyK = originalMap.keys().copy()
copyK.sort()
idx = copyK.binary_search_leftmost(src)
Then left and right side of idx is investigated to show a maximum amount of lines at both sides of last price.
🔹 New map & display
The keys (from sorted array of copied keys) that will be displayed are put in a new map, with the associated volume values from the original map.
newMap = map.new()
🔹 Re-cap
• put in original amp (price key, volume value)
• copy & sort
• find index of last price
• fetch relevant keys left/right from that index
• put keys in new map and fetch volume associated with these keys (from original map)
Simple example (only show 5 lines)
bar 0, price = 2, volume = 23
bar 1, price = 4, volume = 3
bar 2, price = 8, volume = 21
bar 3, price = 6, volume = 7
bar 4, price = 9, volume = 13
bar 5, price = 5, volume = 85
bar 6, price = 3, volume = 13
bar 7, price = 1, volume = 4
bar 8, price = 7, volume = 9
Original map:
Copied keys array:
Sorted:
-> 5 keys around last price (7) are fetched (5, 6, 7, 8, 9)
-> keys are placed into new map + volume values from original map
Lastly, these values are displayed.
🔶 SETTINGS
Source : Set source of choice; default close , can be set as high , low , open , ...
Volume & currency : Enable to multiply volume with price (see Features )
Amount of bars : Set amount of bars which you want to include in the Volume Profile
Max lines : maximum 1000 (if you want to use only lines, and no boxes -> max. 500, see Concepts )
🔹 Round -> ' Round/Step '
Round -> see Concepts
Step -> see Concepts
🔹 Display Volume Profile
Offset: shifts the Volume Profile (max. 500 bars to the right of last bar, see Features )
Max width Volume Profile: largest volume will be x bars wide, the rest is displayed as a ratio against largest volume (see Features )
Show table : Show details (see Features )
🔶 LIMITATIONS
• Lines won't go further than first bar (coded).
• The Volume Profile can be placed maximum 500 bar to the right of last price.
• Maximum 500 lines/boxes can be displayed
BTFD strategy [3min]Hello
I would like to introduce a very simple strategy to buy lows and sell with minimal profit
This strategy works very well in the markets when there is no clear trend and in other words, the trend going sideways
this strategy works very well for stable financial markets like spx500, nasdaq100 and dow jones 30
two indicators were used to determine the best time to enter the market:
volume + rsi values
volume is usually the number of stocks or contracts traded over a certain period of time. Thus, it is an important indicator of market activity and liquidity. Each transaction constitutes an individual exchange between the buyer and the seller and constitutes the trading volume of a given instrument or asset.
The RSI measures the strength of uptrends versus downtrends. The signal is the entry or exit of the indicator value of the oversold or overbought level of the market. It is assumed that a value below or equal 30 indicates an oversold level of the market, and an RSI value above or equal 70 indicates an overbought level.
the strategy uses a maximum of 5 market entries after each candle that meets the condition
uses 5 target point levels to close the position:
tp1= 0.4%
tp2= 0.6%
tp3= 0.8%
tp4= 1.0%
tp5= 1.2%
after reaching a given profit value, a piece of the position is cut off gradually, where tp5 closes 100% of the remaining position
each time you enter a position, a stop loss of 5.0% is set, which is quite a high value, however, when buying each, sometimes very active downward price movement, you need a lot of space for market decisions in which direction it wants to go
to determine the level of stop loss and target point I used a piece of code by RafaelZioni , here is the script from which a piece of code was taken
this strategy is used for automation, however, I would recommend brokers that have the lowest commission values when opening and closing positions, because the strategy generates very high commission costs
Enjoy and trade safe ;)
Mizar_LibraryThe "Mizar_Library" is a powerful tool designed for Pine Script™ programmer’s, providing a collection of general functions that facilitate the usage of Mizar’s DCA (Dollar-Cost-Averaging) bot system.
To begin using the Mizar Library, you first need to import it into your indicator script. Insert the following line below your indicator initiation line: import Mizar_Trading/Mizar_Library/1 as mizar (mizar is the chosen alias).
In the import statement, Mizar_Trading.Mizar_Library_v1 refers to the specific version of the Mizar Library you wish to use. Feel free to modify mizar to your preferred alias name.
Once the library is imported, you can leverage its functions by prefixing them with mizar. . This will prompt auto-completion suggestions displaying all the available user-defined functions provided by the Mizar Library.
Now, let's delve into some of the key functions available in the Mizar Library:
DCA_bot_msg(_cmd)
The DCA_bot_msg function accepts an user-defined type (UDT) _cmd as a parameter and returns a string with the complete JSON command for a Mizar DCA bot.
Parameters:
_cmd (bot_params) : ::: User-defined type (UDT) that holds all the necessary information for the bot command.
Returns: A string with the complete JSON command for a Mizar DCA bot.
rounding_to_ticks(value, ticks, rounding_type)
The rounding_to_ticks function rounds a calculated price to the nearest actual price based on the specified tick size.
Parameters:
value (float) : ::: The calculated price as float type, to be rounded to the nearest real price.
ticks (float) : ::: The smallest possible price obtained through a request in your script.
rounding_type (int) : ::: The rounding type for the price: 0 = closest real price, 1 = closest real price above, 2 = closest real price below.
Returns: A float value representing the rounded price to the next tick.
bot_params
Bot_params is an user-defined type (UDT) that represents the parameters required for a Mizar DCA bot.
Fields:
bot_id (series string) : The ID number of your Mizar DCA bot.
api_key (series string) : Your private API key from your Mizar account (keep it confidential!).
action (series string) : The command to perform: "open" (standard) or "close" optional .
tp_perc (series string) : The take profit percentage in decimal form (1% = "0.01") optional .
base_asset (series string) : The cryptocurrency you want to buy (e.g., "BTC").
quote_asset (series string) : The coin or fiat currency used for payment (e.g., "USDT" is standard if not specified) optional .
direction (series string) : The direction of the position: "long" or "short" (only applicable for two-way hedge bots) optional .
To obtain the JSON command string for the alert_function call, you can use the DCA_bot_msg function provided by the library. Simply pass the cmd_msg UDT as an argument and assign the returned string value to a variable.
Here's an example to illustrate the process:
// Import of the Mizar Library to use the included functions
import/Mizar_Trading/Mizar_Library/1 as mizar
// Example to set a variable called “cmd_msg” and all of its parameters
cmd_msg = mizar.bot_params. new()
cmd_msg.action := "open"
cmd_msg.api_key := "top secret"
cmd_msg.bot_id := "9999"
cmd_msg.base_asset := "BTC"
cmd_msg.quote_asset := "USDT"
cmd_msg.direction := "long"
cmd_msg.tp_perc := "0.015"
// Calling the Mizar conversion function named “DCA_bot_msg()” with the cmd_msg as argument to receive the JSON command and save it in a string variable called “alert_msg”
alert_msg = mizar.DCA_bot_msg(cmd_msg)
Feel free to utilize (series) string variables instead of constant strings. By incorporating the Mizar Library into your Pine Script, you gain access to a powerful set of functions and can leverage them according to your specific requirements.
For additional help or support, you can join the Mizar Discord channel. There, you'll find a dedicated Pine Script channel where you can ask any questions related to Pine Script.
