Dynamic Levels This indicator plots key price levels (Open, High, Low, Mid, Close) from multiple higher timeframes (Monday, Daily, Weekly, Monthly, Yearly).
It allows you to track how price interacts with important reference levels without switching timeframes.
🔑 Features
✅ Monday levels (MO, MH, MM)
By default: shows the last completed Monday (fixed values).
Option: “live mode” to update Monday High/Low/Mid while Monday’s candle is forming.
✅ Daily levels (DO, DH, DL, DM, DC)
Live: Daily High/Low/Mid update dynamically while today’s candle is forming.
Previous Daily Close (DC) is always fixed.
✅ Weekly levels (WO, WH, WL, WM)
Live: Weekly High/Low/Mid update dynamically while this week’s candle is forming.
Weekly Open is fixed.
✅ Monthly levels (MO(n), MH(n-1), ML(n-1), MM(n-1), MC(n-1))
Shows last completed month’s values (constant, never changing).
Current Monthly Open is also shown (naturally fixed).
✅ Yearly levels (YO(n), YH(n-1), YL(n-1), YM(n-1), YC(n-1))
Shows last completed year’s values (constant, never changing).
Current Yearly Open is also shown (naturally fixed).
🎨 Customization
Toggle each level (on/off) in indicator settings.
Individual color settings for Monday, Daily, Weekly, Monthly, and Yearly.
Adjustable line width and transparency.
Optional short labels (MO, DO, WM, etc.) displayed on the right side of the chart.
🔄 Dynamic Logic
Daily and Weekly → update dynamically while their candle is forming.
Monday, Monthly, and Yearly → use fixed values from the last completed bar (do not “breathe”).
📌 Use cases
Quickly see where price stands relative to previous close, current open, or mid-levels.
Use Monday Open/High/Mid as strong intraday references.
Use Monthly/Yearly levels as long-term support/resistance zones.
การจัดการพอร์ตการลงทุน
Dynamic Levels: Mon + D/W/M/Y (O/H/L/C/Mid)Purpose!
This Pine Script plots key reference levels (Open,High,Low,Close,Mid) for Monday,Daily,Weekly, Monthly, and Yearly timeframes.
All levels update live while the bar is forming. ( intrabar updates).
USAGE
Add the script to Pine Editor on TradingView (desktop Web)
Save - Add to chart
On mobile app: Find it under indicators - My scripts.
Great for identifying key reaction zones (opens,mids,previous closes).
Pro Volume Lite📘 Pro Volume Lite
What it is:
Pro Volume Lite is a tool that helps you quickly figure out:
How much quantity to buy or sell,
Where your risk stands,
How volume and trend strength are behaving,
Plus some quick company fundamentals.
🔹 1. Position Size & Risk Management
✅ Settings
Trade Direction:
Long → Bullish trades only.
Short → Bearish trades only.
Both → Auto-switch depending on whether today’s price change is up or down.
Capital (CP):
Enter your account size (example: 10,00,000).
This is the base for position size calculations.
Risk Mode (R):
Currency → Risk a fixed amount per trade (e.g., $5000).
Percentage → Risk a fixed % of your capital (e.g., 0.5%).
⚡ The script automatically calculates how much money you’re risking per trade based on your choice.
✅ Stop & Quantity Calculations
D (Stop Low %) → How far today’s close is from the day’s low.
DH (Stop High %) → How far close is from the mid-body of today’s candle.
Q (Quantity) → How many shares you can buy/sell if stop = day’s low.
QH (Quantity High) → Quantity if stop = mid-body.
SSL #1, #2, #3 → Standard stop-loss setups (e.g., 0.75%, 1%, 1.25%).
💡 If you enable Lot Size, all quantities are converted into nearest lot multiples (good for futures).
🔹 2. Volume Bar Coloring
Green = Price closed higher than it opened.
Red = Price closed lower than it opened.
Plots on the volume chart so you can see bullish/bearish volume.
🔹 3. Trend Intensity (TI)
Uses two moving averages (fast & slow).
Green dot on top → Trend strongly bullish.
Red dot on top → Trend strongly bearish.
Helps you spot momentum shifts.
🔹 4. Episodic Pivot (EP)
Marks big volume spikes with orange triangles under candles.
Default threshold = 9 million volume.
Shows when institutions may be entering/exiting.
🔹 5. Data Metrics Table
Quick fundamentals shown in a table:
MC (Market Cap): Company’s total market value.
Industry × Sector: Classification for the stock.
FF (Free Float): Value of shares available for public trading.
💡 In INR stocks → values are shown in Crores.
💡 In USD stocks → values shown in raw currency format.
⚡ Bottom Line
Pro Volume Lite helps you:
Size your trades correctly,
Control your risk,
Spot strong volume moves,
Check quick fundamentals,
All inside your TradingView chart.
Interval Price AlertsInterval Price Alerts
A versatile indicator that creates horizontal price levels with customizable alerts. Perfect for tracking multiple price levels simultaneously without having to create individual horizontal lines manually.
Features:
• Create evenly spaced price levels between a start and end price
• Customizable price interval spacing
• Optional price labels with flexible positioning
• Alert capabilities for both price crossovers and crossunders
• Highly customizable visual settings
Settings Groups:
1. Price Settings
• Start Price: The lower boundary for price levels
• End Price: The upper boundary for price levels
• Price Interval: The spacing between price levels
2. Line Style
• Line Color: Choose any color for the price level lines
• Line Style: Choose between Solid, Dashed, or Dotted lines
• Line Width: Adjustable from 2-4 pixels (optimized for opacity)
• Line Opacity: Control the transparency of lines (0-100%)
3. Label Style
• Show Price Labels: Toggle price labels on/off
• Label Color: Customize label text color
• Label Size: Choose from Tiny, Small, Normal, or Large
• Label Position: Place labels on Left or Right side
• Label Background: Set the background color
• Background Opacity: Control label background transparency
• Text Opacity: Adjust label text transparency
4. Alert Settings
• Alert on Crossover: Enable/disable upward price cross alerts
• Alert on Crossunder: Enable/disable downward price cross alerts
Usage Tips:
• Great for marking key price levels, support/resistance zones
• Useful for tracking multiple entry/exit points
• Perfect for scalping when you need to monitor multiple price levels
• Ideal for pre-market planning and level setting
Notes:
• Line width starts at 2 for optimal opacity rendering
• Labels can be fully customized or hidden completely
• Alert messages include the symbol and price level crossed
Merged Strategy with $1 TP (Avg Price)Merged Strategy with $1 TP (Avg Price)" is a custom Pine Script that combines moving average signals with an averaging technique. It opens trades based on MA crossovers, manages multiple entries, and automatically sets a fixed $1 take-profit target calculated on the average entry price. The strategy is designed for scalpers who want small, consistent gains without using stop-loss.
Sine Weighted Trend Navigator [QuantAlgo]🟢 Overview
The Sine Weighted Trend Navigator utilizes trigonometric mathematics to create a trend-following system that adapts to various market volatility. Unlike traditional moving averages that apply uniform weights, this indicator employs sine wave calculations to distribute weights across historical price data, creating a more responsive yet smooth trend measurement. Combined with volatility-adjusted boundaries, it produces actionable directional signals for traders and investors across various market conditions and asset classes.
🟢 How It Works
At its core, the indicator applies sine wave mathematics to weight historical prices. The system generates angular values across the lookback period and transforms them through sine calculations, creating a weight distribution pattern that naturally emphasizes recent price action while preserving smoothness. The phase shift feature allows rotation of this weighting pattern, enabling adjustment of the indicator's responsiveness to different market conditions.
Surrounding this sine-weighted calculation, the system establishes volatility-responsive boundaries through market volatility analysis. These boundaries expand and contract based on current market conditions, creating a dynamic framework that helps distinguish meaningful trend movements from random price fluctuations.
The trend determination logic compares the sine-weighted value against these adaptive boundaries. When the weighted value exceeds the upper boundary, it signals upward momentum. When it drops below the lower boundary, it indicates downward pressure. This comparison drives the color transitions of the main trend line, shifting between bullish (green) and bearish (red) states to provide clear directional guidance on price charts.
🟢 How to Use
Green/Bullish Trend Line: Rising momentum indicating optimal conditions for long positions (buy)
Red/Bearish Trend Line: Declining momentum signaling favorable timing for short positions (sell)
Steepening Green Line: Accelerating bullish momentum with increasing sine-weighted values indicating strengthening upward pressure and high-probability trend continuation
Steepening Red Line: Intensifying bearish momentum with declining sine-weighted calculations suggesting persistent downward pressure and optimal shorting opportunities
Flattening Trend Lines: Gradual reduction in directional momentum regardless of color may indicate approaching consolidation or trend exhaustion requiring position management review
🟢 Pro Tips for Trading and Investing
→ Preset Strategy Selection: Utilize the built-in presets strategically - Scalping preset for ultra-responsive 1-15 minute charts, Default preset for balanced general trading, and Swing Trading preset for 1-4 hour charts and multi-day positions.
→ Phase Shift Optimization: Fine-tune the phase shift parameter based on market bias - use positive values (0.1-0.5) in trending bull markets to enhance uptrend sensitivity, negative values (-0.1 to -0.5) in bear markets for improved downtrend detection, and zero for balanced neutral market conditions.
→ Multiplier Calibration: Adjust the multiplier according to market volatility and trading style. Use lower values (0.5-1.0) for tight, responsive signals in stable markets, higher values (2.0-3.0) during earnings seasons or high-volatility periods to filter noise and reduce whipsaws.
→ Sine Period Adaptation: Customize the sine weighted period based on your trading timeframe and market conditions. Use 5-14 for day trading to capture short-term momentum shifts, 14-25 for swing trading to balance responsiveness with reliability, and 25-50 for position trading to maintain long-term trend clarity.
→ Multi-Timeframe Sine Validation: Apply the indicator across multiple timeframes simultaneously, using higher timeframes (4H/Daily) for overall trend bias and lower timeframes (15m/1H) for entry timing, ensuring sine-weighted calculations align across different time horizons.
→ Alert-Driven Systematic Execution: Leverage the built-in trend change alerts to eliminate emotional decision-making and capture every mathematically-confirmed trend transition, particularly valuable for traders managing multiple instruments or those unable to monitor charts continuously.
→ Risk Management: Increase position sizes during strong directional sine-weighted momentum while reducing exposure during frequent color changes that indicate mathematical uncertainty or ranging market conditions lacking clear directional bias.
📊 Portafoglio Verticale Personalizzabile (5 Tickers, Net ROI)📊 Customizable Vertical Portfolio (5 Tickers, Net ROI)
Type: Pine Script v6 Indicator (TradingView)
Layout: Vertical table (up to 5 tickers + header)
🔹 Features
Tracks up to 5 tickers simultaneously
Table position selectable (top, middle, bottom; left, center, right)
Customizable colors (header, rows, borders)
Optional header display
🔹 Calculations
For each ticker:
Total cost = Entry price × Qty + Entry commissions
Current value = Current price × Qty – Exit commissions
Net P/L = Current value – Cost – Taxes
Net ROI (%) = (Net P/L ÷ Cost) × 100
🔹 Commission & Tax
Entry/Exit: Fixed or Percentage
CGT: user-defined %, applied only on profits
🔹 Output Table
| Ticker | Net P/L | Net ROI (%) |
Color-coded: Green = Profit, Red = Loss, Silver = Neutral/NA
✅ Best for
Multi-asset tracking in one chart
Real-time evaluation of profits after fees & taxes
Clear, visual portfolio monitoring
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.
Zakaat CalculatorZakaat Calculator
The Zakaat Calculator is a dedicated tool designed to assist with transparent and structured wealth assessments based on Islamic finance principles. This script dynamically references live gold and silver prices, applies Nisab thresholds, and evaluates whether Zakaat is obligatory based on the user’s net worth.
Core Features
Live market data: Automatically fetches daily gold and silver prices (TVC:GOLD & TVC:SILVER).
Nisab thresholds: Choose between the gold standard (85g) or silver standard (595g) to set the eligibility baseline.
Flexible inputs: Enter your current holdings across gold, silver, investments, and cash.
Automated calculation: Compares your total net worth against the selected Nisab threshold and calculates the payable Zakaat at a customizable percentage (default 2.5%).
Clear visualization: Results are displayed in a structured on-chart table for full transparency, including thresholds, holdings, total net worth, and final Zakaat due.
Practical Use
This tool is built for individuals who want a precise, real-time view of their Zakaat obligations. By combining faith-based calculation rules with live market data, it ensures accuracy and ease of use.
Note
This indicator is designed for educational and personal financial planning purposes. It may also be used for broader applications such as donations or calculating contributions towards charitable causes. Always consult with qualified scholars or financial advisors for personal guidance.
Altcoins Exit Planner [SwissAlgo]Altcoins Exit Planner
Navigating Altcoin Exits: A Strategic Approach: Planning your exits before emotions take over
------------------------------------------------------------------
✅ THE PSYCHOLOGY OF ALTCOIN TRADING
Many traders face recurring challenges when managing altcoin positions:
The Greed Trap : Holding through euphoric rallies, hoping for unrealistic targets, only to watch gains evaporate during market reversals.
The Paralysis Problem : Sitting on large unrealized profits but unsure which assets to exit, when, or how much — leading to inaction.
The FOMO Cycle : Rotating into trending coins too early or too late, often abandoning solid positions prematurely.
Analysis Overload : Consuming endless opinions and indicators without ever forming a clear, actionable exit strategy.
These patterns often stem from a lack of structure and planning . Emotional decision-making in volatile markets can be costly — especially with altcoins.
Developing a systematic framework can help define exit levels in advance , aiming to reduce emotional bias and improve decision clarity. The goal is to build disciplined exit strategies based on predefined logic rather than reactive impulses.
------------------------------------------------------------------
✅ FEATURES & FUNCTIONALITY
This indicator is designed to provide traders with a structured framework for exit planning. It aims to reduce decision-making under pressure by offering a visual roadmap on the chart.
The tool provides an analysis of key data points, including:
Structured Analysis : The indicator evaluates asset strength, identifies potential market phases, and derives potential exit levels from historical price behavior. This analysis may help traders assess whether an asset shows characteristics of strength (e.g., potential for extended targets) or weakness (e.g., early exit signals).
Actionable Information : It generates specific price levels and quantities for consideration as part of a predefined exit strategy.
Proactive Alerts : The system includes configurable alerts that can notify users as prices approach these key levels, allowing time for preparation. This feature is intended to support a shift from reactive trading toward systematic, criteria-based exit planning.
------------------------------------------------------------------
✅ HOW IT WORKS - AUTOMATED ANALYSIS & PLANNING
This indicator is designed to automate key aspects of exit planning that would otherwise require manual effort:
Fibonacci Level Calculation & Plotting : Automatically identifies key historical cycle points (e.g., bear market lows, bull market highs, recent pullbacks) and calculates relevant Fibonacci levels (both "Fib Retracments" from previous cycle ATH to bear market bottom, and "Fib. extensions" - considering major price impulses/waves in current bull market). This may help reduce manual drawing errors and streamline target identification.
Automated Calculation and Plotting of "Fib. Retracement "Levels
(from ATH of previous cycle to bottom in bear market)
Fibonacci retracement levels are a popular tool used in technical analysis to identify potential support and resistance levels in a market. After a significant price move, traders look for the price to "retrace" or pull back to one of several key Fibonacci ratios of the original move before continuing in its original direction. The most common retracement levels are 23.6%, 38.2%, 50%, 61.8%, and 78.6%. These levels are static horizontal lines on a chart, and their predictive power is based on the idea that they are "areas of interest" where a trend might pause or reverse.
Automated Calculation and Plotting of "Fib. Extension" Levels
(Price Impulses/Waves within current Bull Market)
Fibonacci extension levels are used to identify potential price targets or profit zones once a market has moved past its previous high or low. Unlike retracements, which measure a pullback, extensions project how far a trend might continue in the direction of its impulse move. They are typically used to anticipate where a wave or a rally might end and are based on ratios like 127.2%, 161.8%, 261.8%, and sometimes even higher. Extensions are a key tool for traders looking to set price targets for taking profits.
Coin Strength Assessment: Evaluates recovery performance relative to previous cycle peaks and classifies assets into four categories (Weak, Average, Strong, Outlier). Strength ratings may adjust dynamically based on momentum conditions — all derived from price data.
Market Phase Detection : Continuously monitors trend indicators, volume behavior, and altseason dynamics to estimate the current market phase. This may assist in contextualizing exit decisions without requiring manual phase analysis.
Exit Level Generation : Based on the asset’s strength classification and selected strategy (Conservative, Balanced, Aggressive), the system generates sequential exit levels with suggested percentages and quantities. Designed to support structured planning across three stages.
Signal Detection : Tracks multiple conditions — including price extensions, volume surges, momentum shifts, and cycle patterns — to generate alerts when predefined criteria are met.
Emergency Exit Detection : Scans for rare but high-risk scenarios (e.g., cycle top formations with multiple confluences) that may warrant immediate attention. Alerts are designed to highlight potential overextension during volatile phases.
Transfer Alerts : Calculates proximity to key exit zones and may issue early warnings to prepare for execution (e.g., moving assets from cold storage to exchanges), aiming to reduce last-minute decision pressure.
The script operates in two distinct modes:
Coin Analysis Mode Displays automatically-calculated Fibonacci levels, asset strength classification, market phase estimation, and contextual risk factors — designed to support structured analysis.
Exit Plan Mode Generates a customizable exit strategy with calculated price levels, suggested quantities, and potential outcome scenarios — aiming to assist with disciplined planning and reduce emotional bias.
------------------------------------------------------------------
✅ SETUP & INSTALLATION
Step 1: Chart Setup
Add the indicator to your altcoin USD chart (e.g., spot market pairs).
Recommended timeframe: 3 days for signal clarity.
Dark theme suggested for visual contrast.
Step 2: Configure Your Exit Strategy
Open Settings → “Setup Your Exit Plan”
Choose your strategy: Conservative: Prioritizes earlier exits for stricter risk control; Balanced: Combines early and late exits for a mixed approach; Aggressive: Targets later exits, accepting potentially higher volatility.
Input your asset quantity.
(Optional) Set a minimum sell price to block exit signals below your defined threshold.
(Optional) Set a sell-now price to trigger a sell alert when your exit target is reached, bypassing intermediate levels.
Step 3: Choose Display Mode
Coin Analysis Mode: View market conditions, strength classification, Fibonacci levels, and contextual risk insights. Designed to support monitoring and signal validation.
Exit Plan Mode: Displays your structured exit roadmap with suggested price levels, quantities, and visual chart overlays. Focuses on execution and planning.
Step 4: Set Up Alerts (Recommended)
Click the “Alert” button on the chart.
Select “Altcoins Exit Planner” as the condition.
Choose alert type: Planned Exit, Emergency Exit, Transfer Alert, Local Top, Trend Change
Set expiration to “Open-ended”
Configure your preferred notification method.
Alert Types Include:
Planned Exit Alerts: Triggered when suggested exit levels are reached (Exit #1, #2, #3).
Emergency Exit Alerts: Highlight potential cycle tops or full-exit conditions.
Transfer Alerts: Advance notice to prepare for execution (e.g., moving assets to exchanges).
Local Top Alerts: Short-term pullback signals for tactical decisions.
Trend Change Alerts: Indicate potential market phase transitions.
Once configured, the indicator begins analyzing and may notify you when exit conditions align with your selected strategy.
------------------------------------------------------------------
✅ USER INTERFACE
The interface is organized into two primary modes:
1) Coin Analysis Mode
Analysis Table Includes:
Fibonacci levels with price targets and percentage differentials
Market trend status (e.g., Strong Bull, Weakening Bull, Bear Market)
Volume behavior (Normal / Abnormal)
Price extension status (Overextended / Within range)
Altseason detection
Coin strength classification
Reversal risk assessment (Low / Average / High)
Suggested action based on current conditions
Visual Elements:
Bull/Bear trend EMA line
Volume-based candle coloring (overrides default chart candles)
Pivot points for key structural levels
Selectable Fibonacci extension/retracement lines
Background highlighting during altseason periods (potential cycle peak phase)
2) Exit Plan Mode
Exit Plan Table Displays:
Suggested quantity to sell at each exit level
Estimated portfolio value in USD
Structured exit plan with Fibonacci levels, percentages, quantities, and projected amounts
Average exit price calculation
Potential outcome scenarios if all exit levels are reached
Price Lines:
Individual exit level markers with contextual details
Average exit price reference line
Minimum sell price line (if enabled)
Sell-now price line (if enabled)
Signal Indicators:
Blue diamonds: Planned exit levels reached
Red triangles: Cycle top warnings
Orange triangles: Local top signals
These elements are designed to assist with visual interpretation and structured decision-making. All outputs are derived from price data and user-defined settings.
------------------------------------------------------------------
✅ LIMITATIONS
Market Cycle Dependency: This indicator is designed for cryptocurrency market cycles and will not perform similarly in other asset classes or market conditions. Its logic is based on historical crypto behavior, which may not repeat.
Assumption-Based Framework: The methodology relies on assumptions about market cycles, Fibonacci relationships, and altcoin behavior patterns. These assumptions may not hold under future conditions.
User Responsibility
All signals require user interpretation and decision-making.
The indicator provides information, not investment advice.
Signals should be validated with additional analysis.
Position sizing and risk management remain the user's responsibility.
Technical Requirements
Intended for use on the 3-day timeframe.
Designed for altcoin/USD trading pairs.
Requires sufficient historical data for Fibonacci calculations.
May not function properly on newly listed assets with limited price history.
Risk Management Guidelines. Recommended practices include:
Use with limited portions of your portfolio.
Combine with other technical and fundamental tools.
Consider broader market context beyond indicator signals.
Maintain independent stop-loss levels.
Review and adjust settings as market conditions evolve.
Signal Interpretation
Emergency signals highlight conditions that may warrant immediate review.
Planned exits support gradual, structured position reduction.
Transfer alerts provide preparation time before potential execution.
Local top signals may assist short-term tactical decisions.
------------------------------------------------------------------
✅ DISCLAIMER
This indicator is for educational and informational purposes only . It does not constitute financial, investment, or trading advice.
The indicator:
Makes no guarantees about future market performance.
Cannot predict market movements with certainty.
May generate false signals or miss key developments.
Relies on historical patterns that may not repeat.
Should not be used as the sole basis for trading decisions.
Users are responsible for:
Conducting independent research and analysis.
Understanding the risks of cryptocurrency trading.
Making their own investment/divestment decisions.
Managing position sizes and risk exposure appropriately.
Cryptocurrency trading involves substantial risk and may not be suitable for all investors. Past performance does not guarantee future results. Users should only invest what they can afford to lose and consult qualified professionals before making financial decisions.
The indicator’s assumptions may be invalidated by changing market conditions.
By using this tool, users acknowledge these limitations and accept full responsibility for their trading decisions.
Fed Rate Change Impact📊 Fed Rate Change Impact — Macro Event-Driven Indicator
Fed Rate Change Impact is an advanced indicator designed to analyze the impact of Federal Reserve interest rate changes on financial markets. It integrates event-driven logic with dynamic visualization, percentage diagnostics, and multi-asset selection, offering a clear and customizable view of post-event effects.
🔍 Key Features 📅 Preloaded Fed Events : Includes over 30 historical rate cut (↓) and hike (↑) dates from 2008 to 2024.
📈 Post-Event Analysis : Calculates the percentage change of the selected asset 5, 10, and 30 days after each event.
📌 Vertical Chart Lines : Visually highlights each event directly on the chart, with dynamic coloring (red for hikes, green for cuts).
📋 Diagnostic Table : Displays real-time impact for each event, with color-coded values and a compact layout.
🧠 Interactive Filter: Choose to display only hikes, only cuts, or both.
🧭 Flexible Asset Selection : Analyze the current chart asset, pick from a predefined list, or manually input any ticker via input.symbol().
🎯 Contextual Highlighting : The table highlights the analyzed asset if it matches the active chart symbol.
⚙️ Customizable Parameters lookahead5, lookahead10, lookahead30: Define the time horizon for measuring post-event impact.
eventFilter : Choose which type of events to display.
presetAsset / customAsset : Select or input the asset to analyze.
🧪 Recommended Use Cases Macroeconomic analysis on indices, commodities, crypto, and forex
Studying delayed effects of rate changes on sensitive assets
Building event-driven strategies or diagnostic overlays
Visual backtesting and cross-asset comparison
🧠 Technical Notes The indicator is compatible with overlay=true and works best on Daily timeframe.
The table automatically adapts to the number of events and includes visual padding for improved readability.
All calculations are performed in real time and require no external data.
Expected Value Monte CarloI created this indicator after noticing that there was no Expected Value indicator here on TradingView.
The EVMC provides statistical Expected Value to what might happen in the future regarding the asset you are analyzing.
It uses 2 quantitative methods:
Historical Backtest to ground your analysis in long-term, factual data.
Monte Carlo Simulation to project a cone of probable future outcomes based on recent market behavior.
This gives you a data-driven edge to quantify risk, and make more informed trading decisions.
The indicator includes:
Dual analysis: Combines historical probability with forward-looking simulation.
Quantified projections: Provides the Expected Value ($ and %), Win Rate, and Sharpe Ratio for both methods.
Asset-aware: Automatically adjusts its calculations for Stocks (252 trading days) and Crypto (365 days) for mathematical accuracy.
The projection cone shows the mean expected path and the +/- 1 standard deviation range of outcomes.
No repainting
Calculation:
1. Historical Expected Value:
This is a systematic backtest over thousands of bars. It calculates the return Rᵢ for N past trades (buy-and-hold). The Historical EV is the simple average of these returns, giving a baseline performance measure.
Historical EV % = (Σ Rᵢ) / N
2. Monte Carlo Projection:
This projection uses the Geometric Brownian Motion (GBM) model to simulate thousands of future price paths based on the market's recent behavior.
It first measures the drift (μ), or recent trend, and volatility (σ), or recent risk, from the Projection Lookback period. It then projects a final return for each simulation using the core GBM formula:
Projected Return = exp( (μ - σ²/2)T + σ√T * Z ) - 1
(Where T is the time horizon and Z is a random variable for the simulation.)
The purple line on the chart is the average of all simulated outcomes (the Monte Carlo EV). The cone represents one standard deviation of those outcomes.
The dashed lines represent one standard deviation (+/- 1σ) from the average, forming a cone of probable outcomes. Roughly 68% of the simulated paths ended within this cone.
This projection answers the question: "If the recent trend and volatility continue, where is the price most likely to go?"
Here's how to read the indicator
Expected Value ($/%): Is my average trade profitable?
Win Rate: How often can I expect to be right?
Sharpe Ratio: Am I being adequately compensated for the risk I'm taking?
User Guide
Max trade duration (bars): This is your analysis timeframe. Are you interested in the probable outcome over the next month (21 bars), quarter (63 bars), or year (252 bars)?
Position size ($): Set this to your typical trade size to see the Expected Value in real dollar terms.
Projection lookback (bars): This is the most important input for the Monte Carlo model. A short lookback (e.g., 50) makes the projection highly sensitive to recent momentum. Use this to identify potential recency bias. A long lookback (e.g., 252) provides a more stable, long-term projection of trend and volatility.
Historical Lookback (bars): For the historical backtest, more data is always better. Use the maximum that your TradingView plan allows for the most statistically significant results.
Use TP/SL for Historical EV: Check this box to see how the historical performance would have changed if you had used a simple Take Profit and Stop Loss, rather than just holding for the full duration.
I hope you find this indicator useful and please let me know if you have any suggestions. 😊
DCA Cost Basis (with Lump Sum)DCA Cost Basis (with Lump Sum) — Pine Script v6
This indicator simulates a Dollar Cost Averaging (DCA) plan directly on your chart. Pick a start date, choose how often to buy (daily/weekly/monthly), set the per-buy amount, optionally add a one-time lump sum on the first date, and visualize your evolving average cost as a VWAP-style line.
Features
Customizable DCA Plan — Set Start Date , buy Frequency (Daily / Weekly / Monthly), and Recurring Amount (in quote currency, e.g., USD).
Lump Sum Option — Add a one-time lump sum on the very first eligible date; recurring DCA continues automatically after that.
Cost Basis Line — Plots the live average price (Total Cost / Total Units) as a smooth, VWAP-style line for instant breakeven awareness.
Buy Markers — Optional triangles below bars to show when simulated buys occur.
Performance Metrics — Tracks:
Total Invested (quote)
Total Units (base)
Cost Basis (avg entry)
Current Value (mark-to-market)
CAGR (Annualized) from first buy to current bar
On-Chart Summary Table — Displays Start Date, Plan Type (Lump + DCA or DCA only), Total Invested, and CAGR (Annualized).
Data Window Integration — All key values also appear in the Data Window for deeper inspection.
Why use it?
Visualize long-term strategies for Bitcoin, crypto, or stocks.
See how a lump sum affects your average entry over time.
Gauge breakeven at a glance and evaluate historical performance.
Note: This tool is for educational/simulation purposes. Results are based on bar closes and do not represent live orders or fees.
Strategic Omega Portfolio System | QuantumResearchStrategic Omega Portfolio System | QuantumResearch
What it does
The Strategic Omega Portfolio System builds a rules-based multi-asset portfolio that adapts position and weight across up to five tickers (defaults: BTC, ETH, SOL, SUI + a spare slot).
It combines:
a trend/participation filter per asset, and
a two-pillar allocator (performance-quality via Omega and risk parity via inverse volatility).
The output is an evolving portfolio equity curve with a companion table showing signals, weights, and performance metrics.
How it works (principle, no hidden math)
1) Trend Participation (TPI)
Each asset is passed through an adaptive oscillator that gauges how far price has stretched relative to volume-weighted value and adapts its thresholds to current volatility.
When the oscillator exceeds its adaptive upper threshold → participate Long in that asset.
When it falls below the lower threshold → participate Short (or reduce/offset risk).
This focuses exposure on regimes with directional momentum rather than constant holding.
2) Weight Engine = Omega (quality) × Risk Parity (risk)
Omega weighting: Assets with a better gain/loss profile (more upside vs downside in recent returns) receive higher weight. This rewards asymmetric return quality, not just high average returns.
Risk-parity weighting: In parallel, weights are computed from inverse realized volatility of each asset’s strategy equity, so more volatile legs contribute less risk.
Blend: The system averages the Omega and risk-parity weights to get a balanced allocation.
Sign overlay: Final weights inherit the sign of each asset’s TPI (Long if trend-up, Short if trend-down), so exposure direction follows regime while size follows quality and risk.
3) Execution assumptions (inside the script)
Daily compounding of portfolio equity using the weighted sum of asset strategy returns.
Slippage is modeled in the entry/exit routine when positions flip.
You can include/exclude assets 3–5 from the blend.
Everything is computed on-chart; no external links or dependencies are required to understand usage.
What you see on the chart
System equity curve (optionally shaded): the portfolio’s compounded value since your chosen backtest start date.
Metrics table (toggleable): shows for each asset
Position (Long/Short from TPI),
Risk-parity weight, Omega weight, Final % allocation,
Each asset’s strategy equity multiple (x).
It also shows system-level metrics: return multiple, Sharpe, Sortino, Omega, and max equity drawdown.
How to use it
Select your assets (inputs accept any symbols).
Pick a backtest start date relevant to your horizon.
Optionally toggle assets 3–5 and tune the TPI sensitivity and lookback/thresholds if you want a faster or slower regime filter.
Read the table:
Prefer assets with Long TPI and higher final % allocation when you want to lean risk-on.
If several assets are Short, the system will naturally reduce or offset exposure.
Use the system equity and drawdown to sanity-check whether the configuration fits your risk tolerance.
Why this is different (originality & value)
It does not allocate on simple momentum ranks alone or a single classic indicator.
It separates participation (trend regime) from sizing (quality × risk), which helps avoid over-allocating to noisy uptrends or under-allocating to durable ones.
The Omega component prioritizes asymmetric payoffs, not just average returns, while risk parity normalizes contribution so one asset doesn’t dominate portfolio risk.
The adaptive VWMA oscillator uses volatility-responsive thresholds, aiming to reduce whipsaws compared with static bands.
Clean-chart guidance (publishing)
Publish with a clean chart (no unrelated indicators). If you add drawings, explain how they map to positions, weights, or equity. The script stands on its own; no external materials are required to understand intent and usage.
Inputs you can tune
Assets 1–5 (symbols).
Backtest Start Date.
Include/Exclude assets 3–5.
TPI controls.
Risk-parity window (volatility lookback).
Table/System plot toggles.
Limitations & best practices
Works best when assets exhibit persistent trends; allocation will churn more in choppy conditions.
Weights and signs are conditional on the last confirmed bar; intra-bar changes may differ.
Results are sensitive to lookbacks, start date, and asset mix—treat them as parameters to test, not absolutes.
Disclaimer
This script is for research and educational purposes only and is not financial advice. Markets involve risk. Past performance does not predict or guarantee future results. Always validate settings on your instruments and use prudent risk management.
TF Sys-1Richard Dennis (Prince of the Pit) invested 1,600 dollar and reportedly made 350 Million dollars (within 10 years). The key is that, fortunes are caught by catching the big moves and catching them before they are plainly visible to the crowd.
This Trend Following Indicator combine both Trend Following Calculation and Stage Analysis to provide the clarity of trend direction and the complete plan how to trade by risking only 2%. It provides the position sizing, breakout location, stop loss and Pyramiding strategy (Conservative or Aggressive). I will provide a complete guide how to utilize the indicator and trend following Philosophy in my store in Whop.
Next time, when someone recommend any ticker you will see in which stage the ticker is and the breakout point. This indicator will not provide financial advice, it is a tool for decision making and your partner to achieve your goal (to be a successful trend following trader) where fortune lays.
Ratios -> PROFABIGHI_CAPITAL🌟 Overview
This Ratios → PROFABIGHI_CAPITAL implements a comprehensive risk-adjusted performance analysis framework combining Sharpe, Sortino, and Omega ratios for superior portfolio evaluation and trading signal generation.
It provides Triple-ratio calculation engine with Sharpe volatility analysis, Sortino downside deviation measurement, and Omega probability-weighted performance assessment , Advanced smoothing system using EMA filtering for noise reduction and signal clarity , Dynamic threshold-based color coding with configurable strong and weak performance levels , and Configurable annualization framework supporting different market types and trading frequencies for institutional-grade risk management.
🔧 Advanced Risk-Adjusted Analysis Framework
Professional triple-ratio system integrating three distinct risk-adjusted performance methodologies for comprehensive portfolio evaluation
Source Selection Architecture enabling close, high, low, or other price inputs for flexible ratio calculation adaptation
Calculation Period Management with adjustable lookback periods balancing statistical significance versus market responsiveness
EMA Smoothing Integration reducing market noise while preserving important performance trends for enhanced decision-making accuracy
Grouped Parameter Organization separating general settings, Sharpe parameters, Sortino configuration, and Omega controls for streamlined optimization
Configurable Annualization Factor supporting different market types with customizable days-per-year calculation for accurate performance scaling
📊 Sharpe Ratio Implementation Engine
Risk-Free Rate Configuration providing adjustable annual risk-free rate for excess return calculation over benchmark performance
Volatility-Adjusted Performance measuring excess return per unit of total risk using standard deviation methodology
Strong/Weak Threshold Management offering configurable performance levels for signal generation and visual classification
Mathematical Precision Framework implementing proper annualization scaling with square root adjustment for volatility normalization
Zero-Division Protection ensuring continuous calculation through proper handling of zero volatility conditions
Periodic Return Calculation using bar-to-bar percentage changes for accurate return measurement across different timeframes
📈 Sortino Ratio Advanced Framework
Downside Deviation Focus measuring risk-adjusted performance using only negative deviations below risk-free threshold
Sophisticated Downside Calculation implementing loop-based accumulation of squared negative deviations for precise downside risk measurement
Risk-Free Rate Integration supporting independent risk-free rate configuration for Sortino-specific benchmark setting
Downside Risk Isolation excluding upward volatility from risk calculation for more accurate downside risk assessment
Mean Downside Deviation calculating average squared downside deviations with proper mathematical normalization
Square Root Scaling applying proper mathematical transformation for downside deviation with annualization adjustment
⚙️ Omega Ratio Probability Framework
Target Return Configuration enabling customizable annual target return threshold for gain-loss probability analysis
Cumulative Gain Calculation measuring total returns above target threshold through iterative accumulation methodology
Cumulative Loss Measurement calculating total shortfalls below target threshold for comprehensive downside assessment
Probability-Weighted Analysis implementing gains-to-losses ratio for probability-based performance evaluation
Target Return Conversion transforming annual target returns to periodic equivalents for accurate threshold comparison
Null Value Handling managing mathematical edge cases when no losses occur through proper validation logic
🔄 Advanced Smoothing Implementation
Triple-Ratio EMA Smoothing applying Exponential Moving Average filtering to all three ratios for enhanced signal clarity
Configurable Smoothing Period balancing signal responsiveness versus noise reduction through adjustable EMA length
Null Value Protection ensuring continuous smoothing through proper handling of undefined raw ratio values
Omega Ratio Special Handling using zero fallback for undefined Omega values to maintain continuous EMA calculation
Signal Persistence Enhancement reducing false signals while preserving important trend changes through mathematical smoothing
Real-Time Smoothing Updates providing current smoothed values for immediate performance assessment and signal generation
🎨 Dynamic Visualization Framework
Threshold-Based Color Coding using green for strong performance above threshold, red for weak performance below threshold, and gray for neutral zones
Sharpe Ratio Visualization displaying green/red/gray coloring based on smoothed values relative to strong and weak threshold lines
Sortino Ratio Display implementing blue for strong performance, yellow for weak performance, and gray for neutral conditions
Omega Ratio Presentation using orange for strong performance, purple for weak performance, and gray for intermediate levels
Multi-Line Plot System presenting all three smoothed ratios simultaneously with distinct colors and line weights
Reference Line Framework displaying horizontal dashed lines for strong and weak thresholds with color-coded identification
🔍 Mathematical Precision Implementation
Accurate Return Calculation using proper percentage change methodology for consistent return measurement
Annualization Scaling implementing correct mathematical formulations for time-period adjustment with square root factors
Statistical Validation ensuring mathematical accuracy through proper mean and standard deviation calculations
Loop-Based Calculations using efficient iteration for downside deviation and Omega ratio cumulative calculations
Error Prevention Framework incorporating comprehensive validation for zero division and undefined value conditions
Precision Maintenance preserving calculation accuracy across different smoothing periods and market conditions
📋 Performance Analysis Applications
Risk-Adjusted Signal Generation using threshold crossovers for entry and exit signal identification across all three ratios
Portfolio Performance Ranking comparing multiple assets or strategies using standardized risk-adjusted performance metrics
Market Regime Detection identifying favorable and unfavorable market conditions through ratio trend analysis
Strategy Optimization evaluating trading strategy performance using multiple risk-adjusted methodologies simultaneously
Drawdown Analysis Enhancement utilizing Sortino ratio focus on downside risk for better drawdown assessment
Probability-Based Decision Making leveraging Omega ratio gain-loss probability analysis for position sizing and risk management
✅ Key Takeaways
Comprehensive triple-ratio framework combining Sharpe volatility analysis, Sortino downside focus, and Omega probability-weighted assessment for complete risk-adjusted evaluation
Advanced smoothing implementation using EMA filtering for noise reduction while preserving important performance trends and signal clarity
Dynamic threshold-based visualization with color-coded performance states enabling immediate identification of strong, weak, and neutral conditions
Mathematical precision implementation using proper statistical formulations with comprehensive error handling and edge case management
Configurable parameter framework supporting different market types through adjustable annualization factors and independent threshold settings
Professional visualization system with multi-colored ratio lines and reference threshold displays for institutional-grade performance analysis
Flexible calculation periods enabling adaptation to different trading styles and market analysis requirements for versatile risk management applications
Position Sizing Calculator with ADR%, Account %, and RSILET ME KNOW IN COMMENTS IF YOU HAVE ANY ISSUES!
Overview
The Position Sizing Calculator with ADR% + RSI is a indicator that helps traders calculate position sizes based on risk management parameters (stop loss at low of day). It uses a fixed percentage of the account size, risk per trade, and stop loss distance (current price minus daily low) to determine the number of shares or contracts to trade. Additionally, it displays the Average Daily Range (ADR) as a percentage, the Relative Strength Index (RSI), and the price’s percentage distance from the daily low in a real-time table.
Features
Position Sizing: Calculates position size based on a fixed account percentage, risk per trade, and stop loss distance, ensuring the position value stays within the allocated capital.
ADR% Display: Shows the ADR as a percentage of the daily low, colored green if >5% or red if ≤5%.
RSI Display: Shows the RSI, colored green if oversold (<30), red if overbought (>70), or gray otherwise.
Distance from Low: Displays the current price’s percentage distance from the daily low for context.
Real-Time Table: Presents all metrics in a top-right table, updating in real-time.
Position Value Cap: Ensures the position value doesn’t exceed the allocated capital.
Minimum Stop Loss: Prevents oversized positions due to very small stop loss distances.
Customizable Parameters
Account Size ($): Set the total account balance (default: $1,000, min: $100, step: $100).
Risk Per Trade (%): The percentage of allocated capital to risk per trade (default: 1%, range: 0.1% to 10%, step: 0.1%).
Max % of Account: The fixed percentage of the account to allocate for the trade (default: 50%, range: 10% to 100%, step: 1%).
ADR Period: The number of days to calculate the ADR (default: 14, min: 1, step: 1).
RSI Length: The period for RSI calculation (default: 14, min: 1, step: 1).
Min Stop Loss Distance ($): The minimum stop loss distance to prevent oversized positions (default: $0.01, min: $0.001, step: $0.001).
Calculations
Stop Loss Distance: Current price minus daily low, with a minimum value set by the user.
Position Size: (Account Size * Max % of Account * Risk Per Trade %) / Stop Loss Distance, capped so the position value doesn’t exceed the allocated capital.
ADR%: 100 * (SMA(daily high / daily low, ADR Period) - 1), reflecting the average daily range relative to the low.
RSI: Calculated using the smoothed average of gains and losses over the RSI period, with special handling for zero gains or losses.
Distance from Low: (Current Price - Daily Low) / Daily Low * 100.
Table Display
Account Size: The input account balance.
Risk Per Trade: The risk percentage.
Stop Loss Distance: The price difference between the current price and daily low.
Distance from Low: The percentage distance from the daily low.
Account % Used: The fixed percentage of the account allocated.
Position Size: The calculated number of shares or contracts.
Position Value: The position size multiplied by the current price.
ADR %: The ADR percentage, colored green (>5%) or red (≤5%).
RSI: The RSI value, colored green (<30), red (>70), or gray (30–70).
Usage
Ideal for traders managing risk by allocating a fixed portion of their account and sizing positions based on stop loss distance.
The ADR% and RSI provide market context, with color coding to highlight high volatility or overbought/oversold conditions.
Adjust the customizable parameters to fit your trading style, such as increasing the risk percentage for aggressive trades or adjusting the ADR/RSI periods for different time horizons.
Mavi## Core System Structure and Operating Principle
This advanced trading system adopts a multi-dimensional approach to market analysis. Centering on two main trend-following mechanisms, it supports them with 12 different technical analysis tools. Its fundamental philosophy is to simultaneously evaluate different aspects of the market rather than relying on a single indicator. The main signal systems constitute 70% of the total decision, while supporting indicators complete the remaining 30%. Thanks to this mathematical weighting, false signals are minimized while strong market movements are captured early.
The system's most remarkable feature is its automatic calculation of optimal entry points for each trade. During this calculation, the current price position, volatility status, momentum indicators, and critical technical levels are evaluated together. A dynamic algorithm is used to ensure you enter the market at the most suitable price, and this entry point is continuously updated.
## Risk Management and Capital Protection
Risk management is a fundamental element embedded in this system's DNA. Before each trade, the stop loss level is automatically calculated based on volatility, and you are presented with three different profit targets. These targets are determined to optimize the risk/reward ratio. The system recommends risking only 2% of your capital per trade and calculates your position size according to this rule. The profit-taking strategy is based on the principle of graduated exits: 50% of the position at the first target, 30% at the second target, and the remaining 20% at the third target. This approach both protects profits and offers the opportunity to benefit from trend continuation.
Stop loss levels are dynamically adjusted according to the market's current volatility. When volatility increases, the stop distance widens; when it decreases, it narrows. This reduces the risk of unnecessary stops while providing protection against major losses. Additionally, the risk/reward ratio is calculated for each trade, and if this ratio is below 1:2, opening a trade is not recommended.
## Market Condition Analysis and Adaptive Strategy
The system classifies the market into three different regimes: trending, ranging, and consolidation. Different trading strategies are recommended for each regime. During trending periods, more weight is given to signals in the trend direction, and momentum indicators are emphasized. In ranging markets, trading from support and resistance levels is recommended, and overbought/oversold zones receive more attention. During consolidation periods, a major upcoming movement is anticipated, and taking positions in the breakout direction is advised.
Market regime detection is performed by evaluating multiple indicators together. The market's current character is determined by analyzing trend strength, volatility level, volume behavior, and momentum indicators. Through this detection, the appropriate strategy for each market condition is automatically activated.
## Confidence Score and Decision-Making Mechanism
One of this system's most innovative features is the confidence score calculation for each signal. This score is determined by taking the weighted average of 14 different technical indicators and ranges from 0-100. If the confidence score is below 35%, opening a trade is not recommended. The higher the score, the more reliable the signal. Visually represented by stars, this score enables quick decision-making.
The decision-making mechanism adopts an objective and mathematical approach. After all indicators are analyzed, you are presented with a clear recommendation: strong buy, buy, strong sell, sell, or wait. These recommendations are based solely on technical data, completely eliminating emotional factors. This enables disciplined trading free from emotions such as fear and greed.
## Volume and Money Flow Analysis
Volume analysis is an integral part of the system. Metrics such as relative volume, money flow index, accumulated volume indicator, and volume change rate are continuously monitored. Signals are found to be more reliable when trading occurs at more than twice the normal volume. Z-score analysis, particularly used to detect institutional activity, enables you to catch big players' market entries early.
Money flow indicators determine the direction of capital entering or leaving the market. Positive money flow indicates buying pressure, while negative money flow shows selling pressure. By detecting discrepancies between money flow and price movement, potential reversal points are signaled in advance. The combined evaluation of volume and money flow analysis improves signal quality and filters out false breakouts.
## Momentum and Strength Indicators
Momentum analysis enables you to understand the market's internal dynamics. By evaluating the relative strength index, stochastic oscillator, and momentum indicators together, the market's overbought or oversold condition is detected. Trend strength analysis provides information about the sustainability of the current movement. In strong trends, maintaining positions in the trend direction is recommended, while profit realization is advised in weak trends.
Divergence analysis of momentum indicators detects potential reversal points early. If momentum indicators show decline while price makes new highs, this signals trend weakening. Such discrepancies are automatically detected and you are alerted.
## Moving Averages and Trend Analysis
Short, medium, and long-term trends are analyzed using moving averages of different periods. These averages, based on Fibonacci numbers, create natural support and resistance levels. Alignment of all averages in the same direction confirms strong trend presence. Major crossovers are automatically detected and evaluated as harbingers of significant trend changes.
The distance between moving averages is an indicator of trend strength. As averages diverge from each other, the trend strengthens; as they converge, it weakens. This dynamic is continuously monitored, and when the trend weakens, reducing positions or profit realization is recommended.
## Institutional Pattern Recognition
The system automatically detects special formations used by professional investors. Patterns indicating institutional accumulation, such as Spring and UTAD, are evaluated together with large volume movements. A minimum 20-bar cooldown period is applied in detecting these patterns to filter false signals. The Spring pattern indicates potential bottoms and uptrend beginnings, while the UTAD pattern signals tops and downtrend beginnings.
## Practical Use and Application
When you start using the indicator, you should first follow the two main panels in the right corners. The upper panel contains risk management and final decision recommendations, while the lower panel provides detailed market analysis. If there's a high confidence score and a clear signal, you can open a trade from the determined entry point. Always use the recommended stop loss level and stick to profit targets.
You may need to use different parameters in different timeframes. More sensitive settings are preferred for short-term trades, while broader parameters are chosen for long-term trades. Optimized default values are provided for each timeframe, but you can fine-tune according to your own experience.
## Conclusion
This comprehensive trading system is a sophisticated solution developed against the complexity of modern markets. With multiple analysis layers, automatic risk management, and an objective scoring system, it minimizes emotional decisions and enables systematic trading. The system shows you the way, but the final decision is always yours. Disciplined use, patience, and adherence to risk management rules are the keys to long-term success.
The most important rule to remember when trading is that no system is perfect and there are no guarantees in the market. Therefore, always prioritize capital management and only trade with money you can afford to lose. You are provided with professional-level analysis capabilities, but discipline, patience, and continuous learning are essential for success.
Mato Trading Final Trend Score & Alignment (10-Criteria, 0–100)My trend definition is a systematic approach to identify market trends using 10 equally weighted criteria per timeframe, derived from historical prices, historical volatilities and a time projection factor.
The scoring system ranges from 0 (strong short signal) to 100 (strong long signal).
A trigger for a trend signal is generated when all specified timeframes—1-minute, 5-minute, 15-minute, 30-minute, 1-hour, 2-hour, 4-hour, daily, weekly, monthly, and 3-month—align to produce the same directional signal (long or short).
LeTa Pro## Core System Structure and Operating Principle
This advanced trading system adopts a multi-dimensional approach to market analysis. Centering on two main trend-following mechanisms, it supports them with 12 different technical analysis tools. Its fundamental philosophy is to simultaneously evaluate different aspects of the market rather than relying on a single indicator. The main signal systems constitute 70% of the total decision, while supporting indicators complete the remaining 30%. Thanks to this mathematical weighting, false signals are minimized while strong market movements are captured early.
The system's most remarkable feature is its automatic calculation of optimal entry points for each trade. During this calculation, the current price position, volatility status, momentum indicators, and critical technical levels are evaluated together. A dynamic algorithm is used to ensure you enter the market at the most suitable price, and this entry point is continuously updated.
## Risk Management and Capital Protection
Risk management is a fundamental element embedded in this system's DNA. Before each trade, the stop loss level is automatically calculated based on volatility, and you are presented with three different profit targets. These targets are determined to optimize the risk/reward ratio. The system recommends risking only 2% of your capital per trade and calculates your position size according to this rule. The profit-taking strategy is based on the principle of graduated exits: 50% of the position at the first target, 30% at the second target, and the remaining 20% at the third target. This approach both protects profits and offers the opportunity to benefit from trend continuation.
Stop loss levels are dynamically adjusted according to the market's current volatility. When volatility increases, the stop distance widens; when it decreases, it narrows. This reduces the risk of unnecessary stops while providing protection against major losses. Additionally, the risk/reward ratio is calculated for each trade, and if this ratio is below 1:2, opening a trade is not recommended.
## Market Condition Analysis and Adaptive Strategy
The system classifies the market into three different regimes: trending, ranging, and consolidation. Different trading strategies are recommended for each regime. During trending periods, more weight is given to signals in the trend direction, and momentum indicators are emphasized. In ranging markets, trading from support and resistance levels is recommended, and overbought/oversold zones receive more attention. During consolidation periods, a major upcoming movement is anticipated, and taking positions in the breakout direction is advised.
Market regime detection is performed by evaluating multiple indicators together. The market's current character is determined by analyzing trend strength, volatility level, volume behavior, and momentum indicators. Through this detection, the appropriate strategy for each market condition is automatically activated.
## Confidence Score and Decision-Making Mechanism
One of this system's most innovative features is the confidence score calculation for each signal. This score is determined by taking the weighted average of 14 different technical indicators and ranges from 0-100. If the confidence score is below 35%, opening a trade is not recommended. The higher the score, the more reliable the signal. Visually represented by stars, this score enables quick decision-making.
The decision-making mechanism adopts an objective and mathematical approach. After all indicators are analyzed, you are presented with a clear recommendation: strong buy, buy, strong sell, sell, or wait. These recommendations are based solely on technical data, completely eliminating emotional factors. This enables disciplined trading free from emotions such as fear and greed.
## Volume and Money Flow Analysis
Volume analysis is an integral part of the system. Metrics such as relative volume, money flow index, accumulated volume indicator, and volume change rate are continuously monitored. Signals are found to be more reliable when trading occurs at more than twice the normal volume. Z-score analysis, particularly used to detect institutional activity, enables you to catch big players' market entries early.
Money flow indicators determine the direction of capital entering or leaving the market. Positive money flow indicates buying pressure, while negative money flow shows selling pressure. By detecting discrepancies between money flow and price movement, potential reversal points are signaled in advance. The combined evaluation of volume and money flow analysis improves signal quality and filters out false breakouts.
## Momentum and Strength Indicators
Momentum analysis enables you to understand the market's internal dynamics. By evaluating the relative strength index, stochastic oscillator, and momentum indicators together, the market's overbought or oversold condition is detected. Trend strength analysis provides information about the sustainability of the current movement. In strong trends, maintaining positions in the trend direction is recommended, while profit realization is advised in weak trends.
Divergence analysis of momentum indicators detects potential reversal points early. If momentum indicators show decline while price makes new highs, this signals trend weakening. Such discrepancies are automatically detected and you are alerted.
## Moving Averages and Trend Analysis
Short, medium, and long-term trends are analyzed using moving averages of different periods. These averages, based on Fibonacci numbers, create natural support and resistance levels. Alignment of all averages in the same direction confirms strong trend presence. Major crossovers are automatically detected and evaluated as harbingers of significant trend changes.
The distance between moving averages is an indicator of trend strength. As averages diverge from each other, the trend strengthens; as they converge, it weakens. This dynamic is continuously monitored, and when the trend weakens, reducing positions or profit realization is recommended.
## Institutional Pattern Recognition
The system automatically detects special formations used by professional investors. Patterns indicating institutional accumulation, such as Spring and UTAD, are evaluated together with large volume movements. A minimum 20-bar cooldown period is applied in detecting these patterns to filter false signals. The Spring pattern indicates potential bottoms and uptrend beginnings, while the UTAD pattern signals tops and downtrend beginnings.
## Practical Use and Application
When you start using the indicator, you should first follow the two main panels in the right corners. The upper panel contains risk management and final decision recommendations, while the lower panel provides detailed market analysis. If there's a high confidence score and a clear signal, you can open a trade from the determined entry point. Always use the recommended stop loss level and stick to profit targets.
You may need to use different parameters in different timeframes. More sensitive settings are preferred for short-term trades, while broader parameters are chosen for long-term trades. Optimized default values are provided for each timeframe, but you can fine-tune according to your own experience.
## Conclusion
This comprehensive trading system is a sophisticated solution developed against the complexity of modern markets. With multiple analysis layers, automatic risk management, and an objective scoring system, it minimizes emotional decisions and enables systematic trading. The system shows you the way, but the final decision is always yours. Disciplined use, patience, and adherence to risk management rules are the keys to long-term success.
The most important rule to remember when trading is that no system is perfect and there are no guarantees in the market. Therefore, always prioritize capital management and only trade with money you can afford to lose. You are provided with professional-level analysis capabilities, but discipline, patience, and continuous learning are essential for success.
Extended Majors Rotation System | AlphaNattExtended Majors Rotation System | AlphaNatt
A sophisticated cryptocurrency rotation system that dynamically allocates capital to the strongest trending major cryptocurrencies using multi-layered relative strength analysis and adaptive filtering techniques.
"In crypto markets, the strongest get stronger. This system identifies and rides the leaders while avoiding the laggards through mathematical precision."
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 SYSTEM OVERVIEW
The Extended Majors Rotation System (EMRS) is a quantitative momentum rotation strategy that:
Analyzes 10 major cryptocurrencies simultaneously
Calculates relative strength between all possible pairs (45 comparisons)
Applies fractal dimension analysis to identify trending behavior
Uses adaptive filtering to reduce noise while preserving signals
Dynamically allocates to the mathematically strongest asset
Implements multi-layer risk management through market regime filters
Core Philosophy:
Rather than trying to predict which cryptocurrency will perform best, the system identifies which one is already performing best relative to all others and maintains exposure until leadership changes.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎯 WHAT MAKES THIS SYSTEM UNEQUIVOCALLY UNIQUE
1. True Relative Strength Matrix
Unlike simple momentum strategies that look at individual asset performance, EMRS calculates the complete relative strength matrix between all assets. Each asset is compared against every other asset using fractal analysis, creating a comprehensive strength map of the entire crypto market.
2. Hurst Exponent Integration
The system employs the Hurst Exponent to distinguish between:
Trending behavior (H > 0.5) - where momentum is likely to persist
Mean-reverting behavior (H < 0.5) - where reversals are likely
Random walk (H ≈ 0.5) - where no edge exists
This ensures the system only takes positions when mathematical evidence of persistence exists.
3. Dual-Layer Filtering Architecture
Combines two advanced filtering techniques:
Laguerre Polynomial Filters: Provides low-lag smoothing with minimal distortion
Kalman-like Adaptive Smoothing: Adjusts filter parameters based on market volatility
This dual approach preserves important price features while eliminating noise.
4. Market Regime Awareness
The system monitors overall crypto market conditions through multiple lenses and only operates when:
The broad crypto market shows positive technical structure
Sufficient trending behavior exists across major assets
Risk conditions are favorable
5. Rank-Based Selection with Trend Confirmation
Rather than simply choosing the top-ranked asset, the system requires:
High relative strength ranking
Positive individual trend confirmation
Alignment with market regime
This multi-factor approach reduces false signals and whipsaws.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🛡️ SYSTEM ROBUSTNESS & DEVELOPMENT METHODOLOGY
Pre-Coding Design Philosophy
This system was completely designed before any code was written . The mathematical framework, indicator selection, and parameter ranges were determined through:
Theoretical analysis of market microstructure
Study of persistence and mean reversion in crypto markets
Mathematical modeling of relative strength dynamics
Risk framework development based on regime theory
No Post-Optimization
Zero parameter fitting: All parameters remain at their originally designed values
No curve fitting: The system uses the same settings across all market conditions
No cherry-picking: Parameters were not adjusted after seeing results
This approach ensures the system captures genuine market dynamics rather than historical noise
Parameter Robustness Testing
Extensive testing was conducted to ensure stability:
Sensitivity Analysis: System maintains positive expectancy across wide parameter ranges
Walk-Forward Analysis: Consistent performance across different time periods
Regime Testing: Performs in both trending and choppy conditions
Out-of-Sample Validation
System was designed on a selection of 10 assets
System was tested on multiple baskets of 10 other random tokens, to simualte forwards testing
Performance remains consistent across baskets
No adjustments made based on out-of-sample results
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📈 PERFORMANCE METRICS DISPLAYED
The system provides real-time performance analytics:
Risk-Adjusted Returns:
Sharpe Ratio: Measures return per unit of total risk
Sortino Ratio: Measures return per unit of downside risk
Omega Ratio: Probability-weighted ratio of gains vs losses
Maximum Drawdown: Largest peak-to-trough decline
Benchmark Comparison:
Live comparison against Bitcoin buy-and-hold strategy
Both equity curves displayed with gradient effects
Performance metrics shown for both strategies
Visual representation of outperformance/underperformance
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔧 OPERATIONAL MECHANICS
Asset Universe:
The system analyzes 10 major cryptocurrencies, customizable through inputs:
Bitcoin (BTC)
Ethereum (ETH)
Solana (SOL)
XRP
BNB
Dogecoin (DOGE)
Cardano (ADA)
Chainlink (LINK)
Additional majors
Signal Generation Process:
Calculate relative strength matrix
Apply Hurst Exponent analysis to each ratio
Rank assets by aggregate relative strength
Confirm individual asset trend
Verify market regime conditions
Allocate to highest-ranking qualified asset
Position Management:
Single asset allocation (no diversification)
100% in strongest trending asset or 100% cash
Daily rebalancing at close
No leverage employed in base system
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 VISUAL INTERFACE
Information Dashboard:
System state indicator (ON/OFF)
Current allocation display
Real-time performance metrics
Sharpe, Sortino, Omega ratios
Maximum drawdown tracking
Net profit multiplier
Equity Curves:
Cyan curve: System performance with gradient glow effect
Magenta curve: Bitcoin HODL benchmark with gradient
Visual comparison of both strategies
Labels indicating current values
Alert System:
Alerts fire when allocation changes
Displays selected asset symbol
"CASH" alert when system goes defensive
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ IMPORTANT CONSIDERATIONS
Appropriate Use Cases:
Medium to long-term crypto allocation
Systematic approach to crypto investing
Risk-managed exposure to cryptocurrency markets
Alternative to buy-and-hold strategies
Limitations:
Daily rebalancing required
Not suitable for high-frequency trading
Requires liquid markets for all assets
Best suited for spot trading (no derivatives)
Risk Factors:
Cryptocurrency markets are highly volatile
Past performance does not guarantee future results
System can underperform in certain market conditions
Not financial advice - for educational purposes only
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎓 THEORETICAL FOUNDATION
The system is built on several academic principles:
1. Momentum Anomaly
Extensive research shows that assets exhibiting strong relative momentum tend to continue outperforming in the medium term (Jegadeesh & Titman, 1993).
2. Fractal Market Hypothesis
Markets exhibit fractal properties with periods of persistence and mean reversion (Peters, 1994). The Hurst Exponent quantifies these regimes.
3. Adaptive Market Hypothesis
Market efficiency varies over time, creating periods where momentum strategies excel (Lo, 2004).
4. Cross-Sectional Momentum
Relative strength strategies outperform time-series momentum in cryptocurrency markets due to the high correlation structure.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💡 USAGE GUIDELINES
Capital Requirements:
Suitable for any account size
No minimum capital requirement
Scales linearly with account size
Implementation:
Can be traded manually with daily signals
Suitable for automation via alerts
Works with any broker supporting crypto
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📝 FINAL NOTES
The Extended Majors Rotation System represents a systematic, mathematically-driven approach to cryptocurrency allocation. By combining relative strength analysis with fractal market theory and adaptive filtering, it aims to capture the persistent trends that characterize crypto bull markets while avoiding the drawdowns of buy-and-hold strategies.
The system's robustness comes not from optimization, but from sound mathematical principles applied consistently. Every component was chosen for its theoretical merit before any backtesting occurred, ensuring the system captures genuine market dynamics rather than historical artifacts.
"In the race between cryptocurrencies, bet on the horse that's already winning - but only while the track conditions favour racing."
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Developed by AlphaNatt | Quantitative Rotation Systems
Version: 1.0
Strategy Type: Momentum Rotation
Classification: Systematic Trend Following
Not financial advice. Always DYOR.
Market Order Risk CalculatorObviously the Long/Short Position tool does this, but when you are scalping, 10 - 15 seconds matters. What matters more than that is defined risk, you dont want your losses being scattered, 300 here 145 there, you want consistent risk to have consistent data.
What this does is when you are framing a trade, it provides a hands off tool that tells you exactly how many contracts to enter with, that way if you have bracket orders on, your stop will be exactly where you want it to be without going over your defined risk.
Risk Management Plan (Shares)What it does
This indicator displays a compact risk-management panel on the chart (middle-right). It helps you size positions, quantify risk in % and $, estimate shares to buy, and derive suggested stop/target prices from your chosen risk and R/R ratio. It also shows the % move from entry to stop/target and a “Max. Share Price (per system)” threshold derived from your accepted loss and R/R.
Why it’s useful
Many losses come from oversizing and inconsistent risk. This panel keeps the key numbers in one place—capital exposure, shares, stop/target math, and % distances—so your trade planning remains disciplined and repeatable.
Inputs
1. Capital Size ($)
2. Position Size (%)
3. Defined Risk (%) on capital
4. R/R Ratio (R:1) – enter R
5. Entry Price ($) (optional; if 0, the script uses close
Calculations (key formulas)
1. Position Size ($) = Capital × Position Size (%)
2. Shares to Buy = floor(Position Size ($) ÷ Entry Price)
3. Defined Risk ($) = Capital × Defined Risk (%)
4. Suggested Stop Price = (Position Size ($) − Defined Risk ($)) ÷ Shares
5. Suggested Target Price = (Position Size ($) + Defined Risk ($) × R) ÷ Shares
6. Entry → Stop (%) = (Entry − Stop) ÷ Entry × 100 (displayed negative)
7. Entry → Target (%) = (Target − Entry) ÷ Entry × 100
8. Max. Share Price (per system) = Position Size ($) × R ÷ |Defined Risk ($)|
How to use
1. Set Capital Size, Position Size (%), Defined Risk (%), and R/R.
2. Optionally set Entry Price (otherwise the script uses the chart’s close).
3. Read the panel: entry (blue), stop values (red), target values (green), risk (%) and ($) displayed negative for clarity.
4. Use Max. Share Price (per system) as a quick threshold check under your risk assumptions.
Note: If the Suggested Target or Suggested Stop is not aligned with your trading plan, adjust Position Size (%), R/R Ratio, and/or Defined Risk (%). The panel will update the levels accordingly so you can match your plan.
Notes & limitations
* Indicator only (no signals or strategy backtest).
* No lookahead/repainting; values depend on user inputs and current chart data.
* Educational use only; trading involves risk. Consider fees, slippage, and market conditions.
Version: v1.0 – Initial release (Pine Script v6)
