sqa 0.0.24 → 0.0.31

data/examples/README.md

@@ -0,0 +1,354 @@
+# SQA Examples
+
+This directory contains comprehensive examples demonstrating advanced features of the SQA (Simple Qualitative Analysis) library.
+
+## Available Examples
+
+### 1. Strategy Generator (`strategy_generator_example.rb`)
+
+**Reverse engineer profitable trades to discover indicator patterns**
+
+This example demonstrates how to mine historical data for profitable entry points and discover which indicator combinations were active at those times. The strategy generator:
+
+- Scans historical data for trades that yielded ≥X% gain
+- Identifies which indicators were "active" (e.g., RSI oversold, MACD bullish crossover)
+- Discovers common patterns across profitable trades
+- Generates trading strategies from discovered patterns
+- Backtests generated strategies against traditional strategies
+
+**Run it:**
+```bash
+./examples/strategy_generator_example.rb
+```
+
+**Key Examples:**
+- Example 1: Basic pattern discovery for 10% gains
+- Example 2: Generate strategies from top patterns
+- Example 3: Compare different gain thresholds (5%, 10%, 15%, 20%)
+- Example 4: Short-term vs long-term patterns
+- Example 5: Export patterns to CSV
+- Example 6: Performance comparison of discovered vs traditional strategies
+- Example 7: Aggressive pattern mining for 20%+ gains
+
+**Output:**
+- Discovered patterns with frequency, average gain, and conditions
+- Generated strategy performance metrics
+- CSV export of patterns
+- Comparison table of strategy performance
+
+---
+
+### 2. Genetic Programming (`genetic_programming_example.rb`)
+
+**Evolve optimal trading strategy parameters through natural selection**
+
+This example shows how to use genetic algorithms to automatically find the best parameters for trading strategies. The genetic program:
+
+- Defines parameter space (e.g., RSI period 7-30, thresholds 20-80)
+- Creates random population of strategies
+- Evaluates fitness through backtesting
+- Evolves through selection, crossover, and mutation
+- Tracks evolution history and best individuals
+
+**Run it:**
+```bash
+./examples/genetic_programming_example.rb
+```
+
+**What it demonstrates:**
+- Evolving RSI strategy parameters (period, buy/sell thresholds)
+- Tournament selection for parent choosing
+- Crossover and mutation operations
+- Fitness evaluation via backtesting
+- Evolution history tracking
+
+**Output:**
+- Generation-by-generation evolution progress
+- Best parameters found
+- Fitness scores (total return %)
+- Evolution history chart
+
+---
+
+### 3. Knowledge-Based Strategy (`kbs_strategy_example.rb`)
+
+**Build sophisticated rule-based trading systems with RETE forward chaining**
+
+This example demonstrates the knowledge-based strategy system using RETE pattern matching for complex trading rules:
+
+- Define trading rules with multiple conditions
+- Forward-chaining inference engine
+- Pattern matching on market conditions
+- Confidence-based signal aggregation
+- Custom rule creation via DSL
+
+**Run it:**
+```bash
+./examples/kbs_strategy_example.rb
+```
+
+**Key Examples:**
+- Example 1: Using default rules (10 built-in patterns)
+- Example 2: Creating custom rules
+- Example 3: Backtesting KBS strategy
+- Example 4: Interactive rule builder with complex conditions
+
+**Output:**
+- Trading signals with reasoning
+- Working memory facts
+- Rule firing explanations
+- Backtest performance metrics
+
+---
+
+### 4. Real-Time Streaming (`realtime_stream_example.rb`)
+
+**Process live stock price updates and generate on-the-fly trading signals**
+
+This example shows how to build real-time trading signal systems:
+
+- Event-driven architecture for live data
+- Rolling window of recent prices
+- On-demand indicator calculation
+- Multi-strategy consensus signals
+- WebSocket integration patterns
+
+**Run it:**
+```bash
+./examples/realtime_stream_example.rb
+```
+
+**Key Examples:**
+- Example 1: Basic streaming setup with callbacks
+- Example 2: Multi-strategy consensus
+- Example 3: Accessing real-time indicators
+- Example 4: Production WebSocket pattern
+
+**Output:**
+- Real-time signal notifications
+- Price update monitoring
+- Indicator calculations on-the-fly
+- Production-ready patterns
+
+---
+
+### 5. FPL Analysis (`fpop_analysis_example.rb`)
+
+**Analyze Future Period Loss/Profit to identify high-quality trading opportunities**
+
+This example demonstrates how to use the FPL (Future Period Loss/Profit) analysis utilities to discover optimal entry points with controlled risk:
+
+- Calculate min/max price changes over future periods
+- Filter opportunities by magnitude and risk thresholds
+- Identify inflection points (local minima/maxima)
+- Analyze directional bias (UP, DOWN, UNCERTAIN, FLAT)
+- Risk management with max FPL risk constraints
+
+**Run it:**
+```bash
+./examples/fpop_analysis_example.rb
+```
+
+**Key Examples:**
+- Example 1: Basic FPL calculation
+- Example 2: DataFrame FPL convenience methods
+- Example 3: Comprehensive FPL analysis
+- Example 4: Quality filtering (magnitude, risk, direction)
+- Example 5: Integration with Strategy Generator
+
+**Output:**
+- FPL arrays (min/max deltas per price point)
+- Risk metrics and directional analysis
+- Filtered high-quality opportunities
+- Integration with pattern discovery
+
+---
+
+### 6. Pattern Context System (`pattern_context_example.rb`)
+
+**Discover context-aware trading patterns with market regime, seasonal, and sector analysis**
+
+This comprehensive example demonstrates the Pattern Context system that addresses the reality that trading patterns are not universal - they depend on market conditions, seasonality, and sector behavior:
+
+- **Market Regime Detection**: Identify bull/bear/sideways markets with volatility classification
+- **Seasonal Analysis**: Discover calendar-dependent patterns (monthly/quarterly performance)
+- **Sector Analysis**: Cross-stock pattern discovery with separate KBS blackboards per sector
+- **Walk-Forward Validation**: Prevent overfitting with time-series cross-validation
+- **Context-Aware Patterns**: Patterns know when they're valid (regime, season, sector)
+
+**Run it:**
+```bash
+./examples/pattern_context_example.rb
+```
+
+**Key Examples:**
+- Example 1: Market regime detection and history
+- Example 2: Seasonal pattern analysis
+- Example 3: Sector analysis with KBS blackboards
+- Example 4: Context-aware pattern discovery
+- Example 5: Walk-forward validation
+- Example 6: Runtime pattern validation
+
+**Output:**
+- Market regime classification (bull/bear/sideways)
+- Best/worst months and quarters
+- Sector-wide patterns across multiple stocks
+- Validated patterns that work out-of-sample
+- Runtime validation results
+
+---
+
+## Running All Examples
+
+To run all examples in sequence:
+
+```bash
+for example in examples/*.rb; do
+  echo "Running $example..."
+  ruby "$example"
+  echo ""
+done
+```
+
+## Integration Examples
+
+### Combining Strategy Generator + Genetic Programming
+
+```ruby
+# Discover patterns from history
+generator = SQA::StrategyGenerator.new(stock: stock, min_gain_percent: 10.0)
+patterns = generator.discover_patterns
+
+# Use GP to optimize the top pattern's parameters
+top_pattern = patterns.first
+gp = SQA::GeneticProgram.new(stock: stock)
+gp.define_genes(
+  rsi_period: (10..20).to_a,
+  # ... based on pattern conditions
+)
+best = gp.evolve
+```
+
+### Combining KBS + Stream
+
+```ruby
+# Create KBS strategy
+kbs = SQA::Strategy::KBS.new
+
+# Add to real-time stream
+stream = SQA::Stream.new(ticker: 'AAPL', strategies: [kbs])
+stream.on_signal { |signal, data| execute_trade(signal, data) }
+
+# Feed live data
+stream.update(price: 150.25, volume: 1_000_000)
+```
+
+### Combining FPL + Pattern Discovery
+
+```ruby
+# Use FPL analysis to filter high-quality opportunities
+generator = SQA::StrategyGenerator.new(
+  stock: stock,
+  min_gain_percent: 8.0,
+  fpop: 10,
+  max_fpl_risk: 25.0  # Filter by risk
+)
+
+patterns = generator.discover_patterns
+# Only includes opportunities with FPL risk ≤ 25%
+```
+
+### Combining Pattern Context + Sector Analysis
+
+```ruby
+# Discover sector-wide patterns with context
+analyzer = SQA::SectorAnalyzer.new
+tech_stocks = ['AAPL', 'MSFT', 'GOOGL'].map { |t| SQA::Stock.new(ticker: t) }
+
+tech_stocks.each { |stock| analyzer.add_stock(stock.ticker, sector: :technology) }
+
+# Find patterns that work across the sector
+patterns = analyzer.discover_sector_patterns(
+  :technology,
+  tech_stocks,
+  analyze_regime: true,
+  analyze_seasonal: true
+)
+
+# Patterns have full context metadata
+patterns.first.context.market_regime   # => :bull
+patterns.first.context.sector          # => :technology
+patterns.first.context.valid_months    # => [10, 11, 12]
+```
+
+### Full Pipeline: Generate → Optimize → Validate → Stream
+
+```ruby
+# 1. Discover context-aware patterns
+generator = SQA::StrategyGenerator.new(stock: stock, fpop: 10)
+patterns = generator.discover_context_aware_patterns(
+  analyze_regime: true,
+  analyze_seasonal: true,
+  sector: :technology
+)
+
+# 2. Walk-forward validate
+validated = generator.walk_forward_validate(
+  train_size: 250,
+  test_size: 60,
+  step_size: 30
+)
+
+# 3. Generate strategy from best validated pattern
+discovered_strategy = generator.generate_strategy(pattern_index: 0)
+
+# 4. Optimize with GP
+gp = SQA::GeneticProgram.new(stock: stock)
+# ... optimize discovered strategy parameters ...
+optimized_strategy = gp.evolve
+
+# 5. Deploy to real-time stream with runtime validation
+stream = SQA::Stream.new(ticker: 'AAPL', strategies: [optimized_strategy])
+stream.on_signal do |signal, data|
+  # Check if pattern is valid for current conditions
+  regime = SQA::MarketRegime.detect(stock)
+  if patterns.first.context.valid_for?(
+    date: Date.today,
+    regime: regime[:type],
+    sector: :technology
+  )
+    execute_trade(signal, data)
+  end
+end
+```
+
+## Data Requirements
+
+All examples require:
+- Alpha Vantage API key: `export AV_API_KEY=your_key_here`
+- Or use local CSV data in `~/sqa_data/`
+
+## Output Files
+
+Examples may create output files in `/tmp/`:
+- `/tmp/sqa_discovered_patterns.csv` - Exported patterns
+- `/tmp/sqa_evolution_history.csv` - GP evolution history
+- `/tmp/sqa_backtest_results.csv` - Backtest results
+
+## Next Steps
+
+After running these examples:
+
+1. **Customize Parameters**: Adjust thresholds, periods, and constraints
+2. **Test on Multiple Stocks**: Validate patterns across different securities
+3. **Walk-Forward Validation**: Test on out-of-sample data
+4. **Combine Techniques**: Use strategy generator + GP + KBS together
+5. **Production Deployment**: Connect to real WebSocket data feeds
+
+## Educational Disclaimer
+
+⚠️ **Important**: All examples are for educational purposes only. Past performance does not guarantee future results. Always paper trade and thoroughly test before risking real capital.
+
+## Contributing
+
+Found a bug or have an improvement? Please submit an issue or pull request!

