sqa 0.0.24 → 0.0.31

data/docs/advanced/risk-management.md

@@ -0,0 +1,210 @@
+# Risk Management
+
+## Overview
+
+Comprehensive risk management tools including VaR, position sizing, and risk metrics.
+
+## Value at Risk (VaR)
+
+Calculate potential losses at specified confidence level:
+
+```ruby
+require 'sqa'
+
+prices = stock.df["adj_close_price"].to_a
+returns = prices.each_cons(2).map { |a, b| (b - a) / a }
+
+# 95% confidence VaR
+var_95 = SQA::RiskManager.var(returns, confidence: 0.95, method: :historical)
+puts "VaR (95%): #{(var_95 * 100).round(2)}%"
+
+# Conditional VaR (Expected Shortfall)
+cvar_95 = SQA::RiskManager.cvar(returns, confidence: 0.95)
+puts "CVaR (95%): #{(cvar_95 * 100).round(2)}%"
+```
+
+## Position Sizing
+
+### Kelly Criterion
+
+```ruby
+# Optimal position size based on win rate and payoffs
+position = SQA::RiskManager.kelly_criterion(
+  win_rate: 0.60,        # 60% win rate
+  avg_win: 0.10,         # Average 10% gain
+  avg_loss: 0.05,        # Average 5% loss
+  capital: 10_000
+)
+
+puts "Kelly Position: $#{position}"
+```
+
+### Fixed Fractional
+
+```ruby
+# Risk fixed % of capital per trade
+position = SQA::RiskManager.fixed_fractional(
+  capital: 10_000,
+  risk_percent: 0.02,    # Risk 2% per trade
+  stop_loss_percent: 0.05 # 5% stop loss
+)
+
+shares = (position / current_price).to_i
+```
+
+### Percent Volatility
+
+```ruby
+# Size based on volatility
+position = SQA::RiskManager.percent_volatility(
+  capital: 10_000,
+  target_volatility: 0.02,  # 2% target vol
+  price_volatility: 0.25     # Stock's 25% annualized vol
+)
+```
+
+## Risk Metrics
+
+### Sharpe Ratio
+
+```ruby
+sharpe = SQA::RiskManager.sharpe_ratio(returns, risk_free_rate: 0.02)
+puts "Sharpe Ratio: #{sharpe.round(2)}"
+
+# > 1.0 = Good
+# > 2.0 = Very Good
+# > 3.0 = Excellent
+```
+
+### Sortino Ratio
+
+```ruby
+# Like Sharpe but only penalizes downside volatility
+sortino = SQA::RiskManager.sortino_ratio(returns, risk_free_rate: 0.02)
+puts "Sortino Ratio: #{sortino.round(2)}"
+```
+
+### Calmar Ratio
+
+```ruby
+# Annual return / Maximum drawdown
+prices = stock.df["adj_close_price"].to_a
+calmar = SQA::RiskManager.calmar_ratio(prices)
+puts "Calmar Ratio: #{calmar.round(2)}"
+```
+
+### Maximum Drawdown
+
+```ruby
+max_dd = SQA::RiskManager.max_drawdown(prices)
+puts "Max Drawdown: #{(max_dd * 100).round(2)}%"
+```
+
+## Monte Carlo Simulation
+
+```ruby
+# Simulate potential outcomes
+simulations = SQA::RiskManager.monte_carlo_simulation(
+  returns: returns,
+  initial_value: 10_000,
+  periods: 252,          # 1 year
+  num_simulations: 1000
+)
+
+# Analyze results
+outcomes = simulations.map(&:last).sort
+percentile_5 = outcomes[(outcomes.size * 0.05).to_i]
+percentile_95 = outcomes[(outcomes.size * 0.95).to_i]
+
+puts "5th percentile: $#{percentile_5.round(2)}"
+puts "95th percentile: $#{percentile_95.round(2)}"
+```
+
+## Complete Example
+
+```ruby
+# Comprehensive risk assessment
+class RiskAssessment
+  def initialize(stock)
+    @stock = stock
+    @prices = stock.df["adj_close_price"].to_a
+    @returns = calculate_returns
+  end
+  
+  def assess
+    {
+      var_95: SQA::RiskManager.var(@returns, confidence: 0.95),
+      cvar_95: SQA::RiskManager.cvar(@returns, confidence: 0.95),
+      sharpe: SQA::RiskManager.sharpe_ratio(@returns),
+      sortino: SQA::RiskManager.sortino_ratio(@returns),
+      max_dd: SQA::RiskManager.max_drawdown(@prices),
+      volatility: @returns.standard_deviation
+    }
+  end
+  
+  def position_size(capital, method: :kelly)
+    case method
+    when :kelly
+      SQA::RiskManager.kelly_criterion(
+        win_rate: calculate_win_rate,
+        avg_win: calculate_avg_win,
+        avg_loss: calculate_avg_loss,
+        capital: capital
+      )
+    when :fixed
+      SQA::RiskManager.fixed_fractional(
+        capital: capital,
+        risk_percent: 0.02,
+        stop_loss_percent: 0.05
+      )
+    end
+  end
+  
+  private
+  
+  def calculate_returns
+    @prices.each_cons(2).map { |a, b| (b - a) / a }
+  end
+  
+  def calculate_win_rate
+    wins = @returns.count { |r| r > 0 }
+    wins.to_f / @returns.size
+  end
+  
+  def calculate_avg_win
+    wins = @returns.select { |r| r > 0 }
+    wins.sum / wins.size
+  end
+  
+  def calculate_avg_loss
+    losses = @returns.select { |r| r < 0 }
+    losses.sum.abs / losses.size
+  end
+end
+
+# Usage
+assessment = RiskAssessment.new(stock)
+metrics = assessment.assess
+position = assessment.position_size(10_000, method: :kelly)
+
+puts "Risk Metrics:"
+puts "  VaR (95%): #{(metrics[:var_95] * 100).round(2)}%"
+puts "  Sharpe: #{metrics[:sharpe].round(2)}"
+puts "  Max DD: #{(metrics[:max_dd] * 100).round(2)}%"
+puts "\nRecommended Position: $#{position.round(2)}"
+```
+
+## Best Practices
+
+1. **Diversify**: Don't risk more than 2-5% per trade
+2. **Use Stop Losses**: Always define maximum acceptable loss
+3. **Monitor Correlations**: Avoid correlated positions
+4. **Regular Reassessment**: Update risk metrics monthly
+5. **Stress Testing**: Run Monte Carlo simulations
+
+## Related
+
+- [Portfolio Optimizer](portfolio-optimizer.md) - Optimal allocation
+- [FPOP](fpop.md) - Risk/reward analysis
+- [Backtesting](backtesting.md) - Test risk management rules
+

