MFI * %B [seiglerj]Oscillator averaging Money Flow Index and Bollinger Bands' %B
Colored bars indicate buy or sell signals
I have no idea if this is the right way to combine these two, but I'm gonna try it and see what happens
Recherche dans les scripts pour "bollingerband"
Trend Pullback Reversal TPRThe TPR(Trend Pullback Reversal) indicator forms a possible price trend with support and resistance lines. It also comes with a unqiue band and center line as additional features.
TPR works on all timeframes and all symbols and all type of bar chart.
TPR never repaints.
There are 4 Parameters:
Period: umber of bars used for calculations
Factor: Multiplier factor, small number for short trend, large number for long trend
Source: the input series, default is Close
ShowBand: enable to show band and center line
Most trend indicators have similar plot, the difference is where and when they change the direction. Unlike other trend indicators, TPR will focus on main trend and filter out most minor price movements. The green cross-line represents an uptrend, the red cross-line represents a downtrend.
The additional band and center line may look like bollinger band, but the TPR band algorithm is completely different from bollingerband. There is no standard deviation in TPR band calculation.
RSI Bands, RSI %B and RSI BandwidthRSI bands provide an intuitive way of visualizing how the price movement causes RSI to move with in its range (0-100). Upper/Lower bands signify overbought and oversold levels respectively (Default: 70/30, you can customize them via options page). These bands closely match what Constance Brown explains in her book "Technical Analysis for the Trading Professional".
I have also coded up 2 scripts to visualize %B and Bandwidth, just as in BollingerBands. As you can see %B is equivalent to the actual RSI. Along with RSI_Bandwidth and %B, the bands convey a lot of information.
Another tip is to render Bollinger Bands along with RSIBands...endless possibilities :)
I have included all 3 scripts in the same chart, as they are all related. Since TradingView doesn't allow sharing more than one script in the same chart, you can only "Add script" RSI Bands.
If you want to use RSI %B and Bandwidth, follow this guide to "Make mine" this chart and get access to the source:
drive.google.com
For the complete list of my indicators, check this post:
Indicators: Traders Dynamic Index, HLCTrends and Trix Ribbon1) Trix Ribbon
===============================================================
This was built on request. Many Stock/FX traders overlay multiple Trix lines to form the ribbon, this indicator makes it easy.
Also, optionally this can plot a BollingerBand on Trix_1.
More info on Trix:
stockcharts.com
2) High/Low/Close Trend Indicator
===============================================================
Simple indicator using EMAs of H/L/C. If blue line is above the red line, the trend is up, else down. Keep an eye on the zero line too.
3) Traders Dynamic Index
===============================================================
This hybrid indicator helps to decipher and monitor market conditions related to trend direction, market strength, and market volatility.
TDI has the following components:
* Green line = RSI Price line
* Red line = Trade Signal line
* Blue lines = Volatility Bands
* Orange line = Market Base Line
Trend Direction - Immediate and Overall:
----------------------------------------------------
* Immediate = Green over Red...price action is moving up.
Red over Green...price action is moving down.
* Overall = Orange line trends up and down generally between the lines 32 & 68. Watch for Orange line to bounces off these lines for market reversal. Trade long when price is above the Orange line, and trade short when price is below.
Market Strength & Volatility - Immediate and Overall:
----------------------------------------------------
* Immediate = Green Line - Strong = Steep slope up or down.
Weak = Moderate to Flat slope.
* Overall = Blue Lines - When expanding, market is strong and trending. When constricting, market is weak and in a range. When the Blue lines are extremely tight in a narrow range, expect an economic announcement or other market condition to spike the market.
Entry conditions:
----------------------------------------------------
* Scalping - Long = Green over Red,
Short = Red over Green
* Active - Long = Green over Red & Orange lines
Short = Red over Green & Orange lines
* Moderate - Long = Green over Red, Orange, & 50 lines
Short= Red over Green, Green below Orange & 50 line
Exit conditions:
----------------------------------------------------
If Green crosses either Blue lines, consider exiting when the Green line crosses back over the Blue line.
* Long = Green crosses below Red
* Short = Green crosses above Red
More info on a complete system using TDI:
www.forexmt4.com
Copeland Dynamic Dominance Matrix System | GForgeCopeland Dynamic Dominance Matrix System | GForge - v1
---
📊 COMPREHENSIVE SYSTEM OVERVIEW
The GForge Dynamic BB% TrendSync System represents a revolutionary approach to algorithmic portfolio management, combining cutting-edge statistical analysis, momentum detection, and regime identification into a unified framework. This system processes up to 39 different cryptocurrency assets simultaneously, using advanced mathematical models to determine optimal capital allocation across dynamic market conditions.
Core Innovation: Multi-Dimensional Analysis
Unlike traditional single-asset indicators, this system operates on multiple analytical dimensions:
Momentum Analysis: Dual Bollinger Band Modified Deviation (DBBMD) calculations
Relative Strength: Comprehensive dominance matrix with head-to-head comparisons
Fundamental Screening: Alpha and Beta statistical filtering
Market Regime Detection: Five-component statistical testing framework
Portfolio Optimization: Dynamic weighting and allocation algorithms
Risk Management: Multi-layered protection and regime-based positioning
---
🔧 DETAILED COMPONENT BREAKDOWN
1. Dynamic Bollinger Band % Modified Deviation Engine (DBBMD)
The foundation of this system is an advanced oscillator that combines two independent Bollinger Band systems with asymmetric parameters to create unique momentum readings.
Technical Implementation:
[
// BB System 1: Fast-reacting with extended standard deviation
primary_bb1_ma_len = 40 // Shorter MA for responsiveness
primary_bb1_sd_len = 65 // Longer SD for stability
primary_bb1_mult = 1.0 // Standard deviation multiplier
// BB System 2: Complementary asymmetric design
primary_bb2_ma_len = 8 // Longer MA for trend following
primary_bb2_sd_len = 66 // Shorter SD for volatility sensitivity
primary_bb2_mult = 1.7 // Wider bands for reduced noise
Key Features:
Asymmetric Design: The intentional mismatch between MA and Standard Deviation periods creates unique oscillation characteristics that traditional Bollinger Bands cannot achieve
Percentage Scale: All readings are normalized to 0-100% scale for consistent interpretation across assets
Multiple Combination Modes:
BB1 Only: Fast/reactive system
BB2 Only: Smooth/stable system
Average: Balanced blend (recommended)
Both Required: Conservative (both must agree)
Either One: Aggressive (either can trigger)
Mean Deviation Filter: Additional volatility-based layer that measures the standard deviation of the DBBMD% itself, creating dynamic trigger bands
Signal Generation Logic:
// Primary thresholds
primary_long_threshold = 71 // DBBMD% level for bullish signals
primary_short_threshold = 33 // DBBMD% level for bearish signals
// Mean Deviation creates dynamic bands around these thresholds
upper_md_band = combined_bb + (md_mult * bb_std)
lower_md_band = combined_bb - (md_mult * bb_std)
// Signal triggers when DBBMD crosses these dynamic bands
long_signal = lower_md_band > long_threshold
short_signal = upper_md_band < short_threshold
For more information on this BB% indicator, find it here:
2. Revolutionary Dominance Matrix System
This is the system's most sophisticated innovation - a comprehensive framework that compares every asset against every other asset to determine relative strength hierarchies.
Mathematical Foundation:
The system constructs a mathematical matrix where each cell represents whether asset i dominates asset j:
// Core dominance matrix (39x39 for maximum assets)
var matrix dominance_matrix = matrix.new(39, 39, 0)
// For each qualifying asset pair (i,j):
for i = 0 to active_count - 1
for j = 0 to active_count - 1
if i != j
// Calculate price ratio BB% TrendSync for asset_i/asset_j
ratio_array = calculate_price_ratios(asset_i, asset_j)
ratio_dbbmd = calculate_dbbmd(ratio_array)
// Asset i dominates j if ratio is in uptrend
if ratio_dbbmd_state == 1
matrix.set(dominance_matrix, i, j, 1)
Copeland Scoring Algorithm:
Each asset receives a dominance score calculated as:
Dominance Score = Total Wins - Total Losses
// Calculate net dominance for each asset
for i = 0 to active_count - 1
wins = 0
losses = 0
for j = 0 to active_count - 1
if i != j
if matrix.get(dominance_matrix, i, j) == 1
wins += 1
else
losses += 1
copeland_score = wins - losses
array.set(dominance_scores, i, copeland_score)
Head-to-Head Analysis Process:
Ratio Construction: For each asset pair, calculate price_asset_A / price_asset_B
DBBMD Application: Apply the same DBBMD analysis to these ratios
Trend Determination: If ratio DBBMD shows uptrend, Asset A dominates Asset B
Matrix Population: Store dominance relationships in mathematical matrix
Score Calculation: Sum wins minus losses for final ranking
This creates a tournament-style ranking where each asset's strength is measured against all others, not just against a benchmark.
3. Advanced Alpha & Beta Filtering System
The system incorporates fundamental analysis through Capital Asset Pricing Model (CAPM) calculations to filter assets based on risk-adjusted performance.
Alpha Calculation (Excess Return Analysis):
// CAPM Alpha calculation
f_calc_alpha(asset_prices, benchmark_prices, alpha_length, beta_length, risk_free_rate) =>
// Calculate asset and benchmark returns
asset_returns = calculate_returns(asset_prices, alpha_length)
benchmark_returns = calculate_returns(benchmark_prices, alpha_length)
// Get beta for expected return calculation
beta = f_calc_beta(asset_prices, benchmark_prices, beta_length)
// Average returns over period
avg_asset_return = array_average(asset_returns) * 100
avg_benchmark_return = array_average(benchmark_returns) * 100
// Expected return using CAPM: E(R) = Beta * Market_Return + Risk_Free_Rate
expected_return = beta * avg_benchmark_return + risk_free_rate
// Alpha = Actual Return - Expected Return
alpha = avg_asset_return - expected_return
Beta Calculation (Volatility Relationship):
// Beta measures how much an asset moves relative to benchmark
f_calc_beta(asset_prices, benchmark_prices, length) =>
// Calculate return series for both assets
asset_returns =
benchmark_returns =
// Populate return arrays
for i = 0 to length - 1
asset_return = (current_price - previous_price) / previous_price
benchmark_return = (current_bench - previous_bench) / previous_bench
// Calculate covariance and variance
covariance = calculate_covariance(asset_returns, benchmark_returns)
benchmark_variance = calculate_variance(benchmark_returns)
// Beta = Covariance(Asset, Market) / Variance(Market)
beta = covariance / benchmark_variance
Filtering Applications:
Alpha Filter: Only includes assets with alpha above specified threshold (e.g., >0.5% monthly excess return)
Beta Filter: Screens for desired volatility characteristics (e.g., beta >1.0 for aggressive assets)
Combined Screening: Both filters must pass for asset qualification
Dynamic Thresholds: User-configurable parameters for different market conditions
4. Intelligent Tie-Breaking Resolution System
When multiple assets have identical dominance scores, the system employs sophisticated methods to determine final rankings.
Standard Tie-Breaking Hierarchy:
// Primary tie-breaking logic
if score_i == score_j // Tied dominance scores
// Level 1: Compare Beta values (higher beta wins)
beta_i = array.get(beta_values, i)
beta_j = array.get(beta_values, j)
if beta_j > beta_i
swap_positions(i, j)
else if beta_j == beta_i
// Level 2: Compare Alpha values (higher alpha wins)
alpha_i = array.get(alpha_values, i)
alpha_j = array.get(alpha_values, j)
if alpha_j > alpha_i
swap_positions(i, j)
Advanced Tie-Breaking (Head-to-Head Analysis):
For the top 3 performers, an enhanced tie-breaking mechanism analyzes direct head-to-head price ratio performance:
// Advanced tie-breaker for top performers
f_advanced_tiebreaker(asset1_idx, asset2_idx, lookback_period) =>
// Calculate price ratio over lookback period
ratio_history =
for k = 0 to lookback_period - 1
price_ratio = price_asset1 / price_asset2
array.push(ratio_history, price_ratio)
// Apply simplified trend analysis to ratio
current_ratio = array.get(ratio_history, 0)
average_ratio = calculate_average(ratio_history)
// Asset 1 wins if current ratio > average (trending up)
if current_ratio > average_ratio
return 1 // Asset 1 dominates
else
return -1 // Asset 2 dominates
5. Five-Component Aggregate Market Regime Filter
This sophisticated framework combines multiple statistical tests to determine whether market conditions favor trending strategies or require defensive positioning.
Component 1: Augmented Dickey-Fuller (ADF) Test
Tests for unit root presence to distinguish between trending and mean-reverting price series.
// Simplified ADF implementation
calculate_adf_statistic(price_series, lookback) =>
// Calculate first differences
differences =
for i = 0 to lookback - 2
diff = price_series - price_series
array.push(differences, diff)
// Statistical analysis of differences
mean_diff = calculate_mean(differences)
std_diff = calculate_standard_deviation(differences)
// ADF statistic approximation
adf_stat = mean_diff / std_diff
// Compare against threshold for trend determination
is_trending = adf_stat <= adf_threshold
Component 2: Directional Movement Index (DMI)
Classic Wilder indicator measuring trend strength through directional movement analysis.
// DMI calculation for trend strength
calculate_dmi_signal(high_data, low_data, close_data, period) =>
// Calculate directional movements
plus_dm_sum = 0.0
minus_dm_sum = 0.0
true_range_sum = 0.0
for i = 1 to period
// Directional movements
up_move = high_data - high_data
down_move = low_data - low_data
// Accumulate positive/negative movements
if up_move > down_move and up_move > 0
plus_dm_sum += up_move
if down_move > up_move and down_move > 0
minus_dm_sum += down_move
// True range calculation
true_range_sum += calculate_true_range(i)
// Calculate directional indicators
di_plus = 100 * plus_dm_sum / true_range_sum
di_minus = 100 * minus_dm_sum / true_range_sum
// ADX calculation
dx = 100 * math.abs(di_plus - di_minus) / (di_plus + di_minus)
adx = dx // Simplified for demonstration
// Trending if ADX above threshold
is_trending = adx > dmi_threshold
Component 3: KPSS Stationarity Test
Complementary test to ADF that examines stationarity around trend components.
// KPSS test implementation
calculate_kpss_statistic(price_series, lookback, significance_level) =>
// Calculate mean and variance
series_mean = calculate_mean(price_series, lookback)
series_variance = calculate_variance(price_series, lookback)
// Cumulative sum of deviations
cumulative_sum = 0.0
cumsum_squared_sum = 0.0
for i = 0 to lookback - 1
deviation = price_series - series_mean
cumulative_sum += deviation
cumsum_squared_sum += math.pow(cumulative_sum, 2)
// KPSS statistic
kpss_stat = cumsum_squared_sum / (lookback * lookback * series_variance)
// Compare against critical values
critical_value = significance_level == 0.01 ? 0.739 :
significance_level == 0.05 ? 0.463 : 0.347
is_trending = kpss_stat >= critical_value
Component 4: Choppiness Index
Measures market directionality using fractal dimension analysis of price movement.
// Choppiness Index calculation
calculate_choppiness(price_data, period) =>
// Find highest and lowest over period
highest = price_data
lowest = price_data
true_range_sum = 0.0
for i = 0 to period - 1
if price_data > highest
highest := price_data
if price_data < lowest
lowest := price_data
// Accumulate true range
if i > 0
true_range = calculate_true_range(price_data, i)
true_range_sum += true_range
// Choppiness calculation
range_high_low = highest - lowest
choppiness = 100 * math.log10(true_range_sum / range_high_low) / math.log10(period)
// Trending if choppiness below threshold (typically 61.8)
is_trending = choppiness < 61.8
Component 5: Hilbert Transform Analysis
Phase-based cycle detection and trend identification using mathematical signal processing.
// Hilbert Transform trend detection
calculate_hilbert_signal(price_data, smoothing_period, filter_period) =>
// Smooth the price data
smoothed_price = calculate_moving_average(price_data, smoothing_period)
// Calculate instantaneous phase components
// Simplified implementation for demonstration
instant_phase = smoothed_price
delayed_phase = calculate_moving_average(price_data, filter_period)
// Compare instantaneous vs delayed signals
phase_difference = instant_phase - delayed_phase
// Trending if instantaneous leads delayed
is_trending = phase_difference > 0
Aggregate Regime Determination:
// Combine all five components
regime_calculation() =>
trending_count = 0
total_components = 0
// Test each enabled component
if enable_adf and adf_signal == 1
trending_count += 1
if enable_adf
total_components += 1
// Repeat for all five components...
// Calculate trending proportion
trending_proportion = trending_count / total_components
// Market is trending if proportion above threshold
regime_allows_trading = trending_proportion >= regime_threshold
The system only allows asset positions when the specified percentage of components indicate trending conditions. During choppy or mean-reverting periods, the system automatically positions in USD to preserve capital.
6. Dynamic Portfolio Weighting Framework
Six sophisticated allocation methodologies provide flexibility for different market conditions and risk preferences.
Weighting Method Implementations:
1. Equal Weight Distribution:
// Simple equal allocation
if weighting_mode == "Equal Weight"
weight_per_asset = 1.0 / selection_count
for i = 0 to selection_count - 1
array.push(weights, weight_per_asset)
2. Linear Dominance Scaling:
// Linear scaling based on dominance scores
if weighting_mode == "Linear Dominance"
// Normalize scores to 0-1 range
min_score = array.min(dominance_scores)
max_score = array.max(dominance_scores)
score_range = max_score - min_score
total_weight = 0.0
for i = 0 to selection_count - 1
score = array.get(dominance_scores, i)
normalized = (score - min_score) / score_range
weight = 1.0 + normalized * concentration_factor
array.push(weights, weight)
total_weight += weight
// Normalize to sum to 1.0
for i = 0 to selection_count - 1
current_weight = array.get(weights, i)
array.set(weights, i, current_weight / total_weight)
3. Conviction Score (Exponential):
// Exponential scaling for high conviction
if weighting_mode == "Conviction Score"
// Combine dominance score with DBBMD strength
conviction_scores =
for i = 0 to selection_count - 1
dominance = array.get(dominance_scores, i)
dbbmd_strength = array.get(dbbmd_values, i)
conviction = dominance + (dbbmd_strength - 50) / 25
array.push(conviction_scores, conviction)
// Exponential weighting
total_weight = 0.0
for i = 0 to selection_count - 1
conviction = array.get(conviction_scores, i)
normalized = normalize_score(conviction)
weight = math.pow(1 + normalized, concentration_factor)
array.push(weights, weight)
total_weight += weight
// Final normalization
normalize_weights(weights, total_weight)
Advanced Features:
Minimum Position Constraint: Prevents dust allocations below specified threshold
Concentration Factor: Adjustable parameter controlling weight distribution aggressiveness
Dominance Boost: Extra weight for assets exceeding specified dominance thresholds
Dynamic Rebalancing: Automatic weight recalculation on portfolio changes
7. Intelligent USD Management System
The system treats USD as a competing asset with its own dominance score, enabling sophisticated cash management.
USD Scoring Methodologies:
Smart Competition Mode (Recommended):
f_calculate_smart_usd_dominance() =>
usd_wins = 0
// USD beats assets in downtrends or weak uptrends
for i = 0 to active_count - 1
asset_state = get_asset_state(i)
asset_dbbmd = get_asset_dbbmd(i)
// USD dominates shorts and weak longs
if asset_state == -1 or (asset_state == 1 and asset_dbbmd < long_threshold)
usd_wins += 1
// Calculate Copeland-style score
base_score = usd_wins - (active_count - usd_wins)
// Boost during weak market conditions
qualified_assets = count_qualified_long_assets()
if qualified_assets <= active_count * 0.2
base_score := math.round(base_score * usd_boost_factor)
base_score
Auto Short Count Mode:
// USD dominance based on number of bearish assets
usd_dominance = count_assets_in_short_state()
// Apply boost during low activity
if qualified_long_count <= active_count * 0.2
usd_dominance := usd_dominance * usd_boost_factor
Regime-Based USD Positioning:
When the five-component regime filter indicates unfavorable conditions, the system automatically overrides all asset signals and positions 100% in USD, protecting capital during choppy markets.
8. Multi-Asset Infrastructure & Data Management
The system maintains comprehensive data structures for up to 39 assets simultaneously.
Data Collection Framework:
// Full OHLC data matrices (200 bars depth for performance)
var matrix open_data = matrix.new(39, 200, na)
var matrix high_data = matrix.new(39, 200, na)
var matrix low_data = matrix.new(39, 200, na)
var matrix close_data = matrix.new(39, 200, na)
// Real-time data collection
if barstate.isconfirmed
for i = 0 to active_count - 1
ticker = array.get(assets, i)
= request.security(ticker, timeframe.period,
[open , high , low , close ],
lookahead=barmerge.lookahead_off)
// Store in matrices with proper shifting
matrix.set(open_data, i, 0, nz(o, 0))
matrix.set(high_data, i, 0, nz(h, 0))
matrix.set(low_data, i, 0, nz(l, 0))
matrix.set(close_data, i, 0, nz(c, 0))
Asset Configuration:
The system comes pre-configured with 39 major cryptocurrency pairs across multiple exchanges:
Major Pairs: BTC, ETH, XRP, SOL, DOGE, ADA, etc.
Exchange Coverage: Binance, KuCoin, MEXC for optimal liquidity
Configurable Count: Users can activate 2-39 assets based on preferences
Custom Tickers: All asset selections are user-modifiable
---
⚙️ COMPREHENSIVE CONFIGURATION GUIDE
Portfolio Management Settings
Maximum Portfolio Size (1-10):
Conservative (1-2): High concentration, captures strong trends
Balanced (3-5): Moderate diversification with trend focus
Diversified (6-10): Lower concentration, broader market exposure
Dominance Clarity Threshold (0.1-1.0):
Low (0.1-0.4): Prefers diversification, holds multiple assets frequently
Medium (0.5-0.7): Balanced approach, context-dependent allocation
High (0.8-1.0): Concentration-focused, single asset preference
Signal Generation Parameters
DBBMD Thresholds:
// Standard configuration
primary_long_threshold = 71 // Conservative: 75+, Aggressive: 65-70
primary_short_threshold = 33 // Conservative: 25-30, Aggressive: 35-40
// BB System parameters
bb1_ma_len = 40 // Fast system: 20-50
bb1_sd_len = 65 // Stability: 50-80
bb2_ma_len = 8 // Trend: 60-100
bb2_sd_len = 66 // Sensitivity: 10-20
Risk Management Configuration
Alpha/Beta Filters:
Alpha Threshold: 0.0-2.0% (higher = more selective)
Beta Threshold: 0.5-2.0 (1.0+ for aggressive assets)
Calculation Periods: 20-50 bars (longer = more stable)
Regime Filter Settings:
Trending Threshold: 0.3-0.8 (higher = stricter trend requirements)
Component Lookbacks: 30-100 bars (balance responsiveness vs stability)
Enable/Disable: Individual component control for customization
---
📊 PERFORMANCE TRACKING & VISUALIZATION
Real-Time Dashboard Features
The compact dashboard provides essential information:
Current Holdings: Asset names and allocation percentages
Dominance Score: Current position's relative strength ranking
Active Assets: Qualified long signals vs total asset count
Returns: Total portfolio performance percentage
Maximum Drawdown: Peak-to-trough decline measurement
Trade Count: Total portfolio transitions executed
Regime Status: Current market condition assessment
Comprehensive Ranking Table
The left-side table displays detailed asset analysis:
Ranking Position: Numerical order by dominance score
Asset Symbol: Clean ticker identification with color coding
Dominance Score: Net wins minus losses in head-to-head comparisons
Win-Loss Record: Detailed breakdown of dominance relationships
DBBMD Reading: Current momentum percentage with threshold highlighting
Alpha/Beta Values: Fundamental analysis metrics when filters enabled
Portfolio Weight: Current allocation percentage in signal portfolio
Execution Status: Visual indicator of actual holdings vs signals
Visual Enhancement Features
Color-Coded Assets: 39 distinct colors for easy identification
Regime Background: Red tinting during unfavorable market conditions
Dynamic Equity Curve: Portfolio value plotted with position-based coloring
Status Indicators: Symbols showing execution vs signal states
---
🔍 ADVANCED TECHNICAL FEATURES
State Persistence System
The system maintains asset states across bars to prevent excessive switching:
// State tracking for each asset and ratio combination
var array asset_states = array.new(1560, 0) // 39 * 40 ratios
// State changes only occur on confirmed threshold breaks
if long_crossover and current_state != 1
current_state := 1
array.set(asset_states, asset_index, 1)
else if short_crossover and current_state != -1
current_state := -1
array.set(asset_states, asset_index, -1)
Transaction Cost Integration
Realistic modeling of trading expenses:
// Transaction cost calculation
transaction_fee = 0.4 // Default 0.4% (fees + slippage)
// Applied on portfolio transitions
if should_execute_transition
was_holding_assets = check_current_holdings()
will_hold_assets = check_new_signals()
// Charge fees for meaningful transitions
if transaction_fee > 0 and (was_holding_assets or will_hold_assets)
fee_amount = equity * (transaction_fee / 100)
equity -= fee_amount
total_fees += fee_amount
Dynamic Memory Management
Optimized data structures for performance:
200-Bar History: Sufficient for calculations while maintaining speed
Matrix Operations: Efficient storage and retrieval of multi-asset data
Array Recycling: Memory-conscious data handling for long-running backtests
Conditional Calculations: Skip unnecessary computations during initialization
12H 30 assets portfolio
---
🚨 SYSTEM LIMITATIONS & TESTING STATUS
CURRENT DEVELOPMENT PHASE: ACTIVE TESTING & OPTIMIZATION
This system represents cutting-edge algorithmic trading technology but remains in continuous development. Key considerations:
Known Limitations:
Requires significant computational resources for 39-asset analysis
Performance varies significantly across different market conditions
Complex parameter interactions may require extensive optimization
Slippage and liquidity constraints not fully modeled for all assets
No consideration for market impact in large position sizes
Areas Under Active Development:
Enhanced regime detection algorithms
Improved transaction cost modeling
Additional portfolio weighting methodologies
Machine learning integration for parameter optimization
Cross-timeframe analysis capabilities
---
🔒 ANTI-REPAINTING ARCHITECTURE & LIVE TRADING READINESS
One of the most critical aspects of any trading system is ensuring that signals and calculations are based on confirmed, historical data rather than current bar information that can change throughout the trading session. This system implements comprehensive anti-repainting measures to ensure 100% reliability for live trading .
The Repainting Problem in Trading Systems
Repainting occurs when an indicator uses current, unconfirmed bar data in its calculations, causing:
False Historical Signals: Backtests appear better than reality because calculations change as bars develop
Live Trading Failures: Signals that looked profitable in testing fail when deployed in real markets
Inconsistent Results: Different results when running the same indicator at different times during a trading session
Misleading Performance: Inflated win rates and returns that cannot be replicated in practice
GForge Anti-Repainting Implementation
This system eliminates repainting through multiple technical safeguards:
1. Historical Data Usage for All Calculations
// CRITICAL: All calculations use PREVIOUS bar data (note the offset)
= request.security(ticker, timeframe.period,
[open , high , low , close , close],
lookahead=barmerge.lookahead_off)
// Store confirmed previous bar OHLC for calculations
matrix.set(open_data, i, 0, nz(o1, 0)) // Previous bar open
matrix.set(high_data, i, 0, nz(h1, 0)) // Previous bar high
matrix.set(low_data, i, 0, nz(l1, 0)) // Previous bar low
matrix.set(close_data, i, 0, nz(c1, 0)) // Previous bar close
// Current bar close only for visualization
matrix.set(current_prices, i, 0, nz(c0, 0)) // Live price display
2. Confirmed Bar State Processing
// Only process data when bars are confirmed and closed
if barstate.isconfirmed
// All signal generation and portfolio decisions occur here
// using only historical, unchanging data
// Shift historical data arrays
for i = 0 to active_count - 1
for bar = math.min(data_bars, 199) to 1
// Move confirmed data through historical matrices
old_data = matrix.get(close_data, i, bar - 1)
matrix.set(close_data, i, bar, old_data)
// Process new confirmed bar data
calculate_all_signals_and_dominance()
3. Lookahead Prevention
// Explicit lookahead prevention in all security calls
request.security(ticker, timeframe.period, expression,
lookahead=barmerge.lookahead_off)
// This ensures no future data can influence current calculations
// Essential for maintaining signal integrity across all timeframes
4. State Persistence with Historical Validation
// Asset states only change based on confirmed threshold breaks
// using historical data that cannot change
var array asset_states = array.new(1560, 0)
// State changes use only confirmed, previous bar calculations
if barstate.isconfirmed
=
f_calculate_enhanced_dbbmd(confirmed_price_array, ...)
// Only update states after bar confirmation
if long_crossover_confirmed and current_state != 1
current_state := 1
array.set(asset_states, asset_index, 1)
Live Trading vs. Backtesting Consistency
The system's architecture ensures identical behavior in both environments:
Backtesting Mode:
Uses historical offset data for all calculations
Processes confirmed bars with `barstate.isconfirmed`
Maintains identical signal generation logic
No access to future information
Live Trading Mode:
Uses same historical offset data structure
Waits for bar confirmation before signal updates
Identical mathematical calculations and thresholds
Real-time price display without affecting signals
Technical Implementation Details
Data Collection Timing
// Example of proper data collection timing
if barstate.isconfirmed // Wait for bar to close
// Collect PREVIOUS bar's confirmed OHLC data
for i = 0 to active_count - 1
ticker = array.get(assets, i)
// Get confirmed previous bar data (note offset)
=
request.security(ticker, timeframe.period,
[open , high , low , close , close],
lookahead=barmerge.lookahead_off)
// ALL calculations use prev_* values
// current_close only for real-time display
portfolio_calculations_use_previous_bar_data()
Signal Generation Process
// Signal generation workflow (simplified)
if barstate.isconfirmed and data_bars >= minimum_required_bars
// Step 1: Calculate DBBMD using historical price arrays
for i = 0 to active_count - 1
historical_prices = get_confirmed_price_history(i) // Uses offset data
= calculate_dbbmd(historical_prices)
update_asset_state(i, state)
// Step 2: Build dominance matrix using confirmed data
calculate_dominance_relationships() // All historical data
// Step 3: Generate portfolio signals
new_portfolio = generate_target_portfolio() // Based on confirmed calculations
// Step 4: Compare with previous signals for changes
if portfolio_signals_changed()
execute_portfolio_transition()
Verification Methods for Users
Users can verify the anti-repainting behavior through several methods:
1. Historical Replay Test
Run the indicator on historical data
Note signal timing and portfolio changes
Replay the same period - signals should be identical
No retroactive changes in historical signals
2. Intraday Consistency Check
Load indicator during active trading session
Observe that previous day's signals remain unchanged
Only current day's final bar should show potential signal changes
Refresh indicator - historical signals should be identical
Live Trading Deployment Considerations
Data Quality Assurance
Exchange Connectivity: Ensure reliable data feeds for all 39 assets
Missing Data Handling: System includes safeguards for data gaps
Price Validation: Automatic filtering of obvious price errors
Timeframe Synchronization: All assets synchronized to same bar timing
Performance Impact of Anti-Repainting Measures
The robust anti-repainting implementation requires additional computational resources:
Memory Usage: 200-bar historical data storage for 39 assets
Processing Delay: Signals update only after bar confirmation
Calculation Overhead: Multiple historical data validations
Alert Timing: Slight delay compared to current-bar indicators
However, these trade-offs are essential for reliable live trading performance and accurate backtesting results.
Critical: Equity Curve Anti-Repainting Architecture
The most sophisticated aspect of this system's anti-repainting design is the temporal separation between signal generation and performance calculation . This creates a realistic trading simulation that perfectly matches live trading execution.
The Timing Sequence
// STEP 1: Store what we HELD during the current bar (for performance calc)
if barstate.isconfirmed
// Record positions that were active during this bar
array.clear(held_portfolio)
array.clear(held_weights)
for i = 0 to array.size(execution_portfolio) - 1
array.push(held_portfolio, array.get(execution_portfolio, i))
array.push(held_weights, array.get(execution_weights, i))
// STEP 2: Calculate performance based on what we HELD
portfolio_return = 0.0
for i = 0 to array.size(held_portfolio) - 1
held_asset = array.get(held_portfolio, i)
held_weight = array.get(held_weights, i)
// Performance from current_price vs reference_price
// This is what we ACTUALLY earned during this bar
if held_asset != "USD"
current_price = get_current_price(held_asset) // End of bar
reference_price = get_reference_price(held_asset) // Start of bar
asset_return = (current_price - reference_price) / reference_price
portfolio_return += asset_return * held_weight
// STEP 3: Apply return to equity (realistic timing)
equity := equity * (1 + portfolio_return)
// STEP 4: Generate NEW signals for NEXT period (using confirmed data)
= f_generate_target_portfolio()
// STEP 5: Execute transitions if signals changed
if signal_changed
// Update execution_portfolio for NEXT bar
array.clear(execution_portfolio)
array.clear(execution_weights)
for i = 0 to array.size(new_signal_portfolio) - 1
array.push(execution_portfolio, array.get(new_signal_portfolio, i))
array.push(execution_weights, array.get(new_signal_weights, i))
Why This Prevents Equity Curve Repainting
Performance Attribution: Returns are calculated based on positions that were **actually held** during each bar, not future signals
Signal Timing: New signals are generated **after** performance calculation, affecting only **future** bars
Realistic Execution: Mimics real trading where you earn returns on current positions while planning future moves
No Retroactive Changes: Once a bar closes, its performance contribution to equity is permanent and unchangeable
The One-Bar Offset Mechanism
This system implements a critical one-bar timing offset:
// Bar N: Performance Calculation
// ================================
// 1. Calculate returns on positions held during Bar N
// 2. Update equity based on actual holdings during Bar N
// 3. Plot equity point for Bar N (based on what we HELD)
// Bar N: Signal Generation
// ========================
// 4. Generate signals for Bar N+1 (using confirmed Bar N data)
// 5. Send alerts for what will be held during Bar N+1
// 6. Update execution_portfolio for Bar N+1
// Bar N+1: The Cycle Continues
// =============================
// 1. Performance calculated on positions from Bar N signals
// 2. New signals generated for Bar N+2
Alert System Timing
The alert system reflects this sophisticated timing:
Transaction Cost Realism
Even transaction costs follow realistic timing:
// Fees applied when transitioning between different portfolios
if should_execute_transition
// Charge fees BEFORE taking new positions (realistic timing)
if transaction_fee > 0
fee_amount = equity * (transaction_fee / 100)
equity -= fee_amount // Immediate cost impact
total_fees += fee_amount
// THEN update to new portfolio
update_execution_portfolio(new_signals)
transitions += 1
// Fees reduce equity immediately, affecting all future calculations
// This matches real trading where fees are deducted upon execution
LIVE TRADING CERTIFICATION:
This system has been specifically designed and tested for live trading deployment. The comprehensive anti-repainting measures ensure that:
Backtesting results accurately represent real trading potential
Signals are generated using only confirmed, historical data
No retroactive changes can occur to previously generated signals
Portfolio transitions are based on reliable, unchanging calculations
Performance metrics reflect realistic trading outcomes including proper timing
Users can deploy this system with confidence that live trading results will closely match backtesting performance, subject to normal market execution factors such as slippage and liquidity.
---
⚡ ALERT SYSTEM & AUTOMATION
The system provides comprehensive alerting for automation and monitoring:
Available Alert Conditions
Portfolio Signal Change: Triggered when new portfolio composition is generated
Regime Override Active: Alerts when market regime forces USD positioning
Individual Asset Signals: Can be configured for specific asset transitions
Performance Thresholds: Drawdown or return-based notifications
---
📈 BACKTESTING & PERFORMANCE ANALYSIS
8 Comprehensive Metrics Tracking
The system maintains detailed performance statistics:
Equity Curve: Real-time portfolio value progression
Returns Calculation: Total and annualized performance metrics
Drawdown Analysis: Peak-to-trough decline measurements
Transaction Counting: Portfolio transition frequency
Fee Tracking: Cumulative transaction cost impact
Win Rate Analysis: Success rate of position changes
Backtesting Configuration
// Backtesting parameters
initial_capital = 10000.0 // Starting capital
use_custom_start = true // Enable specific start date
custom_start = timestamp("2023-09-01") // Backtest beginning
transaction_fee = 0.4 // Combined fees and slippage %
// Performance calculation
total_return = (equity - initial_capital) / initial_capital * 100
current_drawdown = (peak_equity - equity) / peak_equity * 100
---
🔧 TROUBLESHOOTING & OPTIMIZATION
Common Configuration Issues
Insufficient Data: Ensure 100+ bars available before start date
[*} Not Compiling: Go on an asset's price chart with 2 or 3 years of data to
make the system compile or just simply reapply the indicator again
Too Many Assets: Reduce active count if experiencing timeouts
Regime Filter Too Strict: Lower trending threshold if always in USD
Excessive Switching: Increase MD multiplier or adjust thresholds
---
💡 USER FEEDBACK & ENHANCEMENT REQUESTS
The continuous evolution of this system depends heavily on user experience and community feedback. Your insights will help motivate me for new improvements and new feature developments.
---
⚖️ FINAL COMPREHENSIVE RISK DISCLAIMER
TRADING INVOLVES SUBSTANTIAL RISK OF LOSS
This indicator is a sophisticated analytical tool designed for educational and research purposes. Important warnings and considerations:
System Limitations:
No algorithmic system can guarantee profitable outcomes
Complex systems may fail in unexpected ways during extreme market events
Historical backtesting does not account for all real-world trading challenges
Slippage, liquidity constraints, and market impact can significantly affect results
System parameters require careful optimization and ongoing monitoring
The creator and distributor of this indicator assume no liability for any financial losses, system failures, or adverse outcomes resulting from its use. This tool is provided "as is" without any warranties, express or implied.
By using this indicator, you acknowledge that you have read, understood, and agreed to assume all risks associated with algorithmic trading and cryptocurrency investments.
Multi-Timeframe Bollinger BandsMy hope is to optimize the settings for this indicator and reintroduce it as a "strategy" with suggested position entry and exit points shown in the price pane.
I’ve been having good results setting the “Bollinger Band MA Length” in the Input tab to between 5 and 10. You can use the standard 20 period, but your results will not be as granular.
This indicator has proven very good at finding local tops and bottoms by combining data from multiple timeframes. Use timeframes that are lower than the timeframe you are viewing in your price pane. Be cognizant that the indicator, like other oscillators, does occasionally produce divergences at tops and bottoms.
Any feedback is appreciated.
Overview
This indicator is an oscillator that measures the normalized position of the price relative to Bollinger Bands across multiple timeframes. It takes the price's position within the Bollinger Bands (calculated on different timeframes) and averages those positions to create a single value that oscillates between 0 and 1. This value is then plotted as the oscillator, with reference lines and colored regions to help interpret the price's relative strength or weakness.
How It Works
Bollinger Band Calculation:
The indicator uses a custom function f_getBBPosition() to calculate the position of the price within Bollinger Bands for a given timeframe.
Price Position Normalization:
For each timeframe, the function normalizes the price's position between the upper and lower Bollinger Bands.
It calculates three positions based on the high, low, and close prices of the requested timeframe:
pos_high = (High - Lower Band) / (Upper Band - Lower Band)
pos_low = (Low - Lower Band) / (Upper Band - Lower Band)
pos_close = (Close - Lower Band) / (Upper Band - Lower Band)
If the upper band is not greater than the lower band or if the data is invalid (e.g., na), it defaults to 0.5 (the midline).
The average of these three positions (avg_pos) represents the normalized position for that timeframe, ranging from 0 (at the lower band) to 1 (at the upper band).
Multi-Timeframe Averaging:
The indicator fetches Bollinger Band data from four customizable timeframes (default: 30min, 60min, 240min, daily) using request.security() with lookahead=barmerge.lookahead_on to get the latest available data.
It calculates the normalized position (pos1, pos2, pos3, pos4) for each timeframe using f_getBBPosition().
These four positions are then averaged to produce the final avg_position:avg_position = (pos1 + pos2 + pos3 + pos4) / 4
This average is the oscillator value, which is plotted and typically oscillates between 0 and 1.
Moving Averages:
Two optional moving averages (MA1 and MA2) of the avg_position can be enabled, calculated using simple moving averages (ta.sma) with customizable lengths (default: 5 and 10).
These can be potentially used for MA crossover strategies.
What Is Being Averaged?
The oscillator (avg_position) is the average of the normalized price positions within the Bollinger Bands across the four selected timeframes. Specifically:It averages the avg_pos values (pos1, pos2, pos3, pos4) calculated for each timeframe.
Each avg_pos is itself an average of the normalized positions of the high, low, and close prices relative to the Bollinger Bands for that timeframe.
This multi-timeframe averaging smooths out short-term fluctuations and provides a broader perspective on the price's position within the volatility bands.
Interpretation
0.0 The price is at or below the lower Bollinger Band across all timeframes (indicating potential oversold conditions).
0.15: A customizable level (green band) which can be used for exiting short positions or entering long positions.
0.5: The midline, where the price is at the average of the Bollinger Bands (neutral zone).
0.85: A customizable level (orange band) which can be used for exiting long positions or entering short positions.
1.0: The price is at or above the upper Bollinger Band across all timeframes (indicating potential overbought conditions).
The colored regions and moving averages (if enabled) help identify trends or crossovers for trading signals.
Example
If the 30min timeframe shows the close at the upper band (position = 1.0), the 60min at the midline (position = 0.5), the 240min at the lower band (position = 0.0), and the daily at the upper band (position = 1.0), the avg_position would be:(1.0 + 0.5 + 0.0 + 1.0) / 4 = 0.625
This value (0.625) would plot in the orange region (between 0.85 and 0.5), suggesting the price is relatively strong but not at an extreme.
Notes
The use of lookahead=barmerge.lookahead_on ensures the indicator uses the latest available data, making it more real-time, though its effectiveness depends on the chart timeframe and TradingView's data feed.
The indicator’s sensitivity can be adjusted by changing bb_length ("Bollinger Band MA Length" in the Input tab), bb_mult ("Bollinger Band Standard Deviation," also in the Input tab), or the selected timeframes.
Advanced VWAP Multi-MA System with Bollinger Bands & Dashboard📊 Key Features:
Core Functionality:
* VWAP Calculation with customizable anchor periods (Session/Week/Month/Quarter/Year)
* Multiple Moving Average Types (EMA, SMA, WMA, HMA, RMA, VWMA)
* Three MA Lengths (Fast: 9, Medium: 21, Slow: 50)
* Standard Deviation Bands with 3 levels (1σ, 2σ, 3σ)
* Dynamic band multipliers (adjustable from 0.5 to 5.0)
🎨 Visual Theme System:
* Theme Types: Dark, Light, Pro
* Visual Styles: Quantum, Holographic, Crystalline, Plasma, Nebula
* Visual Intensity Control (20-100%)
* Multi-layer Harmonic Nodes with gradient effects
* Energy Flow Lines based on momentum
* Minimal signal dots for buy/sell conditions
📈 Holographic Dashboard:
* Real-time VWAP position tracking
* MA trend analysis (Bullish/Bearish/Neutral)
* Band position indicator (±1σ, ±2σ, ±3σ)
* Volatility percentage
* Momentum direction
* Current visual theme display
✨ Visual Effects:
* Quantum Fields: Multi-layer boxes with dynamic transparency
* Energy Flow: Momentum-based directional lines
* Gradient Fills: Between bands and MAs
* Borderless Design: Clean, modern appearance
* Emoji Headers: Enhanced visual appeal (⚡ 🌌 📊 🔮)
🎯 Trading Signals:
* Bullish Signal: Close > VWAP AND Close > Fast MA AND Fast MA > Medium MA
* Bearish Signal: Close < VWAP AND Close < Fast MA AND Fast MA < Medium MA
Signalgo BBSignalgo BB: Technical Overview
Signalgo BB is a Bollinger Bands (BB) indicator for TradingView, designed to provide a multi-dimensional view of volatility, trend, and trading opportunities within a single overlay. Below is a detailed, impartial explanation of its workings, inputs, and trading logic.
Core Mechanics
Signalgo BB operates on the principle of nested volatility bands and moving averages. It calculates:
Fast & Slow Bands: Two sets of Bollinger Bands (BB), using different moving average types (EMA or SMA), lengths, and standard deviation multipliers.
Volatility Cloud: A dynamic visual layer indicating when price is inside both, one, or neither band.
Filtering: A short-term RSI is used to confirm trend direction and filter out weak signals.
Inputs & Components
MA Type: Choice between EMA, SMA for both fast and slow MA calculations.
Fast/Slow Lengths
Fast/Slow Deviations
RSI Length/Thresholds
Show Cloud: Toggle for the visual volatility cloud.
Signal Mode: Band Break.
Prevent Repeated Signals: Option to suppress duplicate signals in the same direction.
TP/SL & Trailing Logic: Advanced, automated trade management with ATR-based distances, three take-profit levels, and a dynamic trailing stop.
Signal Generation
Band Break: Triggers when price crosses the fast BB band.
RSI Filter: All signals require RSI confirmation.
Prevent Repeated Signals: Optionally only marks the first breakout in a series to reduce overtrading.
Entry/Exit Marks: Labels are plotted for visual clarity, and signals can trigger TradingView alerts.
Trade Management
Stop Loss (SL): Set at a multiple of ATR from the entry price, adapting to current volatility.
Take Profits (TP1, TP2, TP3): Three levels scaled by risk-reward ratios, supporting partial exits.
Trailing Stop: After the first TP is hit, SL moves to breakeven and then trails at a user-defined multiple of ATR, locking in further gains.
Event Markers: Each TP, SL, and trailing stop event is labeled on the chart.
Direction State: The indicator tracks active trades, allowing for only one open position per direction at a time.
Cloud Visualization: The background color changes depending on whether price is inside both, one, or no bands, making it easier to visualize market conditions.
Multiple Signal Logics: It doesn’t just look at breakouts, it includes cloud crossings, mean reversion, and a choice of how to combine them.
Rigorous Filtering: Signals require RSI trend confirmation, reducing false entries during weak phases.
Automated Trade Management: Built-in TP/SL and trailing logic, dynamically adapting to volatility.
Signal Suppression: Option to prevent repeated signals, reducing noise and overtrading.
Customizable MA Types: Supports EMA, SMA, and a selection algorithm for future expansion.
Trading Strategy Application
Volatility Regimes: The cloud’s color indicates whether price is inside, between, or outside the bands, helping traders identify trending, ranging, or breakout conditions.
Signals: entries can be based on breakouts filtered by RSI trend strength.
Risk Management: All active trades are managed by TP/SL logic, trailing stops after TP1, and visual feedback on exits.
Visual Alerts: Both signals and TP/SL events are marked on the chart for manual review.
Flexibility: Users can switch modes or suppress repeated signals as needed, depending on trading style.
Practical Usage
Intraday to Swing: Suitable for timeframes from minutes to days, depending on the MA periods and volatility profile.
Manual or Automated: The visual overlay and alerts support both manual trading and automated strategies.
Education & Review: The colored cloud and event markers make it easy to review past price action and learn from signals.
What separates this indicator from traditional ones:
1. Dual Bollinger Bands
Traditional: Most indicators use a single set of Bollinger Bands (two standard deviations above/below a moving average).
Signalgo BB: Implements two sets of bands—a "fast" set (shorter moving average, narrower deviation) and a "slow" set (longer moving average, wider deviation). This provides both immediate (fast) and broader context (slow) for volatility and price action.
2. Volatility Cloud Visualization
Traditional: Standard Bollinger Bands display as two lines, with the area between sometimes shaded as a "band" but without dynamic color changes.
Signalgo BB: The background is colored differently depending on whether price is within both, one, or neither band, offering a visual "cloud" that distinguishes trending, ranging, or breakout regimes at a glance.
3. RSI Filtering
Traditional: Many indicators either don’t filter signals, or if they do, it’s not always configurable.
Signalgo BB: Adds an optional RSI filter, requiring signals to be confirmed by short-term RSI overbought/oversold conditions. This reduces false signals in range-bound or low-trend environments.
4. Prevention of Repeated Signals
Traditional: Most indicators will keep firing signals as long as conditions are met, which can cause overtrading.
Signalgo BB: Offers a user-toggleable option to suppress repeated signals in the same direction until the opposite signal occurs. This reduces noise for discretionary traders.
5. Integrated Trade Management
Traditional: Manual or separate coding is required for stop-loss, take-profit, and trailing stop logic.
Signalgo BB: Builds in dynamic, ATR-based stop-loss; up to three take-profit levels and a trailing stop that activates after the first TP is hit. All levels are visually plotted on the chart, and events (TP/SL hits) are labeled, aiding strategy review and automation.
6. Event Labeling and Alerts
Traditional: Alerts may exist for entry/exit, but rarely for each TP/SL event.
Signalgo BB: Places labels for every entry, exit, and TP/SL event. It also provides TradingView alertconditions for each event, enabling automated notifications or integration with trading bots.
7. Directional State Tracking
Traditional: Indicators typically do not track the "state" of a trade (e.g., active long/short/flat) beyond simple signals.
Signalgo BB: Maintains persistent variables for entry price, SL, TP, trailing stop, and trade direction, ensuring only one active signal per direction. This prevents overlapping entries and mimics realistic trade management.
8. User Customization
Traditional: Default settings are often hardcoded, or customization is limited.
Signalgo BB: Offers extensive user inputs for MA type and TP/SL logic—making the tool adaptable to many strategies and timeframes.
Momentum Fusion v1Momentum Fusion v1
Overview
Momentum Fusion v1 (MFusion) is a multi-oscillator indicator that combines several components to analyze market momentum and trend strength. It incorporates modified versions of classic indicators such as PVI (Positive Volume Index), NVI (Negative Volume Index), MFI (Money Flow Index), RSI, Stochastic, and Bollinger Bands Oscillator. The indicator displays a histogram that changes color based on momentum strength and includes "FUSION🔥" signal labels when extreme values are reached.
Indicator Settings
Parameters:
EMA Length – Smoothing period for the moving average (default: 255).
Smoothing Period – Internal calculation smoothing parameter (default: 15).
BB Multiplier – Standard deviation multiplier for Bollinger Bands (default: 2.0).
Show verde / marron / media lines – Toggles the display of auxiliary lines.
Show FUSION🔥 label – Enables/disables signal labels.
Indicator Components
1. PVI (Positive Volume Index)
Formula:
pvi := volume > volume ? nz(pvi ) + (close - close ) / close * sval : nz(pvi )
Description:
PVI increases when volume rises compared to the previous bar and accounts for price percentage change. The stronger the price movement with increasing volume, the higher the PVI value.
2. NVI (Negative Volume Index)
Formula:
nvi := volume < volume ? nz(nvi ) + (close - close ) / close * sval : nz(nvi )
Description:
NVI tracks price movements during declining volume. If the price rises on low volume, it may indicate a "stealth" trend.
3. Money Flow Index (MFI)
Formula:
100 - 100 / (1 + up / dn)
Description:
An oscillator measuring money flow strength. Values above 80 suggest overbought conditions, while values below 20 indicate oversold conditions.
4. Stochastic Oscillator
Formula:
k = 100 * (close - lowest(low, length)) / (highest(high, length) - lowest(low, length))
Description:
A classic stochastic oscillator showing price position relative to the selected period's range.
5. Bollinger Bands Oscillator
Formula:
(tprice - BB midline) / (upper BB - lower BB) * 100
Description:
Indicates the price position relative to Bollinger Bands in percentage terms.
Key Lines & Histogram
1. Verde (Green Line)
Calculation:
verde = marron + oscp (normalized PVI)
Interpretation:
Higher values indicate stronger bullish momentum. A FUSION🔥 signal appears when the value reaches 750+.
2. Marron (Brown Line)
Calculation:
marron = (RSI + MFI + Bollinger Osc + Stochastic / 3) / 2
Interpretation:
A composite oscillator combining multiple indicators. Higher values suggest overbought conditions.
3. Media (Red Line)
Calculation:
media = EMA of marron with smoothing period
Interpretation:
Acts as a signal line for trend confirmation.
4. Histogram
Calculation:
histo = verde - marron
Colors:
Bright green (>100) – Strong bullish momentum.
Light green (>0) – Moderate bullish momentum.
Orange (<0) – Bearish momentum.
Red (<-100) – Strong bearish momentum.
Signals & Alerts
1. FUSION🔥 (Strong Momentum)
Condition:
verde >= 750
Visualization:
A "FUSION🔥" label appears below the chart.
Alert:
Can be set to trigger notifications when the condition is met.
2. Background Aura
Condition:
verde > 850
Visualization:
The chart background turns teal, indicating extreme momentum.
Usage Recommendations
FUSION🔥 Signal – Can be used as a long entry point when confirmed by other indicators.
Histogram:
1. Green bars – Potential long entry.
2. Red/orange bars – Potential short entry.
3. Media & Marron Crossover – Can serve as an additional trend filter.
4. Suitable for a 5-15 minute time frame
Conclusion
Momentum Fusion v1 is a powerful tool for momentum analysis, combining multiple indicators into a unified system. It is suitable for:
Trend traders (catching strong movements).
Scalpers (identifying short-term impulses).
Swing traders (filtering entry points).
The indicator features customizable settings and visual signals, making it adaptable to various trading styles.
Dual Bollinger BandsIndicator Name:
Double Bollinger Bands (2-9 & 2-20)
Description:
This indicator plots two sets of Bollinger Bands on a single chart for enhanced volatility and trend analysis:
Fast Bands (2-9 Length) – Voilet
More responsive to short-term price movements.
Useful for spotting quick reversals or scalping opportunities.
Slow Bands (2-20 Length) – Black
Smoother, trend-following bands for longer-term context.
Helps confirm broader market direction.
Both bands use the standard settings (2 deviations, SMA basis) for consistency. The transparent fills improve visual clarity while keeping the chart uncluttered.
Use Cases:
Trend Confirmation: When both bands expand together, it signals strong momentum.
Squeeze Alerts: A tight overlap suggests low volatility before potential breakouts.
Multi-Timeframe Analysis: Compare short-term vs. long-term volatility in one view.
How to Adjust:
Modify lengths (2-9 and 2-20) in the settings.
Change colors or transparency as needed.
Why Use This Script?
No Repainting – Uses standard Pine Script functions for reliability.
Customizable – Easy to tweak for different trading styles.
Clear Visuals – Color-coded bands with background fills for better readability.
Ideal For:
Swing traders, day traders, and volatility scalpers.
Combining short-term and long-term Bollinger Band strategies.
Double Bollinger Bands MTF and Price projectionI did this script because I wanted to project prices over future bars quickly because I am a options trader.
Options:
Time frame: Default is Chart
Some times I prefer using 15 m with period 200 on a daily chart in a fast moving market. But you can chose what suites you
BB inner deviation 1 is default
When BB inner deviation=1 the outer will be 2X if its 0.5 outer will be 1
Moving Average type : Default EMA
Project next bar in label Default is off
This will calculate a linear projection of price of each band for the number of bars requested and print them in the label. It does not plot the future values
Using: in a trending market the prices will be generally be between band1 and band 2
and other times between -band1 and +band1. The projection can assist in optimal option strategy. Also in a fast moving market I would use 10 period ema for accurate price projections and others 20
Tri-Fold BB(Trend-Strength)*indicator isn't preset to look as displayed, do so accordingly*
"Tri-Fold BB" is an indicator that utilizes three Bollinger Bands, each of different length as a way to represent trend strength. This allows one to see the trend strength relative to multiple timeframes: short, mid, and long term trend strength. This is helpful because it provides the user with a holistic view of the asset.
How it Works
The indicator is preset to utilizing three different Bollinger Bands with length: 20, 50, and 100. This indicator simply plots the price of an asset relative to its specified Bollinger Band. For an example, if the price of the asset were to surpass its 20BB standard deviations, it would display so accordingly, though from the perspective of lets say... the 100, it may have looked like it barely moved up a standard deviation relative to 100BB because the standard deviations of a 100BB are more spread out.
Its important to view the trend strength from multiple lengths because it allows one to gauge whether the short term trend strength is likely to hold or not. A better way to speculate on asset behavior.
Another way to view this indicator is similar to that of the BB% indicator, except this indicator allows us to view price relative to standard deviations, across multiple timeframes. More holistic, more utility provided.
Basic Understanding:
Each line = Standard Deviation (3 upper, 3 lower)
Mid-Line = Basis relative to BB(20sma, 50sma, 100sma)
If price goes under Basis, that means it crossed below their specified sma(significant bull or bear signal)
I've also added HMA's relative to each BB incase one were to decide in creating some sort of trading strategy with it. I personally don't use them but I understand that it could be helpful to some so I left it in there. If you don't like them then simply deselect them and then save your desired setup as default.
In regard to regular indications of bullish or bearishness, i'd like to add that I use this indicator for the sole purpose of providing an idea of trend strength. I personally am unsure to state that cross overs directly indicate that there is a bull or bear move because I've seen instances where the price of an asset went in a direction contrary to what it 'should' have if we were to use that cross over strategy. Though of course, feel free to use this indicator as desired.
Bollinger Bands Reversal Strategy Analyzer█ OVERVIEW
The Bollinger Bands Reversal Overlay is a versatile trading tool designed to help traders identify potential reversal opportunities using Bollinger Bands. It provides visual signals, performance metrics, and a detailed table to analyze the effectiveness of reversal-based strategies over a user-defined lookback period.
█ KEY FEATURES
Bollinger Bands Calculation
The indicator calculates the standard Bollinger Bands, consisting of:
A middle band (basis) as the Simple Moving Average (SMA) of the closing price.
An upper band as the basis plus a multiple of the standard deviation.
A lower band as the basis minus a multiple of the standard deviation.
Users can customize the length of the Bollinger Bands and the multiplier for the standard deviation.
Reversal Signals
The indicator identifies potential reversal signals based on the interaction between the price and the Bollinger Bands.
Two entry strategies are available:
Revert Cross: Waits for the price to close back above the lower band (for longs) or below the upper band (for shorts) after crossing it.
Cross Threshold: Triggers a signal as soon as the price crosses the lower band (for longs) or the upper band (for shorts).
Trade Direction
Users can select a trade bias:
Long: Focuses on bullish reversal signals.
Short: Focuses on bearish reversal signals.
Performance Metrics
The indicator calculates and displays the performance of trades over a user-defined lookback period ( barLookback ).
Metrics include:
Win Rate: The percentage of trades that were profitable.
Mean Return: The average return across all trades.
Median Return: The median return across all trades.
These metrics are calculated for each bar in the lookback period, providing insights into the strategy's performance over time.
Visual Signals
The indicator plots buy and sell signals on the chart:
Buy Signals: Displayed as green triangles below the price bars.
Sell Signals: Displayed as red triangles above the price bars.
Performance Table
A customizable table is displayed on the chart, showing the performance metrics for each bar in the lookback period.
The table includes:
Win Rate: Highlighted with gradient colors (green for high win rates, red for low win rates).
Mean Return: Colored based on profitability (green for positive returns, red for negative returns).
Median Return: Colored similarly to the mean return.
Time Filtering
Users can define a specific time window for the indicator to analyze trades, ensuring that performance metrics are calculated only for the desired period.
Customizable Display
The table's font size can be adjusted to suit the user's preference, with options for "Auto," "Small," "Normal," and "Large."
█ PURPOSE
The Bollinger Bands Reversal Overlay is designed to:
Help traders identify high-probability reversal opportunities using Bollinger Bands.
Provide actionable insights into the performance of reversal-based strategies.
Enable users to backtest and optimize their trading strategies by analyzing historical performance metrics.
█ IDEAL USERS
Swing Traders: Looking for reversal opportunities within a trend.
Mean Reversion Traders: Interested in trading price reversals to the mean.
Strategy Developers: Seeking to backtest and refine Bollinger Bands-based strategies.
Performance Analysts: Wanting to evaluate the effectiveness of reversal signals over time.
Adaptive Range Scalper - KetBotAIThe Adaptive Scalper is designed to dynamically adjust entry, take-profit (TP), and stop-loss (SL) levels based on the latest market price. It combines multiple tools to provide traders with actionable insights, suitable for a range of trading styles and timeframes.
How the Indicator Works
Dynamic Levels:
- Yellow Dotted Line: Represents the entry level, following the latest price dynamically.
- Green Line: The Take Profit (TP) level, calculated as a multiple of the current price, adapts in real-time.
- Red Line: The Stop Loss (SL) level, placed below the price and also dynamically adjusts.
Bollinger Bands:
Provides context for market volatility and potential overbought/oversold zones.
Narrowing bands signal consolidation, while expanding bands indicate increased volatility.
Buy and Sell Signals:
Buy Signal: Triggered when the price crosses above the lower Bollinger Band.
Sell Signal: Triggered when the price crosses below the upper Bollinger Band.
These signals help traders time entries and exits based on momentum shifts.
Risk/Reward Analysis:
Visual shading shows the favorable risk/reward zone between the stop loss and take profit levels.
Timeframe Suggestions
Short-Term Traders (Scalping):
Use on 5-minute to 15-minute charts.
Focus on high-volatility periods for quick entries and exits.
Intraday Traders:
Ideal for 30-minute to 1-hour charts.
Provides more stable signals and less noise.
Swing Traders:
Best suited for 4-hour or daily charts.
Captures broader trends with fewer signals, allowing for larger moves.
Tool Combination
Volume Profile:
Combine with volume-based tools to confirm key support/resistance zones around TP and SL levels.
Trend Indicators:
Use with Moving Averages (e.g., 20-period or 50-period) to identify the broader trend direction.
Example: Only take buy signals in an uptrend and sell signals in a downtrend.
Momentum Oscillators:
Pair with tools like RSI or MACD to avoid entering overbought/oversold conditions.
Support/Resistance Lines:
Manually mark significant levels to confirm alignment with the indicator’s TP and SL zones.
Useful Advice for Traders
Risk Management:
- Always assess the risk/reward ratio; aim for at least 1:2 (risking 1 to gain 2).
- Adjust the multiplier to match your trading style (e.g., higher multiplier for swing trades, lower for scalping).
Avoid Overtrading:
Use the indicator in conjunction with clear rules to avoid false signals during low-volatility periods.
Monitor market volatility:
Pay attention to narrowing Bollinger Bands, which signal consolidations. Avoid trading until a breakout occurs.
Test on Demo Accounts:
Practice using the indicator on a demo account to understand its behavior across different assets and timeframes.
Focus on High-Liquidity Markets:
For the best results, trade highly liquid instruments like major currency pairs, gold, or stock indices.
Summary
The Adaptive Range Indicator dynamically adjusts to market conditions, offering clear entry and exit levels. By combining it with Bollinger Bands and other tools, traders can better navigate market trends and avoid noise. It’s versatile across multiple timeframes and assets, making it a valuable addition to any trader’s toolkit.
Multifactor Buy/Sell Strategy V2 | RSI, MACD, ATR, EMA, Boll.BITGET:1INCHUSDT
This Pine Script code for TradingView is a multifactor Buy/Sell indicator that combines several technical factors to generate trading signals based on trend, volatility, and volume conditions. Here’s a breakdown of the main components and functionality:
Indicator Name
- Multifactor Buy/Sell Strategy V2 — an overlay indicator applied directly on the price chart.
### Input Parameters
The script includes multiple customizable parameters:
- RSI, EMA, MACD parameters — for setting periods and signals of MACD and RSI.
- ATR and Bollinger Bands — used for volatility analysis and level determination.
- Minimum Volatility Threshold — sets a minimum Bollinger Band width threshold for determining high volatility.
Core Indicators
1. RSI — calculated to identify oversold (below 30) and overbought (above 70) conditions.
2. EMA and MACD — calculates exponential moving averages and MACD histogram to determine trend direction.
3. ATR and Bollinger Bands — used to assess current volatility and establish dynamic upper and lower bands.
Volatility and Volume Analysis
- Determines the current ATR level and Bollinger Band width to evaluate high volatility.
- Calculates the volume moving average to track periods of increased volume during high volatility.
Trend Analysis
The script uses the difference between fast and slow EMAs to define strong trends:
- Uptrend — when the fast EMA is above the slow EMA, the price is above the fast EMA, and the trend is strong.
- Downtrend — when the fast EMA is below the slow EMA, the price is below the fast EMA, and the trend is strong.
Momentum Filter
- Based on the price change over the last three bars and compared against the minimum volatility threshold to identify strong momentum.
Buy and Sell Signal Generation
- Buy Signal: Uptrend with RSI oversold, positive MACD histogram, high volatility and volume, strong momentum, and sufficient Bollinger Band width.
- Sell Signal: Downtrend with RSI overbought, negative MACD histogram, high volatility and volume, strong momentum, and sufficient Bollinger Band width.
Visualization
- Buy and sell signals are displayed as green and red triangles on the chart.
- Plots for fast and slow EMAs, upper and lower bands, and Bollinger Bands.
Alerts
The script includes alert conditions for buy and sell signals, allowing notifications to be sent via email or mobile app.
Information Panel
A small table on the chart displays current volatility dataThis Pine Script code for TradingView is a multifactor Buy/Sell indicator that combines several technical factors to generate trading signals based on trend, volatility, and volume conditions. Here’s a breakdown of the main components and functionality:
Indicator Name
- Multifactor Buy/Sell Strategy V2 — an overlay indicator applied directly on the price chart.
Input Parameters
The script includes multiple customizable parameters:
- **RSI, EMA, MACD parameters** — for setting periods and signals of MACD and RSI.
- **ATR and Bollinger Bands** — used for volatility analysis and level determination.
- **Minimum Volatility Threshold** — sets a minimum Bollinger Band width threshold for determining high volatility.
Core Indicators
1. RSI — calculated to identify oversold (below 30) and overbought (above 70) conditions.
2. EMA and MACD — calculates exponential moving averages and MACD histogram to determine trend direction.
3. ATR and Bollinger Bands — used to assess current volatility and establish dynamic upper and lower bands.
Volatility and Volume Analysis
- Determines the current ATR level and Bollinger Band width to evaluate high volatility.
- Calculates the volume moving average to track periods of increased volume during high volatility.
Trend Analysis
The script uses the difference between fast and slow EMAs to define strong trends:
- Uptrend — when the fast EMA is above the slow EMA, the price is above the fast EMA, and the trend is strong.
- Downtrend — when the fast EMA is below the slow EMA, the price is below the fast EMA, and the trend is strong.
Momentum Filter
- Based on the price change over the last three bars and compared against the minimum volatility threshold to identify strong momentum.
Buy and Sell Signal Generation
- Buy Signal: Uptrend with RSI oversold, positive MACD histogram, high volatility and volume, strong momentum, and sufficient Bollinger Band width.
- Sell Signal: Downtrend with RSI overbought, negative MACD histogram, high volatility and volume, strong momentum, and sufficient Bollinger Band width.
Visualization
- Buy and sell signals are displayed as green and red triangles on the chart.
- Plots for fast and slow EMAs, upper and lower bands, and Bollinger Bands.
Alerts
The script includes alert conditions for buy and sell signals, allowing notifications to be sent via email or mobile app.
Information Panel
A small table on the chart displays current volatility
- Volatility Status — indicates high or low volatility.
- Bollinger Band Width — current width as a percentage.
- ATR Ratio — ratio of current ATR to long-term average ATR.
This script is suitable for trading in high-volatility conditions, combining multiple filters and factors to generate precise buy and sell signals.
E9 Bollinger RangeThe E9 Bollinger Range is a technical trading tool that leverages Bollinger Bands to track volatility and price deviations, along with additional trend filtering via EMAs.
The script visually enhances price action with a combination of trend-filtering EMAs, bar colouring for trend direction, signals to indicate potential buy and sell points based on price extension and engulfing patterns.
Here’s a breakdown of its key components:
Bollinger Bands: The strategy plots multiple Bollinger Band deviations to create different price levels. The furthest deviation bands act as warning signs for traders when price extends significantly, signaling potential overbought or oversold conditions.
Bar Colouring: Visual bar colouring is applied to clearly indicate trend direction: green bars for an uptrend and red bars for a downtrend.
EMA Filtering: Two EMAs (50 and 200) are used to help filter out false signals, giving traders a better sense of the underlying trend.
This combination of signals, visual elements, and trend filtering provides traders with a systematic approach to identifying price deviations and taking advantage of market corrections.
Brief History of Bollinger Bands
Bollinger Bands were developed by John Bollinger in the early 1980s as a tool to measure price volatility in financial markets. The bands consist of a moving average (typically 20 periods) with upper and lower bands placed two standard deviations away. These bands expand and contract based on market volatility, offering traders a visual representation of price extremes and potential reversal zones.
John Bollinger’s work revolutionized technical analysis by incorporating volatility into trend detection. His bands remain widely used across markets, including stocks, commodities, and cryptocurrencies. With the ability to highlight overbought and oversold conditions, Bollinger Bands have become a staple in many trading strategies.
Bollinger Band + Mid BandBollinger Band + Mid Band
This indicator combines the classic Bollinger Bands with enhanced customization options, allowing traders to fine-tune the settings according to their specific strategies.
Key Features:
Moving Average Flexibility: Choose between Simple Moving Average (SMA), Exponential Moving Average (EMA), or Weighted Moving Average (WMA) as the central basis for the Bollinger Bands. This flexibility allows you to align the indicator with your preferred method of trend analysis.
Dual Band Deviation: The indicator includes two sets of upper and lower bands based on different standard deviation multipliers. This helps you analyze both the tightness of price action and potential breakout zones.
Customizable Colors: The mid-band, upper bands, and lower bands can be fully customized in terms of color, allowing you to personalize the visual representation of the indicator on your charts.
Dynamic Transparency: The space between the outer Bollinger Bands can be filled with a customizable transparent color, making it easy to visualize price movements within the bands.
Alerts for Crossovers: Alerts are triggered whenever the price crosses above the upper band or below the lower band, giving you timely notifications of potential breakout or breakdown scenarios.
Overbought/Oversold Visualization: The background of the chart changes color when the price crosses above the upper band (indicating overbought conditions) or below the lower band (indicating oversold conditions), providing a visual cue to help you identify market extremes.
Labeling for Significant Events: Labels appear on the chart whenever the price crosses the upper or lower bands, helping you quickly identify key moments for further analysis.
This script is designed for traders who want to leverage Bollinger Bands in their technical analysis but require additional flexibility and customization options. Whether you're using it for trend analysis, volatility assessment, or identifying overbought and oversold conditions, this tool can be tailored to fit a wide variety of trading styles.
Usage:
Ideal for traders looking to enhance the standard Bollinger Bands with more dynamic and customizable features.
Suitable for any market, including stocks, forex, and cryptocurrencies.
Useful in identifying volatility squeezes, breakouts, and potential reversal points.
Hullinger Bands [AlgoAlpha]🎯 Introducing the Hullinger Bands Indicator ! 🎯
Maximize your trading precision with the Hullinger Bands , an advanced tool that combines the strengths of Hull Moving Averages and Bollinger Bands for a robust trading strategy. This indicator is designed to give traders clear and actionable signals, helping you identify trend changes and optimize entry and exit points with confidence.
✨ Key Features :
📊 Dual-Length Settings : Customize your main and TP signal lengths to fit your trading style.
🎯 Enhanced Band Accuracy : The indicator uses a modified standard deviation calculation for more reliable volatility measures.
🟢🔴 Color-Coded Signals : Easily spot bullish and bearish conditions with customizable color settings.
💡 Dynamic Alerts : Get notified for trend changes and TP signals with built-in alert conditions.
🚀 Quick Guide to Using Hullinger Bands
1. ⭐ Add the Indicator : Add the indicator to favorites by pressing the star icon. Adjust the settings to align with your trading preferences, such as length and multiplier values.
2. 🔍 Analyze Readings : Observe the color-coded bands for real-time insights into market conditions. When price is closer to the upper bands it suggests an overbought market and vice versa if price is closer to the lower bands. Price being above or below the basis can be a trend indicator.
3. 🔔 Set Alerts : Activate alerts for bullish/bearish trends and TP signals, ensuring you never miss a crucial market movement.
🔍 How It Works
The Hullinger Bands indicator calculates a central line (basis) using a simple moving average, while the upper and lower bands are derived from a modified standard deviation of price movements. Unlike the traditional Bollinger Bands, the standard deviation in the Hullinger bands uses the Hull Moving Average instead of the Simple Moving Average to calculate the average variance for standard deviation calculations, this give the modified standard deviation output "memory" and the bands can be observed expanding even after the price has started consolidating, this can identify when the trend has exhausted better as the distance between the price and the bands is more apparent. The color of the bands changes dynamically, based on the proximity of the closing price to the bands, providing instant visual cues for market sentiment. The indicator also plots TP signals when price crosses these bands, allowing traders to make informed decisions. Additionally, alerts are configured to notify you of crucial market shifts, ensuring you stay ahead of the curve.
Easy Strategy BuilderHello, I focused on making this indicator as user-friendly as possible while designing it. I avoided complex structures, and as a result, I believe I have created an indicator that everyone can easily use.
With the Strategy Builder indicator, you can automate the strategy you use and visualize signals on the chart. This allows you to scale your strategy and stay informed of new signals through alerts.
How it works?
Firstly, we need to determine the entry condition for the trade. For this, you have 15 different sources at your disposal.
1. Price
2. RSI
3. RSI MA
4. CCI
5. STOCH K
6. STOCH D
7. MA 1
8. MA 2
9. ATR
10. DMI+
11. DMI-
12. SUPERTREND
13. BB Lower
14. BB Middle
15. BB Upper
Using the relationship between these sources or with a key level, we can generate signals. There are 7 different conditions available to control this relationship.
1. > x is greater than y
2. > = x is greater than or equal to y
3. < x is less than y
4. ≤ x is less than or equal to y
5. = x is equal to y
6. Cross Up = x has crossed above y. One bar ago, x was less than y, now x is greater than y.
7. Cross Down = x has crossed below y. One bar ago, x was greater than y, now x is less than y.
Let’s make a few examples
1.
- Entry Condition: RSI crosses above RSI moving average.
- Exit Condition: RSI crosses below RSI moving average.
Let's use more than one condition together
2.
Entry Condition: rsi<30 ve rsi cross up rsi Ma
Exit Condition: Rsi>70 ve rsi cross down rsi Ma
Let's strengthen the signal by adding different indicators and price.
3.
Entry Condition: rsi<30 and price70 and price> bb middle and rsi cross down rsi ma
What if things go wrong? Let's add stop loss
4.
Entry Condition: rsi<30 and price70 and price> bb higher and rsi cross down rsi ma
Stoploss: %2
That's how simple it is to create a strategy. Need a more complex strategy? Feel free to contact me.
Important notes:
1. Avoid continuously triggered conditions.
Example:
Entry Condition: RSI > 0
2. Determine logical entry and exit conditions.
3. Avoid placing stop losses too close to entry points.
Multi Bollinger Bands with Over ZoneThis indicator is called "Multi Bollinger Bands with Over Zone". The indicator uses linear regression to calculate the regression line and standard deviation to calculate the upper and lower deviation lines. It also plots filled areas between the deviation lines to highlight overbought and oversold zones.
The indicator has several customizable inputs, including the length of the regression period, depth, and deviations used to calculate the deviation lines.
The regression line is plotted in green color with circle markers. The upper and lower deviation lines are plotted in blue and red colors, respectively. The area between the deviation lines is filled with light blue color for the overbought zone and light pink color for the oversold zone.
This indicator helps traders in identifying trends and potential price reversals. When the price is above the upper deviation line, it indicates a potential overbought zone, while when the price is below the lower deviation line, it indicates a potential oversold zone.
Please note that this indicator is only a tool for analysis and does not provide direct trading signals. It is important to combine this indicator with additional analysis and appropriate trading strategies.
Bollinger Band Alert with RSI Filter IndicatorThis code is for a technical analysis indicator called Bollinger Band Alert with RSI Filter. It uses two tools: Bollinger Bands and Relative Strength Index (RSI) to identify potential trading signals in the market.
Bollinger Bands are lines plotted two standard deviations away from a simple moving average of the price of a stock or asset. They help traders determine whether prices are high or low on a relative basis.
The RSI is a momentum indicator that measures the strength of recent price changes to evaluate whether an asset is overbought or oversold.
The code has some input parameters that a user can change, such as length and multiplier, which are used to calculate the Bollinger Bands, and upper and lower RSI levels to define the overbought and oversold zones.
The code then uses if statements to generate alerts if certain conditions are met. The alert condition is triggered if the close price of an asset crosses above or below the upper or lower Bollinger Bands, and if the RSI is either above or below the overbought or oversold threshold levels.
Finally, the code generates plots to visualize the Bollinger Bands and displays triangles above or below the bars indicating when to enter a long or short position based on the strategy's criteria.
Dual Bollinger Band Mean ReversionSimple but solid mean reversion indicator with sl and tp levels. Most of the code is based on the built in bollinger bands script. Designed for scalping 1-5 minute timeframes.
The indicator consists of two sets of bollinger bands.
Price has to close below the lower (fast) bollinger band, above the moving average of the (slower) bollinger band.
If price now closes above the lower (fast) bb, the indicator draws a label at the open of the next candle (which would be a potential entry point). Take profit becomes the upper bollinger band, stop loss the same distance below the open of the candle.
I've built in a simple backtesting function that calculates the potential win/loss-ratio. Loss and profit levels are 1:1. Exit strategy could be improved on.
Adjusting the lengths depending on the asset proves to be a good idea.
The slower bollinger bands can help to identify ranging markets and/or trends following regular bollinger bands theory.
Feel free to comment with any changes that you'd like to be made.
[Floride] 4 Layers of Bollinger Shadow
This is the indicator I named 4LBS. That means four layers of bollinger shadow.
This is an indicator that I made to see how far past prices could affect the future prices.
And I found some very interesting and beautiful things about it, and I wanted to share them with you, so I publish this indicator.
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
Hello, nice to meet you all. my name as a trader is Floride.
First of all, I am not good at English, so there may be many grammatically incorrect sentences below.
I ask for your understanding in advance. Thanks for your understanding.
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
What is it?
bollinger Bands usually has one moving average line. And there's two bands that uses same period value of standard deviation as the former MA. And this indicator, by the way, has a 4 shadow bands
that uses twice,three,four,five time the value of the MA's period.
Appearance -
This indicator has four layers, and there are also other layers between them.
You can turn on or off all the shadow layers.
Uses of Indicator and Examples
examples of actual use
1. market strongness diagnosis
-It seems all layers of shadow has some degree resist/support forces.
This indicator has the 4th layer - "L4". (indicated by red lines).
I saw emergence of volatility quite frequently when this last layer breaks through.
When price breaks through this area or line, shade appear on the L4 layer in red. and red cross appear on the that point. This is I called Marlin signal.
If you saw red color shadow in this indicator, then the market may have quite high volatility.
(of course, there's not 100%. Please be careful about this.)
But I've also checked in quite several markets. when this volatility emerges, then also that market seems to started to building quite directional power afterwards.
I mean, after the marlin signal, market tends to have bigger volatility, and tends to go one direction.
again, it's not 100%. but probability is quite high.
But maybe depending on the type of market you need some adjustment.
Recommended values are M2-1.618, M3-2.618
Or M2-1, M3-2. default value is M2-1.618, M3-2.618
and also, if prices breakthrough the channels, or layers, It tends to break through the at once, in first bar. In other words, if price don't break through the first or second candle, it's very likely that the price won't break through channel for the time being.
2. market weakness diagnosis
Usually, without external momentum, the price converges to the average value and does not deviate from the band. And if price fails to break through the most inner first layer-"L1 - the green channel", In that case, the market is usually assumed to be weak, or has low volatility.
- you can set alarms on tuna, marlin signal. and you don't have to watch chart all the time.
3. Signals
I put two signals in this indicator.
One has the name "Tuna," and the second has the name "Marlin."
As you can already tell from the name's feeling, tuna is a weaker signal and marlin is a stronger signal.
Actual example of a signal
1. Tuna signal
- When the tuna signal appears, you can guess that the current market is generally not weak. or has quite good directional force. or medium volatility.
Below is important.
- If a tuna signal appears, there is a possibility that a marlin will appear later.
- In my opinion, it might be wise not to have a position without a tuna signal.
- Almost all of the marlin signal appeared shortly after the tuna signal appeared.
2. Marlin signal
- When marlin signal appears, with a high probability, volatility can increase large.
- In the backtesting of the stock, in some cases, the market moved quite frequently in the direction of the marlin signal.
- The emergence of marlin can be seen as a pretty strong indication of the emergences of direction.
