About Equity.Finance

# High-Frequency Trading Algorithm
import numpy as np
import time

class HFTStrategy:
    def __init__(self, symbols, threshold=0.0048):
        self.symbols = symbols
        self.threshold = threshold
        self.positions = {s: 0 for s in symbols}
        self.pnl = 0
    
    def generate_signals(self, prices):
        """Generate trading signals based on momentum"""
        signals = {}
        
        for symbol, price in prices.items():
            momentum = self.calculate_momentum(symbol, price)
            
            if momentum > self.threshold:
                signals[symbol] = 1  # BUY
            elif momentum < -self.threshold:
                signals[symbol] = -1  # SELL
            else:
                signals[symbol] = 0  # HOLD
                
        return signals
    
    def execute_trades(self, signals):
        """Execute trades with ultra-low latency"""
        for symbol, signal in signals.items():
            if signal != 0:
                print(f"{symbol}: {'BUY' if signal == 1 else 'SELL'}")
                self.positions[symbol] += signal
    
    def calculate_momentum(self, symbol, price):
        # Simplified momentum calculation
        return (price - 100) / 100

# Monte Carlo Risk Analysis
import numpy as np

def monte_carlo_var(returns, confidence=0.05, simulations=10000):
    """
    Calculate Value at Risk using Monte Carlo simulation
    """
    mean_return = np.mean(returns)
    volatility = np.std(returns)
    
    # Generate random scenarios
    simulated_returns = np.random.normal(
        mean_return, volatility, simulations
    )
    
    # Calculate VaR and Expected Shortfall
    var_95 = np.percentile(simulated_returns, confidence * 100)
    es_95 = np.mean(simulated_returns[simulated_returns <= var_95])
    
    return {
        'VaR_95': var_95,
        'Expected_Shortfall': es_95,
        'Worst_Case': np.min(simulated_returns)
    }

# Portfolio risk assessment
portfolio_returns = np.random.normal(0.001, 0.02, 252)  # Daily returns
risk_metrics = monte_carlo_var(portfolio_returns)

print(f"95% VaR: {risk_metrics['VaR_95']:.2%}")
print(f"Expected Shortfall: {risk_metrics['Expected_Shortfall']:.2%}")

# Dynamic Portfolio Optimization
import numpy as np
from scipy.optimize import minimize

class PortfolioOptimizer:
    def __init__(self, expected_returns, covariance_matrix):
        self.expected_returns = expected_returns
        self.covariance_matrix = covariance_matrix
        self.n_assets = len(expected_returns)
    
    def optimize_sharpe(self, risk_free_rate=0.02):
        """Optimize portfolio for maximum Sharpe ratio"""
        
        def objective(weights):
            portfolio_return = np.sum(weights * self.expected_returns)
            portfolio_risk = np.sqrt(np.dot(weights.T, 
                np.dot(self.covariance_matrix, weights)))
            
            return -(portfolio_return - risk_free_rate) / portfolio_risk
        
        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
        bounds = tuple((0, 1) for _ in range(self.n_assets))
        
        initial_weights = np.array([1/self.n_assets] * self.n_assets)
        
        result = minimize(objective, initial_weights, 
                         method='SLSQP', bounds=bounds, 
                         constraints=constraints)
        
        return result.x
    
    def calculate_efficient_frontier(self, target_returns):
        """Calculate efficient frontier points"""
        efficient_portfolios = []
        
        for target in target_returns:
            weights = self.optimize_return(target)
            risk = self.calculate_portfolio_risk(weights)
            efficient_portfolios.append((target, risk, weights))
            
        return efficient_portfolios