data/docs/advanced/strategy-generator.md

@@ -0,0 +1,158 @@
+# Strategy Generator
+
+## Overview
+
+Reverse-engineer profitable trades to discover patterns and automatically generate executable trading strategies.
+
+## How It Works
+
+1. **Identify Profitable Points**: Scan historical data for entry points that led to profitable exits
+2. **Capture Indicator States**: Record all indicator values at those profitable points
+3. **Mine Patterns**: Find common combinations of indicator states
+4. **Generate Strategies**: Create executable strategy code from patterns
+
+## Quick Start
+
+```ruby
+require 'sqa'
+
+# Load stock data
+stock = SQA::Stock.new(ticker: 'AAPL')
+
+# Create generator
+generator = SQA::StrategyGenerator.new(
+  stock: stock,
+  min_gain_percent: 10.0,  # Minimum 10% profit
+  fpop: 10                  # Look ahead 10 periods
+)
+
+# Discover patterns
+patterns = generator.discover_patterns
+
+# Generate strategy from first pattern
+strategy_code = generator.generate_strategy(pattern_index: 0)
+puts strategy_code
+```
+
+## Configuration
+
+```ruby
+generator = SQA::StrategyGenerator.new(
+  stock: stock,
+  min_gain_percent: 10.0,      # Minimum profit required
+  max_loss_percent: -5.0,       # Maximum acceptable loss
+  fpop: 10,                     # Future periods to analyze
+  min_support: 3                # Minimum pattern occurrences
+)
+```
+
+## Discovering Patterns
+
+```ruby
+patterns = generator.discover_patterns
+
+patterns.each_with_index do |pattern, i|
+  puts "\nPattern #{i}:"
+  puts "  Support: #{pattern[:support]} occurrences"
+  puts "  Avg Gain: #{pattern[:avg_gain].round(2)}%"
+  puts "  Win Rate: #{pattern[:win_rate].round(2)}%"
+  
+  puts "  Conditions:"
+  pattern[:conditions].each do |cond|
+    puts "    - #{cond[:indicator]}: #{cond[:state]}"
+  end
+end
+```
+
+## Generating Strategy Code
+
+```ruby
+strategy_code = generator.generate_strategy(
+  pattern_index: 0,
+  class_name: 'DiscoveredStrategy'
+)
+
+# Save to file
+File.write('lib/sqa/strategy/discovered_strategy.rb', strategy_code)
+
+# Load and use
+require_relative 'lib/sqa/strategy/discovered_strategy'
+signal = SQA::Strategy::DiscoveredStrategy.trade(vector)
+```
+
+## Context-Aware Patterns
+
+```ruby
+# Include market context in pattern discovery
+patterns = generator.discover_context_aware_patterns(
+  analyze_regime: true,     # Include bull/bear/sideways
+  analyze_seasonal: true,   # Include month/quarter
+  sector: :technology       # Sector classification
+)
+
+# Patterns include context
+pattern = patterns.first
+puts "Valid in: #{pattern.context.valid_months}"      # => [10, 11, 12]
+puts "Valid regimes: #{pattern.context.valid_regimes}" # => [:bull]
+puts "Sector: #{pattern.context.sector}"               # => :technology
+```
+
+## Walk-Forward Validation
+
+```ruby
+# Prevent overfitting with out-of-sample testing
+validated_patterns = generator.walk_forward_validate(
+  train_size: 250,  # Training period (days)
+  test_size: 60     # Testing period (days)
+)
+
+validated_patterns.each do |result|
+  puts "Pattern #{result[:pattern_index]}:"
+  puts "  Train Return: #{result[:train_return]}%"
+  puts "  Test Return: #{result[:test_return]}%"
+  puts "  Robust: #{result[:robust]}"  # true if test performance acceptable
+end
+```
+
+## Example Output
+
+```ruby
+# Generated strategy example
+class SQA::Strategy::Pattern_1
+  def self.trade(vector)
+    return :hold unless valid_data?(vector)
+    
+    # Pattern: Oversold RSI + Bullish MACD + High Volume
+    if vector.rsi[:trend] == :over_sold &&
+       vector.macd[:crossover] == :bullish &&
+       vector.volume_ratio > 1.5
+      :buy
+    else
+      :hold
+    end
+  end
+  
+  private
+  
+  def self.valid_data?(vector)
+    vector.respond_to?(:rsi) &&
+    vector.respond_to?(:macd) &&
+    vector.respond_to?(:volume_ratio)
+  end
+end
+```
+
+## Best Practices
+
+1. **Use Sufficient Data**: At least 1-2 years of historical data
+2. **Validate Patterns**: Use walk-forward testing
+3. **Filter by Support**: Require minimum pattern occurrences (3-5)
+4. **Consider Context**: Include market regime and seasonality
+5. **Backtest Generated Strategies**: Always test before using live
+
+## Related
+
+- [Genetic Programming](../genetic_programming.md) - Optimize strategy parameters
+- [KBS Strategy](../strategies/kbs.md) - Rule-based strategies
+- [Backtesting](backtesting.md) - Test discovered strategies
+

