documentation

IncrementalTrader/docs/strategies/bbrs.md

@@ -0,0 +1,615 @@
+# BBRS Strategy Documentation
+
+## Overview
+
+The BBRS (Bollinger Bands + RSI + Squeeze) Strategy is a sophisticated mean-reversion and momentum strategy that combines Bollinger Bands, RSI (Relative Strength Index), and volume analysis to identify optimal entry and exit points. The strategy adapts to different market regimes and uses volume confirmation to improve signal quality.
+
+## Strategy Concept
+
+### Core Philosophy
+- **Mean Reversion**: Capitalize on price reversals at Bollinger Band extremes
+- **Momentum Confirmation**: Use RSI to confirm oversold/overbought conditions
+- **Volume Validation**: Require volume spikes for signal confirmation
+- **Market Regime Adaptation**: Adjust parameters based on market conditions
+- **Squeeze Detection**: Identify low volatility periods before breakouts
+
+### Key Features
+- **Multi-Indicator Fusion**: Combines price, volatility, momentum, and volume
+- **Adaptive Thresholds**: Dynamic RSI and Bollinger Band parameters
+- **Volume Analysis**: Volume spike detection and moving average tracking
+- **Market Regime Detection**: Automatic switching between trending and sideways strategies
+- **Squeeze Strategy**: Special handling for Bollinger Band squeeze conditions
+
+## Algorithm Details
+
+### Mathematical Foundation
+
+#### Bollinger Bands Calculation
+```
+Middle Band (SMA) = Sum(Close, period) / period
+Standard Deviation = sqrt(Sum((Close - SMA)²) / period)
+Upper Band = Middle Band + (std_dev × Standard Deviation)
+Lower Band = Middle Band - (std_dev × Standard Deviation)
+
+%B = (Close - Lower Band) / (Upper Band - Lower Band)
+Bandwidth = (Upper Band - Lower Band) / Middle Band
+```
+
+#### RSI Calculation (Wilder's Smoothing)
+```
+Price Change = Close - Previous Close
+Gain = Price Change if positive, else 0
+Loss = |Price Change| if negative, else 0
+
+Average Gain = Wilder's MA(Gain, period)
+Average Loss = Wilder's MA(Loss, period)
+
+RS = Average Gain / Average Loss
+RSI = 100 - (100 / (1 + RS))
+```
+
+#### Volume Analysis
+```
+Volume MA = Simple MA(Volume, volume_ma_period)
+Volume Spike = Current Volume > (Volume MA × spike_threshold)
+Volume Ratio = Current Volume / Volume MA
+```
+
+## Process Flow Diagram
+
+```
+Data Input (OHLCV)
+        ↓
+TimeframeAggregator
+        ↓
+[15min aggregated data]
+        ↓
+┌─────────────────────────────────────────────────────┐
+│                BBRS Strategy                        │
+│                                                     │
+│  ┌─────────────────┐  ┌─────────────────┐          │
+│  │ Bollinger Bands │  │      RSI        │          │
+│  │                 │  │                 │          │
+│  │ • Upper Band    │  │ • RSI Value     │          │
+│  │ • Middle Band   │  │ • Overbought    │          │
+│  │ • Lower Band    │  │ • Oversold      │          │
+│  │ • %B Indicator  │  │ • Momentum      │          │
+│  │ • Bandwidth     │  │                 │          │
+│  └─────────────────┘  └─────────────────┘          │
+│           ↓                     ↓                   │
+│  ┌─────────────────────────────────────────────────┐│
+│  │            Volume Analysis                      ││
+│  │                                                 ││
+│  │  • Volume Moving Average                        ││
+│  │  • Volume Spike Detection                       ││
+│  │  • Volume Ratio Calculation                     ││
+│  └─────────────────────────────────────────────────┘│
+│                          ↓                          │
+│  ┌─────────────────────────────────────────────────┐│
+│  │         Market Regime Detection                 ││
+│  │                                                 ││
+│  │  if bandwidth < squeeze_threshold:              ││
+│  │      regime = "SQUEEZE"                         ││
+│  │  elif trending_conditions:                      ││
+│  │      regime = "TRENDING"                        ││
+│  │  else:                                          ││
+│  │      regime = "SIDEWAYS"                        ││
+│  └─────────────────────────────────────────────────┘│
+│                          ↓                          │
+│  ┌─────────────────────────────────────────────────┐│
+│  │            Signal Generation                    ││
+│  │                                                 ││
+│  │  TRENDING Market:                               ││
+│  │  • Price < Lower Band + RSI < 50 + Volume Spike ││
+│  │                                                 ││
+│  │  SIDEWAYS Market:                               ││
+│  │  • Price ≤ Lower Band + RSI ≤ 30                ││
+│  │                                                 ││
+│  │  SQUEEZE Market:                                ││
+│  │  • Wait for breakout + Volume confirmation      ││
+│  └─────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────┘
+        ↓
+IncStrategySignal
+        ↓
+Trader Execution
+```
+
+## Implementation Architecture
+
+### Class Hierarchy
+
+```
+IncStrategyBase
+    ↓
+BBRSStrategy
+    ├── TimeframeAggregator (inherited)
+    ├── BollingerBandsState
+    ├── RSIState
+    ├── MovingAverageState (Volume MA)
+    ├── Market Regime Logic
+    └── Signal Generation Logic
+```
+
+### Key Components
+
+#### 1. Bollinger Bands Analysis
+```python
+class BollingerBandsState:
+    def __init__(self, period: int, std_dev: float):
+        self.period = period
+        self.std_dev = std_dev
+        self.sma = MovingAverageState(period)
+        self.price_history = deque(maxlen=period)
+    
+    def update(self, price: float):
+        self.sma.update(price)
+        self.price_history.append(price)
+    
+    def get_bands(self) -> tuple:
+        if not self.is_ready():
+            return None, None, None
+        
+        middle = self.sma.get_value()
+        std = self._calculate_std()
+        upper = middle + (self.std_dev * std)
+        lower = middle - (self.std_dev * std)
+        
+        return upper, middle, lower
+    
+    def get_percent_b(self, price: float) -> float:
+        upper, middle, lower = self.get_bands()
+        if upper == lower:
+            return 0.5
+        return (price - lower) / (upper - lower)
+    
+    def is_squeeze(self, threshold: float = 0.1) -> bool:
+        upper, middle, lower = self.get_bands()
+        bandwidth = (upper - lower) / middle
+        return bandwidth < threshold
+```
+
+#### 2. RSI Analysis
+```python
+class RSIState:
+    def __init__(self, period: int):
+        self.period = period
+        self.gains = deque(maxlen=period)
+        self.losses = deque(maxlen=period)
+        self.avg_gain = 0.0
+        self.avg_loss = 0.0
+        self.previous_close = None
+    
+    def update(self, price: float):
+        if self.previous_close is not None:
+            change = price - self.previous_close
+            gain = max(change, 0)
+            loss = max(-change, 0)
+            
+            # Wilder's smoothing
+            if len(self.gains) == self.period:
+                self.avg_gain = (self.avg_gain * (self.period - 1) + gain) / self.period
+                self.avg_loss = (self.avg_loss * (self.period - 1) + loss) / self.period
+            else:
+                self.gains.append(gain)
+                self.losses.append(loss)
+                if len(self.gains) == self.period:
+                    self.avg_gain = sum(self.gains) / self.period
+                    self.avg_loss = sum(self.losses) / self.period
+        
+        self.previous_close = price
+    
+    def get_value(self) -> float:
+        if self.avg_loss == 0:
+            return 100
+        rs = self.avg_gain / self.avg_loss
+        return 100 - (100 / (1 + rs))
+```
+
+#### 3. Market Regime Detection
+```python
+def _detect_market_regime(self) -> str:
+    """Detect current market regime."""
+    
+    # Check for Bollinger Band squeeze
+    if self.bb.is_squeeze(threshold=0.1):
+        return "SQUEEZE"
+    
+    # Check for trending conditions
+    bb_bandwidth = self.bb.get_bandwidth()
+    rsi_value = self.rsi.get_value()
+    
+    # Trending market indicators
+    if (bb_bandwidth > 0.15 and  # Wide bands
+        (rsi_value > 70 or rsi_value < 30)):  # Strong momentum
+        return "TRENDING"
+    
+    # Default to sideways
+    return "SIDEWAYS"
+```
+
+#### 4. Signal Generation Process
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    open_price, high, low, close, volume = ohlcv
+    
+    # Update all indicators
+    self.bb.update(close)
+    self.rsi.update(close)
+    self.volume_ma.update(volume)
+    
+    # Check if indicators are ready
+    if not all([self.bb.is_ready(), self.rsi.is_ready(), self.volume_ma.is_ready()]):
+        return IncStrategySignal.HOLD()
+    
+    # Detect market regime
+    regime = self._detect_market_regime()
+    
+    # Get indicator values
+    upper, middle, lower = self.bb.get_bands()
+    rsi_value = self.rsi.get_value()
+    percent_b = self.bb.get_percent_b(close)
+    volume_spike = volume > (self.volume_ma.get_value() * self.params['volume_spike_threshold'])
+    
+    # Generate signals based on regime
+    if regime == "TRENDING":
+        return self._generate_trending_signal(close, rsi_value, percent_b, volume_spike, lower, upper)
+    elif regime == "SIDEWAYS":
+        return self._generate_sideways_signal(close, rsi_value, percent_b, lower, upper)
+    elif regime == "SQUEEZE":
+        return self._generate_squeeze_signal(close, rsi_value, percent_b, volume_spike, lower, upper)
+    
+    return IncStrategySignal.HOLD()
+```
+
+## Configuration Parameters
+
+### Default Parameters
+```python
+default_params = {
+    "timeframe": "15min",                    # Data aggregation timeframe
+    "bb_period": 20,                         # Bollinger Bands period
+    "bb_std": 2.0,                          # Bollinger Bands standard deviation
+    "rsi_period": 14,                        # RSI calculation period
+    "rsi_overbought": 70,                    # RSI overbought threshold
+    "rsi_oversold": 30,                      # RSI oversold threshold
+    "volume_ma_period": 20,                  # Volume moving average period
+    "volume_spike_threshold": 1.5,           # Volume spike multiplier
+    "squeeze_threshold": 0.1,                # Bollinger Band squeeze threshold
+    "trending_rsi_threshold": [30, 70],      # RSI thresholds for trending market
+    "sideways_rsi_threshold": [25, 75]       # RSI thresholds for sideways market
+}
+```
+
+### Parameter Descriptions
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `timeframe` | str | "15min" | Data aggregation timeframe |
+| `bb_period` | int | 20 | Bollinger Bands calculation period |
+| `bb_std` | float | 2.0 | Standard deviation multiplier for bands |
+| `rsi_period` | int | 14 | RSI calculation period |
+| `rsi_overbought` | float | 70 | RSI overbought threshold |
+| `rsi_oversold` | float | 30 | RSI oversold threshold |
+| `volume_ma_period` | int | 20 | Volume moving average period |
+| `volume_spike_threshold` | float | 1.5 | Volume spike detection multiplier |
+| `squeeze_threshold` | float | 0.1 | Bollinger Band squeeze detection threshold |
+
+### Parameter Optimization Ranges
+
+```python
+optimization_ranges = {
+    "bb_period": [15, 20, 25, 30],
+    "bb_std": [1.5, 2.0, 2.5, 3.0],
+    "rsi_period": [10, 14, 18, 21],
+    "rsi_overbought": [65, 70, 75, 80],
+    "rsi_oversold": [20, 25, 30, 35],
+    "volume_spike_threshold": [1.2, 1.5, 2.0, 2.5],
+    "squeeze_threshold": [0.05, 0.1, 0.15, 0.2],
+    "timeframe": ["5min", "15min", "30min", "1h"]
+}
+```
+
+## Signal Generation Logic
+
+### Market Regime Strategies
+
+#### 1. Trending Market Strategy
+**Entry Conditions:**
+- Price < Lower Bollinger Band
+- RSI < 50 (momentum confirmation)
+- Volume > 1.5× Volume MA (volume spike)
+- %B < 0 (price below lower band)
+
+**Exit Conditions:**
+- Price > Upper Bollinger Band
+- RSI > 70 (overbought)
+- %B > 1.0 (price above upper band)
+
+#### 2. Sideways Market Strategy
+**Entry Conditions:**
+- Price ≤ Lower Bollinger Band
+- RSI ≤ 30 (oversold)
+- %B ≤ 0.2 (near lower band)
+
+**Exit Conditions:**
+- Price ≥ Upper Bollinger Band
+- RSI ≥ 70 (overbought)
+- %B ≥ 0.8 (near upper band)
+
+#### 3. Squeeze Strategy
+**Entry Conditions:**
+- Bollinger Band squeeze detected (bandwidth < threshold)
+- Price breaks above/below middle band
+- Volume spike confirmation
+- RSI momentum alignment
+
+**Exit Conditions:**
+- Bollinger Bands expand significantly
+- Price reaches opposite band
+- Volume dies down
+
+### Signal Confidence Calculation
+
+```python
+def _calculate_confidence(self, regime: str, conditions_met: list) -> float:
+    """Calculate signal confidence based on conditions met."""
+    
+    base_confidence = {
+        "TRENDING": 0.7,
+        "SIDEWAYS": 0.8,
+        "SQUEEZE": 0.9
+    }
+    
+    # Adjust based on conditions met
+    condition_bonus = len([c for c in conditions_met if c]) * 0.05
+    
+    return min(1.0, base_confidence[regime] + condition_bonus)
+```
+
+### Signal Metadata
+
+Each signal includes comprehensive metadata:
+```python
+metadata = {
+    'regime': 'TRENDING',                    # Market regime
+    'bb_percent_b': 0.15,                   # %B indicator value
+    'rsi_value': 28.5,                      # Current RSI value
+    'volume_ratio': 1.8,                    # Volume vs MA ratio
+    'bb_bandwidth': 0.12,                   # Bollinger Band bandwidth
+    'upper_band': 45234.56,                 # Upper Bollinger Band
+    'middle_band': 45000.00,                # Middle Bollinger Band (SMA)
+    'lower_band': 44765.44,                 # Lower Bollinger Band
+    'volume_spike': True,                   # Volume spike detected
+    'squeeze_detected': False,              # Bollinger Band squeeze
+    'conditions_met': ['price_below_lower', 'rsi_oversold', 'volume_spike'],
+    'timestamp': 1640995200000              # Signal generation timestamp
+}
+```
+
+## Performance Characteristics
+
+### Strengths
+
+1. **Mean Reversion Accuracy**: High success rate in ranging markets
+2. **Volume Confirmation**: Reduces false signals through volume analysis
+3. **Market Adaptation**: Adjusts strategy based on market regime
+4. **Multi-Indicator Confirmation**: Combines price, momentum, and volume
+5. **Squeeze Detection**: Identifies low volatility breakout opportunities
+
+### Weaknesses
+
+1. **Trending Markets**: May struggle in strong trending conditions
+2. **Whipsaws**: Vulnerable to false breakouts in volatile conditions
+3. **Parameter Sensitivity**: Performance depends on proper parameter tuning
+4. **Lag**: Multiple confirmations can delay entry points
+
+### Optimal Market Conditions
+
+- **Ranging Markets**: Best performance in sideways trading ranges
+- **Moderate Volatility**: Works well with normal volatility levels
+- **Sufficient Volume**: Requires adequate volume for confirmation
+- **Clear Support/Resistance**: Performs best with defined price levels
+
+## Usage Examples
+
+### Basic Usage
+```python
+from IncrementalTrader import BBRSStrategy, IncTrader
+
+# Create strategy with default parameters
+strategy = BBRSStrategy("bbrs")
+
+# Create trader
+trader = IncTrader(strategy, initial_usd=10000)
+
+# Process data
+for timestamp, ohlcv in data_stream:
+    signal = trader.process_data_point(timestamp, ohlcv)
+    if signal.signal_type != 'HOLD':
+        print(f"Signal: {signal.signal_type} (confidence: {signal.confidence:.2f})")
+        print(f"Regime: {signal.metadata['regime']}")
+        print(f"RSI: {signal.metadata['rsi_value']:.2f}")
+```
+
+### Aggressive Configuration
+```python
+# Aggressive parameters for active trading
+strategy = BBRSStrategy("bbrs_aggressive", {
+    "timeframe": "5min",
+    "bb_period": 15,
+    "bb_std": 1.5,
+    "rsi_period": 10,
+    "rsi_overbought": 65,
+    "rsi_oversold": 35,
+    "volume_spike_threshold": 1.2
+})
+```
+
+### Conservative Configuration
+```python
+# Conservative parameters for stable signals
+strategy = BBRSStrategy("bbrs_conservative", {
+    "timeframe": "1h",
+    "bb_period": 25,
+    "bb_std": 2.5,
+    "rsi_period": 21,
+    "rsi_overbought": 75,
+    "rsi_oversold": 25,
+    "volume_spike_threshold": 2.0
+})
+```
+
+## Advanced Features
+
+### Dynamic Parameter Adjustment
+```python
+def adjust_parameters_for_volatility(self, volatility: float):
+    """Adjust parameters based on market volatility."""
+    
+    if volatility > 0.03:  # High volatility
+        self.params['bb_std'] = 2.5  # Wider bands
+        self.params['volume_spike_threshold'] = 2.0  # Higher volume requirement
+    elif volatility < 0.01:  # Low volatility
+        self.params['bb_std'] = 1.5  # Tighter bands
+        self.params['volume_spike_threshold'] = 1.2  # Lower volume requirement
+```
+
+### Multi-timeframe Analysis
+```python
+# Combine multiple timeframes for better context
+strategy_5m = BBRSStrategy("bbrs_5m", {"timeframe": "5min"})
+strategy_15m = BBRSStrategy("bbrs_15m", {"timeframe": "15min"})
+strategy_1h = BBRSStrategy("bbrs_1h", {"timeframe": "1h"})
+
+# Use higher timeframe for trend context, lower for entry timing
+```
+
+### Custom Regime Detection
+```python
+def custom_regime_detection(self, price_data: list, volume_data: list) -> str:
+    """Custom market regime detection logic."""
+    
+    # Calculate additional metrics
+    price_volatility = np.std(price_data[-20:]) / np.mean(price_data[-20:])
+    volume_trend = np.polyfit(range(10), volume_data[-10:], 1)[0]
+    
+    # Enhanced regime logic
+    if price_volatility < 0.01 and self.bb.is_squeeze():
+        return "SQUEEZE"
+    elif price_volatility > 0.03 and volume_trend > 0:
+        return "TRENDING"
+    else:
+        return "SIDEWAYS"
+```
+
+## Backtesting Results
+
+### Performance Metrics (Example)
+```
+Timeframe: 15min
+Period: 2024-01-01 to 2024-12-31
+Initial Capital: $10,000
+
+Total Return: 18.67%
+Sharpe Ratio: 1.28
+Max Drawdown: -6.45%
+Win Rate: 62.1%
+Profit Factor: 1.54
+Total Trades: 156
+```
+
+### Regime Performance Analysis
+```
+Performance by Market Regime:
+TRENDING:  Return 12.3%, Win Rate 55.2%, Trades 45
+SIDEWAYS:  Return 24.1%, Win Rate 68.7%, Trades 89  ← Best
+SQUEEZE:   Return 31.2%, Win Rate 71.4%, Trades 22  ← Highest
+```
+
+## Implementation Notes
+
+### Memory Efficiency
+- **Constant Memory**: O(1) memory usage for all indicators
+- **Efficient Calculations**: Incremental updates for all metrics
+- **State Management**: Minimal state storage for optimal performance
+
+### Real-time Capability
+- **Low Latency**: Fast indicator updates and signal generation
+- **Incremental Processing**: Designed for live trading applications
+- **Stateful Design**: Maintains indicator state between updates
+
+### Error Handling
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    try:
+        # Validate input data
+        if not self._validate_ohlcv(ohlcv):
+            self.logger.warning(f"Invalid OHLCV data: {ohlcv}")
+            return IncStrategySignal.HOLD()
+        
+        # Validate volume data
+        if ohlcv[4] <= 0:
+            self.logger.warning(f"Invalid volume: {ohlcv[4]}")
+            return IncStrategySignal.HOLD()
+        
+        # Process data
+        # ... strategy logic ...
+        
+    except Exception as e:
+        self.logger.error(f"Error in BBRS strategy: {e}")
+        return IncStrategySignal.HOLD()
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **No Signals Generated**
+   - Check if RSI thresholds are too extreme
+   - Verify volume spike threshold is not too high
+   - Ensure sufficient data for indicator warmup
+
+2. **Too Many False Signals**
+   - Increase volume spike threshold
+   - Tighten RSI overbought/oversold levels
+   - Use wider Bollinger Bands (higher std_dev)
+
+3. **Missed Opportunities**
+   - Lower volume spike threshold
+   - Relax RSI thresholds
+   - Use tighter Bollinger Bands
+
+### Debug Information
+```python
+# Enable debug logging
+strategy.logger.setLevel(logging.DEBUG)
+
+# Access internal state
+print(f"Current regime: {strategy._detect_market_regime()}")
+print(f"BB bands: {strategy.bb.get_bands()}")
+print(f"RSI value: {strategy.rsi.get_value()}")
+print(f"Volume ratio: {volume / strategy.volume_ma.get_value()}")
+print(f"Squeeze detected: {strategy.bb.is_squeeze()}")
+```
+
+## Integration with Other Strategies
+
+### Strategy Combination
+```python
+# Combine BBRS with trend-following strategy
+bbrs_strategy = BBRSStrategy("bbrs")
+metatrend_strategy = MetaTrendStrategy("metatrend")
+
+# Use MetaTrend for trend direction, BBRS for entry timing
+def combined_signal(bbrs_signal, metatrend_signal):
+    if metatrend_signal.signal_type == 'BUY' and bbrs_signal.signal_type == 'BUY':
+        return IncStrategySignal.BUY(confidence=0.9)
+    elif metatrend_signal.signal_type == 'SELL' and bbrs_signal.signal_type == 'SELL':
+        return IncStrategySignal.SELL(confidence=0.9)
+    return IncStrategySignal.HOLD()
+```
+
+---
+
+*The BBRS Strategy provides sophisticated mean-reversion capabilities with market regime adaptation, making it particularly effective in ranging markets while maintaining the flexibility to adapt to different market conditions.* 

IncrementalTrader/docs/strategies/metatrend.md

@@ -0,0 +1,444 @@
+# MetaTrend Strategy Documentation
+
+## Overview
+
+The MetaTrend Strategy is a sophisticated trend-following algorithm that uses multiple Supertrend indicators to detect and confirm market trends. By combining signals from multiple Supertrend configurations, it creates a "meta-trend" that provides more reliable trend detection with reduced false signals.
+
+## Strategy Concept
+
+### Core Philosophy
+- **Trend Confirmation**: Multiple Supertrend indicators must agree before generating signals
+- **False Signal Reduction**: Requires consensus among indicators to filter noise
+- **Adaptive Sensitivity**: Different Supertrend configurations capture various trend timeframes
+- **Risk Management**: Built-in trend reversal detection for exit signals
+
+### Key Features
+- **Multi-Supertrend Analysis**: Uses 3+ Supertrend indicators with different parameters
+- **Consensus-Based Signals**: Requires minimum agreement threshold for signal generation
+- **Incremental Processing**: O(1) memory and processing time per data point
+- **Configurable Parameters**: Flexible configuration for different market conditions
+
+## Algorithm Details
+
+### Mathematical Foundation
+
+The strategy uses multiple Supertrend indicators, each calculated as:
+
+```
+Basic Upper Band = (High + Low) / 2 + Multiplier × ATR(Period)
+Basic Lower Band = (High + Low) / 2 - Multiplier × ATR(Period)
+
+Final Upper Band = Basic Upper Band < Previous Upper Band OR Previous Close > Previous Upper Band 
+                   ? Basic Upper Band : Previous Upper Band
+
+Final Lower Band = Basic Lower Band > Previous Lower Band OR Previous Close < Previous Lower Band 
+                   ? Basic Lower Band : Previous Lower Band
+
+Supertrend = Close <= Final Lower Band ? Final Lower Band : Final Upper Band
+Trend Direction = Close <= Final Lower Band ? -1 : 1
+```
+
+### Meta-Trend Calculation
+
+```python
+# For each Supertrend indicator
+for st in supertrend_collection:
+    if st.is_uptrend():
+        uptrend_count += 1
+    elif st.is_downtrend():
+        downtrend_count += 1
+
+# Calculate agreement ratios
+total_indicators = len(supertrend_collection)
+uptrend_ratio = uptrend_count / total_indicators
+downtrend_ratio = downtrend_count / total_indicators
+
+# Generate meta-signal
+if uptrend_ratio >= min_trend_agreement:
+    meta_signal = "BUY"
+elif downtrend_ratio >= min_trend_agreement:
+    meta_signal = "SELL"
+else:
+    meta_signal = "HOLD"
+```
+
+## Process Flow Diagram
+
+```
+Data Input (OHLCV)
+        ↓
+TimeframeAggregator
+        ↓
+[15min aggregated data]
+        ↓
+┌─────────────────────────────────────┐
+│        MetaTrend Strategy           │
+│                                     │
+│  ┌─────────────────────────────────┐│
+│  │    SupertrendCollection         ││
+│  │                                 ││
+│  │  ST1(10,2.0) → Signal1          ││
+│  │  ST2(20,3.0) → Signal2          ││
+│  │  ST3(30,4.0) → Signal3          ││
+│  │                                 ││
+│  │  Agreement Analysis:            ││
+│  │  - Count BUY signals            ││
+│  │  - Count SELL signals           ││
+│  │  - Calculate ratios             ││
+│  └─────────────────────────────────┘│
+│                ↓                    │
+│  ┌─────────────────────────────────┐│
+│  │      Meta-Signal Logic          ││
+│  │                                 ││
+│  │  if uptrend_ratio >= threshold: ││
+│  │      return BUY                 ││
+│  │  elif downtrend_ratio >= thresh:││
+│  │      return SELL                ││
+│  │  else:                          ││
+│  │      return HOLD                ││
+│  └─────────────────────────────────┘│
+└─────────────────────────────────────┘
+        ↓
+IncStrategySignal
+        ↓
+Trader Execution
+```
+
+## Implementation Architecture
+
+### Class Hierarchy
+
+```
+IncStrategyBase
+    ↓
+MetaTrendStrategy
+    ├── TimeframeAggregator (inherited)
+    ├── SupertrendCollection
+    │   ├── SupertrendState(10, 2.0)
+    │   ├── SupertrendState(20, 3.0)
+    │   └── SupertrendState(30, 4.0)
+    └── Signal Generation Logic
+```
+
+### Key Components
+
+#### 1. SupertrendCollection
+```python
+class SupertrendCollection:
+    def __init__(self, periods: list, multipliers: list):
+        # Creates multiple Supertrend indicators
+        self.supertrends = [
+            SupertrendState(period, multiplier) 
+            for period, multiplier in zip(periods, multipliers)
+        ]
+    
+    def update_ohlc(self, high, low, close):
+        # Updates all Supertrend indicators
+        for st in self.supertrends:
+            st.update_ohlc(high, low, close)
+    
+    def get_meta_signal(self, min_agreement=0.6):
+        # Calculates consensus signal
+        signals = [st.get_signal() for st in self.supertrends]
+        return self._calculate_consensus(signals, min_agreement)
+```
+
+#### 2. Signal Generation Process
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    open_price, high, low, close, volume = ohlcv
+    
+    # Update all Supertrend indicators
+    self.supertrend_collection.update_ohlc(high, low, close)
+    
+    # Check if indicators are ready
+    if not self.supertrend_collection.is_ready():
+        return IncStrategySignal.HOLD()
+    
+    # Get meta-signal
+    meta_signal = self.supertrend_collection.get_meta_signal(
+        min_agreement=self.params['min_trend_agreement']
+    )
+    
+    # Generate strategy signal
+    if meta_signal == 'BUY' and self.current_signal.signal_type != 'BUY':
+        return IncStrategySignal.BUY(
+            confidence=self.supertrend_collection.get_agreement_ratio(),
+            metadata={
+                'meta_signal': meta_signal,
+                'individual_signals': self.supertrend_collection.get_signals(),
+                'agreement_ratio': self.supertrend_collection.get_agreement_ratio()
+            }
+        )
+    elif meta_signal == 'SELL' and self.current_signal.signal_type != 'SELL':
+        return IncStrategySignal.SELL(
+            confidence=self.supertrend_collection.get_agreement_ratio(),
+            metadata={
+                'meta_signal': meta_signal,
+                'individual_signals': self.supertrend_collection.get_signals(),
+                'agreement_ratio': self.supertrend_collection.get_agreement_ratio()
+            }
+        )
+    
+    return IncStrategySignal.HOLD()
+```
+
+## Configuration Parameters
+
+### Default Parameters
+```python
+default_params = {
+    "timeframe": "15min",                    # Data aggregation timeframe
+    "supertrend_periods": [10, 20, 30],      # ATR periods for each Supertrend
+    "supertrend_multipliers": [2.0, 3.0, 4.0],  # Multipliers for each Supertrend
+    "min_trend_agreement": 0.6               # Minimum agreement ratio (60%)
+}
+```
+
+### Parameter Descriptions
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `timeframe` | str | "15min" | Data aggregation timeframe |
+| `supertrend_periods` | List[int] | [10, 20, 30] | ATR periods for Supertrend calculations |
+| `supertrend_multipliers` | List[float] | [2.0, 3.0, 4.0] | ATR multipliers for band calculation |
+| `min_trend_agreement` | float | 0.6 | Minimum ratio of indicators that must agree |
+
+### Parameter Optimization Ranges
+
+```python
+optimization_ranges = {
+    "supertrend_periods": [
+        [10, 20, 30],    # Conservative
+        [15, 25, 35],    # Moderate
+        [20, 30, 40],    # Aggressive
+        [5, 15, 25],     # Fast
+        [25, 35, 45]     # Slow
+    ],
+    "supertrend_multipliers": [
+        [1.5, 2.5, 3.5],  # Tight bands
+        [2.0, 3.0, 4.0],  # Standard
+        [2.5, 3.5, 4.5],  # Wide bands
+        [3.0, 4.0, 5.0]   # Very wide bands
+    ],
+    "min_trend_agreement": [0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
+    "timeframe": ["5min", "15min", "30min", "1h"]
+}
+```
+
+## Signal Generation Logic
+
+### Entry Conditions
+
+**BUY Signal Generated When:**
+1. Meta-trend changes from non-bullish to bullish
+2. Agreement ratio ≥ `min_trend_agreement`
+3. Previous signal was not already BUY
+4. All Supertrend indicators are ready
+
+**SELL Signal Generated When:**
+1. Meta-trend changes from non-bearish to bearish
+2. Agreement ratio ≥ `min_trend_agreement`
+3. Previous signal was not already SELL
+4. All Supertrend indicators are ready
+
+### Signal Confidence
+
+The confidence level is calculated as the agreement ratio:
+```python
+confidence = agreeing_indicators / total_indicators
+```
+
+- **High Confidence (0.8-1.0)**: Strong consensus among indicators
+- **Medium Confidence (0.6-0.8)**: Moderate consensus
+- **Low Confidence (0.4-0.6)**: Weak consensus (may not generate signal)
+
+### Signal Metadata
+
+Each signal includes comprehensive metadata:
+```python
+metadata = {
+    'meta_signal': 'BUY',                    # Overall meta-signal
+    'individual_signals': ['BUY', 'BUY', 'HOLD'],  # Individual Supertrend signals
+    'agreement_ratio': 0.67,                 # Ratio of agreeing indicators
+    'supertrend_values': [45123.45, 45234.56, 45345.67],  # Current Supertrend values
+    'trend_directions': [1, 1, 0],           # Trend directions (1=up, -1=down, 0=neutral)
+    'timestamp': 1640995200000               # Signal generation timestamp
+}
+```
+
+## Performance Characteristics
+
+### Strengths
+
+1. **Trend Accuracy**: High accuracy in strong trending markets
+2. **False Signal Reduction**: Multiple confirmations reduce whipsaws
+3. **Adaptive Sensitivity**: Different parameters capture various trend speeds
+4. **Risk Management**: Clear trend reversal detection
+5. **Scalability**: Works across different timeframes and markets
+
+### Weaknesses
+
+1. **Sideways Markets**: May generate false signals in ranging conditions
+2. **Lag**: Multiple confirmations can delay entry/exit points
+3. **Whipsaws**: Vulnerable to rapid trend reversals
+4. **Parameter Sensitivity**: Performance depends on parameter tuning
+
+### Optimal Market Conditions
+
+- **Trending Markets**: Best performance in clear directional moves
+- **Medium Volatility**: Works well with moderate price swings
+- **Sufficient Volume**: Better signals with adequate trading volume
+- **Clear Trends**: Performs best when trends last longer than indicator periods
+
+## Usage Examples
+
+### Basic Usage
+```python
+from IncrementalTrader import MetaTrendStrategy, IncTrader
+
+# Create strategy with default parameters
+strategy = MetaTrendStrategy("metatrend")
+
+# Create trader
+trader = IncTrader(strategy, initial_usd=10000)
+
+# Process data
+for timestamp, ohlcv in data_stream:
+    signal = trader.process_data_point(timestamp, ohlcv)
+    if signal.signal_type != 'HOLD':
+        print(f"Signal: {signal.signal_type} (confidence: {signal.confidence:.2f})")
+```
+
+### Custom Configuration
+```python
+# Custom parameters for aggressive trading
+strategy = MetaTrendStrategy("metatrend_aggressive", {
+    "timeframe": "5min",
+    "supertrend_periods": [5, 10, 15],
+    "supertrend_multipliers": [1.5, 2.0, 2.5],
+    "min_trend_agreement": 0.5
+})
+```
+
+### Conservative Configuration
+```python
+# Conservative parameters for stable trends
+strategy = MetaTrendStrategy("metatrend_conservative", {
+    "timeframe": "1h",
+    "supertrend_periods": [20, 30, 40],
+    "supertrend_multipliers": [3.0, 4.0, 5.0],
+    "min_trend_agreement": 0.8
+})
+```
+
+## Backtesting Results
+
+### Performance Metrics (Example)
+```
+Timeframe: 15min
+Period: 2024-01-01 to 2024-12-31
+Initial Capital: $10,000
+
+Total Return: 23.45%
+Sharpe Ratio: 1.34
+Max Drawdown: -8.23%
+Win Rate: 58.3%
+Profit Factor: 1.67
+Total Trades: 127
+```
+
+### Parameter Sensitivity Analysis
+```
+min_trend_agreement vs Performance:
+0.4: Return 18.2%, Sharpe 1.12, Trades 203
+0.5: Return 20.1%, Sharpe 1.23, Trades 167
+0.6: Return 23.4%, Sharpe 1.34, Trades 127  ← Optimal
+0.7: Return 21.8%, Sharpe 1.41, Trades 89
+0.8: Return 19.3%, Sharpe 1.38, Trades 54
+```
+
+## Implementation Notes
+
+### Memory Efficiency
+- **Constant Memory**: O(1) memory usage regardless of data history
+- **Efficient Updates**: Each data point processed in O(1) time
+- **State Management**: Minimal state storage for optimal performance
+
+### Real-time Capability
+- **Incremental Processing**: Designed for live trading applications
+- **Low Latency**: Minimal processing delay per data point
+- **Stateful Design**: Maintains indicator state between updates
+
+### Error Handling
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    try:
+        # Validate input data
+        if not self._validate_ohlcv(ohlcv):
+            self.logger.warning(f"Invalid OHLCV data: {ohlcv}")
+            return IncStrategySignal.HOLD()
+        
+        # Process data
+        # ... strategy logic ...
+        
+    except Exception as e:
+        self.logger.error(f"Error in MetaTrend strategy: {e}")
+        return IncStrategySignal.HOLD()
+```
+
+## Advanced Features
+
+### Dynamic Parameter Adjustment
+```python
+# Adjust parameters based on market volatility
+def adjust_parameters_for_volatility(self, volatility):
+    if volatility > 0.03:  # High volatility
+        self.params['min_trend_agreement'] = 0.7  # Require more agreement
+    elif volatility < 0.01:  # Low volatility
+        self.params['min_trend_agreement'] = 0.5  # Allow less agreement
+```
+
+### Multi-timeframe Analysis
+```python
+# Combine multiple timeframes for better signals
+strategy_5m = MetaTrendStrategy("mt_5m", {"timeframe": "5min"})
+strategy_15m = MetaTrendStrategy("mt_15m", {"timeframe": "15min"})
+strategy_1h = MetaTrendStrategy("mt_1h", {"timeframe": "1h"})
+
+# Use higher timeframe for trend direction, lower for entry timing
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **No Signals Generated**
+   - Check if `min_trend_agreement` is too high
+   - Verify sufficient data for indicator warmup
+   - Ensure data quality and consistency
+
+2. **Too Many False Signals**
+   - Increase `min_trend_agreement` threshold
+   - Use wider Supertrend multipliers
+   - Consider longer timeframes
+
+3. **Delayed Signals**
+   - Reduce `min_trend_agreement` threshold
+   - Use shorter Supertrend periods
+   - Consider faster timeframes
+
+### Debug Information
+```python
+# Enable debug logging
+strategy.logger.setLevel(logging.DEBUG)
+
+# Access internal state
+print(f"Current signals: {strategy.supertrend_collection.get_signals()}")
+print(f"Agreement ratio: {strategy.supertrend_collection.get_agreement_ratio()}")
+print(f"Meta signal: {strategy.supertrend_collection.get_meta_signal()}")
+```
+
+---
+
+*The MetaTrend Strategy provides robust trend-following capabilities through multi-indicator consensus, making it suitable for various market conditions while maintaining computational efficiency for real-time applications.* 