data/examples/advanced_features_example.rb

@@ -0,0 +1,350 @@
+#!/usr/bin/env ruby
+# examples/advanced_features_example.rb
+# frozen_string_literal: true
+
+#####################################################################
+###
+##  File: advanced_features_example.rb
+##  Desc: Comprehensive examples of advanced SQA features
+##  By:   Dewayne VanHoozer (dvanhoozer@gmail.com)
+#
+
+require 'sqa'
+require 'ostruct'
+
+puts "\n" + "=" * 70
+puts "SQA Advanced Features Examples"
+puts "=" * 70
+
+# Initialize SQA
+SQA.init
+
+#############################################################
+## Example 1: Risk Management
+##
+
+puts "\n" + "-" * 70
+puts "Example 1: Risk Management"
+puts "-" * 70
+
+# Load stock data
+stock = SQA::Stock.new(ticker: 'AAPL')
+prices = stock.df["adj_close_price"].to_a
+
+# Calculate returns
+returns = prices.each_cons(2).map { |a, b| (b - a) / a }
+
+puts "\n1.1 Value at Risk (VaR)"
+var_95 = SQA::RiskManager.var(returns, confidence: 0.95, method: :historical)
+var_99 = SQA::RiskManager.var(returns, confidence: 0.99, method: :historical)
+puts "  95% VaR: #{(var_95 * 100).round(2)}% (max expected daily loss)"
+puts "  99% VaR: #{(var_99 * 100).round(2)}% (max expected daily loss)"
+
+puts "\n1.2 Conditional VaR (CVaR / Expected Shortfall)"
+cvar_95 = SQA::RiskManager.cvar(returns, confidence: 0.95)
+puts "  95% CVaR: #{(cvar_95 * 100).round(2)}% (avg loss in worst 5% of days)"
+
+puts "\n1.3 Position Sizing - Kelly Criterion"
+# Calculate win rate and avg win/loss from recent trades
+winning_returns = returns.select { |r| r > 0 }
+losing_returns = returns.select { |r| r < 0 }
+
+win_rate = winning_returns.size.to_f / returns.size
+avg_win = winning_returns.sum / winning_returns.size.to_f
+avg_loss = losing_returns.sum / losing_returns.size.to_f
+
+position_size = SQA::RiskManager.kelly_criterion(
+  win_rate: win_rate,
+  avg_win: avg_win.abs,
+  avg_loss: avg_loss.abs,
+  capital: 10_000,
+  max_fraction: 0.25
+)
+puts "  Optimal position size: $#{position_size.round(2)}"
+puts "  Win rate: #{(win_rate * 100).round(1)}%"
+puts "  Avg win: #{(avg_win * 100).round(2)}%"
+puts "  Avg loss: #{(avg_loss * 100).round(2)}%"
+
+puts "\n1.4 Maximum Drawdown"
+dd_result = SQA::RiskManager.max_drawdown(prices)
+puts "  Max drawdown: #{(dd_result[:max_drawdown] * 100).round(2)}%"
+puts "  Peak price: $#{dd_result[:peak_value].round(2)}"
+puts "  Trough price: $#{dd_result[:trough_value].round(2)}"
+
+puts "\n1.5 Risk Metrics"
+sharpe = SQA::RiskManager.sharpe_ratio(returns, risk_free_rate: 0.02)
+sortino = SQA::RiskManager.sortino_ratio(returns, target_return: 0.0)
+calmar = SQA::RiskManager.calmar_ratio(returns)
+puts "  Sharpe Ratio: #{sharpe.round(2)}"
+puts "  Sortino Ratio: #{sortino.round(2)}"
+puts "  Calmar Ratio: #{calmar.round(2)}"
+
+puts "\n1.6 Monte Carlo Simulation"
+simulation = SQA::RiskManager.monte_carlo_simulation(
+  initial_capital: 10_000,
+  returns: returns,
+  periods: 252,  # 1 year
+  simulations: 1000
+)
+puts "  Median outcome (1 year): $#{simulation[:median].round(2)}"
+puts "  95% confidence interval: $#{simulation[:percentile_5].round(2)} - $#{simulation[:percentile_95].round(2)}"
+puts "  Best case: $#{simulation[:max].round(2)}"
+puts "  Worst case: $#{simulation[:min].round(2)}"
+
+#############################################################
+## Example 2: Portfolio Optimization
+##
+
+puts "\n" + "-" * 70
+puts "Example 2: Portfolio Optimization"
+puts "-" * 70
+
+# Load multiple stocks
+tickers = ['AAPL', 'MSFT', 'GOOGL']
+stocks = tickers.map { |t| SQA::Stock.new(ticker: t) }
+
+# Get returns for each stock (last 100 days)
+returns_matrix = stocks.map do |stock|
+  prices = stock.df["adj_close_price"].to_a.last(100)
+  prices.each_cons(2).map { |a, b| (b - a) / a }
+end
+
+puts "\n2.1 Maximum Sharpe Ratio Portfolio"
+max_sharpe = SQA::PortfolioOptimizer.maximum_sharpe(returns_matrix, risk_free_rate: 0.02)
+puts "  Optimal weights:"
+tickers.each_with_index do |ticker, i|
+  puts "    #{ticker}: #{(max_sharpe[:weights][i] * 100).round(1)}%"
+end
+puts "  Sharpe ratio: #{max_sharpe[:sharpe].round(2)}"
+puts "  Expected return: #{(max_sharpe[:return] * 100).round(2)}%"
+puts "  Volatility: #{(max_sharpe[:volatility] * 100).round(2)}%"
+
+puts "\n2.2 Minimum Variance Portfolio"
+min_var = SQA::PortfolioOptimizer.minimum_variance(returns_matrix)
+puts "  Optimal weights:"
+tickers.each_with_index do |ticker, i|
+  puts "    #{ticker}: #{(min_var[:weights][i] * 100).round(1)}%"
+end
+puts "  Volatility: #{(min_var[:volatility] * 100).round(2)}%"
+
+puts "\n2.3 Risk Parity Portfolio"
+risk_parity = SQA::PortfolioOptimizer.risk_parity(returns_matrix)
+puts "  Optimal weights:"
+tickers.each_with_index do |ticker, i|
+  puts "    #{ticker}: #{(risk_parity[:weights][i] * 100).round(1)}%"
+end
+
+puts "\n2.4 Multi-Objective Optimization"
+multi_obj = SQA::PortfolioOptimizer.multi_objective(
+  returns_matrix,
+  objectives: {
+    maximize_return: 0.4,
+    minimize_volatility: 0.3,
+    minimize_drawdown: 0.3
+  }
+)
+puts "  Optimal weights:"
+tickers.each_with_index do |ticker, i|
+  puts "    #{ticker}: #{(multi_obj[:weights][i] * 100).round(1)}%"
+end
+puts "  Expected return: #{(multi_obj[:return] * 100).round(2)}%"
+puts "  Volatility: #{(multi_obj[:volatility] * 100).round(2)}%"
+puts "  Max drawdown: #{(multi_obj[:max_drawdown] * 100).round(2)}%"
+
+#############################################################
+## Example 3: Ensemble Methods
+##
+
+puts "\n" + "-" * 70
+puts "Example 3: Ensemble Strategy Combination"
+puts "-" * 70
+
+# Create ensemble of strategies
+ensemble = SQA::Ensemble.new(
+  strategies: [SQA::Strategy::RSI, SQA::Strategy::MACD, SQA::Strategy::SMA],
+  voting_method: :majority
+)
+
+# Create vector for signal generation
+prices = stock.df["adj_close_price"].to_a
+vector = OpenStruct.new(
+  prices: prices,
+  close: prices.last,
+  rsi: SQAI.rsi(prices, period: 14).last,
+  macd: SQAI.macd(prices, fast_period: 12, slow_period: 26).last,
+  macd_signal: SQAI.ema(prices, period: 9).last,
+  sma_20: SQAI.sma(prices, period: 20).last,
+  sma_50: SQAI.sma(prices, period: 50).last
+)
+
+puts "\n3.1 Majority Voting"
+signal = ensemble.majority_vote(vector)
+puts "  Ensemble signal: #{signal}"
+
+puts "\n3.2 Weighted Voting"
+ensemble.instance_variable_set(:@voting_method, :weighted)
+ensemble.instance_variable_set(:@weights, [0.5, 0.3, 0.2])  # Give more weight to RSI
+signal = ensemble.weighted_vote(vector)
+puts "  Weighted signal (RSI 50%, MACD 30%, SMA 20%): #{signal}"
+
+puts "\n3.3 Strategy Rotation Based on Market Conditions"
+selected_strategy = ensemble.rotate(stock)
+puts "  Selected strategy for current market: #{selected_strategy}"
+
+#############################################################
+## Example 4: Multi-Timeframe Analysis
+##
+
+puts "\n" + "-" * 70
+puts "Example 4: Multi-Timeframe Analysis"
+puts "-" * 70
+
+mta = SQA::MultiTimeframe.new(stock: stock)
+
+puts "\n4.1 Trend Alignment"
+alignment = mta.trend_alignment(lookback: 20)
+puts "  Daily trend: #{alignment[:daily]}"
+puts "  Weekly trend: #{alignment[:weekly]}"
+puts "  Monthly trend: #{alignment[:monthly]}"
+puts "  All timeframes aligned? #{alignment[:aligned]}"
+puts "  Overall direction: #{alignment[:direction]}"
+
+puts "\n4.2 Multi-Timeframe Signal"
+signal = mta.signal(
+  strategy_class: SQA::Strategy::RSI,
+  higher_timeframe: :weekly,
+  lower_timeframe: :daily
+)
+puts "  Signal (weekly trend + daily timing): #{signal}"
+
+puts "\n4.3 Support/Resistance Across Timeframes"
+levels = mta.support_resistance(tolerance: 0.02)
+puts "  Current price: $#{levels[:current_price].round(2)}"
+puts "  Support levels (from multiple timeframes):"
+levels[:support].first(3).each do |level|
+  puts "    $#{level[:price].round(2)} (appears in #{level[:count]} timeframes)"
+end
+puts "  Resistance levels (from multiple timeframes):"
+levels[:resistance].first(3).each do |level|
+  puts "    $#{level[:price].round(2)} (appears in #{level[:count]} timeframes)"
+end
+
+puts "\n4.4 Divergence Detection"
+divergences = mta.detect_divergence
+divergences.each do |timeframe, divergence|
+  puts "  #{timeframe}: #{divergence}"
+end
+
+#############################################################
+## Example 5: Pattern Similarity Search
+##
+
+puts "\n" + "-" * 70
+puts "Example 5: Pattern Similarity Search"
+puts "-" * 70
+
+matcher = SQA::PatternMatcher.new(stock: stock)
+
+puts "\n5.1 Find Similar Historical Patterns"
+similar = matcher.find_similar(lookback: 10, num_matches: 5, method: :euclidean)
+puts "  Found #{similar.size} similar 10-day patterns:"
+similar.each_with_index do |match, i|
+  puts "  #{i + 1}. Distance: #{match[:distance].round(4)}, Future return: #{(match[:future_return] * 100).round(2)}%"
+end
+
+puts "\n5.2 Forecast Based on Similar Patterns"
+forecast = matcher.forecast(lookback: 10, forecast_periods: 5, num_matches: 10)
+current_price = forecast[:current_price]
+forecast_price = forecast[:forecast_price]
+lower, upper = forecast[:confidence_interval_95]
+
+puts "  Current price: $#{current_price.round(2)}"
+puts "  Forecast price (5 days): $#{forecast_price.round(2)} (#{((forecast_price - current_price) / current_price * 100).round(2)}%)"
+puts "  95% confidence interval: $#{lower.round(2)} - $#{upper.round(2)}"
+puts "  Based on #{forecast[:num_matches]} similar historical patterns"
+
+puts "\n5.3 Chart Pattern Detection"
+[:double_top, :double_bottom, :head_and_shoulders, :triangle].each do |pattern_type|
+  patterns = matcher.detect_chart_pattern(pattern_type)
+  if patterns.any?
+    puts "  Found #{patterns.size} #{pattern_type.to_s.gsub('_', ' ')} pattern(s)"
+    patterns.first(2).each do |pattern|
+      puts "    - #{pattern.inspect}"
+    end
+  else
+    puts "  No #{pattern_type.to_s.gsub('_', ' ')} patterns detected"
+  end
+end
+
+puts "\n5.4 Pattern Clustering"
+clusters = matcher.cluster_patterns(pattern_length: 10, num_clusters: 5)
+puts "  Clustered patterns into #{clusters.size} groups:"
+clusters.each_with_index do |cluster, i|
+  puts "    Cluster #{i + 1}: #{cluster.size} similar patterns"
+end
+
+#############################################################
+## Example 6: Combined Advanced Workflow
+##
+
+puts "\n" + "-" * 70
+puts "Example 6: Complete Advanced Workflow"
+puts "-" * 70
+puts "(Combining all features for optimal trading decision)"
+
+puts "\n6.1 Risk Assessment"
+var_95 = SQA::RiskManager.var(returns, confidence: 0.95)
+cvar_95 = SQA::RiskManager.cvar(returns, confidence: 0.95)
+puts "  VaR (95%): #{(var_95 * 100).round(2)}%"
+puts "  CVaR (95%): #{(cvar_95 * 100).round(2)}%"
+
+# Position size based on risk
+position_size = SQA::RiskManager.fixed_fractional(capital: 10_000, risk_fraction: 0.02)
+puts "  Position size (2% risk): $#{position_size.round(2)}"
+
+puts "\n6.2 Multi-Timeframe Confirmation"
+alignment = mta.trend_alignment
+if alignment[:aligned]
+  puts "  ✓ All timeframes aligned #{alignment[:direction]}"
+else
+  puts "  ✗ Mixed timeframe signals - exercise caution"
+end
+
+puts "\n6.3 Ensemble Strategy Signal"
+signal = ensemble.signal(vector)
+puts "  Ensemble recommendation: #{signal.to_s.upcase}"
+
+puts "\n6.4 Pattern-Based Forecast"
+forecast = matcher.forecast(lookback: 10, forecast_periods: 5)
+expected_return = forecast[:forecast_return]
+puts "  Expected return (5 days): #{(expected_return * 100).round(2)}%"
+
+puts "\n6.5 Final Trading Decision"
+decision = if signal == :buy && alignment[:aligned] && expected_return > 0.02
+             "STRONG BUY"
+           elsif signal == :buy && expected_return > 0.01
+             "BUY"
+           elsif signal == :sell && expected_return < -0.02
+             "STRONG SELL"
+           elsif signal == :sell
+             "SELL"
+           else
+             "HOLD"
+           end
+
+puts "  Final decision: #{decision}"
+puts "  Position size: $#{position_size.round(2)}"
+puts "  Stop loss: $#{(prices.last * (1 + var_95)).round(2)}"
+puts "  Target: $#{(prices.last * (1 + expected_return)).round(2)}"
+
+puts "\n" + "=" * 70
+puts "Advanced Features Examples Complete!"
+puts "=" * 70
+puts "\nThese examples demonstrate:"
+puts "1. Risk Management: VaR, CVaR, position sizing, risk metrics"
+puts "2. Portfolio Optimization: Sharpe, min variance, risk parity, multi-objective"
+puts "3. Ensemble Methods: Strategy combination, voting, rotation"
+puts "4. Multi-Timeframe Analysis: Trend alignment, multi-TF signals, S/R levels"
+puts "5. Pattern Matching: Similar patterns, forecasting, chart patterns"
+puts "6. Complete workflow combining all features"
+puts "\n"