data/docs/advanced/streaming.md

@@ -0,0 +1,209 @@
+# Real-Time Streaming
+
+## Overview
+
+Process live price data with event callbacks and parallel strategy execution for real-time trading signals.
+
+## Quick Start
+
+```ruby
+require 'sqa'
+
+# Create stream
+stream = SQA::Stream.new(
+  ticker: 'AAPL',
+  strategies: [SQA::Strategy::RSI, SQA::Strategy::MACD],
+  window_size: 50
+)
+
+# Register callback
+stream.on_signal do |signal, data|
+  puts "#{Time.now}: Signal = #{signal}"
+  puts "Price: #{data[:price]}"
+  puts "Volume: #{data[:volume]}"
+  
+  # Execute trade, send alert, log data, etc.
+  execute_trade(signal, data) if signal != :hold
+end
+
+# Start receiving updates
+stream.update(price: 150.25, volume: 1_000_000)
+stream.update(price: 150.50, volume: 1_200_000)
+```
+
+## Features
+
+### Rolling Window
+Maintains recent price/volume history:
+
+```ruby
+stream = SQA::Stream.new(
+  ticker: 'AAPL',
+  window_size: 50  # Keep last 50 data points
+)
+
+# Automatically manages memory
+1000.times do |i|
+  stream.update(price: 100 + rand, volume: 1000000)
+  # Only keeps most recent 50 points
+end
+```
+
+### On-the-Fly Indicators
+Calculates indicators from rolling window:
+
+```ruby
+stream.update(price: 150.0, volume: 1_000_000)
+
+# Indicators calculated automatically
+# - RSI from last 14 prices
+# - MACD from price history
+# - SMA/EMA from rolling window
+```
+
+### Parallel Strategy Execution
+Runs multiple strategies simultaneously:
+
+```ruby
+stream = SQA::Stream.new(
+  ticker: 'AAPL',
+  strategies: [
+    SQA::Strategy::RSI,
+    SQA::Strategy::MACD,
+    SQA::Strategy::BollingerBands
+  ]
+)
+
+# All strategies execute on each update
+stream.update(price: 150.0, volume: 1_000_000)
+# Each strategy generates independent signal
+```
+
+### Signal Aggregation
+Combine multiple strategy signals:
+
+```ruby
+stream.on_signal do |signals, data|
+  # signals = {
+  #   RSI: :buy,
+  #   MACD: :hold,
+  #   BollingerBands: :buy
+  # }
+  
+  # Count votes
+  buy_votes = signals.values.count(:buy)
+  sell_votes = signals.values.count(:sell)
+  
+  # Consensus decision
+  if buy_votes >= 2
+    execute_buy(data[:price])
+  elsif sell_votes >= 2
+    execute_sell(data[:price])
+  end
+end
+```
+
+## Complete Example
+
+```ruby
+# Initialize stream
+stream = SQA::Stream.new(
+  ticker: 'AAPL',
+  strategies: [
+    SQA::Strategy::RSI,
+    SQA::Strategy::MACD
+  ],
+  window_size: 100
+)
+
+# Track performance
+trades = []
+
+# Register callbacks
+stream.on_signal do |signals, data|
+  consensus = calculate_consensus(signals)
+  
+  if consensus == :buy
+    trades << {
+      action: :buy,
+      price: data[:price],
+      time: Time.now
+    }
+    send_alert("BUY signal at $#{data[:price]}")
+  elsif consensus == :sell
+    trades << {
+      action: :sell,
+      price: data[:price],
+      time: Time.now
+    }
+    send_alert("SELL signal at $#{data[:price]}")
+  end
+end
+
+# Simulate live data feed
+loop do
+  # Get current price from API/feed
+  current_data = fetch_live_data('AAPL')
+  
+  stream.update(
+    price: current_data[:price],
+    volume: current_data[:volume]
+  )
+  
+  sleep 60  # Update every minute
+end
+```
+
+## Integration Examples
+
+### With WebSocket Feed
+
+```ruby
+require 'faye/websocket'
+require 'eventmachine'
+
+EM.run do
+  ws = Faye::WebSocket::Client.new('wss://stream.example.com')
+  
+  ws.on :message do |event|
+    data = JSON.parse(event.data)
+    stream.update(
+      price: data['price'],
+      volume: data['volume']
+    )
+  end
+end
+```
+
+### With REST API Polling
+
+```ruby
+require 'faraday'
+
+loop do
+  response = Faraday.get("https://api.example.com/quote/AAPL")
+  data = JSON.parse(response.body)
+  
+  stream.update(
+    price: data['lastPrice'],
+    volume: data['volume']
+  )
+  
+  sleep 10
+end
+```
+
+## Best Practices
+
+1. **Error Handling**: Wrap callbacks in begin/rescue
+2. **Performance**: Limit callback complexity
+3. **Memory**: Use appropriate window_size
+4. **Validation**: Verify data before processing
+5. **Logging**: Track all signals and actions
+
+## Related
+
+- [Portfolio Management](portfolio.md) - Execute trades from signals
+- [Backtesting](backtesting.md) - Test strategies before going live
+- [Risk Management](risk-management.md) - Position sizing for live trading
+

