Exhaustion Candle Indicator (ECI)The Exhaustion Candle Indicator (ECI) is designed to help traders identify significant exhaustion points in price action. These points can indicate potential areas of interest where price may experience a change in momentum, providing insights into both continuation and reversal setups.
Key Features:
Exhaustion Candles: ECI identifies key exhaustion points by analyzing bullish and bearish candle patterns, helping traders spot potential support and resistance areas or moments of market pause.
Customizable Alerts: Built-in alert functionality allows traders to receive notifications when an exhaustion candle forms, providing timely updates for monitoring price action.
Time-Based Filtering: The indicator analyzes price action during peak trading hours (6 AM to 11 AM New York Time), reducing noise and focusing on more impactful market moves.
How It Works:
Bullish Exhaustion: Detects potential market hesitation or demand in a downtrend by spotting bearish-to-bullish candle patterns with long upper wicks.
Bearish Exhaustion: Identifies potential resistance or supply in an uptrend by spotting bullish-to-bearish candle patterns with long lower wicks.
Usage:
This indicator is ideal for traders seeking to understand points of potential market exhaustion, useful in both continuation and reversal setups. It can be used alongside other indicators and technical analysis methods to enhance trading strategies.
Search in scripts for "11月1日是什么星座"
Relative Measured Volatility (RMV) – Spot Tight Entry ZonesTitle: Relative Measured Volatility (RMV) – Spot Tight Entry Zones
Introduction
The Relative Measured Volatility (RMV) indicator is designed to highlight tight price consolidation zones , making it an ideal tool for traders seeking optimal entry points before potential breakouts. By focusing on tightness rather than general volatility, RMV offers traders a practical way to detect consolidation phases that often precede significant market moves.
How RMV Works
The RMV calculates short-term tightness by averaging three ATR (Average True Range) values over different lookback periods and then normalizing them within a specified lookback window. The result is a percentage-based scale from 0 to 100, indicating how tight the current price range is compared to recent history.
Here’s the breakdown:
Three ATR values are computed using user-defined short lookback periods to represent short-term price movements. An average of the ATRs provides a smoothed measure of current tightness. The RMV normalizes this average against the highest and lowest values over the defined lookback period, scaling it from 0 to 100.
This approach helps traders identify consolidation zones that are more likely to lead to breakouts.
Key Features of RMV
Multi-Period ATR Calculation : Uses three ATR values to effectively capture market tightness over the short term. Normalization : Converts the tightness measure to a 0-100 scale for easy interpretation. Dynamic Histogram and Background Colors : The RMV indicator uses a color-coded system for clarity.
How to Use the RMV Indicator
Identify Tight Consolidation Zones:
a - RMV values between 0-10 indicate very tight price ranges, making this the most optimal zone for potential entries before breakouts.
b - RMV values between 11-20 suggest moderate tightness, still favorable for entries.
Monitor Potential Breakout Areas:
As RMV moves from 21-30 , tightness reduces, signaling expanding volatility that may require wider stops or more flexible entry strategies.
Adjust Trading Strategies:
Use RMV values to identify tight zones for entering trades, especially in trending markets or at key support/resistance levels.
Customize the Indicator:
a - Adjust the short-term ATR lookback periods to control sensitivity.
b - Modify the lookback period to match your trading horizon, whether short-term or long-term.
Color-Coding Guide for RMV
ibb.co
How to Add RMV to Your Chart
Open your chart on TradingView.
Go to the “Indicators” section.
Search for "Relative Measured Volatility (RMV)" in the Community Scripts section.
Click on the indicator to add it to your chart.
Customize the input parameters to fit your trading strategy.
Input Parameters
Lookback Period : Defines the period over which tightness is measured and normalized.
Short-term ATR Lookbacks (1, 2, 3) : Control sensitivity to short-term tightness.
Histogram Threshold : Sets the threshold for differentiating between bright (tight) and dim (less tight) histogram colors.
Conclusion
The Relative Measured Volatility (RMV) is a versatile tool designed to help traders identify tight entry zones by focusing on market consolidation. By highlighting narrow price ranges, the RMV guides traders toward potential breakout setups while providing clear visual cues for better decision-making. Add RMV to your trading toolkit today and enhance your ability to identify optimal entry points!
Z-Score Weighted Trend System I [InvestorUnknown]The Z-Score Weighted Trend System I is an advanced and experimental trading indicator designed to utilize a combination of slow and fast indicators for a comprehensive analysis of market trends. The system is designed to identify stable trends using slower indicators while capturing rapid market shifts through dynamically weighted fast indicators. The core of this indicator is the dynamic weighting mechanism that utilizes the Z-score of price , allowing the system to respond effectively to significant market movements.
Dynamic Z-Score-Based Weighting System
The Z-Score Weighted Trend System I utilizes the Z-score of price to assign weights dynamically to fast indicators. This mechanism is designed to capture rapid market shifts at potential turning points, providing timely entry and exit signals.
Traders can choose from two primary weighting mechanisms:
Threshold-Based Weighting: The fast indicators are given weight only when the absolute Z-score exceeds a user-defined threshold. Below this threshold, fast indicators have no impact on the final signal.
Continuous Weighting: By setting the threshold to zero, fast indicators always contribute to the final signal, regardless of Z-score levels. However, this increases the likelihood of false signals during ranging or low-volatility markets
// Calculate weight for Fast Indicators based on Z-Score (Slow Indicator weight is kept to 1 for simplicity)
f_zscore_weights(series float z, simple float weight_thre) =>
float fast_weight = na
float slow_weight = na
if weight_thre > 0
if math.abs(z) <= weight_thre
fast_weight := 0
slow_weight := 1
else
fast_weight := 0 + math.sqrt(math.abs(z))
slow_weight := 1
else
fast_weight := 0 + math.sqrt(math.abs(z))
slow_weight := 1
Choice of Z-Score Normalization
Traders have the flexibility to select different Z-score processing methods to better suit their trading preferences:
Raw Z-Score or Moving Average: Traders can opt for either the raw Z-score or a moving average of the Z-score to smooth out fluctuations.
Normalized Z-Score (ranging from -1 to 1) or Z-Score Percentile: The normalized Z-score is simply the raw Z-score divided by 3, while the Z-score percentile utilizes a normal distribution for transformation.
f_zscore_perc(series float zscore_src, simple int zscore_len, simple string zscore_a, simple string zscore_b, simple string ma_type, simple int ma_len) =>
z = (zscore_src - ta.sma(zscore_src, zscore_len)) / ta.stdev(zscore_src, zscore_len)
zscore = switch zscore_a
"Z-Score" => z
"Z-Score MA" => ma_type == "EMA" ? (ta.ema(z, ma_len)) : (ta.sma(z, ma_len))
output = switch zscore_b
"Normalized Z-Score" => (zscore / 3) > 1 ? 1 : (zscore / 3) < -1 ? -1 : (zscore / 3)
"Z-Score Percentile" => (f_percentileFromZScore(zscore) - 0.5) * 2
output
Slow and Fast Indicators
The indicator uses a combination of slow and fast indicators:
Slow Indicators (constant weight) for stable trend identification: DMI (Directional Movement Index), CCI (Commodity Channel Index), Aroon
Fast Indicators (dynamic weight) to identify rapid trend shifts: ZLEMA (Zero-Lag Exponential Moving Average), IIRF (Infinite Impulse Response Filter)
Each indicator is calculated using for-loop methods to provide a smoothed and averaged view of price data over varying lengths, ensuring stability for slow indicators and responsiveness for fast indicators.
Signal Calculation
The final trading signal is determined by a weighted combination of both slow and fast indicators. The slow indicators provide a stable view of the trend, while the fast indicators offer agile responses to rapid market movements. The signal calculation takes into account the dynamic weighting of fast indicators based on the Z-score:
// Calculate Signal (as weighted average)
float sig = math.round(((DMI*slow_w) + (CCI*slow_w) + (Aroon*slow_w) + (ZLEMA*fast_w) + (IIRF*fast_w)) / (3*slow_w + 2*fast_w), 2)
Backtest Mode and Performance Metrics
The indicator features a detailed backtesting mode, allowing traders to compare the effectiveness of their selected settings against a traditional Buy & Hold strategy. The backtesting provides:
Equity calculation based on signals generated by the indicator.
Performance metrics comparing Buy & Hold metrics with the system’s signals, including: Mean, positive, and negative return percentages, Standard deviations, Sharpe, Sortino, and Omega Ratios
// Calculate Performance Metrics
f_PerformanceMetrics(series float base, int Lookback, simple float startDate, bool Annualize = true) =>
// Initialize variables for positive and negative returns
pos_sum = 0.0
neg_sum = 0.0
pos_count = 0
neg_count = 0
returns_sum = 0.0
returns_squared_sum = 0.0
pos_returns_squared_sum = 0.0
neg_returns_squared_sum = 0.0
// Loop through the past 'Lookback' bars to calculate sums and counts
if (time >= startDate)
for i = 0 to Lookback - 1
r = (base - base ) / base
returns_sum += r
returns_squared_sum += r * r
if r > 0
pos_sum += r
pos_count += 1
pos_returns_squared_sum += r * r
if r < 0
neg_sum += r
neg_count += 1
neg_returns_squared_sum += r * r
float export_array = array.new_float(12)
// Calculate means
mean_all = math.round((returns_sum / Lookback), 4)
mean_pos = math.round((pos_count != 0 ? pos_sum / pos_count : na), 4)
mean_neg = math.round((neg_count != 0 ? neg_sum / neg_count : na), 4)
// Calculate standard deviations
stddev_all = math.round((math.sqrt((returns_squared_sum - (returns_sum * returns_sum) / Lookback) / Lookback)) * 100, 2)
stddev_pos = math.round((pos_count != 0 ? math.sqrt((pos_returns_squared_sum - (pos_sum * pos_sum) / pos_count) / pos_count) : na) * 100, 2)
stddev_neg = math.round((neg_count != 0 ? math.sqrt((neg_returns_squared_sum - (neg_sum * neg_sum) / neg_count) / neg_count) : na) * 100, 2)
// Calculate probabilities
prob_pos = math.round((pos_count / Lookback) * 100, 2)
prob_neg = math.round((neg_count / Lookback) * 100, 2)
prob_neu = math.round(((Lookback - pos_count - neg_count) / Lookback) * 100, 2)
// Calculate ratios
sharpe_ratio = math.round((mean_all / stddev_all * (Annualize ? math.sqrt(Lookback) : 1))* 100, 2)
sortino_ratio = math.round((mean_all / stddev_neg * (Annualize ? math.sqrt(Lookback) : 1))* 100, 2)
omega_ratio = math.round(pos_sum / math.abs(neg_sum), 2)
// Set values in the array
array.set(export_array, 0, mean_all), array.set(export_array, 1, mean_pos), array.set(export_array, 2, mean_neg),
array.set(export_array, 3, stddev_all), array.set(export_array, 4, stddev_pos), array.set(export_array, 5, stddev_neg),
array.set(export_array, 6, prob_pos), array.set(export_array, 7, prob_neu), array.set(export_array, 8, prob_neg),
array.set(export_array, 9, sharpe_ratio), array.set(export_array, 10, sortino_ratio), array.set(export_array, 11, omega_ratio)
// Export the array
export_array
//}
Calibration Mode
A Calibration Mode is included for traders to focus on individual indicators, helping them fine-tune their settings without the influence of other components. In Calibration Mode, the user can visualize each indicator separately, making it easier to adjust parameters.
Alerts
The indicator includes alerts for long and short signals when the indicator changes direction, allowing traders to set automated notifications for key market events.
// Alert Conditions
alertcondition(long_alert, "LONG (Z-Score Weighted Trend System)", "Z-Score Weighted Trend System flipped ⬆LONG⬆")
alertcondition(short_alert, "SHORT (Z-Score Weighted Trend System)", "Z-Score Weighted Trend System flipped ⬇Short⬇")
Important Note:
The default settings of this indicator are not optimized for any particular market condition. They are generic starting points for experimentation. Traders are encouraged to use the calibration tools and backtesting features to adjust the system to their specific trading needs.
The results generated from the backtest are purely historical and are not indicative of future results. Market conditions can change, and the performance of this system may differ under different circumstances. Traders and investors should exercise caution and conduct their own research before using this indicator for any trading decisions.
CMF and Scaled EFI OverlayCMF and Scaled EFI Overlay Indicator
Overview
The CMF and Scaled EFI Overlay indicator combines the Chaikin Money Flow (CMF) and a scaled version of the Elder Force Index (EFI) into a single chart. This allows traders to analyze both indicators simultaneously, facilitating better insights into market momentum and volume dynamics , specifically focusing on buying/selling pressure and momentum , without compromising the integrity of either indicator.
Purpose
Chaikin Money Flow (CMF): Measures buying and selling pressure by evaluating price and volume over a specified period. It indicates accumulation (buying pressure) when values are positive and distribution (selling pressure) when values are negative.
Elder Force Index (EFI): Combines price changes and volume to assess the momentum behind market moves. Positive values indicate upward momentum (prices rising with strong volume), while negative values indicate downward momentum (prices falling with strong volume).
By scaling the EFI to match the amplitude of the CMF, this indicator enables a direct comparison between pressure and momentum , preserving their shapes and zero crossings. Traders can observe the relationship between price movements, volume, and momentum more effectively, aiding in decision-making.
Understanding Pressure vs. Momentum
Chaikin Money Flow (CMF):
- Indicates the level of demand (buying pressure) or supply (selling pressure) in the market based on volume and price movements.
- Accumulation: When institutional or large investors are buying significant amounts of an asset, leading to an increase in buying pressure.
- Distribution: When these investors are selling off their holdings, increasing selling pressure.
Elder Force Index (EFI):
- Measures the strength and speed of price movements, indicating how forceful the current trend is.
- Positive Momentum: Prices are rising quickly, indicating a strong uptrend.
- Negative Momentum: Prices are falling rapidly, indicating a strong downtrend.
Understanding the difference between pressure and momentum is crucial. For example, a market may exhibit strong buying pressure (positive CMF) but weak momentum (low EFI), suggesting accumulation without significant price movement yet.
Features
Overlay of CMF and Scaled EFI: Both indicators are plotted on the same chart for easy comparison of pressure and momentum dynamics.
Customizable Parameters: Adjust lengths for CMF and EFI calculations and fine-tune the scaling factor for optimal alignment.
Preserved Indicator Integrity: The scaling method preserves the shape and zero crossings of the EFI, ensuring accurate analysis.
How It Works
CMF Calculation:
- Calculates the Money Flow Multiplier (MFM) and Money Flow Volume (MFV) to assess buying and selling pressure.
- CMF is computed by summing the MFV over the specified length and dividing by the sum of volume over the same period:
CMF = (Sum of MFV over n periods) / (Sum of Volume over n periods)
EFI Calculation:
- Calculates the EFI using the Exponential Moving Average (EMA) of the price change multiplied by volume:
EFI = EMA(n, Change in Close * Volume)
Scaling the EFI:
- The EFI is scaled by multiplying it with a user-defined scaling factor to match the CMF's amplitude.
Plotting:
- Both the CMF and the scaled EFI are plotted on the same chart.
- A zero line is included for reference, aiding in identifying crossovers and divergences.
Indicator Settings
Inputs
CMF Length (`cmf_length`):
- Default: 20
- Description: The number of periods over which the CMF is calculated. A higher value smooths the indicator but may delay signals.
EFI Length (`efi_length`):
- Default: 13
- Description: The EMA length for the EFI calculation. Adjusting this value affects the sensitivity of the EFI to price changes.
EFI Scaling Factor (`efi_scaling_factor`):
- Default: 0.000001
- Description: A constant used to scale the EFI to match the CMF's amplitude. Fine-tuning this value ensures the indicators align visually.
How to Adjust the EFI Scaling Factor
Start with the Default Value:
- Begin with the default scaling factor of `0.000001`.
Visual Inspection:
- Observe the plotted indicators. If the EFI appears too large or small compared to the CMF, proceed to adjust the scaling factor.
Fine-Tune the Scaling Factor:
- Increase or decrease the scaling factor incrementally (e.g., `0.000005`, `0.00001`, `0.00005`) until the amplitudes of the CMF and EFI visually align.
- The optimal scaling factor may vary depending on the asset and timeframe.
Verify Alignment:
- Ensure that the scaled EFI preserves the shape and zero crossings of the original EFI.
- Overlay the original EFI (if desired) to confirm alignment.
How to Use the Indicator
Analyze Buying/Selling Pressure and Momentum:
- Positive CMF (>0): Indicates accumulation (buying pressure).
- Negative CMF (<0): Indicates distribution (selling pressure).
- Positive EFI: Indicates positive momentum (prices rising with strong volume).
- Negative EFI: Indicates negative momentum (prices falling with strong volume).
Look for Indicator Alignment:
- Both CMF and EFI Positive:
- Suggests strong bullish conditions with both buying pressure and upward momentum.
- Both CMF and EFI Negative:
- Indicates strong bearish conditions with selling pressure and downward momentum.
Identify Divergences:
- CMF Positive, EFI Negative:
- Buying pressure exists, but momentum is negative; potential for a bullish reversal if momentum shifts.
- CMF Negative, EFI Positive:
- Selling pressure exists despite rising prices; caution advised as it may indicate a potential bearish reversal.
Confirm Signals with Other Analysis:
- Use this indicator in conjunction with other technical analysis tools (e.g., trend lines, support/resistance levels) to confirm trading decisions.
Example Usage
Scenario 1: Bullish Alignment
- CMF Positive: Indicates accumulation (buying pressure).
- EFI Positive and Increasing: Shows strengthening upward momentum.
- Interpretation:
- Strong bullish signal suggesting that buyers are active, and the price is likely to continue rising.
- Action:
- Consider entering a long position or adding to existing ones.
Scenario 2: Bearish Divergence
- CMF Negative: Indicates distribution (selling pressure).
- EFI Positive but Decreasing: Momentum is positive but weakening.
- Interpretation:
- Potential bearish reversal; price may be rising but underlying selling pressure suggests caution.
- Action:
- Be cautious with long positions; consider tightening stop-losses or preparing for a possible trend reversal.
Tips
Adjust for Different Assets:
- The optimal scaling factor may differ across assets due to varying price and volume characteristics.
- Always adjust the scaling factor when analyzing a new asset.
Monitor Indicator Crossovers:
- Crossings above or below the zero line can signal potential trend changes.
Watch for Divergences:
- Divergences between the CMF and EFI can provide early warning signs of trend reversals.
Combine with Other Indicators:
- Enhance your analysis by combining this overlay with other indicators like moving averages, RSI, or Ichimoku Cloud.
Limitations
Scaling Factor Sensitivity:
- An incorrect scaling factor may misalign the indicators, leading to inaccurate interpretations.
- Regular adjustments may be necessary when switching between different assets or timeframes.
Not a Standalone Indicator:
- Should be used as part of a comprehensive trading strategy.
- Always consider other market factors and indicators before making trading decisions.
Disclaimer
No Guarantee of Performance:
- Past performance is not indicative of future results.
- Trading involves risk, and losses can exceed deposits.
Use at Your Own Risk:
- This indicator is provided for educational purposes.
- The author is not responsible for any financial losses incurred while using this indicator.
Code Summary
//@version=5
indicator(title="CMF and Scaled EFI Overlay", shorttitle="CMF & Scaled EFI", overlay=false)
cmf_length = input.int(20, minval=1, title="CMF Length")
efi_length = input.int(13, minval=1, title="EFI Length")
efi_scaling_factor = input.float(0.000001, title="EFI Scaling Factor", minval=0.0, step=0.000001)
// --- CMF Calculation ---
ad = high != low ? ((2 * close - low - high) / (high - low)) * volume : 0
mf = math.sum(ad, cmf_length) / math.sum(volume, cmf_length)
// --- EFI Calculation ---
efi_raw = ta.ema(ta.change(close) * volume, efi_length)
// --- Scale EFI ---
efi_scaled = efi_raw * efi_scaling_factor
// --- Plotting ---
plot(mf, color=color.green, title="CMF", linewidth=2)
plot(efi_scaled, color=color.red, title="EFI (Scaled)", linewidth=2)
hline(0, color=color.gray, title="Zero Line", linestyle=hline.style_dashed)
- Lines 4-6: Define input parameters for CMF length, EFI length, and EFI scaling factor.
- Lines 9-11: Calculate the CMF.
- Lines 14-16: Calculate the EFI.
- Line 19: Scale the EFI by the scaling factor.
- Lines 22-24: Plot the CMF, scaled EFI, and zero line.
Feedback and Support
Suggestions: If you have ideas for improvements or additional features, please share your feedback.
Support: For assistance or questions regarding this indicator, feel free to contact the author through TradingView.
---
By combining the CMF and scaled EFI into a single overlay, this indicator provides a powerful tool for traders to analyze market dynamics more comprehensively. Adjust the parameters to suit your trading style, and always practice sound risk management.
RSI Weighted Trend System I [InvestorUnknown]The RSI Weighted Trend System I is an experimental indicator designed to combine both slow-moving trend indicators for stable trend identification and fast-moving indicators to capture potential major turning points in the market. The novelty of this system lies in the dynamic weighting mechanism, where fast indicators receive weight based on the current Relative Strength Index (RSI) value, thus providing a flexible tool for traders seeking to adapt their strategies to varying market conditions.
Dynamic RSI-Based Weighting System
The core of the indicator is the dynamic weighting of fast indicators based on the value of the RSI. In essence, the higher the absolute value of the RSI (whether positive or negative), the higher the weight assigned to the fast indicators. This enables the system to capture rapid price movements around potential turning points.
Users can choose between a threshold-based or continuous weight system:
Threshold-Based Weighting: Fast indicators are activated only when the absolute RSI value exceeds a user-defined threshold. Below this threshold, fast indicators receive no weight.
Continuous Weighting: By setting the weight threshold to zero, the fast indicators always receive some weight, although this can result in more false signals in ranging markets.
// Calculate weight for Fast Indicators based on RSI (Slow Indicator weight is kept to 1 for simplicity)
f_RSI_Weight_System(series float rsi, simple float weight_thre) =>
float fast_weight = na
float slow_weight = na
if weight_thre > 0
if math.abs(rsi) <= weight_thre
fast_weight := 0
slow_weight := 1
else
fast_weight := 0 + math.sqrt(math.abs(rsi))
slow_weight := 1
else
fast_weight := 0 + math.sqrt(math.abs(rsi))
slow_weight := 1
Slow and Fast Indicators
Slow Indicators are designed to identify stable trends, remaining constant in weight. These include:
DMI (Directional Movement Index) For Loop
CCI (Commodity Channel Index) For Loop
Aroon For Loop
Fast Indicators are more responsive and designed to spot rapid trend shifts:
ZLEMA (Zero-Lag Exponential Moving Average) For Loop
IIRF (Infinite Impulse Response Filter) For Loop
Each of these indicators is calculated using a for-loop method to generate a moving average, which captures the trend of a given length range.
RSI Normalization
To facilitate the weighting system, the RSI is normalized from its usual 0-100 range to a -1 to 1 range. This allows for easy scaling when calculating weights and helps the system adjust to rapidly changing market conditions.
// Normalize RSI (1 to -1)
f_RSI(series float rsi_src, simple int rsi_len, simple string rsi_wb, simple string ma_type, simple int ma_len) =>
output = switch rsi_wb
"RAW RSI" => ta.rsi(rsi_src, rsi_len)
"RSI MA" => ma_type == "EMA" ? (ta.ema(ta.rsi(rsi_src, rsi_len), ma_len)) : (ta.sma(ta.rsi(rsi_src, rsi_len), ma_len))
Signal Calculation
The final trading signal is a weighted average of both the slow and fast indicators, depending on the calculated weights from the RSI. This ensures a balanced approach, where slow indicators maintain overall trend guidance, while fast indicators provide timely entries and exits.
// Calculate Signal (as weighted average)
sig = math.round(((DMI*slow_w) + (CCI*slow_w) + (Aroon*slow_w) + (ZLEMA*fast_w) + (IIRF*fast_w)) / (3*slow_w + 2*fast_w), 2)
Backtest Mode and Performance Metrics
This version of the RSI Weighted Trend System includes a comprehensive backtesting mode, allowing users to evaluate the performance of their selected settings against a Buy & Hold strategy. The backtesting includes:
Equity calculation based on the signals generated by the indicator.
Performance metrics table comparing Buy & Hold strategy metrics with the system’s signals, including: Mean, positive, and negative return percentages, Standard deviations (of all, positive and negative returns), Sharpe Ratio, Sortino Ratio, and Omega Ratio
f_PerformanceMetrics(series float base, int Lookback, simple float startDate, bool Annualize = true) =>
// Initialize variables for positive and negative returns
pos_sum = 0.0
neg_sum = 0.0
pos_count = 0
neg_count = 0
returns_sum = 0.0
returns_squared_sum = 0.0
pos_returns_squared_sum = 0.0
neg_returns_squared_sum = 0.0
// Loop through the past 'Lookback' bars to calculate sums and counts
if (time >= startDate)
for i = 0 to Lookback - 1
r = (base - base ) / base
returns_sum += r
returns_squared_sum += r * r
if r > 0
pos_sum += r
pos_count += 1
pos_returns_squared_sum += r * r
if r < 0
neg_sum += r
neg_count += 1
neg_returns_squared_sum += r * r
float export_array = array.new_float(12)
// Calculate means
mean_all = math.round((returns_sum / Lookback) * 100, 2)
mean_pos = math.round((pos_count != 0 ? pos_sum / pos_count : na) * 100, 2)
mean_neg = math.round((neg_count != 0 ? neg_sum / neg_count : na) * 100, 2)
// Calculate standard deviations
stddev_all = math.round((math.sqrt((returns_squared_sum - (returns_sum * returns_sum) / Lookback) / Lookback)) * 100, 2)
stddev_pos = math.round((pos_count != 0 ? math.sqrt((pos_returns_squared_sum - (pos_sum * pos_sum) / pos_count) / pos_count) : na) * 100, 2)
stddev_neg = math.round((neg_count != 0 ? math.sqrt((neg_returns_squared_sum - (neg_sum * neg_sum) / neg_count) / neg_count) : na) * 100, 2)
// Calculate probabilities
prob_pos = math.round((pos_count / Lookback) * 100, 2)
prob_neg = math.round((neg_count / Lookback) * 100, 2)
prob_neu = math.round(((Lookback - pos_count - neg_count) / Lookback) * 100, 2)
// Calculate ratios
sharpe_ratio = math.round(mean_all / stddev_all * (Annualize ? math.sqrt(Lookback) : 1), 2)
sortino_ratio = math.round(mean_all / stddev_neg * (Annualize ? math.sqrt(Lookback) : 1), 2)
omega_ratio = math.round(pos_sum / math.abs(neg_sum), 2)
// Set values in the array
array.set(export_array, 0, mean_all), array.set(export_array, 1, mean_pos), array.set(export_array, 2, mean_neg),
array.set(export_array, 3, stddev_all), array.set(export_array, 4, stddev_pos), array.set(export_array, 5, stddev_neg),
array.set(export_array, 6, prob_pos), array.set(export_array, 7, prob_neu), array.set(export_array, 8, prob_neg),
array.set(export_array, 9, sharpe_ratio), array.set(export_array, 10, sortino_ratio), array.set(export_array, 11, omega_ratio)
// Export the array
export_array
The metrics help traders assess the effectiveness of their strategy over time and can be used to optimize their settings.
Calibration Mode
A calibration mode is included to assist users in tuning the indicator to their specific needs. In this mode, traders can focus on a specific indicator (e.g., DMI, CCI, Aroon, ZLEMA, IIRF, or RSI) and fine-tune it without interference from other signals.
The calibration plot visualizes the chosen indicator's performance against a zero line, making it easy to see how changes in the indicator’s settings affect its trend detection.
Customization and Default Settings
Important Note: The default settings provided are not optimized for any particular market or asset. They serve as a starting point for experimentation. Traders are encouraged to calibrate the system to suit their own trading strategies and preferences.
The indicator allows deep customization, from selecting which indicators to use, adjusting the lengths of each indicator, smoothing parameters, and the RSI weight system.
Alerts
Traders can set alerts for both long and short signals when the indicator flips, allowing for automated monitoring of potential trading opportunities.
TASC 2024.11 Ultimate Strength Index█ OVERVIEW
This script implements the Ultimate Strength Index (USI) indicator, introduced by John Ehlers in his article titled "Ultimate Strength Index (USI)" from the November 2024 edition of TASC's Traders' Tips . The USI is a modified version of Wilder's original Relative Strength Index (RSI) that incorporates Ehlers' UltimateSmoother lowpass filter to produce an output with significantly reduced lag.
█ CONCEPTS
Many technical indicators, including the RSI, lag due to their heavy reliance on historical data. John Ehlers reformulated the RSI to substantially reduce lag by applying his UltimateSmoother filter to upward movements ( strength up - SU ) and downward movements ( strength down - SD ) in the time series, replacing the standard process of smoothing changes with rolling moving averages (RMAs). Ehlers' recent works, covered in our recent script publications, have shown that the UltimateSmoother is an effective alternative to other classic averages, offering notably less lag in its response.
Ehlers also modified the RSI formula to produce an index that ranges from -1 to +1 instead of 0 to 100. As a result, the USI indicates bullish conditions when its value moves above 0 and bearish conditions when it falls below 0.
The USI retains many of the strengths of the traditional RSI while offering the advantage of reduced lag. It generally uses a larger lookback window than the conventional RSI to achieve similar behavior, making it suitable for trend trading with longer data lengths. When applied with shorter lengths, the USI's peaks and valleys tend to align closely with significant turning points in the time series, making it a potentially helpful tool for timing swing trades.
█ CALCULATIONS
The first step in the USI's calculation is determining each bar's strength up (SU) and strength down (SD) values. If the current bar's close exceeds the previous bar's, the calculation assigns the difference to SU. Otherwise, SU is zero. Likewise, if the current bar's close is below the previous bar's, it assigns the difference to SD. Otherwise, SD is zero.
Next, instead of the RSI's typical smoothing process, the USI's calculation applies the UltimateSmoother to the short-term average SU and SD values, reducing high-frequency chop in the series with low lag.
Finally, this formula determines the USI value:
USI = ( Ult (SU) − Ult (SD)) / ( Ult (SU) + Ult (SD)),
where Ult (SU) and Ult (SD) are the smoothed average strength up and strength down values.
ICT MACROS (UTC-4)This Pine Script creates an indicator that draws vertical lines on a TradingView chart to mark specific time intervals during the day. It allows the user to see when certain predefined time periods start and end, using vertical lines of different colors. The script is designed to work with time frames aligned to the UTC-4 timezone.
### Key Features of the Script
1. **Vertical Line Drawing Function**:
- The script uses a custom function, `draw_vertical_line`, to draw vertical lines at specific times.
- This function takes four parameters:
- `specificTime`: The specific timestamp when the vertical line should be drawn.
- `lineColor`: The color of the vertical line.
- `labelText`: The text label for the line (used internally for debugging purposes).
- `adjustment_minutes`: An integer value that allows time adjustment (in minutes) to make the lines align more accurately with the chart’s candles.
- The function calculates an adjusted time using the `adjustment_minutes` parameter and checks if the current time (`time`) falls within a 3-minute range of the adjusted time. If it does, it draws a vertical line.
2. **User Input for Time Adjustment**:
- The `adjustment_minutes` input allows users to fine-tune the appearance of the lines by shifting them slightly forward or backward in time to ensure they align with the chart candles. This is useful because of potential minor discrepancies between the script’s timestamps and the chart’s actual candle times.
3. **Predefined Time Intervals**:
- The script specifies six different time intervals (using the UTC-4 timezone) and draws vertical lines to mark the start and end of each interval:
- **First interval**: 8:50 - 9:10 AM
- **Second interval**: 9:50 - 10:10 AM
- **Third interval**: 10:50 - 11:10 AM
- **Fourth interval**: 13:10 - 13:40 PM
- **Fifth interval**: 14:50 - 15:10 PM
- **Sixth interval**: 15:15 - 15:45 PM
- For each interval, there are two timestamps: the start time and the end time. The script draws a green vertical line for the start and a red vertical line for the end.
4. **Line Drawing Logic**:
- For each time interval, the script calculates the timestamp using the `timestamp()` function with the specified time in UTC-4.
- The `draw_vertical_line` function is called twice for each interval: once for the start time (with a green line) and once for the end time (with a red line).
5. **Visual Overlay**:
- The script uses the `overlay=true` setting, which means that the vertical lines are drawn directly on top of the existing price chart. This helps in visually identifying the specific time intervals without cluttering the chart.
### Summary
This Pine Script is designed for traders or analysts who want to visualize specific time intervals directly on their TradingView charts. It provides a customizable way to highlight these intervals using vertical lines, making it easier to analyze price action or trading volume during key times of the day. The `adjustment_minutes` input adds flexibility to align these lines accurately with chart data.
ICT Asian Range and KillzonesThis TradingView indicator highlights key trading sessions and their price ranges on a chart. It identifies the Asian Range and the Killzones for both the London Open and New York Open sessions. Here’s a brief breakdown:
Asian Range:
Defines the high and low price levels during the Asian trading session (between the specified start and end hours, default 00:00 to 04:00 UTC).
Plots horizontal lines to mark the highest and lowest prices reached during the Asian session.
Adds labels showing the values of these high and low points after the session ends.
London and New York Killzones:
Identifies the “Killzones” or key trading windows for the London Open (default 06:00 to 09:00 UTC) and the New York Open (default 11:00 to 14:00 UTC).
Tracks the high and low price levels within these windows and plots rectangles ("boxes") on the chart to visualize these ranges.
The boxes are color-coded and customizable, indicating potential areas of high market activity or volatility.
Customizable Visuals:
Users can adjust the colors, border widths, and other visual properties for better clarity and chart integration.
Double Ribbon [ChartPrime]The Double Ribbon - ChartPrime indicator is a powerful tool that combines two sets of Simple Moving Averages (SMAs) into a visually intuitive ribbon, which helps traders assess market trends and momentum. This indicator features two distinct ribbons: one with a fixed length but changing offset (displayed in gray) and another with varying lengths (displayed in colors). The relationship between these ribbons forms the basis of a trend score, which is visualized as an oscillator. This comprehensive approach provides traders with a clear view of market direction and strength.
◆ KEY FEATURES
Dual Ribbon Visualization : Displays two sets of 11 SMAs—one in a neutral gray color with a fixed length but varying offset, and another in vibrant colors with lengths that increase incrementally.
Trend Score Calculation : The trend score is derived from comparing each SMA in the colored ribbon with its corresponding SMA in the gray ribbon. If a colored SMA is above its gray counterpart, a positive score is added; if below, a negative score is assigned.
// Loop to calculate SMAs and update the score based on their relationships
for i = 0 to length
// Calculate SMA with increasing lengths
sma = ta.sma(src, len + 1 + i)
// Update score based on comparison of primary SMA with current SMA
if sma1 < sma
score += 1
else
score -= 1
// Store calculated SMAs in the arrays
sma_array.push(sma)
sma_array1.push(sma1 )
Dynamic Trend Analysis : The score oscillator provides a dynamic analysis of the trend, allowing traders to quickly gauge market conditions and potential reversals.
Customizable Ribbon Display : Users can toggle the display of the ribbon for a cleaner chart view, focusing solely on the trend score if desired.
◆ USAGE
Trend Confirmation : Use the position and color of the ribbon to confirm the current market trend. When the colored ribbon consistently stays above the gray ribbon, it indicates a strong uptrend, and vice versa for a downtrend.
Momentum Assessment : The score oscillator provides insight into the strength of the current trend. Higher scores suggest stronger trends, while lower scores may indicate weakening momentum or a potential reversal.
Strategic Entry/Exit Points : Consider using crossovers between the ribbons and changes in the score oscillator to identify potential entry or exit points in trades.
⯁ USER INPUTS
Length : Sets the base length for the primary SMAs in the ribbons.
Source : Determines the price data used for calculating the SMAs (e.g., close, open).
Ribbon Display Toggle : Allows users to show or hide the ribbon on the chart, focusing on either the ribbon, the trend score, or both.
⯁ CONCLUSION
The Double Ribbon indicator offers traders a comprehensive tool for analyzing market trends and momentum. By combining two ribbons with varying SMA lengths and offsets, it provides a clear visual representation of market conditions. The trend score oscillator enhances this analysis by quantifying trend strength, making it easier for traders to identify potential trading opportunities and manage risk effectively.
TCLC(TraderChitra Learning Class)-Option ChainThis indicator plots the Option chain data of the following instruments and columns..
It plots 11 rows ,
5 Rows above the input strike price
1 Row for the input strike price
5 Rows below the input strike price
Instruments :
1. NIFTY
2. BANKNIFTY
3. FINNIFTY
4. MIDCPNifty
Columns :
1. StrikePrice
2.CMP
3.Volume
4.VWAP
5.Diff (Open-Close)
Traders need to change the expiry date to check the premium of the corresponding instruments...
There are few key things,
1. Rows in yellow are marked as ATM strike price
2. Cell values in red / green indicates the prices are trading above / below the VWAP
The prices are expected to be bullish when cmp trades above VWAP and we can gauge the trend
The column Volume provides the details in which strike price more traders are actively traded..
The far month contracts can also be changed in the settings and it helps the swing/positional traders
The Strike price can be modified to check the appropriate strikes
Advanced ADX [CryptoSea]The Advanced ADX Analysis is a sophisticated tool designed to enhance market analysis through detailed ADX calculations. This tool is built for traders who seek to identify market trends, strength, and potential reversals with higher accuracy. By leveraging the Average Directional Index (ADX), Directional Indicator Plus (DI+), and Directional Indicator Minus (DI-), this indicator offers a comprehensive view of market dynamics.
New Overlay Feature: This script uses the new 'force overlay' feature which lets you plot on the chart as well as plotting in an oscillator pane at the same time.
force_overlay=true
Key Features
Comprehensive ADX Tracking: Tracks ADX values along with DI+ and DI- to provide a complete view of market trend strength and direction. The ADX measures the strength of the trend, while DI+ and DI- indicate the trend direction. This combined analysis helps traders identify strong and weak trends with precision.
Trend Duration Monitoring: Monitors the duration of strong and weak trends, offering insights into trend persistence and potential reversals. By keeping track of how long the ADX has been above or below a certain threshold, traders can gauge the sustainability of the current trend.
Customizable Alerts: Features multiple alert options for strong trends, weak trends, and DI crossovers, ensuring traders are notified of significant market events. These alerts can be tailored to notify traders when certain conditions are met, such as when the ADX crosses a threshold or when DI+ crosses DI-.
Adaptive Display Options: Includes customizable background color settings and extended statistics display for in-depth market analysis. Users can choose to highlight strong or weak trends on the chart background, making it easier to visualize market conditions at a glance.
In the example below, we have a bullish scenario play out where the DI+ has been above the DI- for 11 candles and our dashboard shows the average is 10.48 candles. With the ADX above its threshold this would be a bullish signal.
This ended up in a 20%+ move to the upside. The dashboard will help point out things to consider when looking to exit the position, the DI+ getting close to the max DI+ duration would be a sign that momentum is weakening and that price may cool off or even reverse.
How it Works
ADX Calculation: Computes the ADX, DI+, and DI- values using a user-defined period. The ADX is derived from the smoothed average of the absolute difference between DI+ and DI-. This calculation helps determine the strength of a trend without considering its direction.
Trend Duration Analysis: Tracks and calculates the duration of strong and weak trends, as well as DI+ and DI- durations. This analysis provides a detailed view of how long a trend has been in place, helping traders assess the reliability of the trend.
Alert System: Provides a robust alert system that triggers notifications for strong trends, weak trends, and DI crossovers. The alerts are based on specific conditions such as the duration of the trend or the crossover of directional indicators, ensuring traders are informed about critical market movements.
Visual Enhancements: Utilizes color gradients and background settings to visually represent trend strength and duration. This feature enhances the visual analysis of trends, making it easier for traders to identify significant market changes at a glance.
In the example below, we see the ADX weakening after we have just had a move up, if you are looking to get into this position you want to see the ADX growing with either the DI+ or DI- breaking their average durations.
As you can see below, although the ADX manages to move above the threshold, there are no DI+/- breaks which is shown by price moving sideways. Not something most traders would be interested in.
Application
Strategic Decision-Making: Assists traders in making informed decisions by providing detailed analysis of ADX movements and trend durations. By understanding the strength and direction of trends, traders can better time their entries and exits.
Trend Confirmation: Reinforces trading strategies by confirming potential reversals and trend strength through ADX and DI analysis. This confirmation helps traders validate their trading signals, reducing the risk of false signals.
Customized Analysis: Adapts to various trading styles with extensive input settings that control the display and sensitivity of trend data. Traders can customize the indicator to suit their specific needs, making it a versatile tool for different trading strategies.
The Advanced ADX Analysis by is an invaluable addition to a trader's toolkit, offering depth and precision in market trend analysis to navigate complex market conditions effectively. With its comprehensive tracking, alert system, and customizable display options, this indicator provides traders with the tools they need to stay ahead of the market.
Advanced Gold Scalping Strategy with RSI Divergence# Advanced Gold Scalping Strategy with RSI Divergence
## Overview
This Pine Script implements an advanced scalping strategy for gold (XAUUSD) trading, primarily designed for the 1-minute timeframe. The strategy utilizes the Relative Strength Index (RSI) indicator along with its moving average to identify potential trade setups based on divergences between price action and RSI movements.
## Key Components
### 1. RSI Calculation
- Uses a customizable RSI length (default: 60)
- Allows selection of the source for RSI calculation (default: close price)
### 2. Moving Average of RSI
- Supports multiple MA types: SMA, EMA, SMMA (RMA), WMA, VWMA, and Bollinger Bands
- Customizable MA length (default: 3)
- Option to display Bollinger Bands with adjustable standard deviation multiplier
### 3. Divergence Detection
- Implements both bullish and bearish divergence identification
- Uses pivot high and pivot low points to detect divergences
- Allows for customization of lookback periods and range for divergence detection
### 4. Entry Conditions
- Long Entry: Bullish divergence when RSI is below 40
- Short Entry: Bearish divergence when RSI is above 60
### 5. Trade Management
- Stop Loss: Customizable, default set to 11 pips
- Take Profit: Customizable, default set to 33 pips
### 6. Visualization
- Plots RSI line and its moving average
- Displays horizontal lines at 30, 50, and 70 RSI levels
- Shows Bollinger Bands when selected
- Highlights divergences with "Bull" and "Bear" labels on the chart
## Input Parameters
- RSI Length: Adjusts the period for RSI calculation
- RSI Source: Selects the price source for RSI (close, open, high, low, hl2, hlc3, ohlc4)
- MA Type: Chooses the type of moving average applied to RSI
- MA Length: Sets the period for the moving average
- BB StdDev: Adjusts the standard deviation multiplier for Bollinger Bands
- Show Divergence: Toggles the display of divergence labels
- Stop Loss: Sets the stop loss distance in pips
- Take Profit: Sets the take profit distance in pips
## Strategy Logic
1. **RSI Calculation**:
- Computes RSI using the specified length and source
- Calculates the chosen type of moving average on the RSI
2. **Divergence Detection**:
- Identifies pivot points in both price and RSI
- Checks for higher lows in RSI with lower lows in price (bullish divergence)
- Checks for lower highs in RSI with higher highs in price (bearish divergence)
3. **Trade Entry**:
- Enters a long position when a bullish divergence is detected and RSI is below 40
- Enters a short position when a bearish divergence is detected and RSI is above 60
4. **Position Management**:
- Places a stop loss order at the entry price ± stop loss pips (depending on the direction)
- Sets a take profit order at the entry price ± take profit pips (depending on the direction)
5. **Visualization**:
- Plots the RSI and its moving average
- Draws horizontal lines for overbought/oversold levels
- Displays Bollinger Bands if selected
- Shows divergence labels on the chart for identified setups
## Usage Instructions
1. Apply the script to a 1-minute XAUUSD (Gold) chart in TradingView
2. Adjust the input parameters as needed:
- Increase RSI Length for less frequent but potentially more reliable signals
- Modify MA Type and Length to change the sensitivity of the RSI moving average
- Adjust Stop Loss and Take Profit levels based on current market volatility
3. Monitor the chart for Bull (long) and Bear (short) labels indicating potential trade setups
4. Use in conjunction with other analysis and risk management techniques
## Considerations
- This strategy is designed for short-term scalping and may not be suitable for all market conditions
- Always backtest and forward test the strategy before using it with real capital
- The effectiveness of divergence-based strategies can vary depending on market trends and volatility
- Consider using additional confirmation signals or filters to improve the strategy's performance
Remember to adapt the strategy parameters to your risk tolerance and trading style, and always practice proper risk management.
Strategic Multi-Step Supertrend - Strategy [presentTrading]The code is mainly developed for me to stimulate the multi-step taking profit function for strategies. The result shows the drawdown can be reduced but at the same time reduced the profit as well. It can be a heuristic for futures leverage traders.
█ Introduction and How it is Different
The "Strategic Multi-Step Supertrend" is a trading strategy designed to leverage the power of multiple steps to optimize trade entries and exits across the Supertrend indicator. Unlike traditional strategies that rely on single entry and exit points, this strategy employs a multi-step approach to take profit, allowing traders to lock in gains incrementally. Additionally, the strategy is adaptable to both long and short trades, providing a comprehensive solution for dynamic market conditions.
This template strategy lies in its dual Supertrend calculation, which enhances the accuracy of trend detection and provides more reliable signals for trade entries and exits. This approach minimizes false signals and increases the overall profitability of trades by ensuring that positions are entered and exited at optimal points.
BTC 6h L/S Performance
█ Strategy, How It Works: Detailed Explanation
The "Strategic Multi-Step Supertrend Trader" strategy utilizes two Supertrend indicators calculated with different parameters to determine the direction and strength of the market trend. This dual approach increases the robustness of the signals, reducing the likelihood of entering trades based on false signals. Here is a detailed breakdown of how the strategy operates:
🔶 Supertrend Indicator Calculation
The Supertrend indicator is a trend-following overlay on the price chart, typically used to identify the direction of the trend. It is calculated using the Average True Range (ATR) to ensure that the indicator adapts to market volatility. The formula for the Supertrend indicator is:
Upper Band = (High + Low) / 2 + (Factor * ATR)
Lower Band = (High + Low) / 2 - (Factor * ATR)
Where:
- High and Low are the highest and lowest prices of the period.
- Factor is a user-defined multiplier.
- ATR is the Average True Range over a specified period.
The Supertrend changes its direction based on the closing price in relation to these bands.
🔶 Entry-Exit Conditions
The strategy enters long positions when both Supertrend indicators signal an uptrend, and short positions when both indicate a downtrend. Specifically:
- Long Condition: Supertrend1 < 0 and Supertrend2 < 0
- Short Condition: Supertrend1 > 0 and Supertrend2 > 0
- Long Exit Condition: Supertrend1 > 0 and Supertrend2 > 0
- Short Exit Condition: Supertrend1 < 0 and Supertrend2 < 0
🔶 Multi-Step Take Profit Mechanism
The strategy features a multi-step take profit mechanism, which allows traders to lock in profits incrementally. This is achieved through four user-configurable take profit levels. For each level, the strategy specifies a percentage increase (for long trades) or decrease (for short trades) in the entry price at which a portion of the position is exited:
- Step 1: Exit a portion of the trade at Entry Price * (1 + Take Profit Percent1 / 100)
- Step 2: Exit a portion of the trade at Entry Price * (1 + Take Profit Percent2 / 100)
- Step 3: Exit a portion of the trade at Entry Price * (1 + Take Profit Percent3 / 100)
- Step 4: Exit a portion of the trade at Entry Price * (1 + Take Profit Percent4 / 100)
This staggered exit strategy helps in locking profits at multiple levels, thereby reducing risk and increasing the likelihood of capturing the maximum possible profit from a trend.
BTC Local
█ Trade Direction
The strategy is highly flexible, allowing users to specify the trade direction. There are three options available:
- Long Only: The strategy will only enter long trades.
- Short Only: The strategy will only enter short trades.
- Both: The strategy will enter both long and short trades based on the Supertrend signals.
This flexibility allows traders to adapt the strategy to various market conditions and their own trading preferences.
█ Usage
1. Add the strategy to your trading platform and apply it to the desired chart.
2. Configure the take profit settings under the "Take Profit Settings" group.
3. Set the trade direction under the "Trade Direction" group.
4. Adjust the Supertrend settings in the "Supertrend Settings" group to fine-tune the indicator calculations.
5. Monitor the chart for entry and exit signals as indicated by the strategy.
█ Default Settings
- Use Take Profit: True
- Take Profit Percentages: Step 1 - 6%, Step 2 - 12%, Step 3 - 18%, Step 4 - 50%
- Take Profit Amounts: Step 1 - 12%, Step 2 - 8%, Step 3 - 4%, Step 4 - 0%
- Number of Take Profit Steps: 3
- Trade Direction: Both
- Supertrend Settings: ATR Length 1 - 10, Factor 1 - 3.0, ATR Length 2 - 11, Factor 2 - 4.0
These settings provide a balanced starting point, which can be customized further based on individual trading preferences and market conditions.
ICT Silver Bullet | Flux Charts💎 GENERAL OVERVIEW
Introducing our new ICT Silver Bullet Indicator! This indicator is built around the ICT's "Silver Bullet" strategy. The strategy has 5 steps for execution and works best in 1-5 min timeframes. For more information about the process, check the "HOW DOES IT WORK" section.
Features of the new ICT Silver Bullet Indicator :
Implementation of ICT's Silver Bullet Strategy
Customizable Execution Settings
2 NY Sessions & London Session
Customizable Backtesting Dashboard
Alerts for Buy, Sell, TP & SL Signals
📌 HOW DOES IT WORK ?
ICT's Silver Bullet strategy has 5 steps :
1. Mark your market sessions open (This indicator has 3 -> NY 10-11, NY 14-15, LDN 03-04)
2. Mark the swing liquidity points
3. Wait for market to take down one liquidity side
4. Look for a market structure-shift for reversals
5. Wait for a FVG for execution
This indicator follows these steps and inform you step by step by plotting them in your chart. You can switch execution types between FVG and MSS.
🚩UNIQUENESS
This indicator is an all-in-one suit for the ICT's Silver Bullet concept. It's capable of plotting the strategy, giving signals, a backtesting dashboard and alerts feature. It's designed for simplyfing a rather complex strategy, helping you to execute it with clean signals. The backtesting dashboard allows you to see how your settings perform in the current ticker. You can also set up alerts to get informed when the strategy is executable for different tickers.
⚙️SETTINGS
1. General Configuration
Execution Type -> FVG execution type will require a FVG to take an entry, while the MSS setting will take an entry as soon as it detects a market structure-shift.
MSS Swing Length -> The swing length when finding liquidity zones for market structure-shift detection.
Breakout Method -> If "Wick" is selected, a bar wick will be enough to confirm a market structure-shift. If "Close" is selected, the bar must close above / below the liquidity zone to confirm a market structure-shift.
FVG Detection -> "Same Type" means that all 3 bars that formed the FVG should be the same type. (Bullish / Bearish). "All" means that bar types may vary between bullish / bearish.
FVG Detection Sensitivity -> You can turn this setting on and off. If it's off, any 3 consecutive bullish / bearish bars will be calculated as FVGs. If it's on, the size of FVGs will be filtered by the selected sensitivity. Lower settings mean less but larger FVGs.
2. TP / SL
TP / SL Method -> If "Fixed" is selected, you can adjust the TP / SL ratios from the settings below. If "Dynamic" is selected, the TP / SL zones will be auto-determined by the algorithm.
Risk -> The risk you're willing to take if "Dynamic" TP / SL Method is selected. Higher risk usually means a better winrate at the cost of losing more if the strategy fails.
Close Position @ Session End -> If this setting is enabled, the current position (if any) will be closed at the beginning of a new session, regardless if it hit the TP / SL zone. If it's off, the position will be open until it hits a TP / SL zone.
True stock performance based on Earnings YieldThe whole basis of the stock market is that you invest your money into a business that can use that money to increase it's earnings and pay you back for that investment with dividends and increased stock value. But because we are human the market often overbuy stocks that cant keep up their earnings with the current inflow of investments. We can also oversell a stock that is keeping up with earnings in regards to the stock price but we don't care because of the sentiment we have.
Earnings Yield is simply the percentage of Earnings Per Share in relation to the stock price. Alone, it's a great fundamental indicator to analyze a company. But I wanted to use it in another way and got tired of using the calculator all the time so that's why I made this indicator.
The goal is to see if the STOCK price is moving accordingly to the BUSINESS earnings. It works by calculating the difference of EY (TTM) previous close (1 bar) to the close thereafter. It then calculates the stock performance of the latest bar and divides that to get decimal form instead of percent. Then it divides the stock performance in decimal form with the difference of EY calculated before. The result shows how much the stock prices moves in relation to how much EY is moving. The theory is that if EY barely moves but the stock price moves heavily, you have a sentiment driven trend.
Example: Week 1 EY = 1.201. Week 2 EY = 1.105.
1.201 - 1.105 = 0.096
Week 2 performed a 11,2% increase in stock price. = 0.112 in decimal form.
0.112 / 0.096 = 1.67
1.67 is the multiple that plots this indicator.
Here is an good example of a stock that's currently in a highly sentiment driven trend, NVIDIA! (Posted 2024-03-30)
Here is an example of a Swedish stock that retail investors flocked to that have been blowned out completely.
When do I buy and sell?
This indicator is not meant to give exact entries or exits. The purpose is to scout the current and past sentiment, possible divergencies and see if a stock is over or under valued. I did add a 50 EMA to get some form of mean plotted. One could buy when true performance is low and sell when true performance drops below the 50 EMA. You could also just sell a part of your position and set a trailing exit with a ordinary 50 EMA or something like that. Often the sentiment will keep driving the price up. But if it last for 1 month or 1 year is impossible to tell.
Try it out and learn how it works and use it as you like. Cheers!
Statistics • Chi Square • P-value • SignificanceThe Statistics • Chi Square • P-value • Significance publication aims to provide a tool for combining different conditions and checking whether the outcome is significant using the Chi-Square Test and P-value.
🔶 USAGE
The basic principle is to compare two or more groups and check the results of a query test, such as asking men and women whether they want to see a romantic or non-romantic movie.
–––––––––––––––––––––––––––––––––––––––––––––
| | ROMANTIC | NON-ROMANTIC | ⬅︎ MOVIE |
–––––––––––––––––––––––––––––––––––––––––––––
| MEN | 2 | 8 | 10 |
–––––––––––––––––––––––––––––––––––––––––––––
| WOMEN | 7 | 3 | 10 |
–––––––––––––––––––––––––––––––––––––––––––––
|⬆︎ SEX | 10 | 10 | 20 |
–––––––––––––––––––––––––––––––––––––––––––––
We calculate the Chi-Square Formula, which is:
Χ² = Σ ( (Observed Value − Expected Value)² / Expected Value )
In this publication, this is:
chiSquare = 0.
for i = 0 to rows -1
for j = 0 to colums -1
observedValue = aBin.get(i).aFloat.get(j)
expectedValue = math.max(1e-12, aBin.get(i).aFloat.get(colums) * aBin.get(rows).aFloat.get(j) / sumT) //Division by 0 protection
chiSquare += math.pow(observedValue - expectedValue, 2) / expectedValue
Together with the 'Degree of Freedom', which is (rows − 1) × (columns − 1) , the P-value can be calculated.
In this case it is P-value: 0.02462
A P-value lower than 0.05 is considered to be significant. Statistically, women tend to choose a romantic movie more, while men prefer a non-romantic one.
Users have the option to choose a P-value, calculated from a standard table or through a math.ucla.edu - Javascript-based function (see references below).
Note that the population (10 men + 10 women = 20) is small, something to consider.
Either way, this principle is applied in the script, where conditions can be chosen like rsi, close, high, ...
🔹 CONDITION
Conditions are added to the left column ('CONDITION')
For example, previous rsi values (rsi ) between 0-100, divided in separate groups
🔹 CLOSE
Then, the movement of the last close is evaluated
UP when close is higher then previous close (close )
DOWN when close is lower then previous close
EQUAL when close is equal then previous close
It is also possible to use only 2 columns by adding EQUAL to UP or DOWN
UP
DOWN/EQUAL
or
UP/EQUAL
DOWN
In other words, when previous rsi value was between 80 and 90, this resulted in:
19 times a current close higher than previous close
14 times a current close lower than previous close
0 times a current close equal than previous close
However, the P-value tells us it is not statistical significant.
NOTE: Always keep in mind that past behaviour gives no certainty about future behaviour.
A vertical line is drawn at the beginning of the chosen population (max 4990)
Here, the results seem significant.
🔹 GROUPS
It is important to ensure that the groups are formed correctly. All possibilities should be present, and conditions should only be part of 1 group.
In the example above, the two top situations are acceptable; close against close can only be higher, lower or equal.
The two examples at the bottom, however, are very poorly constructed.
Several conditions can be placed in more than 1 group, and some conditions are not integrated into a group. Even if the results are significant, they are useless because of the group formation.
A population count is added as an aid to spot errors in group formation.
In this example, there is a discrepancy between the population and total count due to the absence of a condition.
The results when rsi was between 5-25 are not included, resulting in unreliable results.
🔹 PRACTICAL EXAMPLES
In this example, we have specific groups where the condition only applies to that group.
For example, the condition rsi > 55 and rsi <= 65 isn't true in another group.
Also, every possible rsi value (0 - 100) is present in 1 of the groups.
rsi > 15 and rsi <= 25 28 times UP, 19 times DOWN and 2 times EQUAL. P-value: 0.01171
When looking in detail and examining the area 15-25 RSI, we see this:
The population is now not representative (only checking for RSI between 15-25; all other RSI values are not included), so we can ignore the P-value in this case. It is merely to check in detail. In this case, the RSI values 23 and 24 seem promising.
NOTE: We should check what the close price did without any condition.
If, for example, the close price had risen 100 times out of 100, this would make things very relative.
In this case (at least two conditions need to be present), we set 1 condition at 'always true' and another at 'always false' so we'll get only the close values without any condition:
Changing the population or the conditions will change the P-value.
In the following example, the outcome is evaluated when:
close value from 1 bar back is higher than the close value from 2 bars back
close value from 1 bar back is lower/equal than the close value from 2 bars back
Or:
close value from 1 bar back is higher than the close value from 2 bars back
close value from 1 bar back is equal than the close value from 2 bars back
close value from 1 bar back is lower than the close value from 2 bars back
In both examples, all possibilities of close against close are included in the calculations. close can only by higher, equal or lower than close
Both examples have the results without a condition included (5 = 5 and 5 < 5) so one can compare the direction of current close.
🔶 NOTES
• Always keep in mind that:
Past behaviour gives no certainty about future behaviour.
Everything depends on time, cycles, events, fundamentals, technicals, ...
• This test only works for categorical data (data in categories), such as Gender {Men, Women} or color {Red, Yellow, Green, Blue} etc., but not numerical data such as height or weight. One might argue that such tests shouldn't use rsi, close, ... values.
• Consider what you're measuring
For example rsi of the current bar will always lead to a close higher than the previous close, since this is inherent to the rsi calculations.
• Be careful; often, there are na -values at the beginning of the series, which are not included in the calculations!
• Always keep in mind considering what the close price did without any condition
• The numbers must be large enough. Each entry must be five or more. In other words, it is vital to make the 'population' large enough.
• The code can be developed further, for example, by splitting UP, DOWN in close UP 1-2%, close UP 2-3%, close UP 3-4%, ...
• rsi can be supplemented with stochRSI, MFI, sma, ema, ...
🔶 SETTINGS
🔹 Population
• Choose the population size; in other words, how many bars you want to go back to. If fewer bars are available than set, this will be automatically adjusted.
🔹 Inputs
At least two conditions need to be chosen.
• Users can add up to 11 conditions, where each condition can contain two different conditions.
🔹 RSI
• Length
🔹 Levels
• Set the used levels as desired.
🔹 Levels
• P-value: P-value retrieved using a standard table method or a function.
• Used function, derived from Chi-Square Distribution Function; JavaScript
LogGamma(Z) =>
S = 1
+ 76.18009173 / Z
- 86.50532033 / (Z+1)
+ 24.01409822 / (Z+2)
- 1.231739516 / (Z+3)
+ 0.00120858003 / (Z+4)
- 0.00000536382 / (Z+5)
(Z-.5) * math.log(Z+4.5) - (Z+4.5) + math.log(S * 2.50662827465)
Gcf(float X, A) => // Good for X > A +1
A0=0., B0=1., A1=1., B1=X, AOLD=0., N=0
while (math.abs((A1-AOLD)/A1) > .00001)
AOLD := A1
N += 1
A0 := A1+(N-A)*A0
B0 := B1+(N-A)*B0
A1 := X*A0+N*A1
B1 := X*B0+N*B1
A0 := A0/B1
B0 := B0/B1
A1 := A1/B1
B1 := 1
Prob = math.exp(A * math.log(X) - X - LogGamma(A)) * A1
1 - Prob
Gser(X, A) => // Good for X < A +1
T9 = 1. / A
G = T9
I = 1
while (T9 > G* 0.00001)
T9 := T9 * X / (A + I)
G := G + T9
I += 1
G *= math.exp(A * math.log(X) - X - LogGamma(A))
Gammacdf(x, a) =>
GI = 0.
if (x<=0)
GI := 0
else if (x
Chisqcdf = Gammacdf(Z/2, DF/2)
Chisqcdf := math.round(Chisqcdf * 100000) / 100000
pValue = 1 - Chisqcdf
🔶 REFERENCES
mathsisfun.com, Chi-Square Test
Chi-Square Distribution Function
BAERMThe Bitcoin Auto-correlation Exchange Rate Model: A Novel Two Step Approach
THIS IS NOT FINANCIAL ADVICE. THIS ARTICLE IS FOR EDUCATIONAL AND ENTERTAINMENT PURPOSES ONLY.
If you enjoy this software and information, please consider contributing to my lightning address
Prelude
It has been previously established that the Bitcoin daily USD exchange rate series is extremely auto-correlated
In this article, we will utilise this fact to build a model for Bitcoin/USD exchange rate. But not a model for predicting the exchange rate, but rather a model to understand the fundamental reasons for the Bitcoin to have this exchange rate to begin with.
This is a model of sound money, scarcity and subjective value.
Introduction
Bitcoin, a decentralised peer to peer digital value exchange network, has experienced significant exchange rate fluctuations since its inception in 2009. In this article, we explore a two-step model that reasonably accurately captures both the fundamental drivers of Bitcoin’s value and the cyclical patterns of bull and bear markets. This model, whilst it can produce forecasts, is meant more of a way of understanding past exchange rate changes and understanding the fundamental values driving the ever increasing exchange rate. The forecasts from the model are to be considered inconclusive and speculative only.
Data preparation
To develop the BAERM, we used historical Bitcoin data from Coin Metrics, a leading provider of Bitcoin market data. The dataset includes daily USD exchange rates, block counts, and other relevant information. We pre-processed the data by performing the following steps:
Fixing date formats and setting the dataset’s time index
Generating cumulative sums for blocks and halving periods
Calculating daily rewards and total supply
Computing the log-transformed price
Step 1: Building the Base Model
To build the base model, we analysed data from the first two epochs (time periods between Bitcoin mining reward halvings) and regressed the logarithm of Bitcoin’s exchange rate on the mining reward and epoch. This base model captures the fundamental relationship between Bitcoin’s exchange rate, mining reward, and halving epoch.
where Yt represents the exchange rate at day t, Epochk is the kth epoch (for that t), and epsilont is the error term. The coefficients beta0, beta1, and beta2 are estimated using ordinary least squares regression.
Base Model Regression
We use ordinary least squares regression to estimate the coefficients for the betas in figure 2. In order to reduce the possibility of over-fitting and ensure there is sufficient out of sample for testing accuracy, the base model is only trained on the first two epochs. You will notice in the code we calculate the beta2 variable prior and call it “phaseplus”.
The code below shows the regression for the base model coefficients:
\# Run the regression
mask = df\ < 2 # we only want to use Epoch's 0 and 1 to estimate the coefficients for the base model
reg\_X = df.loc\ [mask, \ \].shift(1).iloc\
reg\_y = df.loc\ .iloc\
reg\_X = sm.add\_constant(reg\_X)
ols = sm.OLS(reg\_y, reg\_X).fit()
coefs = ols.params.values
print(coefs)
The result of this regression gives us the coefficients for the betas of the base model:
\
or in more human readable form: 0.029, 0.996869586, -0.00043. NB that for the auto-correlation/momentum beta, we did NOT round the significant figures at all. Since the momentum is so important in this model, we must use all available significant figures.
Fundamental Insights from the Base Model
Momentum effect: The term 0.997 Y suggests that the exchange rate of Bitcoin on a given day (Yi) is heavily influenced by the exchange rate on the previous day. This indicates a momentum effect, where the price of Bitcoin tends to follow its recent trend.
Momentum effect is a phenomenon observed in various financial markets, including stocks and other commodities. It implies that an asset’s price is more likely to continue moving in its current direction, either upwards or downwards, over the short term.
The momentum effect can be driven by several factors:
Behavioural biases: Investors may exhibit herding behaviour or be subject to cognitive biases such as confirmation bias, which could lead them to buy or sell assets based on recent trends, reinforcing the momentum.
Positive feedback loops: As more investors notice a trend and act on it, the trend may gain even more traction, leading to a self-reinforcing positive feedback loop. This can cause prices to continue moving in the same direction, further amplifying the momentum effect.
Technical analysis: Many traders use technical analysis to make investment decisions, which often involves studying historical exchange rate trends and chart patterns to predict future exchange rate movements. When a large number of traders follow similar strategies, their collective actions can create and reinforce exchange rate momentum.
Impact of halving events: In the Bitcoin network, new bitcoins are created as a reward to miners for validating transactions and adding new blocks to the blockchain. This reward is called the block reward, and it is halved approximately every four years, or every 210,000 blocks. This event is known as a halving.
The primary purpose of halving events is to control the supply of new bitcoins entering the market, ultimately leading to a capped supply of 21 million bitcoins. As the block reward decreases, the rate at which new bitcoins are created slows down, and this can have significant implications for the price of Bitcoin.
The term -0.0004*(50/(2^epochk) — (epochk+1)²) accounts for the impact of the halving events on the Bitcoin exchange rate. The model seems to suggest that the exchange rate of Bitcoin is influenced by a function of the number of halving events that have occurred.
Exponential decay and the decreasing impact of the halvings: The first part of this term, 50/(2^epochk), indicates that the impact of each subsequent halving event decays exponentially, implying that the influence of halving events on the Bitcoin exchange rate diminishes over time. This might be due to the decreasing marginal effect of each halving event on the overall Bitcoin supply as the block reward gets smaller and smaller.
This is antithetical to the wrong and popular stock to flow model, which suggests the opposite. Given the accuracy of the BAERM, this is yet another reason to question the S2F model, from a fundamental perspective.
The second part of the term, (epochk+1)², introduces a non-linear relationship between the halving events and the exchange rate. This non-linear aspect could reflect that the impact of halving events is not constant over time and may be influenced by various factors such as market dynamics, speculation, and changing market conditions.
The combination of these two terms is expressed by the graph of the model line (see figure 3), where it can be seen the step from each halving is decaying, and the step up from each halving event is given by a parabolic curve.
NB - The base model has been trained on the first two halving epochs and then seeded (i.e. the first lag point) with the oldest data available.
Constant term: The constant term 0.03 in the equation represents an inherent baseline level of growth in the Bitcoin exchange rate.
In any linear or linear-like model, the constant term, also known as the intercept or bias, represents the value of the dependent variable (in this case, the log-scaled Bitcoin USD exchange rate) when all the independent variables are set to zero.
The constant term indicates that even without considering the effects of the previous day’s exchange rate or halving events, there is a baseline growth in the exchange rate of Bitcoin. This baseline growth could be due to factors such as the network’s overall growth or increasing adoption, or changes in the market structure (more exchanges, changes to the regulatory environment, improved liquidity, more fiat on-ramps etc).
Base Model Regression Diagnostics
Below is a summary of the model generated by the OLS function
OLS Regression Results
\==============================================================================
Dep. Variable: logprice R-squared: 0.999
Model: OLS Adj. R-squared: 0.999
Method: Least Squares F-statistic: 2.041e+06
Date: Fri, 28 Apr 2023 Prob (F-statistic): 0.00
Time: 11:06:58 Log-Likelihood: 3001.6
No. Observations: 2182 AIC: -5997.
Df Residuals: 2179 BIC: -5980.
Df Model: 2
Covariance Type: nonrobust
\==============================================================================
coef std err t P>|t| \
\------------------------------------------------------------------------------
const 0.0292 0.009 3.081 0.002 0.011 0.048
logprice 0.9969 0.001 1012.724 0.000 0.995 0.999
phaseplus -0.0004 0.000 -2.239 0.025 -0.001 -5.3e-05
\==============================================================================
Omnibus: 674.771 Durbin-Watson: 1.901
Prob(Omnibus): 0.000 Jarque-Bera (JB): 24937.353
Skew: -0.765 Prob(JB): 0.00
Kurtosis: 19.491 Cond. No. 255.
\==============================================================================
Below we see some regression diagnostics along with the regression itself.
Diagnostics: We can see that the residuals are looking a little skewed and there is some heteroskedasticity within the residuals. The coefficient of determination, or r2 is very high, but that is to be expected given the momentum term. A better r2 is manually calculated by the sum square of the difference of the model to the untrained data. This can be achieved by the following code:
\# Calculate the out-of-sample R-squared
oos\_mask = df\ >= 2
oos\_actual = df.loc\
oos\_predicted = df.loc\
residuals\_oos = oos\_actual - oos\_predicted
SSR = np.sum(residuals\_oos \*\* 2)
SST = np.sum((oos\_actual - oos\_actual.mean()) \*\* 2)
R2\_oos = 1 - SSR/SST
print("Out-of-sample R-squared:", R2\_oos)
The result is: 0.84, which indicates a very close fit to the out of sample data for the base model, which goes some way to proving our fundamental assumption around subjective value and sound money to be accurate.
Step 2: Adding the Damping Function
Next, we incorporated a damping function to capture the cyclical nature of bull and bear markets. The optimal parameters for the damping function were determined by regressing on the residuals from the base model. The damping function enhances the model’s ability to identify and predict bull and bear cycles in the Bitcoin market. The addition of the damping function to the base model is expressed as the full model equation.
This brings me to the question — why? Why add the damping function to the base model, which is arguably already performing extremely well out of sample and providing valuable insights into the exchange rate movements of Bitcoin.
Fundamental reasoning behind the addition of a damping function:
Subjective Theory of Value: The cyclical component of the damping function, represented by the cosine function, can be thought of as capturing the periodic fluctuations in market sentiment. These fluctuations may arise from various factors, such as changes in investor risk appetite, macroeconomic conditions, or technological advancements. Mathematically, the cyclical component represents the frequency of these fluctuations, while the phase shift (α and β) allows for adjustments in the alignment of these cycles with historical data. This flexibility enables the damping function to account for the heterogeneity in market participants’ preferences and expectations, which is a key aspect of the subjective theory of value.
Time Preference and Market Cycles: The exponential decay component of the damping function, represented by the term e^(-0.0004t), can be linked to the concept of time preference and its impact on market dynamics. In financial markets, the discounting of future cash flows is a common practice, reflecting the time value of money and the inherent uncertainty of future events. The exponential decay in the damping function serves a similar purpose, diminishing the influence of past market cycles as time progresses. This decay term introduces a time-dependent weight to the cyclical component, capturing the dynamic nature of the Bitcoin market and the changing relevance of past events.
Interactions between Cyclical and Exponential Decay Components: The interplay between the cyclical and exponential decay components in the damping function captures the complex dynamics of the Bitcoin market. The damping function effectively models the attenuation of past cycles while also accounting for their periodic nature. This allows the model to adapt to changing market conditions and to provide accurate predictions even in the face of significant volatility or structural shifts.
Now we have the fundamental reasoning for the addition of the function, we can explore the actual implementation and look to other analogies for guidance —
Financial and physical analogies to the damping function:
Mathematical Aspects: The exponential decay component, e^(-0.0004t), attenuates the amplitude of the cyclical component over time. This attenuation factor is crucial in modelling the diminishing influence of past market cycles. The cyclical component, represented by the cosine function, accounts for the periodic nature of market cycles, with α determining the frequency of these cycles and β representing the phase shift. The constant term (+3) ensures that the function remains positive, which is important for practical applications, as the damping function is added to the rest of the model to obtain the final predictions.
Analogies to Existing Damping Functions: The damping function in the BAERM is similar to damped harmonic oscillators found in physics. In a damped harmonic oscillator, an object in motion experiences a restoring force proportional to its displacement from equilibrium and a damping force proportional to its velocity. The equation of motion for a damped harmonic oscillator is:
x’’(t) + 2γx’(t) + ω₀²x(t) = 0
where x(t) is the displacement, ω₀ is the natural frequency, and γ is the damping coefficient. The damping function in the BAERM shares similarities with the solution to this equation, which is typically a product of an exponential decay term and a sinusoidal term. The exponential decay term in the BAERM captures the attenuation of past market cycles, while the cosine term represents the periodic nature of these cycles.
Comparisons with Financial Models: In finance, damped oscillatory models have been applied to model interest rates, stock prices, and exchange rates. The famous Black-Scholes option pricing model, for instance, assumes that stock prices follow a geometric Brownian motion, which can exhibit oscillatory behavior under certain conditions. In fixed income markets, the Cox-Ingersoll-Ross (CIR) model for interest rates also incorporates mean reversion and stochastic volatility, leading to damped oscillatory dynamics.
By drawing on these analogies, we can better understand the technical aspects of the damping function in the BAERM and appreciate its effectiveness in modelling the complex dynamics of the Bitcoin market. The damping function captures both the periodic nature of market cycles and the attenuation of past events’ influence.
Conclusion
In this article, we explored the Bitcoin Auto-correlation Exchange Rate Model (BAERM), a novel 2-step linear regression model for understanding the Bitcoin USD exchange rate. We discussed the model’s components, their interpretations, and the fundamental insights they provide about Bitcoin exchange rate dynamics.
The BAERM’s ability to capture the fundamental properties of Bitcoin is particularly interesting. The framework underlying the model emphasises the importance of individuals’ subjective valuations and preferences in determining prices. The momentum term, which accounts for auto-correlation, is a testament to this idea, as it shows that historical price trends influence market participants’ expectations and valuations. This observation is consistent with the notion that the price of Bitcoin is determined by individuals’ preferences based on past information.
Furthermore, the BAERM incorporates the impact of Bitcoin’s supply dynamics on its price through the halving epoch terms. By acknowledging the significance of supply-side factors, the model reflects the principles of sound money. A limited supply of money, such as that of Bitcoin, maintains its value and purchasing power over time. The halving events, which reduce the block reward, play a crucial role in making Bitcoin increasingly scarce, thus reinforcing its attractiveness as a store of value and a medium of exchange.
The constant term in the model serves as the baseline for the model’s predictions and can be interpreted as an inherent value attributed to Bitcoin. This value emphasizes the significance of the underlying technology, network effects, and Bitcoin’s role as a medium of exchange, store of value, and unit of account. These aspects are all essential for a sound form of money, and the model’s ability to account for them further showcases its strength in capturing the fundamental properties of Bitcoin.
The BAERM offers a potential robust and well-founded methodology for understanding the Bitcoin USD exchange rate, taking into account the key factors that drive it from both supply and demand perspectives.
In conclusion, the Bitcoin Auto-correlation Exchange Rate Model provides a comprehensive fundamentally grounded and hopefully useful framework for understanding the Bitcoin USD exchange rate.
Hodl Calculation v1.0I have developed an indicator that calculates the value of our currency if we had periodically bought any stock or cryptocurrency on any exchange. I believe many individuals would be interested in computing such values.
You can customize the start and end times, choose the amount of currency to be used for each deal, and select from two frequency options.
The first option involves specific intervals, such as hourly, every three days, or bi-weekly.
The second option allows purchases at specific dates or times, like every 15th of the month at 12:00 PM, every Monday at 11:00 AM, or every day at 6:00 AM.
After selecting the frequency, the indicator performs calculations and presents statistical information in a table.
The summarized data includes frequency value, total selected period duration, number of deals, total quantity, total cost, current value, and profit/loss status.
X% Drop in X Days, sold X Days afterIt identifies potential buy signals based on a specified percentage drop in price over a set number of days and calculates the total profit or loss (P/L) over a predefined period. Here's a breakdown of the script and its key parameters:
Script Description:
Indicator Name: "X% Drop in X Days, sold X Days after"
Functionality:
The script signals a buy opportunity when the price of an asset drops by a certain percentage (percentage_drop) within a specified length (length) in days.
It calculates the profit or loss percentage after a set number of days (hold_days) from the buy signal.
The script also displays the cumulative total profit or loss over a specified time frame, from a start date (start_period) to an end date (end_period), which is by default set to the current date.
Display:
Buy signals are marked on the chart.
The profit or loss for each trade after the hold period is displayed.
A label showing the total cumulative profit or loss, along with the start and end dates, is displayed on the chart.
Key Parameters:
percentage_drop (10.0% by default) : The percentage decrease in price that triggers a buy signal. It represents the threshold for the price drop to consider a buying opportunity.
length (3 days by default): The period over which the drop in price is considered. It's the timeframe used to evaluate the percentage drop.
hold_days (30 days by default) : The duration for holding the asset after the buy signal before selling. This parameter defines the time after which the profit or loss is calculated.
start_period (Set to "2022-11-21" by default): The beginning date for calculating the cumulative total profit or loss. This parameter allows the user to define a specific starting point for the analysis.
end_period (Set to the current date by default): The end date for the cumulative total profit or loss calculation. It defaults to the current date but can be set to a specific date for backtesting purposes.
Script Mechanics:
Buy Signal Logic: A buy signal is generated when the closing price is below the highest price of the last 'length' days, adjusted by the 'percentage_drop'.
Profit/Loss Calculation: For each buy signal, the script calculates the profit or loss percentage after 'hold_days' from the purchase. This is displayed on the chart for each trade.
Total P/L Display: The script calculates and displays the cumulative total profit or loss in the defined period (from 'start_period' to 'end_period') in a label on the chart.
Usage:
This script is useful for traders who follow a strategy based on buying assets after significant price drops and holding for a predetermined period. It automates the detection of potential buy opportunities and the calculation of profit or loss, aiding in decision-making and performance analysis.
ColorPalettesThis is my first public (and I hope not the last) library providing different color palettes used for data visualization. Each palette can contain either 3 to 9 colors or 3 to 11 colors.
So there you go. Happy New Year!
I want your new year to be as colorful, vibrant and rich as these color palettes.
Dedicated to @veryfid . RIP, dude.
---
Library "ColorPalettes"
A library of various color palettes for data visualization
Reds(n)
A function to generate the sequential `Reds` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Reds` palette.
Blues(n)
A function to generate the sequential `Blues` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Blues` palette.
Greens(n)
A function to generate the sequential `Greens` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Greens` palette.
Purples(n)
A function to generate the sequential `Purples` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Purples` palette.
Oranges(n)
A function to generate the sequential `Oranges` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Oranges` palette.
Greys(n)
A function to generate the sequential `Greys` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Greys` palette.
YlGn(n)
A function to generate the sequential `YlGn` (Yellow/Green) palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `YlGn` palette.
YlGnBu(n)
A function to generate the sequential `YlGnBu` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `YlGnBu` palette.
GnBu(n)
A function to generate the sequential `GnBu` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `GnBu` palette.
BuGn(n)
A function to generate the sequential `BuGn` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `BuGn` palette.
PuBuGn(n)
A function to generate the sequential `PuBuGn` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `PuBuGn` palette.
PuBu(n)
A function to generate the sequential `PuBu` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `PuBu` palette.
BuPu(n)
A function to generate the sequential `BuPu` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `BuPu` palette.
RdPu(n)
A function to generate the sequential `RdPu` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `RdPu` palette.
PuRd(n)
A function to generate the sequential `PuRd` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `PuRd` palette.
OrRd(n)
A function to generate the sequential `OrRd` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `OrRd` palette.
YlOrRd(n)
A function to generate the sequential `YlOrRd` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `YlOrRd` palette.
YlOrBr(n)
A function to generate the sequential `YlOrBr` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `YlOrBr` palette.
Inferno(n)
A function to generate the sequential `Inferno` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Inferno` palette.
Magma(n)
A function to generate the sequential `Magma` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Magma` palette.
Plasma(n)
A function to generate the sequential `Plasma` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Plasma` palette.
Viridis(n)
A function to generate the sequential `Viridis` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Viridis` palette.
Cividis(n)
A function to generate the sequential `Cividis` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Cividis` palette.
Spectral(n)
A function to generate the diverging `Spectral` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Spectral` palette.
Turbo(n)
A function to generate the diverging `Turbo` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `Turbo` palette.
BrBG(n)
A function to generate the diverging `BrBG` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `BrBG` palette.
PiYG(n)
A function to generate the diverging `PiYG` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `PiYG` palette.
PRGn(n)
A function to generate the diverging `PRGn` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `PRGn` palette.
PuOr(n)
A function to generate the diverging `PuOr` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `PuOr` palette.
RdBu(n)
A function to generate the diverging `RdBu` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `RdBu` palette.
RdGy(n)
A function to generate the diverging `RdGy` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `RdGy` palette.
RdYlBu(n)
A function to generate the diverging `RdYlBu` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `RdYlBu` palette.
RdYlGn(n)
A function to generate the diverging `RdYlGn` palette of the specified size.
Parameters:
n (int) The size of the output palette to generate. Default is 9.
Returns: An array of colors from the `RdYlGn` palette.
London BreakOut ClassicHey there, this is my first time publishing a strategy. The strategy is based on the London Breakout Idea, an incredibly popular concept with abundant information available online.
Let me summarize the London Breakout Strategy in a nutshell: It involves identifying key price levels based on the Tokyo Session before the London Session starts. Typically, these key levels are the high and low of the previous Tokyo session. If a breakout occurs during the London session, you simply follow the trend.
The purpose of this code
After conducting my research, I came across numerous posts, videos, and articles discussing the London Breakout Strategy. I aimed to automatically test it myself to verify whether the claims made by these so-called trading gurus are accurate or not. Consequently, I wrote this script to gain an understanding of how this strategy would perform if I were to follow its basic settings blindly.
Explanation of drawings on the chart:
Red or Green Box: A box is drawn on our chart displaying the exact range of the Tokyo trading session. This box is colored red if the trend during the session was downward and green if it was upward. The box is always drawn between the high and the low between 0:00 AM and 7:00 AM UTC. You can change the settings via the Inputs "Session time Tokyo" & "Session time zone".
Green Background: The green background represents the London trading session. My code allows us to make entries only during this time. If we haven't entered a trade, any pending orders are canceled. I've also programmed a timeout at 11 pm to ensure every trade is closed before the new Tokyo session begins.
Red Line: The red line is automatically placed in the middle of our previous Tokyo range. This line acts as our stop loss. If we cross this line after entering a trade but before reaching our take profit, we'll be stopped out.
When do we enter a trade?
We wait for a candle body to close outside of the previous Tokyo range to enter a trade with the opening of the next candle. We only enter one trade per day.
Where do we put our Take Profit?
The code calculates the exact distance between our entry point and the stop loss. We are trading a risk-reward ratio of 1:1 by default, meaning our take profit is always the same number of pips away from our entry as the stop loss. The Stop Loss is always defined by the red line on the chart. You can change the risk-reward ratio via the inputs setting "CRV", to see how the result changes.
What is the purpose of this script?
I wanted to backtest the London breakout strategy to see how it actually works. Therefore, I wrote this code so that everybody can test it for themselves. You can change the settings and see how the result changes. Typically, you should test this strategy on forex markets and on either 1Min, 5 Min, or 15 Min timeframe.
What are the results?
Over the last 3-6 months (over 100 trades), trading the strategy with my default settings hasn't proven to be very successful. Consequently, I do not recommend trading this strategy blindly. The purpose of this code is to provide you with a foundation for the London Breakout Strategy, allowing you to modify and enhance it according to your preferences. If you're contemplating whether to give it a try, you can assess the results from the past months by using this code as a starting point.
Scale Ability [TrendX_]Scale Ability indicator can indicate a company’s potential for future growth and profitability.
A scalable company is one that can increase its revenue and market share without increasing its costs proportionally, which can benefit from economies of scale. Therefore, the high-scale ability can generate more value for its shareholders - which is important for investment decisions.
Scale Ability indicator consists of 3 financial components:
Cash Flow from Investing Activities to Total Assets Ratio (CFIA / TA)
Net Income to Total Debt Ratio (NI / TD)
Earnings Before Interest, Taxes, Depreciation and Amortization to Equity Ratio (EBITDA / E)
These measures can help investors assess how efficiently and effectively a company uses its resources to generate revenue and profit.
Note:
This can be customizable between Fiscal Quarter (FQ) and Fiscal Year (Fy)
This is suitable for companies in fast-growing industries.
FUNCTION
CFIA / TA Ratio
A company with a net income to total debt of 9% could indicate that it is investing in its assets to keep up with the market demand and the technological changes which can create competitive advantages.
NI/ TD Ratio
A company with a net income to total debt of 9% could show that it is profitable and has a strong financial position, which can easily cover its debt payments.
EBITDA / E Ratio
A company with a net income to total debt of 14% illustrates that it is generating a high return on its equity.
USAGE
Scale index division:
> 43 : Excellent
32 - 43 : Good
12 - 31 : Above Average
= 11 : Average
8 - 10 : Below Average
5 - 7 : Poor
< 4 : Very Poor
DISCLAIMER
This is only a rough estimate, and the actual ratio may differ significantly depending on the stage of the business cycle and the company’s strategy, and the comparison of each company and its peers.
This indicator is not financial advice, it can only help traders make better decisions. There are many factors and uncertainties that can affect the outcome of any endeavor, and no one can guarantee or predict with certainty what will occur.
Therefore, one should always exercise caution and judgment when making decisions based on past performance.
Captain Backtest Model [TFO]Created by @imjesstwoone and @mickey1984, this trade model attempts to capture the expansion from the 10:00-14:00 EST 4h candle using just 3 simple steps. All of the information presented in this description has been outlined by its creators, all I did was translate it to Pine Script. All core settings of the trade model may be edited so that users can test several variations, however this description will cover its default, intended behavior using NQ 5m as an example.
Step 1 is to identify our Price Range. In this case, we are concerned with the highest high and the lowest low created from 6:00-10:00 EST.
Step 2 is to wait for either the high or low of said range to be taken out. Whichever side gets taken first determines the long/short bias for the remainder of the Trade Window (i.e. if price takes the range high, bias is long, and vice versa). Bias must be determined by 11:15 EST, otherwise no trades will be taken. This filter is intended to weed out "choppy" trading days.
Step 3 is to wait for a retracement and enter with a close through the previous candle's high (if long biased) or low (if short biased). There are a couple toggleable criteria that we use to define a retracement; one is checking for opposite close candles that indicate a pullback; another is checking if price took the previous candle's low (if long biased) or high (if short biased).
This trade model was initially tested for index futures, particularly ES and NQ, using a 5m chart, however this indicator allows us to backtest any symbol on any timeframe. Creators @imjesstwoone and @mickey1984 specified a 5 point stop loss on ES and a 25 point stop loss on NQ with their testing.
I've personally found some success in backtesting NQ 5m using a 25 point stop loss and 75 point profit target (3:1 R). Enabling the Use Fixed R:R parameter will ensure that these stops and targets are utilized, otherwise it will enter and hold the position until the close of the Trade Window.
