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)))
ค้นหาในสคริปต์สำหรับ "美元未来10天走势预测"
Market Volatility Key: CHOP, ATR, VIX & 10Y BondThis script builds upon existing market analysis tools by providing a comprehensive dashboard that combines the Choppiness Index (CHOP), Average True Range (ATR) with a user-selectable timeframe, VIX (Volatility Index), and the 10-year US Treasury bond price in a compact tile format. The color-coded key provides quick visual cues for market conditions—highlighting whether the market is trending or consolidating—allowing traders to make informed decisions quickly.
For example, when trading the Nasdaq (NQ), you might use this indicator to help manage your scalping trades. If you trade on a 10-minute chart but set the ATR timeframe to 1 minute, it helps identify whether there is enough price movement to justify entering a trade. If the ATR is less than 10, it suggests there's not enough range for scalping opportunities, and you may choose to stay out of the trade.
This expanded indicator integrates and enhances existing concepts to deliver a well-rounded view of volatility, trend strength, and market conditions all in one glance, making it an essential tool for both trend-following and scalping strategies.
Statistics plot1. setting the price range
At the beginning of the script, set the price range (interval). Price ranges are used to divide prices into several groups (buckets) and record how many prices have been reached within each group. For example, setting the price range to “10” will divide the price into intervals 0-10, 10-20, 20-30, and so on.
The price range can also be set manually by the user or automatically calculated based on the initial price. This allows for flexibility in adjusting price ranges for different assets and different time frames.
2. aggregate the number of times a price is reached
Record how many times the price reached each price range (e.g., 100-110, 110-120, etc.). This aggregate data is stored in a data structure called an array.
Each element of the array corresponds to a price range, and when a price reaches that range, the corresponding array value is incremented by one. This process is performed in real time, tracking price movements.
3. initializing and extending price ranges
The first bar of the script (when the chart is first loaded) divides the price ranges into several groups and initializes a count of 0 for each range.
When a price reaches a new range, the array is expanded as needed to add the new price range. This allows the script to work with any price movement, even if the price range continues to grow.
4. visualize the number of price arrivals with a histogram
The aggregated number of arrivals per price range is visually displayed in the form of a histogram. This histogram is designed to allow the user to see at a glance which price range is being reached most frequently.
For example, if prices frequently reach the 100-110 range, the histogram bar corresponding to that range will appear higher than the other ranges. This allows you to visually identify price “dwell points” or support and resistance levels.
5. display of moving averages
A moving average (MA) of the number of times a price has been reached is drawn above the histogram. Moving averages are indicators that show a smooth trend for the number of price arrivals and are useful for understanding the overall direction of price movements.
The duration of the moving average (how many data points it is calculated based on) can be set by the user. This allows for flexible analysis of short or long term price trends. 6.
6. price range tracking and labeling
The script keeps track of which price range the current price is located in. Based on this, information related to the current price range is displayed on the chart as labels.
In particular, labels indicate the beginning and end points of the price range, including which range the price was in at the beginning and which range the price reached at the end. These labels are a useful feature to visually identify price ranges on the chart.
7. labeling of current price range
To confirm which price range the current price is in, when a price reaches a specific price range, a label corresponding to that price range is displayed. This label indicates the position of the price in real-time, allowing traders to visually track where the current price is in the area.
8. calculating the start and end points of the range
The script calculates the start and end points of a range with a non-zero number of price arrivals to find the minimum and maximum of the range. This calculation allows you to see where prices are concentrated within a range.
9. out-of-range price processing
When a price reaches outside the range, the script automatically adds the array element corresponding to that price range and inserts the data in the appropriate location for the count. This allows the script to follow the price as it moves unexpectedly.
Supertrend Scanner on ChartThis Indicator is Used to scan 10 stock on chart.
Supertrend is widely used indicator on tradingview. So we have used the originals indicator codes of supertrend by tradingview here. Background color has been changed as per supertrend trrend.
Problem : Sometime trader wants to track multiple stocks supertrend at a time. Mostly those stock are of same sector. To track all the stocks of same sector in one chart , trader has to open multiple charts for that.
Solution : This indicator pointout where other stocks has changed the trend. Like if you see "SBIN" written in GEREEN at bottom of the candle , that means on that particular candle SBIN supertrend has changed to positive. Similarly if you see "KOTAK" written in RED at top of the candle the means supertrend has changed to Negative on that particular candle. Its so easy to trace 10 stock on same chart which stocks labelling.
How to use :
When you trade on any index , then apply all the index constituents stock on this indicator. When Index changes the trend and that change in trend is confirmed by other constituents ( like 7/10 confirmed ) then that is confirmed trend. If all the constituents are on same direction than that's the confirmed trend.
Disclamer : This indicator is for education purpose , for any profit or loss , we are not responsible. Trade on your own risk.
Export Candles DataThis program is written in Pine Script (version 5) and is designed to retrieve candlestick data (open, high, low, and close prices) from the TradingView chart. The data is displayed in a table located in the upper right corner of the chart.
Main Functions of the Program:
Retrieving candlestick data: The program processes data for the last 10 candlesticks on the selected timeframe (e.g., hourly, minute, etc.) in the TradingView chart. For each candlestick, it retrieves:
Time of the candle's close
Opening price
Highest price during the period
Lowest price during the period
Closing price
Displaying data in a table: The data is presented in a compact table located in the upper right corner of the chart. The table contains 5 columns:
Time of the candle's close (formatted as yyyy-MM-dd HH:mm)
Opening price
Highest price
Lowest price
Closing price
Clearing the table every 50 bars: To prevent the table from becoming overloaded, it clears itself every 50 bars, starting from the first row and first column.
Data updates dynamically: The table dynamically updates, displaying the latest 10 candles, allowing traders to track current market changes.
Application:
This indicator is useful for traders who want a quick view of key candlestick parameters directly on the chart.
The indicator can be easily applied to any instrument or index in TradingView, such as the IMOEX index.
The table view makes it easy to quickly analyze market movements without needing to inspect each candle individually.
How the Program Works:
On each new bar, the program checks the current bar's index.
The program clears the table if 50 bars have passed since the last clearing.
It writes the data of the last 10 candlesticks into the table: the time of the candle's close, opening price, highest and lowest prices, and closing price.
The table updates automatically and continuously displays the latest data.
This indicator is suitable for both short-term and long-term market analysis, providing a convenient and efficient way to monitor price movements directly on the chart.
BTC Arcturus IndicatorBTC Arcturus Indicator: This indicator is designed to create buy and sell signals based on the market value of Bitcoin. It also predicts potential market tops with the Pi Cycle Top indicator.
How Does It Work?
1. MVRVZ (Market Value to Realized Value-Z Score) Calculation:
MC: Bitcoin's market cap (Market Cap) is pulled daily from Glassnode data.
MCR: Realized Market Cap of Bitcoin is taken daily from Coinmetrics data.
MVRVZ: It is calculated by dividing the difference between Bitcoin's market value and realized market value by one standard deviation. This value indicates whether the market is overvalued or undervalued.
2. Reception and Warning Signals:
Buy Signal: When MVRVZ falls below the -0.255 threshold value, the indicator gives a "Buy" signal. This indicates that Bitcoin is undervalued and may be a buying opportunity.
Warning Signal: A warning signal turns on when MVRVZ exceeds the threshold value of 2.765. This indicates that the market is approaching saturation and caution is warranted.
3. Tracking the Highest MVRVZ Value:
The indicator records the highest MVRVZ value in the last 10 candlesticks. This value is used to determine whether the market has reached its highest risk levels.
4. Warning Display:
If the MVRVZ value matches the highest value in the last 10 bars and this warning has not been displayed before, a "Warning" signal is displayed.
Once the warning signal is shown, no further warnings are shown for 10 candles.
5. Pi Cycle Top Indicator:
Pi Cycle Top: This indicator predicts Bitcoin tops by comparing two moving averages (350-day and 111-day). If the short-term moving average falls below the long-term moving average, this is considered a sell signal.
The indicator displays this signal with the label "Sell", indicating a potential market top.
User Guide:
Green Buy Signal: It means Bitcoin is cheap and offers a buying opportunity.
Yellow Warning Signal: Indicates that Bitcoin has reached possible profit taking points and caution should be exercised.
Red Sell Signal: Indicates that Bitcoin has reached market saturation and it may be appropriate to sell.
Pivot Channel Breaks [BigBeluga]Pivot Channel Break
The Pivot Channel Break indicator identifies key pivot points and creates a dynamic channel based on these pivots. It detects breakouts from this channel, providing potential entry and exit signals for traders.
🔵 How to Use
Channel Identification:
- Upper and lower channel lines drawn based on pivot highs and lows
- Channel width dynamically adjusted using ATR-like calculation
Breakout Signals:
- Upward breakout: Price closes above upper channel line
- Downward breakout: Price closes below lower channel line
- Signals shown as X marks on the chart
Pivot Points:
- High pivots marked with "H" triangles
- Low pivots marked with "L" triangles
Support & Resistance:
- Optional signals when price touches but doesn't break channel lines
Trend Visualization:
- Optional bar coloring based on the most recent breakout direction
🔵 Customization
• Pivot Right: Lookback period for pivot detection (default: 10)
• Pivot Left: Forward period for pivot confirmation (default: 40)
• Channel Width: Multiplier for channel width calculation (default: 1.0)
• Support & Resistance Signals: Toggle additional touch signals
• Bar Color: Enable/disable trend-based bar coloring
Calculation:
Detect pivot highs and lows using specified lookback periods
Calculate channel basis using 10-period SMA of close prices
Determine channel width using ATR-like calculation: RMA(high - low, 10) * width multiplier
Set channel lines based on pivot points and calculated deviations
Identify breakouts when price crosses beyond channel lines
The Pivot Channel Break indicator offers a dynamic approach to identifying potential trend changes and breakout opportunities. It combines pivot point analysis with a flexible channel calculation, providing traders with a visual tool for market structure analysis. Use this indicator in conjunction with other technical analysis methods to confirm signals and manage risk effectively.
Dual Chain StrategyDual Chain Strategy - Technical Overview
How It Works:
The Dual Chain Strategy is a unique approach to trading that utilizes Exponential Moving Averages (EMAs) across different timeframes, creating two distinct "chains" of trading signals. These chains can work independently or together, capturing both long-term trends and short-term price movements.
Chain 1 (Longer-Term Focus):
Entry Signal: The entry signal for Chain 1 is generated when the closing price crosses above the EMA calculated on a weekly timeframe. This suggests the start of a bullish trend and prompts a long position.
bullishChain1 = enableChain1 and ta.crossover(src1, entryEMA1)
Exit Signal: The exit signal is triggered when the closing price crosses below the EMA on a daily timeframe, indicating a potential bearish reversal.
exitLongChain1 = enableChain1 and ta.crossunder(src1, exitEMA1)
Parameters: Chain 1's EMA length is set to 10 periods by default, with the flexibility for user adjustment to match various trading scenarios.
Chain 2 (Shorter-Term Focus):
Entry Signal: Chain 2 generates an entry signal when the closing price crosses above the EMA on a 12-hour timeframe. This setup is designed to capture quicker, shorter-term movements.
bullishChain2 = enableChain2 and ta.crossover(src2, entryEMA2)
Exit Signal: The exit signal occurs when the closing price falls below the EMA on a 9-hour timeframe, indicating the end of the shorter-term trend.
exitLongChain2 = enableChain2 and ta.crossunder(src2, exitEMA2)
Parameters: Chain 2's EMA length is set to 9 periods by default, and can be customized to better align with specific market conditions or trading strategies.
Key Features:
Dual EMA Chains: The strategy's originality shines through its dual-chain configuration, allowing traders to monitor and react to both long-term and short-term market trends. This approach is particularly powerful as it combines the strengths of trend-following with the agility of momentum trading.
Timeframe Flexibility: Users can modify the timeframes for both chains, ensuring the strategy can be tailored to different market conditions and individual trading styles. This flexibility makes it versatile for various assets and trading environments.
Independent Trade Logic: Each chain operates independently, with its own set of entry and exit rules. This allows for simultaneous or separate execution of trades based on the signals from either or both chains, providing a robust trading system that can handle different market phases.
Backtesting Period: The strategy includes a configurable backtesting period, enabling thorough performance assessment over a historical range. This feature is crucial for understanding how the strategy would have performed under different market conditions.
time_cond = time >= startDate and time <= finishDate
What It Does:
The Dual Chain Strategy offers traders a distinctive trading tool that merges two separate EMA-based systems into one cohesive framework. By integrating both long-term and short-term perspectives, the strategy enhances the ability to adapt to changing market conditions. The originality of this script lies in its innovative dual-chain design, providing traders with a unique edge by allowing them to capitalize on both significant trends and smaller, faster price movements.
Whether you aim to capture extended market trends or take advantage of more immediate price action, the Dual Chain Strategy provides a comprehensive solution with a high degree of customization and strategic depth. Its flexibility and originality make it a valuable tool for traders seeking to refine their approach to market analysis and execution.
How to Use the Dual Chain Strategy
Step 1: Access the Strategy
Add the Script: Start by adding the Dual Chain Strategy to your TradingView chart. You can do this by searching for the script by name or using the link provided.
Select the Asset: Apply the strategy to your preferred trading pair or asset, such as #BTCUSD, to see how it performs.
Step 2: Configure the Settings
Enable/Disable Chains:
The strategy is designed with two independent chains. You can choose to enable or disable each chain depending on your trading style and the market conditions.
enableChain1 = input.bool(true, title='Enable Chain 1')
enableChain2 = input.bool(true, title='Enable Chain 2')
By default, both chains are enabled. If you prefer to focus only on longer-term trends, you might disable Chain 2, or vice versa if you prefer shorter-term trades.
Set EMA Lengths:
Adjust the EMA lengths for each chain to match your trading preferences.
Chain 1: The default EMA length is 10 periods. This chain uses a weekly timeframe for entry signals and a daily timeframe for exits.
len1 = input.int(10, minval=1, title='Length Chain 1 EMA', group="Chain 1")
Chain 2: The default EMA length is 9 periods. This chain uses a 12-hour timeframe for entries and a 9-hour timeframe for exits.
len2 = input.int(9, minval=1, title='Length Chain 2 EMA', group="Chain 2")
Customize Timeframes:
You can customize the timeframes used for entry and exit signals for both chains.
Chain 1:
Entry Timeframe: Weekly
Exit Timeframe: Daily
tf1_entry = input.timeframe("W", title='Chain 1 Entry Timeframe', group="Chain 1")
tf1_exit = input.timeframe("D", title='Chain 1 Exit Timeframe', group="Chain 1")
Chain 2:
Entry Timeframe: 12 Hours
Exit Timeframe: 9 Hours
tf2_entry = input.timeframe("720", title='Chain 2 Entry Timeframe (12H)', group="Chain 2")
tf2_exit = input.timeframe("540", title='Chain 2 Exit Timeframe (9H)', group="Chain 2")
Set the Backtesting Period:
Define the period over which you want to backtest the strategy. This allows you to see how the strategy would have performed historically.
startDate = input.time(timestamp('2015-07-27'), title="StartDate")
finishDate = input.time(timestamp('2026-01-01'), title="FinishDate")
Step 3: Analyze the Signals
Understand the Entry and Exit Signals:
Buy Signals: When the price crosses above the entry EMA, the strategy generates a buy signal.
bullishChain1 = enableChain1 and ta.crossover(src1, entryEMA1)
Sell Signals: When the price crosses below the exit EMA, the strategy generates a sell signal.
bearishChain2 = enableChain2 and ta.crossunder(src2, entryEMA2)
Review the Visual Indicators:
The strategy plots buy and sell signals on the chart with labels for easy identification:
BUY C1/C2 for buy signals from Chain 1 and Chain 2.
SELL C1/C2 for sell signals from Chain 1 and Chain 2.
This visual aid helps you quickly understand when and why trades are being executed.
Step 4: Optimize the Strategy
Backtest Results:
Review the strategy’s performance over the backtesting period. Look at key metrics like net profit, drawdown, and trade statistics to evaluate its effectiveness.
Adjust the EMA lengths, timeframes, and other settings to see how changes affect the strategy’s performance.
Customize for Live Trading:
Once satisfied with the backtest results, you can apply the strategy settings to live trading. Remember to continuously monitor and adjust as needed based on market conditions.
Step 5: Implement Risk Management
Use Realistic Position Sizing:
Keep your risk exposure per trade within a comfortable range, typically between 1-2% of your trading capital.
Set Alerts:
Set up alerts for buy and sell signals, so you don’t miss trading opportunities.
Paper Trade First:
Consider running the strategy in a paper trading account to understand its behavior in real market conditions before committing real capital.
This dual-layered approach offers a distinct advantage: it enables the strategy to adapt to varying market conditions by capturing both broad trends and immediate price action without one chain's activity impacting the other's decision-making process. The independence of these chains in executing transactions adds a level of sophistication and flexibility that is rarely seen in more conventional trading systems, making the Dual Chain Strategy not just unique, but a powerful tool for traders seeking to navigate complex market environments.
S&P Short-Range Oscillator**SHOULD BE USED ON THE S&P 500 ONLY**
The S&P Short-Range Oscillator (SRO), inspired by the principles of Jim Cramer's oscillator, is a technical analysis tool designed to help traders identify potential buy and sell signals in the stock market, specifically for the S&P 500 index. The SRO combines several market indicators to provide a normalized measure of market sentiment, assisting traders in making informed decisions.
The SRO utilizes two simple moving averages (SMAs) of different lengths: a 5-day SMA and a 10-day SMA. It also incorporates the daily price change and market breadth (the net change of closing prices). The 5-day and 10-day SMAs are calculated based on the closing prices. The daily price change is determined by subtracting the opening price from the closing price. Market breadth is calculated as the difference between the current closing price and the previous closing price.
The raw value of the oscillator, referred to as SRO Raw, is the sum of the daily price change, the 5-day SMA, the 10-day SMA, and the market breadth. This raw value is then normalized using its mean and standard deviation over a 20-day period, ensuring that the oscillator is centered and maintains a consistent scale. Finally, the normalized value is scaled to fit within the range of -15 to 15.
When interpreting the SRO, a value below -5 indicates that the market is potentially oversold, suggesting it might be a good time to start buying stocks as the market could be poised for a rebound. Conversely, a value above 5 suggests that the market is potentially overbought. In this situation, it may be prudent to hold on to existing positions or consider selling if you have substantial gains.
The SRO is visually represented as a blue line on a chart, making it easy to track its movements. Red and green horizontal lines mark the overbought (5) and oversold (-5) levels, respectively. Additionally, the background color changes to light red when the oscillator is overbought and light green when it is oversold, providing a clear visual cue.
By incorporating the S&P Short-Range Oscillator into your trading strategy, you can gain valuable insights into market conditions and make more informed decisions about when to buy, sell, or hold your stocks. However, always consider other market factors and perform your own analysis before making any trading decisions.
The S&P Short-Range Oscillator is a powerful tool for traders looking to gain insights into market sentiment. It provides clear buy and sell signals through its combination of multiple indicators and normalization process. However, traders should be aware of its lagging nature and potential complexity, and use it in conjunction with other analysis methods for the best results.
Disclaimer
The S&P Short-Range Oscillator is for informational purposes only and should not be considered financial advice. Trading involves risk, and you should conduct your own research or consult a financial advisor before making investment decisions. The author is not responsible for any losses incurred from using this indicator. Use at your own risk.
Equal Highs and Lows {Reh's and Rel's }# Equal Highs and Lows {Reh's and Rel's} Indicator
## Overview
The "Equal Highs and Lows {Reh's and Rel's}" indicator is designed to identify and mark equal highs and lows on a price chart. It detects both exact and relative equal levels, draws lines connecting these levels, and optionally labels them. This tool can help traders identify potential support and resistance zones based on historical price levels.
## Key Features
1. **Exact and Relative Equality**: Detects both precise price matches and relative equality within a specified threshold.
2. **Customizable Appearance**: Allows users to adjust colors, line styles, and widths.
3. **Dynamic Line Management**: Automatically extends or removes lines based on ongoing price action.
4. **Labeling System**: Optional labels to identify types of equal levels (e.g., "Equal High", "REH/Equal High").
5. **Flexible Settings**: Adjustable parameters for lookback periods, maximum bars apart, and relative equality thresholds.
## User Inputs
### Appearance
- `lineColorHigh`: Color for lines marking equal highs (default: red)
- `lineColorLow`: Color for lines marking equal lows (default: green)
- `lineWidth`: Thickness of the lines (range: 1-5, default: 1)
- `lineStyle`: Style of the lines (options: Solid, Dash, Dotted)
- `showLabels`: Toggle to show or hide labels for equal highs and lows
### Settings
- `lookbackLength`: Number of bars to look back for finding equal highs and lows (default: 200)
- `maxBarsApart`: Maximum number of bars apart for equal highs/lows to be considered (range: 2-10, default: 5)
### Relative Equality
- `considerRelativeEquals`: Enable detection of relative equal highs and lows
- `thresholdIndex`: Maximum tick difference for relative equality in index instruments (range: 1-10, default: 2)
- `thresholdStocks`: Maximum tick difference for relative equality in stock instruments (range: 5-200, step: 5, default: 10)
## How It Works
The indicator scans historical price data to identify equal or relatively equal highs and lows. It draws lines connecting these levels and updates them as new price data comes in. Lines are extended if the level holds and removed if the price breaks through. The tool adapts to different market conditions by allowing adjustments to the equality thresholds for various instrument types.
## Practical Use
Traders can use this indicator to:
- Identify potential support and resistance levels
- Spot areas where price might react based on historical turning points
- Enhance their understanding of price structure and repetitive patterns
## Disclaimer
This indicator is provided as a tool to assist in identifying potential price levels of interest. It is not financial advice. Users should not rely solely on this or any single indicator for trading decisions. Always conduct thorough analysis, consider multiple factors, and be aware that past price behavior does not guarantee future results. All trading involves risk.
Ripster MTF CloudsDescription:
MTF EMA Cloud By Ripster
EMA Cloud System is a Trading System Invented by Ripster where areas are shaded between two desired EMAs. The concept implies the EMA cloud area serves as support or resistance for Intraday & Swing Trading. This can be utilized effectively on 10 Min for day trading and 1Hr/Daily for Swings. Ripster himself utilizes various combinations of the 5-12, 34-50, 8-9, 20-21 EMA clouds but the possibilities are endless to find what works best for you.
“Ideally, 5-12 or 5-13 EMA cloud acts as a fluid trendline for day trades. 8-9 EMA Clouds can be used as pullback Levels –(optional). Additionally, a high level price over or under 34-50 EMA clouds confirms either bullish or bearish bias on the price action for any timeframe” – Ripster
This indicator is an extension of the Ripster EMA Clouds. It allows you to visualize Exponential Moving Average (EMA) clouds from any time frame on your current chart, regardless of the chart's own time frame. This functionality is especially useful for traders who want to monitor higher time frame trends and support/resistance levels while trading on lower time frames.
What does this code do?
The Ripster MTF Clouds indicator displays two sets of EMA clouds. Each set consists of a short EMA and a long EMA. By default, the indicator uses Daily 20/21 and 50/55 EMAs, but you can customize these settings to fit your trading strategy. The EMAs are plotted on your chart along with their corresponding clouds, colored for easy differentiation:
EMA 1 (default 50/55): Plotted in blue.
EMA 2 (default 20/21): Plotted in teal.
The indicator uses the security function to fetch EMA values from higher time frames and plots them on your current chart, allowing you to see how these higher time frame EMAs interact with your current time frame's price action.
How to use this indicator:
Adjust Resolution:
Set the "Resolution" input to the time frame from which you want to fetch EMA values. For example, set it to "1H" if you want to see 1-hour EMAs on your current chart.
Customize EMAs:
Modify the "EMA 1 Short Length" and "EMA 1 Long Length" inputs to change the default 50/55 EMAs.
Adjust the "EMA 2 Short Length" and "EMA 2 Long Length" inputs to change the default 20/21 EMAs.
Monitor Clouds:
The indicator fills the area between the short and long EMAs, creating a cloud that helps visualize the trend. A blue cloud indicates the area between the EMA 1 pair, while a teal cloud indicates the area between the EMA 2 pair.
Use Multiple Instances:
You can add multiple instances of this indicator to your chart to monitor multiple higher time frames simultaneously. For instance, one instance can show daily clouds while another shows hourly clouds.
Integration with Trading Strategy:
Use this indicator to identify higher time frame trends and support/resistance levels, which can help improve your trading decisions on lower time frames.
For example, you can go long when the stock is above the 50-55 EMA clouds and 20-21 EMA clouds with daily resolution on a 10-minute chart and short when it is below it.
Similarly, you can short a stock under the 1-hour 34/50 EMA clouds while still trading on a 10-minute chart.
Bollinger Bands Fast Trend Indicator [DCD]Description:
The Bollinger Bands Fast Trend Detector indicator is an advanced tool designed to provide traders with more precise trend detection and clearer entry and exit signals. This script builds upon the traditional Bollinger Bands indicator by adding customizable standard deviations and incorporating multiple moving averages to enhance the accuracy of the signals.
Main Features:
1. **Customizable Bollinger Bands**:
- Each Bollinger Band has its own standard deviation setting, allowing for more granular control and better trend detection.
- The short Bollinger Band is set to a 10-period SMA for faster trend recognition.
2. **Multiple Moving Averages**:
- The indicator includes several types of moving averages (SMA, EMA, LSMA, HMA, WMA) applied to the Bollinger Trend value, giving traders flexibility to choose the best fit for their strategy.
3. **Crossover and Crossdown Detection**:
- The script identifies crossover and crossdown points between the Bollinger Trend value and the selected moving average, marking potential buy and sell signals with green and red circles, respectively.
4. **Color-Coded Histogram**:
- The histogram bars are color-coded to indicate the strength and direction of the trend, making it easy to visualize market conditions at a glance.
Instructions:
1. **Adding the Script to Your Chart**:
- Open your TradingView chart and add the Bollinger Bands Fast Trend Detector indicator.
2. **Adjusting Parameters**:
- Customize the Bollinger Bands and moving average settings according to your trading preferences:
- `Short BB Length` (default: 10): Adjusts the length of the short Bollinger Band.
- `Long BB Length` (default: 50): Adjusts the length of the long Bollinger Band.
- `StdDev` (for both bands): Sets the standard deviation multiplier.
- `Moving Average Type`: Choose between SMA, EMA, LSMA, HMA, and WMA.
- `Moving Average Length` (default: 14): Sets the length of the moving average.
3. **Interpreting the Output**:
- Observe the BBTrend and moving average plots on your chart.
- Look for green circles indicating crossover points (potential buy signals) and red circles indicating crossdown points (potential sell signals).
- Use the color-coded histogram bars to assess the strength and direction of the trend.
Configurable Parameters:
- `shortLengthInput` (default: 10): Length of the short Bollinger Band.
- `longLengthInput` (default: 50): Length of the long Bollinger Band.
- `shortDevMultInput` (default: 1.0): Standard deviation multiplier for the short Bollinger Band.
- `longDevMultInput` (default: 2.0): Standard deviation multiplier for the long Bollinger Band.
- `maTypeInput` (default: SMA): Type of moving average (options: SMA, EMA, LSMA, HMA, WMA).
- `maLengthInput` (default: 14): Length of the moving average.
Code Explanation:
The script calculates two sets of Bollinger Bands with distinct lengths and standard deviations. The difference between the lower bands and upper bands is normalized by the short middle band to compute the BBTrend value. A selected moving average is then applied to this BBTrend value. The script plots the BBTrend, the moving average, and uses color-coded histogram bars to represent trend strength and direction. It also identifies and marks crossover and crossdown points to provide potential trading signals.
Disclaimer:
This script is for educational purposes only and should not be considered financial advice. Always perform your own analysis before making any trading decisions.
Average price in candlePlots the average price a security had within a candle.
So, for example: If you have a 15m candle, and price stayed near the candle's high for 10 out of the 15 minutes, you would expect the average price top be near the candle's high as well. And that's actually how it is.
(Blue 10:30 candle in the screenshot.)
I think this "average in-candle price" could be a useful thing to know. You can't gather this information from the normal chart (as you would need to go to a lower timeframe). Plus this plot can be smoother than plots of, say, closing price or hl2.
The calculation happens in a lower timeframe which is selected automatically. There is a precision selector which allows you to influence this. By default, at least 10 values are sampled for each candle.
If you have TradingView Premium, the script is able to use second-based intervals to look inside 1m candles. (Tick the corresponding checkbox to enable this.)
How it works: I collect timestamps and hl2 values from the lower timeframe. (I figure hl2 is the best choice here because a close is so arbitrary. If we don't have further information, our guess is the average is simply exactly in the middle of the candle's range.)
Then I throw the last close and current close (from the CHART timeframe) into the mix and calculate an average of the prices we collected weighted by the duration that price was in effect.
tl;dr; It's just math baby
Kyrie Crossover ( @zaytradellc )Unlocking Market Dynamics: Kyrie Crossover Script by @zaytradellc
personalized trading success with the "Kyrie Crossover" script, meticulously crafted by @zaytrade. This innovative Pine Script, tailored to the birthdays of Kyrie and the script creator, combines the power of technical analysis with a touch of personalization to revolutionize your trading experience.
**Exponential Moving Average (EMA) Crossover Strategy:**
At the heart of the "Kyrie Crossover" script lies a sophisticated EMA crossover strategy. By utilizing a 10-period EMA and a 323-period EMA (symbolizing long term price action ), the strategy effectively captures market trends with precision and insight.
- **Short-Term EMA (10-period):** This EMA reacts swiftly to recent price changes, offering heightened sensitivity to short-term fluctuations. It excels in identifying immediate shifts in market sentiment, making it invaluable for pinpointing short-lived trends and potential reversal points.
- **Long-Term EMA (323-period):** In contrast, the long-term EMA provides a broader perspective by smoothing out short-term noise and focusing on longer-term trend direction. Its extended length filters out market noise effectively, providing a clear representation of the underlying trend's momentum and sustainability.
**Directional Movement Index (DMI) Metrics:**
The "Kyrie Crossover" script goes beyond traditional indicators by incorporating DMI metrics across multiple timeframes. By assessing trend strength and direction, traders gain valuable insights into market dynamics, allowing for informed decision-making.
**Simple Instructions to Profit:**
1. **Identify EMA Crossovers:** Look for instances where the short-term EMA (10-period) crosses above the long-term EMA (323-period) for a bullish signal, indicating a potential buying opportunity. Conversely, a crossover where the short-term EMA crosses below the long-term EMA signals a bearish trend and a potential selling opportunity.
2. **Confirm with DMI Metrics:** Validate EMA crossovers by checking DMI metrics across different timeframes (5 minutes, 15 minutes, 30 minutes, and 1 hour). Pay attention to color-coded indicators, with green indicating a bullish trend, red indicating a bearish trend, and white indicating no clear trend.
3. **Manage Risk:** Implement proper risk management techniques, such as setting stop-loss orders and position sizing based on your risk tolerance and trading objectives.
4. **Stay Informed:** Regularly monitor market conditions and adjust your trading strategy accordingly based on new signals and emerging trends.
Historical Correlation [LuxAlgo]The Historical Correlation tool aims to provide the historical correlation coefficients of up to 10 pairs of user-defined tickers starting from a user-defined point in time.
Users can choose to display the historical values as lines or the most recent correlation values as a heat map.
🔶 USAGE
This tool provides historical correlation coefficients, the correlation coefficient between two assets highlight their linear relationship and is always within the range (-1, 1).
It is a simple and easy to use statistical tool, with the following interpretation:
Positive correlation (values close to +1.0): the two assets move in sync, they rise and fall at the same time.
Negative correlation (values close to -1.0): the two assets move in opposite directions: when one goes up, the other goes down and vice versa.
No correlation (values close to 0): the two assets move independently.
The user must confirm the selection of the anchor point in order for the tool to be executed; this can be done directly on the chart by clicking on any bar, or via the date field in the settings panel.
For the parameter Anchor period , the user can choose between the following values NONE, HOURLY, DAILY, WEEKLY, MONTHLY, QUARTERLY and YEARLY. If NONE is selected, there will be no resetting of the calculations, otherwise the calculations will start from the first bar of the new period.
There is a wide range of trading strategies that make use of correlation coefficients between assets, some examples are:
Pair Trading: Traders may wish to take advantage of divergences in the price movements of highly positively correlated assets; even highly positively correlated assets do not always move in the same direction; when assets with a correlation close to +1.0 diverge in their behavior, traders may see this as an opportunity to buy one and sell the other in the expectation that the assets will return to the likely same price behavior.
Sector rotation: Traders may want to favor some sectors that are expected to perform in the next cycle, tracking the correlation between different sectors and between the sector and the overall market.
Diversification: Traders can aim to have a diversified portfolio of uncorrelated assets. From a risk management perspective, it is useful to know the correlation between the assets in your portfolio, if you hold equal positions in positively correlated assets, your risk is tilted in the same direction, so if the assets move against you, your risk is doubled. You can avoid this increased risk by choosing uncorrelated assets so that they move independently.
Hedging: Traders may want to hedge positions with correlated assets, from a hedging perspective, if you are long an asset, you can hedge going long a negative correlated asset or going short a positive correlated asset.
Traders generally need to develop awareness, a key point is to be aware of the relationships between the assets we hold or trade, the historical correlation is an invaluable tool in our arsenal which allows us to make better informed decisions.
On this chart we have an example of historical correlations for several futures markets.
We can clearly see how positively correlated the Nasdaq100 and Dow30 are with the SP500 over the whole period, or how the correlation between the Euro and the SP500 falls from almost +85% to almost -4% since 2021.
As we can see, correlations, like everything else in the market, are not static and vary over time depending on many factors, from macro to technical and everything in between.
🔹 Heatmap
The chart above shows the tool with the default settings and the Drawing Mode set to 'HEATMAP'.
We can see the current correlation between the assets, in this case the FX pairs.
The highest positive correlation is +90% (+0.90) between EURUSD and GBPUSD.
The highest negative correlation is -78% (-0.78) between EURUSD and USDJPY.
The pair with no correlation is AUDUSD and EURCAD with 1% (0.01)
On the above chart we can see the current correlations for the futures markets.
Currently, the assets that are less correlated to the SP500 are NaturalGas and the Euro, the more positive correlations are Nasdaq100 and Dow20, and the more negative correlations are the Yen, Treasury Bonds and 10-Year Notes.
🔶 DETAILS
🔹 Anchor Period
This chart shows the standard FX correlations with the Anchor Period set to `MONTHLY`.
We can clearly see how the calculations restart with the new month, in this case we can clearly see the differences between the correlations from month to month.
Let us look at the correlation coefficient between GBPUSD and USDJPY
In January, their correlation started at close to -100%, rose to close to +50%, only to fall to close to 0% and remain there for the second half of the month.
In February it was -90% in the first few days of the month and is now around -57%.
And between AUDUSD and EURCAD
Last month their correlation was negative for most of the month, reaching -70% and ending around -14%.
This month their correlation has never gone below +21% and at the time of writing is close to +53%.
🔶 SETTINGS
Anchor point: Starting point from which the tool is executed
Anchor period: At the beginning of each new period, the tool will reset the calculations
Pairs from 1 to 10: For each pair of tickers, you can: enable/disable the pair, select the color and specify the two tickers from which you wish to obtain the correlation
🔹 Style
Drawing Mode: Output style, `LINES` will show the historical correlations as lines, `HEATMAP` will show the current correlations with a color gradient from green for correlations near 1 to red for correlations near -1.
LV Stock Valuation by Benjamin Graham's FormulaBenjamin Graham's stock valuation formula for growth companies is based on the principle that a stock is a part of a business, and that by analyzing the fundamentals of any company in the stock market, you should be able to derive its intrinsic value independent from its current stock price. Graham suggests that over the long-term, the stock price of a company and its intrinsic/fair value will converge towards each other until the stock price reflects the true value of the company. Finally, Graham recommends that after estimating the intrinsic value of a stock, investors should always purchase the stock with a "margin of safety," to protect oneself from assumptions and potential errors made in the valuation process.
Graham's stock valuation formula to calculate intrinsic value was originally shown in the 1962 edition of Security Analysis as follows:
V = EPS * (8.5 + 2g)
where:
V = intrinsic value per share (over the next 7-10 years)
EPS = earnings per share (over the trailing twelve months (TTM))
8.5 = price-to-earnings (P/E) base for a no-growth company
g = reasonably expected annual growth rate (over the next 7-10 years)
In 1974, Graham revised this formula, as published in The Intelligent Investor, to include a discount rate (aka required rate of return). This was after he concluded that the greatest contributing to stock values and prices over the past decade had been due to interest rates.
Graham's current stock valuation formula is shown below:
V = (EPS * (8.5 + 2g) * Z) / Y
where:
V = intrinsic value per share (over the next 7-10 years)
EPS = diluted earnings per share (over the trailing twelve months (TTM))
8.5 = price-to-earnings (P/E) base for a no-growth company (you can change it manually)
g = reasonably expected annual growth rate (calculated by 5-Yr EPS CAGR%) (you can change year period)
Z = average yield of XXX Bonds (4.4 is default on Graham's formula)
Y = current yield of XXX Bonds
Current bond yield values (Z and Y) are selected as an example from Turkey. You need to change it according to the country of stocks.
Buy price (BP) = Intrinsic value per share * (1 - Margin of safety %)
Margin of safety = selected 20% (you need to change it to 0, if you don’t want to use margin of safety and to see intrinsic value)
Buy price > Current market price: Consider buying the stock, as the current market price appears to be undervalued.
Buy price < Current market price: Consider selling or not buying the stock, as the current market price appears to be overvalued.
Keep in mind that this buy/sell recommendation is purely based on Graham's stock valuation formula and the current market price, and ignores all other fundamental, news, and market factors investors should examine as well before making an investment decision.
Buy price is calculated for 5 different P/E values in the script.
1. with fixed P/E
2. with current P/E
3. with forward P/E
4. with sector P/E (optional)
5. with index P/E (optional)
You can also do calculations by using different growth rate by selecting that option.
Different type of moving averages is also included in the script as an option.
AI SuperTrend x Pivot Percentile - Strategy [PresentTrading]█ Introduction and How it is Different
The AI SuperTrend x Pivot Percentile strategy is a sophisticated trading approach that integrates AI-driven analysis with traditional technical indicators. Combining the AI SuperTrend with the Pivot Percentile strategy highlights several key advantages:
1. Enhanced Accuracy in Trend Prediction: The AI SuperTrend utilizes K-Nearest Neighbors (KNN) algorithm for trend prediction, improving accuracy by considering historical data patterns. This is complemented by the Pivot Percentile analysis which provides additional context on trend strength.
2. Comprehensive Market Analysis: The integration offers a multi-faceted approach to market analysis, combining AI insights with traditional technical indicators. This dual approach captures a broader range of market dynamics.
BTC 6H L/S Performance
Local
█ Strategy: How it Works - Detailed Explanation
🔶 AI-Enhanced SuperTrend Indicators
1. SuperTrend Calculation:
- The SuperTrend indicator is calculated using a moving average and the Average True Range (ATR). The basic formula is:
- Upper Band = Moving Average + (Multiplier × ATR)
- Lower Band = Moving Average - (Multiplier × ATR)
- The moving average type (SMA, EMA, WMA, RMA, VWMA) and the length of the moving average and ATR are adjustable parameters.
- The direction of the trend is determined based on the position of the closing price in relation to these bands.
2. AI Integration with K-Nearest Neighbors (KNN):
- The KNN algorithm is applied to predict trend direction. It uses historical price data and SuperTrend values to classify the current trend as bullish or bearish.
- The algorithm calculates the 'distance' between the current data point and historical points. The 'k' nearest data points (neighbors) are identified based on this distance.
- A weighted average of these neighbors' trends (bullish or bearish) is calculated to predict the current trend.
For more please check: Multi-TF AI SuperTrend with ADX - Strategy
🔶 Pivot Percentile Analysis
1. Percentile Calculation:
- This involves calculating the percentile ranks for high and low prices over a set of predefined lengths.
- The percentile function is typically defined as:
- Percentile = Value at (P/100) × (N + 1)th position
- Where P is the desired percentile, and N is the number of data points.
2. Trend Strength Evaluation:
- The calculated percentiles for highs and lows are used to determine the strength of bullish and bearish trends.
- For instance, a high percentile rank in the high prices may indicate a strong bullish trend, and vice versa for bearish trends.
For more please check: Pivot Percentile Trend - Strategy
🔶 Strategy Integration
1. Combining SuperTrend and Pivot Percentile:
- The strategy synthesizes the insights from both AI-enhanced SuperTrend and Pivot Percentile analysis.
- It compares the trend direction indicated by the SuperTrend with the strength of the trend as suggested by the Pivot Percentile analysis.
2. Signal Generation:
- A trading signal is generated when both the AI-enhanced SuperTrend and the Pivot Percentile analysis agree on the trend direction.
- For instance, a bullish signal is generated when both the SuperTrend is bullish, and the Pivot Percentile analysis shows strength in bullish trends.
🔶 Risk Management and Filters
- ADX and DMI Filter: The strategy uses the Average Directional Index (ADX) and the Directional Movement Index (DMI) as filters to assess the trend's strength and direction.
- Dynamic Trailing Stop Loss: Based on the SuperTrend indicator, the strategy dynamically adjusts stop-loss levels to manage risk effectively.
This strategy stands out for its ability to combine real-time AI analysis with established technical indicators, offering traders a nuanced and responsive tool for navigating complex market conditions. The equations and algorithms involved are pivotal in accurately identifying market trends and potential trade opportunities.
█ Usage
To effectively use this strategy, traders should:
1. Understand the AI and Pivot Percentile Indicators: A clear grasp of how these indicators work will enable traders to make informed decisions.
2. Interpret the Signals Accurately: The strategy provides bullish, bearish, and neutral signals. Traders should align these signals with their market analysis and trading goals.
3. Monitor Market Conditions: Given that this strategy is sensitive to market dynamics, continuous monitoring is crucial for timely decision-making.
4. Adjust Settings as Needed: Traders should feel free to tweak the input parameters to suit their trading preferences and to respond to changing market conditions.
█Default Settings and Their Impact on Performance
1. Trading Direction (Default: "Both")
Effect: Determines whether the strategy will take long positions, short positions, or both. Adjusting this setting can align the strategy with the trader's market outlook or risk preference.
2. AI Settings (Neighbors: 3, Data Points: 24)
Neighbors: The number of nearest neighbors in the KNN algorithm. A higher number might smooth out noise but could miss subtle, recent changes. A lower number makes the model more sensitive to recent data but may increase noise.
Data Points: Defines the amount of historical data considered. More data points provide a broader context but may dilute recent trends' impact.
3. SuperTrend Settings (Length: 10, Factor: 3.0, MA Source: "WMA")
Length: Affects the sensitivity of the SuperTrend indicator. A longer length results in a smoother, less sensitive indicator, ideal for long-term trends.
Factor: Determines the bandwidth of the SuperTrend. A higher factor creates wider bands, capturing larger price movements but potentially missing short-term signals.
MA Source: The type of moving average used (e.g., WMA - Weighted Moving Average). Different MA types can affect the trend indicator's responsiveness and smoothness.
4. AI Trend Prediction Settings (Price Trend: 10, Prediction Trend: 80)
Price Trend and Prediction Trend Lengths: These settings define the lengths of weighted moving averages for price and SuperTrend, impacting the responsiveness and smoothness of the AI's trend predictions.
5. Pivot Percentile Settings (Length: 10)
Length: Influences the calculation of pivot percentiles. A shorter length makes the percentile more responsive to recent price changes, while a longer length offers a broader view of price trends.
6. ADX and DMI Settings (ADX Length: 14, Time Frame: 'D')
ADX Length: Defines the period for the Average Directional Index calculation. A longer period results in a smoother ADX line.
Time Frame: Sets the time frame for the ADX and DMI calculations, affecting the sensitivity to market changes.
7. Commission, Slippage, and Initial Capital
These settings relate to transaction costs and initial investment, directly impacting net profitability and strategy feasibility.
Turtle Trader StrategyTurtle Trader Strategy :
Introduction :
This strategy is based on the well known « Turtle Trader Strategy », that has proven itself over the years. It sends long and short signals with pyramid orders of up to 5, meaning that the strategy can trigger up to 5 orders in the same direction. Good risk and money management.
It's important to note that the strategy combines 2 systems working together (S1 and S2). Let’s describe the specific features of this strategy.
1/ Position size :
Position size is very important for turtle traders to manage risk properly. This position sizing strategy adapts to market volatility and to account (gains and losses). It’s based on ATR (Average True Range) which can also be called « N ». Its length is per default 20.
ATR(20) = (previous_atr(20)*19 + actual_true_range)/20
The number of units to buy is :
Unit = 1% * account/(ATR(20)*dollar_per_point)
where account is the actual account value and dollar_per_point is the variation in dollar of the asset with a 1 point move.
Depending on your risk aversion, you can increase the percentage of your account, but turtle traders default to 1%. If you trade contracts, units must be rounded down by default.
There is also an additional rule to reduce the risk if the value of the account falls below the initial capital : in this case and only in this case, account in the unit formula must be replace by :
account = actual_account*actual_account/initial capital
2/ Open a position :
2 systems are working together :
System 1 : Entering a new 20 day breakout
System 2 : Entering a new 55 day breakout
A breakout is a new high or new low. If it’s a new high, we open long position and vice versa if it’s a new low we enter in short position.
We add an additional rule :
System 1 : Breakout is ignored if last long/short position was a winner
System 2 : All signals are taken
This additional rule allows the trader to be in the major trends if the system 1 signal has been skipped. If a signal for system 1 has been skipped, and next candle is also a new 20 day breakout, S1 doesn’t give a signal. We have to wait S2 signal or wait for a candle that doesn’t make a new breakout to reactivate S1.
3/ Pyramid orders :
Turtle Strategy allows us to add extra units to the position if the price moves in our favor. I've configured the strategy to allow up to 5 orders to be added in the same direction. So if the price varies from 0.5*ATR(20) , we add units with the position size formula. Note that the value of account will be replaced by "remaining_account", i.e. the cash remaining in our account after subtracting the value of open positions.
4/ Stop Loss :
We set a stop loss at 1.5*ATR(20) below the entry price for longs and above the entry price for shorts. If pyramid units are added, the stop is increased/decreased by 0.5*ATR(20). Note that if SL is configured for a loss of more than 10%, we set the SL to 10% for the first entry order to avoid big losses. This configuration does not work for pyramid orders as SL moves by 0.5*ATR(20).
5/ Exit signals :
System 1 :
Exit long on a 10 day low
Exit short on a 10 day high
System 2 :
Exit long on a 20 day low
Exit short on a 20 day high
6/ What types of orders are placed ?
To enter in a position, stop orders are placed meaning that we place orders that will be automatically triggered by the signal at the exact breakout price. Stop loss and exit signals are also stop orders. Pyramid orders are market orders which will be triggered at the opening of the next candle to avoid repainting.
PARAMETERS :
Risk % of capital : Percentage used in the position size formula. Default is 1%
ATR period : ATR length used to calculate ATR. Default is 20
Stop ATR : Parameters used to fix stop loss. Default is 1.5 meaning that stop loss will be set at : buy_price - 1.5*ATR(20) for long and buy_price + 1.5*ATR(20) for short. Turtle traders default is 2 but 1.5 is better for cryptocurrency as there is a huge volatility.
S1 Long : System 1 breakout length for long. Default is 20
S2 Long : System 2 breakout length for long. Default is 55
S1 Long Exit : System 1 breakout length to exit long. Default is 10
S2 Long Exit : System 2 breakout length to exit long. Default is 20
S1 Short : System 1 breakout length for short. Default is 15
S2 Short : System 2 breakout length for short. Default is 55
S1 Short Exit : System 1 breakout length to exit short. Default is 7
S2 Short Exit : System 2 breakout length to exit short. Default is 20
Initial capital : $1000
Fees : Interactive Broker fees apply to this strategy. They are set at 0.18% of the trade value.
Slippage : 3 ticks or $0.03 per trade. Corresponds to the latency time between the moment the signal is received and the moment the order is executed by the broker.
Pyramiding : Number of orders that can be passed in the same direction. Default is 5.
Important : Turtle traders don't trade crypto. For this specific asset type, I modify some parameters such as SL and Short S1 in order to maximize return while limiting drawdown. This strategy is the most optimal on BINANCE:BTCUSD in 1D timeframe with the parameters set per default. If you want to use this strategy for a different crypto please adapt parameters.
NOTE :
It's important to note that the first entry order (long or short) will be the largest. Subsequent pyramid orders will have fewer units than the first order. We've set a maximum SL for the first order of 10%, meaning that you won't lose more than 10% of the value of your first order. However, it is possible to lose more on your pyramid orders, as the SL is increased/decreased by 0.5*ATR(20), which does not secure a loss of more than 10% on your pyramid orders. The risk remains well managed because the value of these orders is less than the value of the first order. Remain vigilant to this small detail and adjust your risk according to your risk aversion.
Enjoy the strategy and don’t forget to take the trade :)
Key Levels | Flux Charts💎 GENERAL OVERVIEW
Introducing our new Key Levels indicator! This indicator allows you to see the key levels on the current chart such as previous day lows / highs, pre-market data, yesterday's close, today's open, pivot points, and much more! It's highly user-friendly with every line being individually customizable and having a wide range of text options.
Features of the new Key Levels indicator :
Today & Yesterday High, Low, Open & Close
Previous 3-10th Day Highs & Lows
Pre-Market Highs & Lows
Previous Month High & Low
High & Low Pivots
Combination Of Same Levels
Wide Customization Options
📌 HOW DOES IT WORK ?
Key levels are important areas in a chart where a significant reaction is expected. In this indicator, you can enable up to the previous 10 days highs and lows, yesterday's close / today's open, and the latest pivot points. Key levels generally act like support & resistance. Here are a few examples :
As shown, key levels play an important role determining the current trend and can be useful in identifying potential levels where the market will reverse or breakout.
🚩UNIQUENESS
1. More Key Levels
We believe that past key levels may be as important as current ones. Some of the key-levels indicators do not include them even though strong reactions can happen around them. Thus, our indicator let's you check up to 10 days backwards.
You can select the ones you think that are the most important and just enable them, making the indicator customizable to your liking.
2. Pre-Market Data
With assets that have pre-market data available, it's crucial to analyze it to have a better understanding of the market in regular trading hours. Our indicator will plot pre-market highs and lows, even if your chart is in the regular trading hours only mode. We believe this will be helpful with your analyzing process.
3. Combination
The indicator can dynamically combine same key levels, so you can have a clear look to the chart without lines & text colliding with each other. This would also help you determine stronger key levels as if a key level occured more than a time, it could be a sign that it's a stronger one. An example :
To summarize, using key levels is an essential skill while detecting zones where strong reactions are expected. This indicator provides up to 10 day's high and low levels, and all of them can be individually turned on / off. Traders that believe older key levels can be important and want to look at the whole picture may use this feature. Also for assets that have pre-market data available, the indicator provides pre-market levels as well. Besides all that, High & Low pivots will provide latest key levels so traders can use them in their decisions.
⚙️SETTINGS
1. General Configuration
You can enable / disable :
1. Today's High / Low / Open
2. Yesterday's High / Low / Close
3. 3th-10th Day High / Low
4. Pre-Market High / Low
5. Previous Month High / Low
You can also change the colors and switch their line styles between solid, dashed and dotted.
2. High & Low Pivots
Enabled -> Enable / Disable High & Low Pivots
Pivot Range -> The range used in the detection of pivot points. Larger values will result in less pivot points, while smaller values will provide more pivot points. This essentially determines how many bars to the right & left shouldn't exceed the pivot's high or low.
You can also change the text color and text size of the pivots from the settings.
3. Style settings
Text Offset -> How many bars of offset should the texts have to the right. Increase if text collides with bars while Align Labels option is set to "Right".
Extend Lines -> If enabled, lines will be extended infinitely to right & left. If disabled, all lines will be clamped in their timelines.
Show Line Values -> If enabled, line information text will contain their price.
Align Labels ->
Right = Align line labels to right.
Center = Line labels will always be at the center of the screen.
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.
// =================================
Targets For Many Indicators [LuxAlgo]The Targets For Many Indicators is a useful utility tool able to display targets for many built-in indicators as well as external indicators. Targets can be set for specific user-set conditions between two series of values, with the script being able to display targets for two different user-set conditions.
Alerts are included for the occurrence of a new target as well as for reached targets.
🔶 USAGE
Targets can help users determine the price limit where the price might start deviating from an indication given by one or multiple indicators. In the context of trading, targets can help secure profits/reduce losses of a trade, as such this tool can be useful to evaluate/determine user take profits/stop losses.
Due to these essentially being horizontal levels, they can also serve as potential support/resistances, with breakouts potentially confirming new trends.
In the above example, we set targets 3 ATR's away from the closing price when the price crosses over the script built-in SuperTrend indicator using ATR period 10 and factor 3. Using "Long Position Target" allows setting a target above the price, disabling this setting will place targets below the price.
Users might be interested in obtaining new targets once one is reached, this can be done by enabling "New Target When Reached" in the target logic setting section, resulting in more frequent targets.
Lastly, users can restrict new target creation until current ones are reached. This can result in fewer and longer-term targets, with a higher reach rate.
🔹 Dashboard
A dashboard is displayed on the top right of the chart, displaying the amount, reach rate of targets 1/2, and total amount.
This dashboard can be useful to evaluate the selected target distances relative to the selected conditions, with a higher reach rate suggesting the distance of the targets from the price allows them to be reached.
🔶 DETAILS
🔹 Indicators
Besides 'External' sources, each source can be set at 1 of the following Build-In Indicators :
ACCDIST : Accumulation/distribution index
ATR : Average True Range
BB (Middle, Upper or Lower): Bollinger Bands
CCI : Commodity Channel Index
CMO : Chande Momentum Oscillator
COG : Center Of Gravity
DC (High, Mid or Low): Donchian Channels
DEMA : Double Exponential Moving Average
EMA : Exponentially weighted Moving Average
HMA : Hull Moving Average
III : Intraday Intensity Index
KC (Middle, Upper or Lower): Keltner Channels
LINREG : Linear regression curve
MACD (macd, signal or histogram): Moving Average Convergence/Divergence
MEDIAN : median of the series
MFI : Money Flow Index
MODE : the mode of the series
MOM : Momentum
NVI : Negative Volume Index
OBV : On Balance Volume
PVI : Positive Volume Index
PVT : Price-Volume Trend
RMA : Relative Moving Average
ROC : Rate Of Change
RSI : Relative Strength Index
SMA : Simple Moving Average
STOCH : Stochastic
Supertrend
TEMA : Triple EMA or Triple Exponential Moving Average
VWAP : Volume Weighted Average Price
VWMA : Volume-Weighted Moving Average
WAD : Williams Accumulation/Distribution
WMA : Weighted Moving Average
WVAD : Williams Variable Accumulation/Distribution
%R : Williams %R
Each indicator is provided with a link to the Reference Manual or to the Build-In Indicators page.
The latter contains more information about each indicator.
Note that when "Show Source Values" is enabled, only values that can be logically found around the price will be shown. For example, Supertrend , SMA , EMA , BB , ... will be made visible. Values like RSI , OBV , %R , ... will not be visible since they will deviate too much from the price.
🔹 Interaction with settings
This publication contains input fields, where you can enter the necessary inputs per indicator.
Some indicators need only 1 value, others 2 or 3.
When several input values are needed, you need to separate them with a comma.
You can use 0 to 4 spaces between without a problem. Even an extra comma doesn't give issues.
The red colored help text will guide you further along (Only when Target is enabled)
Some examples that work without issues:
Some examples that work with issues:
As mentioned, the errors won't be visible when the concerning target is disabled
🔶 SETTINGS
Show Target Labels: Display target labels on the chart.
Candle Coloring: Apply candle coloring based on the most recent active target.
Target 1 and Target 2 use the same settings below:
Enable Target: Display the targets on the chart.
Long Position Target: Display targets above the price a user selected condition is true. If disabled will display the targets below the price.
New Target Condition: Conditional operator used to compare "Source A" and "Source B", options include CrossOver, CrossUnder, Cross, and Equal.
🔹 Sources
Source A: Source A input series, can be an indicator or external source.
External: External source if 'External" is selected in "Source A".
Settings: Settings of the selected indicator in "Source A", entered settings of indicators requiring multiple ones must be comma separated, for example, "10, 3".
Source B: Source B input series, can be an indicator or external source.
External: External source if 'External" is selected in "Source B".
Settings: Settings of the selected indicator in "Source B", entered settings of indicators requiring multiple ones must be comma separated, for example, "10, 3".
Source B Value: User-defined numerical value if "value" is selected in "Source B".
Show Source Values: Display "Source A" and "Source B" on the chart.
🔹 Logic
Wait Until Reached: When enabled will not create a new target until an existing one is reached.
New Target When Reached: Will create a new target when an existing one is reached.
Evaluate Wicks: Will use high/low prices to determine if a target is reached. Unselecting this setting will use the closing price.
Target Distance From Price: Controls the distance of a target from the price. Can be determined in currencies/points, percentages, ATR multiples, ticks, or using multiple of external values.
External Distance Value: External distance value when "External Value" is selected in "Target Distance From Price".
10x Bull Vs. Bear VP Intraday Sessions [Kioseff Trading]Hello!
This script "10x Bull Vs. Bear VP Intraday Sessions" lets the user configure up to 10 session ranges for Bull Vs. Bear volume profiles!
Features
Up To 10 Fixed Ranges!
Volume Profile Anchored to Fixed Range
Delta Ladder Anchored to Range
Bull vs Bear Profiles!
Standard Poc and Value Area Lines, in Addition to Separated POCs and Value Area Lines for Bull Profiles and Bear Profiles
Configurable Value Area Target
Up to 2000 Profile Rows per Visible Range
Stylistic Options for Profiles
This script generates Bull vs. Bear volume profiles for up to 10 fixed ranges!
Up to 2000 volume profile levels (price levels) Can be calculated for each profile, thanks to the new polyline feature, allowing for less aggregation / more precision of volume at price and volume delta.
Bull vs Bear Profiles
The image above shows primary functionality!
Green profiles = buying volume
Red profiles = selling volume
All colors are configurable.
Bullish & bearish POC + value areas for each fixed range are displayable!
That’s about it :D
This indicator is part of a series titled “Bull vs. Bear”.
If you have any suggestions please feel free to share!
Moving Average TransformThe MAT is essentially a different kind of smoothed moving average. It is made to filter out data sets that deviate from the specified absolute threshold and the result becomes a smoothing function. The goal here, inspired by time series analysis within mathematical study, is to eliminate data anomalies and generate a more accurate trendline.
Functionality:
This script calculates a filtered average by:
Determining the mean of the entire data series.
Initializing sum and count variables.
Iterating through the data to filter values that deviate from the mean beyond the threshold.
Calculating a filtered mean based on the filtered data.
The filtered mean is then passed through a moving average function, where various types of moving averages like SMA, EMA, DEMA, TEMA, and ALMA can be applied. Some popular averages such as the HMA were omitted due to their heavy dependency on weighing specific data points.
Some information from "Time Series Analysis" regarding deviations
Definition of Anomaly: An anomaly or outlier is a data point that differs significantly from other observations in the dataset. It can be caused by various reasons such as measurement errors, data entry errors, or genuine extreme observations.
Impact on Mean: The mean (or average) of a dataset is calculated by summing all the values and dividing by the number of values. Since the mean is sensitive to extreme values, even a single outlier can significantly skew the mean.
Example: Consider a simple time series dataset: . The value "150" is an anomaly in this context. If we calculate the mean with this outlier, it is (10 + 12 + 11 + 9 + 150) / 5 = 38.4. However, if we exclude the outlier, the mean becomes (10 + 12 + 11 + 9) / 4 = 10.5. The presence of the outlier has substantially increased the mean.
Accuracy and Representativeness: While the mean calculated without outliers might be more "accurate" in the sense of being more representative of the central tendency of the bulk of the data, it's essential to note that anomalies might convey important information about the system being studied. Blindly removing or ignoring them might lead to overlooking significant events or phenomena.
Approaches to Handle Anomalies?
Detection and Removal
Robust Statistics
Transformation