data/docs/ai_and_ml.md

@@ -0,0 +1,80 @@
+## AI and ML in Trading -- Advancing Decision-Making
+
+The realm of financial trading has experienced a wonderful transformation with the benefit of algorithmic trading. This innovative approach, which utilizes automated and pre-programmed instructions, has elevated the trading game to new heights. It excels in executing trades with incredible speed and accuracy, focusing on various factors such as price, timing, and volume. The key to its enhanced performance lies in the integration of machine learning (ML) and artificial intelligence (AI). These technologies are useful for the prediction power which was impossible permitting traders to understand the difficulties of the market with enhancement.  
+  
+
+Machine learning in Algo trading, in particular, has been a game-changer. It enables systems to learn from historical data, adapt to changing market dynamics, and make informed predictions about future market behaviors. This evolution has not only streamlined trading operations but also opened up new avenues for strategic and dynamic trading decisions, revolutionizing the way financial markets operate.
+
+## Applications in Algorithmic Trading
+
+Algorithmic trading has revolutionized the financial world by its rapidness and accuracy in the trading procedure. With the integration of artificial intelligence, these systems have become more easier. Here are several key applications of AI in algo trading:
+
+## Predictive Analytics for Market Trends
+
+AI algorithms analyze vast datasets, including historical price data, news, and economic reports, to predict market trends. Techniques like sentiment analysis are used to gauge market mood from social media and news sources, offering insights into potential market movements. Time-series forecasting models, driven by AI, help in predicting future price movements based on past trends.
+
+  
+Risk Management and Mitigation  
+  
+
+AI in algo trading enhances the ability to identify and assess risks. By analyzing market conditions and historical data, these systems can predict volatility and potential downturns. Advanced models help in diversifying portfolios to minimize risk and optimize returns. Real-time monitoring tools powered by AI detect anomalies and potential market manipulations, safeguarding investments.
+
+## Portfolio Optimization
+
+AI systems analyze historical performance data and market conditions to construct optimized portfolios that align with specific investment goals and risk tolerances. These algorithms continuously adjust portfolios in response to market changes, ensuring optimal asset allocation.
+
+## Algorithmic Market Making
+
+AI-driven algorithms act as market makers, providing liquidity to the market by continuously buying and selling securities. These algorithms adjust bid-ask spreads based on market conditions, balancing profit-making with the need to maintain market stability.
+
+## Sentiment Analysis and Behavioral Finance
+
+AI tools perform sentiment analysis on news articles, social media, and financial reports to understand market sentiment. Behavioral biases in trading decisions are identified and countered using AI, leading to more rational decision-making.
+
+## Fraud Detection and Compliance
+
+AI algorithms in algo trading detect patterns indicative of fraudulent activities, enhancing the security of trading platforms. Compliance monitoring is automated, ensuring adherence to regulatory standards and reducing the risk of legal issues.
+
+## Customized Trading Solutions
+
+AI app development companies enable the creation of personalized trading strategies based on individual investor profiles and preferences. It offers tailored advice and recommendations, improving client engagement and satisfaction.
+
+## Real-time Data Processing and Decision Making
+
+AI systems process real-time market data to make immediate trading decisions, capitalizing on short-lived trading opportunities. They can adjust strategies instantaneously in response to live market data, maintaining relevance and effectiveness.
+
+## Predictive Maintenance in Trading Infrastructure
+
+AI is used to predict and prevent system failures in trading infrastructure, ensuring uninterrupted operations. Predictive maintenance minimizes downtime and maintains the reliability of trading systems.
+
+# Advancing Decision Making with AI and ML in Algorithmic Trading
+
+### Incorporation of AI in Software Development for Trading Systems
+
+The evolution of algorithmic trading is significantly influenced by advancements in AI-driven software development. Software development companies are now focusing on integrating AI and ML into trading platforms, enhancing their capability to process and analyze massive data sets rapidly. This integration allows for the creation of more sophisticated and accurate trading models. By adopting AI, these companies can develop software that not only processes historical and real-time market data efficiently but also predicts future market trends, contributing to more informed trading decisions.
+
+### Mobile App Development for On-the-Go Trading
+
+The demand for [mobile app development services](https://www.nevinainfotech.com/mobile-app-development-service) in the financial sector has reached the heights of the sky mainly for algorithmic trading.  These mobile apps, empowered by AI and ML algorithms, provide traders with the flexibility to monitor and execute trades anytime and anywhere. The incorporation of AI in these apps offers real-time analytics, market insights, and personalized notifications, ensuring that traders stay ahead in the fast-paced trading environment. This advancement in mobile technology means that traders can now make data-driven decisions on the go, with AI providing constant insights and updates.
+
+### Enhancing Trading Platforms with Dedicated AI Expertise.
+
+To harness the full potential of AI and ML in algorithmic trading, it's essential to hire dedicated developers who specialize in AI. Their expertise helps in refining the AI models used in algo trading platforms, ensuring that they are not only efficient but also accurate and reliable. Dedicated developers bring a depth of knowledge in AI and ML, driving innovations that keep trading platforms at the forefront of the financial industry.
+
+### Collaboration with Artificial Intelligence Development Companies
+
+The partnership between algo trading firms and [artificial intelligence development companies](https://www.nevinainfotech.com/artificial-intelligence-development) is pivotal in advancing trading strategies. These collaborations bring together financial expertise and cutting-edge AI technology. AI development companies provide the technological backbone, developing complex algorithms capable of predictive analytics, risk assessment, and decision automation. It leads to more powerful trading platforms, which can process a huge amount of data and make autonomous, great decisions that would be hard to make for human traders.
+
+### Leveraging Algo Trading Platforms for Enhanced Decision-Making
+
+Algo trading platforms have become more advanced with the integration of AI and ML, offering traders a myriad of tools for enhanced decision-making. These platforms utilize AI to analyze market conditions, predict price movements, and identify trading opportunities. They can automatically adjust trading strategies in real-time, responding to market changes instantaneously. This level of automation and precision in decision-making permits traders to focus on market opportunities more efficiently, minimizing risks, and enhancing overall trading performance.
+
+### Future Trends and Developments in AI and ML for Trading
+
+Looking forward, the continued integration of AI and ML in algorithmic trading promises even more sophisticated and efficient trading systems. Growth in areas like deep learning, and natural language processing will again improve the abilities of algo trading platforms. As AI and ML technologies evolve, they will offer more nuanced and complex analysis, leading to even more refined decision-making processes in trading. The ongoing collaboration with dedicated AI developers, and financial experts will be crucial in driving these advancements and shaping the future of algorithmic trading in the financial markets.
+
+The advancement of decision-making in algorithmic trading through AI and ML is a multifaceted process that involves the collaboration of software development companies, the creation of mobile trading apps, the hiring of dedicated developers, partnerships with AI development firms, and the continuous improvement of algo trading platforms.
+
+### Conclusion:
+
+The blend of artificial intelligence and machine learning in algo trading is nothing but a kind of transformation in the financial world. This blend has not just automated the existing processes but has infused them with an unprecedented level of accuracy and sophistication. These advancements empower traders to make decisions swiftly and more accurately, effectively reshaping the entire trading landscape. As we look ahead, the continuous evolution of these technologies heralds a future rich with innovative strategies and heightened efficiency in trading. In this new era, driven by AI and ML, the essence of successful trading will increasingly hinge on the ability to harness data-driven insights and automated decision-making.