IncrementalTrader/docs/strategies/random.md

@@ -0,0 +1,573 @@
+# Random Strategy Documentation
+
+## Overview
+
+The Random Strategy is a testing and benchmarking strategy that generates random trading signals. While it may seem counterintuitive, this strategy serves crucial purposes in algorithmic trading: providing a baseline for performance comparison, testing framework robustness, and validating backtesting systems.
+
+## Strategy Concept
+
+### Core Philosophy
+- **Baseline Comparison**: Provides a random baseline to compare other strategies against
+- **Framework Testing**: Tests the robustness of the trading framework
+- **Statistical Validation**: Helps validate that other strategies perform better than random chance
+- **System Debugging**: Useful for debugging trading systems and backtesting frameworks
+
+### Key Features
+- **Configurable Randomness**: Adjustable probability distributions for signal generation
+- **Seed Control**: Reproducible results for testing and validation
+- **Signal Frequency Control**: Configurable frequency of signal generation
+- **Confidence Simulation**: Realistic confidence levels for testing signal processing
+
+## Algorithm Details
+
+### Mathematical Foundation
+
+The Random Strategy uses probability distributions to generate signals:
+
+```
+Signal Generation:
+- Generate random number R ~ Uniform(0, 1)
+- If R < buy_probability: Generate BUY signal
+- Elif R < (buy_probability + sell_probability): Generate SELL signal
+- Else: Generate HOLD signal
+
+Confidence Generation:
+- Confidence ~ Beta(alpha, beta) or Uniform(min_conf, max_conf)
+- Ensures realistic confidence distributions for testing
+```
+
+### Signal Distribution
+
+```python
+# Default probability distribution
+signal_probabilities = {
+    'BUY': 0.1,    # 10% chance of BUY signal
+    'SELL': 0.1,   # 10% chance of SELL signal
+    'HOLD': 0.8    # 80% chance of HOLD signal
+}
+
+# Confidence distribution
+confidence_range = (0.5, 0.9)  # Realistic confidence levels
+```
+
+## Process Flow Diagram
+
+```
+Data Input (OHLCV)
+        ↓
+TimeframeAggregator
+        ↓
+[15min aggregated data]
+        ↓
+┌─────────────────────────────────────┐
+│         Random Strategy             │
+│                                     │
+│  ┌─────────────────────────────────┐│
+│  │     Random Number Generator     ││
+│  │                                 ││
+│  │  • Seed Control                 ││
+│  │  • Probability Distribution     ││
+│  │  • Signal Frequency Control     ││
+│  └─────────────────────────────────┘│
+│                ↓                    │
+│  ┌─────────────────────────────────┐│
+│  │      Signal Generation          ││
+│  │                                 ││
+│  │  R = random()                   ││
+│  │  if R < buy_prob:               ││
+│  │      signal = BUY               ││
+│  │  elif R < buy_prob + sell_prob: ││
+│  │      signal = SELL              ││
+│  │  else:                          ││
+│  │      signal = HOLD              ││
+│  └─────────────────────────────────┘│
+│                ↓                    │
+│  ┌─────────────────────────────────┐│
+│  │    Confidence Generation        ││
+│  │                                 ││
+│  │  confidence = random_uniform(   ││
+│  │      min_confidence,            ││
+│  │      max_confidence             ││
+│  │  )                              ││
+│  └─────────────────────────────────┘│
+└─────────────────────────────────────┘
+        ↓
+IncStrategySignal
+        ↓
+Trader Execution
+```
+
+## Implementation Architecture
+
+### Class Hierarchy
+
+```
+IncStrategyBase
+    ↓
+RandomStrategy
+    ├── TimeframeAggregator (inherited)
+    ├── Random Number Generator
+    ├── Probability Configuration
+    └── Signal Generation Logic
+```
+
+### Key Components
+
+#### 1. Random Number Generator
+```python
+class RandomStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        super().__init__(name, params)
+        
+        # Initialize random seed for reproducibility
+        if self.params.get('seed') is not None:
+            random.seed(self.params['seed'])
+            np.random.seed(self.params['seed'])
+        
+        self.signal_count = 0
+        self.last_signal_time = 0
+```
+
+#### 2. Signal Generation Process
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    open_price, high, low, close, volume = ohlcv
+    
+    # Check signal frequency constraint
+    if not self._should_generate_signal(timestamp):
+        return IncStrategySignal.HOLD()
+    
+    # Generate random signal
+    rand_val = random.random()
+    
+    if rand_val < self.params['buy_probability']:
+        signal_type = 'BUY'
+    elif rand_val < (self.params['buy_probability'] + self.params['sell_probability']):
+        signal_type = 'SELL'
+    else:
+        signal_type = 'HOLD'
+    
+    # Generate random confidence
+    confidence = random.uniform(
+        self.params['min_confidence'],
+        self.params['max_confidence']
+    )
+    
+    # Create signal with metadata
+    if signal_type == 'BUY':
+        self.signal_count += 1
+        self.last_signal_time = timestamp
+        return IncStrategySignal.BUY(
+            confidence=confidence,
+            metadata=self._create_metadata(timestamp, rand_val, signal_type)
+        )
+    elif signal_type == 'SELL':
+        self.signal_count += 1
+        self.last_signal_time = timestamp
+        return IncStrategySignal.SELL(
+            confidence=confidence,
+            metadata=self._create_metadata(timestamp, rand_val, signal_type)
+        )
+    
+    return IncStrategySignal.HOLD()
+```
+
+#### 3. Signal Frequency Control
+```python
+def _should_generate_signal(self, timestamp: int) -> bool:
+    """Control signal generation frequency."""
+    
+    # Check minimum time between signals
+    min_interval = self.params.get('min_signal_interval_minutes', 0) * 60 * 1000
+    if timestamp - self.last_signal_time < min_interval:
+        return False
+    
+    # Check maximum signals per day
+    max_daily_signals = self.params.get('max_daily_signals', float('inf'))
+    if self.signal_count >= max_daily_signals:
+        # Reset counter if new day (simplified)
+        if self._is_new_day(timestamp):
+            self.signal_count = 0
+        else:
+            return False
+    
+    return True
+```
+
+## Configuration Parameters
+
+### Default Parameters
+```python
+default_params = {
+    "timeframe": "15min",                    # Data aggregation timeframe
+    "buy_probability": 0.1,                  # Probability of generating BUY signal
+    "sell_probability": 0.1,                 # Probability of generating SELL signal
+    "min_confidence": 0.5,                   # Minimum confidence level
+    "max_confidence": 0.9,                   # Maximum confidence level
+    "seed": None,                           # Random seed (None for random)
+    "min_signal_interval_minutes": 0,        # Minimum minutes between signals
+    "max_daily_signals": float('inf'),       # Maximum signals per day
+    "signal_frequency": 1.0                  # Signal generation frequency multiplier
+}
+```
+
+### Parameter Descriptions
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `timeframe` | str | "15min" | Data aggregation timeframe |
+| `buy_probability` | float | 0.1 | Probability of generating BUY signal (0-1) |
+| `sell_probability` | float | 0.1 | Probability of generating SELL signal (0-1) |
+| `min_confidence` | float | 0.5 | Minimum confidence level for signals |
+| `max_confidence` | float | 0.9 | Maximum confidence level for signals |
+| `seed` | int | None | Random seed for reproducible results |
+| `min_signal_interval_minutes` | int | 0 | Minimum minutes between signals |
+| `max_daily_signals` | int | inf | Maximum signals per day |
+
+### Parameter Optimization Ranges
+
+```python
+optimization_ranges = {
+    "buy_probability": [0.05, 0.1, 0.15, 0.2, 0.25],
+    "sell_probability": [0.05, 0.1, 0.15, 0.2, 0.25],
+    "min_confidence": [0.3, 0.4, 0.5, 0.6],
+    "max_confidence": [0.7, 0.8, 0.9, 1.0],
+    "signal_frequency": [0.5, 1.0, 1.5, 2.0],
+    "timeframe": ["5min", "15min", "30min", "1h"]
+}
+```
+
+## Signal Generation Logic
+
+### Signal Types and Probabilities
+
+**Signal Distribution:**
+- **BUY**: Configurable probability (default 10%)
+- **SELL**: Configurable probability (default 10%)
+- **HOLD**: Remaining probability (default 80%)
+
+**Confidence Generation:**
+- Uniform distribution between min_confidence and max_confidence
+- Simulates realistic confidence levels for testing
+
+### Signal Metadata
+
+Each signal includes comprehensive metadata for testing:
+```python
+metadata = {
+    'random_value': 0.0847,                  # Random value that generated signal
+    'signal_number': 15,                     # Sequential signal number
+    'probability_used': 0.1,                 # Probability threshold used
+    'confidence_range': [0.5, 0.9],         # Confidence range used
+    'seed_used': 12345,                      # Random seed if specified
+    'generation_method': 'uniform',          # Random generation method
+    'signal_frequency': 1.0,                 # Signal frequency multiplier
+    'timestamp': 1640995200000               # Signal generation timestamp
+}
+```
+
+## Performance Characteristics
+
+### Expected Performance
+
+1. **Random Walk**: Should approximate random walk performance
+2. **Zero Alpha**: No systematic edge over random chance
+3. **High Volatility**: Typically high volatility due to random signals
+4. **50% Win Rate**: Expected win rate around 50% (before costs)
+
+### Statistical Properties
+
+- **Sharpe Ratio**: Expected to be around 0 (random performance)
+- **Maximum Drawdown**: Highly variable, can be significant
+- **Return Distribution**: Should approximate normal distribution over time
+- **Signal Distribution**: Follows configured probability distribution
+
+### Use Cases
+
+1. **Baseline Comparison**: Compare other strategies against random performance
+2. **Framework Testing**: Test trading framework with known signal patterns
+3. **Statistical Validation**: Validate that other strategies beat random chance
+4. **System Debugging**: Debug backtesting and trading systems
+
+## Usage Examples
+
+### Basic Usage
+```python
+from IncrementalTrader import RandomStrategy, IncTrader
+
+# Create strategy with default parameters
+strategy = RandomStrategy("random")
+
+# Create trader
+trader = IncTrader(strategy, initial_usd=10000)
+
+# Process data
+for timestamp, ohlcv in data_stream:
+    signal = trader.process_data_point(timestamp, ohlcv)
+    if signal.signal_type != 'HOLD':
+        print(f"Random Signal: {signal.signal_type} (confidence: {signal.confidence:.2f})")
+```
+
+### Reproducible Testing
+```python
+# Create strategy with fixed seed for reproducible results
+strategy = RandomStrategy("random_test", {
+    "seed": 12345,
+    "buy_probability": 0.15,
+    "sell_probability": 0.15,
+    "min_confidence": 0.6,
+    "max_confidence": 0.8
+})
+```
+
+### Controlled Signal Frequency
+```python
+# Create strategy with controlled signal frequency
+strategy = RandomStrategy("random_controlled", {
+    "buy_probability": 0.2,
+    "sell_probability": 0.2,
+    "min_signal_interval_minutes": 60,  # At least 1 hour between signals
+    "max_daily_signals": 5              # Maximum 5 signals per day
+})
+```
+
+## Advanced Features
+
+### Custom Probability Distributions
+```python
+def custom_signal_generation(self, timestamp: int) -> str:
+    """Custom signal generation with time-based probabilities."""
+    
+    # Vary probabilities based on time of day
+    hour = datetime.fromtimestamp(timestamp / 1000).hour
+    
+    if 9 <= hour <= 16:  # Market hours
+        buy_prob = 0.15
+        sell_prob = 0.15
+    else:  # After hours
+        buy_prob = 0.05
+        sell_prob = 0.05
+    
+    rand_val = random.random()
+    if rand_val < buy_prob:
+        return 'BUY'
+    elif rand_val < buy_prob + sell_prob:
+        return 'SELL'
+    return 'HOLD'
+```
+
+### Confidence Distribution Modeling
+```python
+def generate_realistic_confidence(self) -> float:
+    """Generate confidence using beta distribution for realism."""
+    
+    # Beta distribution parameters for realistic confidence
+    alpha = 2.0  # Shape parameter
+    beta = 2.0   # Shape parameter
+    
+    # Generate beta-distributed confidence
+    beta_sample = np.random.beta(alpha, beta)
+    
+    # Scale to desired range
+    min_conf = self.params['min_confidence']
+    max_conf = self.params['max_confidence']
+    
+    return min_conf + beta_sample * (max_conf - min_conf)
+```
+
+### Market Regime Simulation
+```python
+def simulate_market_regimes(self, timestamp: int) -> dict:
+    """Simulate different market regimes for testing."""
+    
+    # Simple regime switching based on time
+    regime_cycle = (timestamp // (24 * 60 * 60 * 1000)) % 3
+    
+    if regime_cycle == 0:  # Bull market
+        return {
+            'buy_probability': 0.2,
+            'sell_probability': 0.05,
+            'confidence_boost': 0.1
+        }
+    elif regime_cycle == 1:  # Bear market
+        return {
+            'buy_probability': 0.05,
+            'sell_probability': 0.2,
+            'confidence_boost': 0.1
+        }
+    else:  # Sideways market
+        return {
+            'buy_probability': 0.1,
+            'sell_probability': 0.1,
+            'confidence_boost': 0.0
+        }
+```
+
+## Backtesting Results
+
+### Expected Performance Metrics
+```
+Timeframe: 15min
+Period: 2024-01-01 to 2024-12-31
+Initial Capital: $10,000
+
+Expected Results:
+Total Return: ~0% (random walk)
+Sharpe Ratio: ~0.0
+Max Drawdown: Variable (10-30%)
+Win Rate: ~50%
+Profit Factor: ~1.0 (before costs)
+Total Trades: Variable based on probabilities
+```
+
+### Statistical Analysis
+```
+Signal Distribution Analysis:
+BUY Signals: ~10% of total data points
+SELL Signals: ~10% of total data points
+HOLD Signals: ~80% of total data points
+
+Confidence Distribution:
+Mean Confidence: 0.7 (midpoint of range)
+Std Confidence: Varies by distribution type
+Min Confidence: 0.5
+Max Confidence: 0.9
+```
+
+## Implementation Notes
+
+### Memory Efficiency
+- **Minimal State**: Only tracks signal count and timing
+- **No Indicators**: No technical indicators to maintain
+- **Constant Memory**: O(1) memory usage
+
+### Real-time Capability
+- **Ultra-Fast**: Minimal processing per data point
+- **No Dependencies**: No indicator calculations required
+- **Immediate Signals**: Instant signal generation
+
+### Error Handling
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    try:
+        # Validate basic data
+        if not self._validate_ohlcv(ohlcv):
+            self.logger.warning(f"Invalid OHLCV data: {ohlcv}")
+            return IncStrategySignal.HOLD()
+        
+        # Generate random signal
+        return self._generate_random_signal(timestamp)
+        
+    except Exception as e:
+        self.logger.error(f"Error in Random strategy: {e}")
+        return IncStrategySignal.HOLD()
+```
+
+## Testing and Validation
+
+### Framework Testing
+```python
+def test_signal_distribution():
+    """Test that signal distribution matches expected probabilities."""
+    
+    strategy = RandomStrategy("test", {"seed": 12345})
+    signals = []
+    
+    # Generate many signals
+    for i in range(10000):
+        signal = strategy._generate_random_signal(i)
+        signals.append(signal.signal_type)
+    
+    # Analyze distribution
+    buy_ratio = signals.count('BUY') / len(signals)
+    sell_ratio = signals.count('SELL') / len(signals)
+    hold_ratio = signals.count('HOLD') / len(signals)
+    
+    assert abs(buy_ratio - 0.1) < 0.02   # Within 2% of expected
+    assert abs(sell_ratio - 0.1) < 0.02  # Within 2% of expected
+    assert abs(hold_ratio - 0.8) < 0.02  # Within 2% of expected
+```
+
+### Reproducibility Testing
+```python
+def test_reproducibility():
+    """Test that same seed produces same results."""
+    
+    strategy1 = RandomStrategy("test1", {"seed": 12345})
+    strategy2 = RandomStrategy("test2", {"seed": 12345})
+    
+    signals1 = []
+    signals2 = []
+    
+    # Generate signals with both strategies
+    for i in range(1000):
+        sig1 = strategy1._generate_random_signal(i)
+        sig2 = strategy2._generate_random_signal(i)
+        signals1.append((sig1.signal_type, sig1.confidence))
+        signals2.append((sig2.signal_type, sig2.confidence))
+    
+    # Should be identical
+    assert signals1 == signals2
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Non-Random Results**
+   - Check if seed is set (removes randomness)
+   - Verify probability parameters are correct
+   - Ensure random number generator is working
+
+2. **Too Many/Few Signals**
+   - Adjust buy_probability and sell_probability
+   - Check signal frequency constraints
+   - Verify timeframe settings
+
+3. **Unrealistic Performance**
+   - Random strategy should perform around 0% return
+   - If significantly positive/negative, check for bugs
+   - Verify transaction costs are included
+
+### Debug Information
+```python
+# Enable debug logging
+strategy.logger.setLevel(logging.DEBUG)
+
+# Check signal statistics
+print(f"Total signals generated: {strategy.signal_count}")
+print(f"Buy probability: {strategy.params['buy_probability']}")
+print(f"Sell probability: {strategy.params['sell_probability']}")
+print(f"Current seed: {strategy.params.get('seed', 'None (random)')}")
+```
+
+## Integration with Testing Framework
+
+### Benchmark Comparison
+```python
+def compare_with_random_baseline(strategy_results, random_results):
+    """Compare strategy performance against random baseline."""
+    
+    strategy_return = strategy_results['total_return']
+    random_return = random_results['total_return']
+    
+    # Calculate excess return over random
+    excess_return = strategy_return - random_return
+    
+    # Statistical significance test
+    t_stat, p_value = stats.ttest_ind(
+        strategy_results['daily_returns'],
+        random_results['daily_returns']
+    )
+    
+    return {
+        'excess_return': excess_return,
+        'statistical_significance': p_value < 0.05,
+        't_statistic': t_stat,
+        'p_value': p_value
+    }
+```
+
+---
+
+*The Random Strategy serves as a crucial testing and benchmarking tool, providing a baseline for performance comparison and validating that other strategies perform better than random chance. While it generates no alpha by design, it's invaluable for framework testing and statistical validation.* 

IncrementalTrader/docs/strategies/strategies.md

@@ -0,0 +1,580 @@
+# Strategy Development Guide
+
+This guide explains how to create custom trading strategies using the IncrementalTrader framework.
+
+## Overview
+
+IncrementalTrader strategies are built around the `IncStrategyBase` class, which provides a robust framework for incremental computation, timeframe aggregation, and signal generation.
+
+## Basic Strategy Structure
+
+```python
+from IncrementalTrader.strategies.base import IncStrategyBase, IncStrategySignal
+from IncrementalTrader.strategies.indicators import MovingAverageState
+
+class MyCustomStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        super().__init__(name, params)
+        
+        # Initialize indicators
+        self.sma_fast = MovingAverageState(period=self.params.get('fast_period', 10))
+        self.sma_slow = MovingAverageState(period=self.params.get('slow_period', 20))
+        
+        # Strategy state
+        self.current_signal = IncStrategySignal.HOLD()
+        
+    def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+        """Process aggregated data and generate signals."""
+        open_price, high, low, close, volume = ohlcv
+        
+        # Update indicators
+        self.sma_fast.update(close)
+        self.sma_slow.update(close)
+        
+        # Generate signals
+        if self.sma_fast.is_ready() and self.sma_slow.is_ready():
+            fast_sma = self.sma_fast.get_value()
+            slow_sma = self.sma_slow.get_value()
+            
+            if fast_sma > slow_sma and self.current_signal.signal_type != 'BUY':
+                self.current_signal = IncStrategySignal.BUY(
+                    confidence=0.8,
+                    metadata={'fast_sma': fast_sma, 'slow_sma': slow_sma}
+                )
+            elif fast_sma < slow_sma and self.current_signal.signal_type != 'SELL':
+                self.current_signal = IncStrategySignal.SELL(
+                    confidence=0.8,
+                    metadata={'fast_sma': fast_sma, 'slow_sma': slow_sma}
+                )
+        
+        return self.current_signal
+```
+
+## Key Components
+
+### 1. Base Class Inheritance
+
+All strategies must inherit from `IncStrategyBase`:
+
+```python
+class MyStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        super().__init__(name, params)
+        # Your initialization code here
+```
+
+### 2. Required Methods
+
+#### `_process_aggregated_data()`
+
+This is the core method where your strategy logic goes:
+
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    """
+    Process aggregated OHLCV data and return a signal.
+    
+    Args:
+        timestamp: Unix timestamp
+        ohlcv: Tuple of (open, high, low, close, volume)
+        
+    Returns:
+        IncStrategySignal: BUY, SELL, or HOLD signal
+    """
+    # Your strategy logic here
+    return signal
+```
+
+### 3. Signal Generation
+
+Use the factory methods to create signals:
+
+```python
+# Buy signal
+signal = IncStrategySignal.BUY(
+    confidence=0.8,  # Optional: 0.0 to 1.0
+    metadata={'reason': 'Golden cross detected'}  # Optional: additional data
+)
+
+# Sell signal
+signal = IncStrategySignal.SELL(
+    confidence=0.9,
+    metadata={'reason': 'Death cross detected'}
+)
+
+# Hold signal
+signal = IncStrategySignal.HOLD()
+```
+
+## Using Indicators
+
+### Built-in Indicators
+
+IncrementalTrader provides many built-in indicators:
+
+```python
+from IncrementalTrader.strategies.indicators import (
+    MovingAverageState,
+    ExponentialMovingAverageState,
+    ATRState,
+    SupertrendState,
+    RSIState,
+    BollingerBandsState
+)
+
+class MyStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        super().__init__(name, params)
+        
+        # Moving averages
+        self.sma = MovingAverageState(period=20)
+        self.ema = ExponentialMovingAverageState(period=20, alpha=0.1)
+        
+        # Volatility
+        self.atr = ATRState(period=14)
+        
+        # Trend
+        self.supertrend = SupertrendState(period=10, multiplier=3.0)
+        
+        # Oscillators
+        self.rsi = RSIState(period=14)
+        self.bb = BollingerBandsState(period=20, std_dev=2.0)
+```
+
+### Indicator Usage Pattern
+
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    open_price, high, low, close, volume = ohlcv
+    
+    # Update indicators
+    self.sma.update(close)
+    self.rsi.update(close)
+    self.atr.update_ohlc(high, low, close)
+    
+    # Check if indicators are ready
+    if not (self.sma.is_ready() and self.rsi.is_ready()):
+        return IncStrategySignal.HOLD()
+    
+    # Get indicator values
+    sma_value = self.sma.get_value()
+    rsi_value = self.rsi.get_value()
+    atr_value = self.atr.get_value()
+    
+    # Your strategy logic here
+    # ...
+```
+
+## Advanced Features
+
+### 1. Timeframe Aggregation
+
+The base class automatically handles timeframe aggregation:
+
+```python
+class MyStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        # Set timeframe in params
+        default_params = {"timeframe": "15min"}
+        if params:
+            default_params.update(params)
+        super().__init__(name, default_params)
+```
+
+Supported timeframes:
+- `"1min"`, `"5min"`, `"15min"`, `"30min"`
+- `"1h"`, `"4h"`, `"1d"`
+
+### 2. State Management
+
+Track strategy state for complex logic:
+
+```python
+class TrendFollowingStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        super().__init__(name, params)
+        
+        # Strategy state
+        self.trend_state = "UNKNOWN"  # BULLISH, BEARISH, SIDEWAYS
+        self.position_state = "NONE"  # LONG, SHORT, NONE
+        self.last_signal_time = 0
+        
+    def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+        # Update trend state
+        self._update_trend_state(ohlcv)
+        
+        # Generate signals based on trend and position
+        if self.trend_state == "BULLISH" and self.position_state != "LONG":
+            self.position_state = "LONG"
+            return IncStrategySignal.BUY(confidence=0.8)
+        elif self.trend_state == "BEARISH" and self.position_state != "SHORT":
+            self.position_state = "SHORT"
+            return IncStrategySignal.SELL(confidence=0.8)
+        
+        return IncStrategySignal.HOLD()
+```
+
+### 3. Multi-Indicator Strategies
+
+Combine multiple indicators for robust signals:
+
+```python
+class MultiIndicatorStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        super().__init__(name, params)
+        
+        # Trend indicators
+        self.supertrend = SupertrendState(period=10, multiplier=3.0)
+        self.sma_50 = MovingAverageState(period=50)
+        self.sma_200 = MovingAverageState(period=200)
+        
+        # Momentum indicators
+        self.rsi = RSIState(period=14)
+        
+        # Volatility indicators
+        self.bb = BollingerBandsState(period=20, std_dev=2.0)
+        
+    def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+        open_price, high, low, close, volume = ohlcv
+        
+        # Update all indicators
+        self.supertrend.update_ohlc(high, low, close)
+        self.sma_50.update(close)
+        self.sma_200.update(close)
+        self.rsi.update(close)
+        self.bb.update(close)
+        
+        # Wait for all indicators to be ready
+        if not all([
+            self.supertrend.is_ready(),
+            self.sma_50.is_ready(),
+            self.sma_200.is_ready(),
+            self.rsi.is_ready(),
+            self.bb.is_ready()
+        ]):
+            return IncStrategySignal.HOLD()
+        
+        # Get indicator values
+        supertrend_signal = self.supertrend.get_signal()
+        sma_50 = self.sma_50.get_value()
+        sma_200 = self.sma_200.get_value()
+        rsi = self.rsi.get_value()
+        bb_upper, bb_middle, bb_lower = self.bb.get_bands()
+        
+        # Multi-condition buy signal
+        buy_conditions = [
+            supertrend_signal == 'BUY',
+            sma_50 > sma_200,  # Long-term uptrend
+            rsi < 70,  # Not overbought
+            close < bb_upper  # Not at upper band
+        ]
+        
+        # Multi-condition sell signal
+        sell_conditions = [
+            supertrend_signal == 'SELL',
+            sma_50 < sma_200,  # Long-term downtrend
+            rsi > 30,  # Not oversold
+            close > bb_lower  # Not at lower band
+        ]
+        
+        if all(buy_conditions):
+            confidence = sum([1 for c in buy_conditions if c]) / len(buy_conditions)
+            return IncStrategySignal.BUY(
+                confidence=confidence,
+                metadata={
+                    'supertrend': supertrend_signal,
+                    'sma_trend': 'UP' if sma_50 > sma_200 else 'DOWN',
+                    'rsi': rsi,
+                    'bb_position': 'MIDDLE'
+                }
+            )
+        elif all(sell_conditions):
+            confidence = sum([1 for c in sell_conditions if c]) / len(sell_conditions)
+            return IncStrategySignal.SELL(
+                confidence=confidence,
+                metadata={
+                    'supertrend': supertrend_signal,
+                    'sma_trend': 'DOWN' if sma_50 < sma_200 else 'UP',
+                    'rsi': rsi,
+                    'bb_position': 'MIDDLE'
+                }
+            )
+        
+        return IncStrategySignal.HOLD()
+```
+
+## Parameter Management
+
+### Default Parameters
+
+Define default parameters in your strategy:
+
+```python
+class MyStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        # Define defaults
+        default_params = {
+            "timeframe": "15min",
+            "fast_period": 10,
+            "slow_period": 20,
+            "rsi_period": 14,
+            "rsi_overbought": 70,
+            "rsi_oversold": 30
+        }
+        
+        # Merge with provided params
+        if params:
+            default_params.update(params)
+            
+        super().__init__(name, default_params)
+        
+        # Use parameters
+        self.fast_sma = MovingAverageState(period=self.params['fast_period'])
+        self.slow_sma = MovingAverageState(period=self.params['slow_period'])
+        self.rsi = RSIState(period=self.params['rsi_period'])
+```
+
+### Parameter Validation
+
+Add validation for critical parameters:
+
+```python
+def __init__(self, name: str, params: dict = None):
+    super().__init__(name, params)
+    
+    # Validate parameters
+    if self.params['fast_period'] >= self.params['slow_period']:
+        raise ValueError("fast_period must be less than slow_period")
+    
+    if not (1 <= self.params['rsi_period'] <= 100):
+        raise ValueError("rsi_period must be between 1 and 100")
+```
+
+## Testing Your Strategy
+
+### Unit Testing
+
+```python
+import unittest
+from IncrementalTrader.strategies.base import IncStrategySignal
+
+class TestMyStrategy(unittest.TestCase):
+    def setUp(self):
+        self.strategy = MyCustomStrategy("test", {
+            "fast_period": 5,
+            "slow_period": 10
+        })
+    
+    def test_initialization(self):
+        self.assertEqual(self.strategy.name, "test")
+        self.assertEqual(self.strategy.params['fast_period'], 5)
+    
+    def test_signal_generation(self):
+        # Feed test data
+        test_data = [
+            (1000, (100, 105, 95, 102, 1000)),
+            (1001, (102, 108, 100, 106, 1200)),
+            # ... more test data
+        ]
+        
+        for timestamp, ohlcv in test_data:
+            signal = self.strategy.process_data_point(timestamp, ohlcv)
+            self.assertIsInstance(signal, IncStrategySignal)
+```
+
+### Backtesting
+
+```python
+from IncrementalTrader import IncBacktester, BacktestConfig
+
+# Test your strategy
+config = BacktestConfig(
+    initial_usd=10000,
+    start_date="2024-01-01",
+    end_date="2024-03-31"
+)
+
+backtester = IncBacktester()
+results = backtester.run_single_strategy(
+    strategy_class=MyCustomStrategy,
+    strategy_params={"fast_period": 10, "slow_period": 20},
+    config=config,
+    data_file="test_data.csv"
+)
+
+print(f"Total Return: {results['performance_metrics']['total_return_pct']:.2f}%")
+```
+
+## Best Practices
+
+### 1. Incremental Design
+
+Always design for incremental computation:
+
+```python
+# Good: Incremental calculation
+class IncrementalSMA:
+    def __init__(self, period):
+        self.period = period
+        self.values = deque(maxlen=period)
+        self.sum = 0
+    
+    def update(self, value):
+        if len(self.values) == self.period:
+            self.sum -= self.values[0]
+        self.values.append(value)
+        self.sum += value
+    
+    def get_value(self):
+        return self.sum / len(self.values) if self.values else 0
+
+# Bad: Batch calculation
+def calculate_sma(prices, period):
+    return [sum(prices[i:i+period])/period for i in range(len(prices)-period+1)]
+```
+
+### 2. State Management
+
+Keep minimal state and ensure it's always consistent:
+
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    # Update all indicators first
+    self._update_indicators(ohlcv)
+    
+    # Then update strategy state
+    self._update_strategy_state()
+    
+    # Finally generate signal
+    return self._generate_signal()
+```
+
+### 3. Error Handling
+
+Handle edge cases gracefully:
+
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    try:
+        open_price, high, low, close, volume = ohlcv
+        
+        # Validate data
+        if not all(isinstance(x, (int, float)) for x in ohlcv):
+            self.logger.warning(f"Invalid OHLCV data: {ohlcv}")
+            return IncStrategySignal.HOLD()
+        
+        if high < low or close < 0:
+            self.logger.warning(f"Inconsistent price data: {ohlcv}")
+            return IncStrategySignal.HOLD()
+        
+        # Your strategy logic here
+        # ...
+        
+    except Exception as e:
+        self.logger.error(f"Error processing data: {e}")
+        return IncStrategySignal.HOLD()
+```
+
+### 4. Logging
+
+Use the built-in logger for debugging:
+
+```python
+def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+    open_price, high, low, close, volume = ohlcv
+    
+    # Log important events
+    if self.sma_fast.get_value() > self.sma_slow.get_value():
+        self.logger.debug(f"Fast SMA ({self.sma_fast.get_value():.2f}) > Slow SMA ({self.sma_slow.get_value():.2f})")
+    
+    # Log signal generation
+    if signal.signal_type != 'HOLD':
+        self.logger.info(f"Generated {signal.signal_type} signal with confidence {signal.confidence}")
+    
+    return signal
+```
+
+## Example Strategies
+
+### Simple Moving Average Crossover
+
+```python
+class SMAStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        default_params = {
+            "timeframe": "15min",
+            "fast_period": 10,
+            "slow_period": 20
+        }
+        if params:
+            default_params.update(params)
+        super().__init__(name, default_params)
+        
+        self.sma_fast = MovingAverageState(period=self.params['fast_period'])
+        self.sma_slow = MovingAverageState(period=self.params['slow_period'])
+        self.last_signal = 'HOLD'
+        
+    def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+        _, _, _, close, _ = ohlcv
+        
+        self.sma_fast.update(close)
+        self.sma_slow.update(close)
+        
+        if not (self.sma_fast.is_ready() and self.sma_slow.is_ready()):
+            return IncStrategySignal.HOLD()
+        
+        fast = self.sma_fast.get_value()
+        slow = self.sma_slow.get_value()
+        
+        if fast > slow and self.last_signal != 'BUY':
+            self.last_signal = 'BUY'
+            return IncStrategySignal.BUY(confidence=0.7)
+        elif fast < slow and self.last_signal != 'SELL':
+            self.last_signal = 'SELL'
+            return IncStrategySignal.SELL(confidence=0.7)
+        
+        return IncStrategySignal.HOLD()
+```
+
+### RSI Mean Reversion
+
+```python
+class RSIMeanReversionStrategy(IncStrategyBase):
+    def __init__(self, name: str, params: dict = None):
+        default_params = {
+            "timeframe": "15min",
+            "rsi_period": 14,
+            "oversold": 30,
+            "overbought": 70
+        }
+        if params:
+            default_params.update(params)
+        super().__init__(name, default_params)
+        
+        self.rsi = RSIState(period=self.params['rsi_period'])
+        
+    def _process_aggregated_data(self, timestamp: int, ohlcv: tuple) -> IncStrategySignal:
+        _, _, _, close, _ = ohlcv
+        
+        self.rsi.update(close)
+        
+        if not self.rsi.is_ready():
+            return IncStrategySignal.HOLD()
+        
+        rsi_value = self.rsi.get_value()
+        
+        if rsi_value < self.params['oversold']:
+            return IncStrategySignal.BUY(
+                confidence=min(1.0, (self.params['oversold'] - rsi_value) / 20),
+                metadata={'rsi': rsi_value, 'condition': 'oversold'}
+            )
+        elif rsi_value > self.params['overbought']:
+            return IncStrategySignal.SELL(
+                confidence=min(1.0, (rsi_value - self.params['overbought']) / 20),
+                metadata={'rsi': rsi_value, 'condition': 'overbought'}
+            )
+        
+        return IncStrategySignal.HOLD()
+```
+
+This guide provides a comprehensive foundation for developing custom strategies with IncrementalTrader. Remember to always test your strategies thoroughly before using them in live trading!