From Equations to Capital

def black_scholes_price(S, K, T, r, sigma, option_type='call'):
    d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)
    if option_type == 'call':
        return S*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
    return K*np.exp(-r*T)*norm.cdf(-d2) - S*norm.cdf(-d1)

def efficient_frontier(returns, cov_matrix, n_portfolios=100):
    n_assets = len(returns)
    results = np.zeros((3, n_portfolios))
    for i in range(n_portfolios):
        weights = np.random.random(n_assets)
        weights /= np.sum(weights)
        portfolio_return = np.dot(weights, returns)
        portfolio_std = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
        results[0,i] = portfolio_std
        results[1,i] = portfolio_return
    return results

def fama_french_regression(returns, factors):
    """
    Regress asset returns on Fama-French factors
    Returns: alpha, betas, t-stats, R-squared
    """
    X = sm.add_constant(factors)
    model = sm.OLS(returns, X).fit(cov_type='HC3')
    return {
        'alpha': model.params[0],
        'betas': model.params[1:],
        't_stats': model.tvalues,
        'r_squared': model.rsquared
    }

def monte_carlo_var(portfolio_value, returns, confidence=0.95, n_sims=10000):
    """Value at Risk via Monte Carlo simulation"""
    mu = returns.mean()
    sigma = returns.std()
    simulated_returns = np.random.normal(mu, sigma, n_sims)
    simulated_values = portfolio_value * (1 + simulated_returns)
    var = portfolio_value - np.percentile(simulated_values, (1-confidence)*100)
    return var

def optimal_capital_structure(ebit, tax_rate, cost_of_debt, 
                               cost_of_equity_unlevered, debt_levels):
    """Find optimal debt level minimizing WACC"""
    results = []
    for D in debt_levels:
        E = firm_value_unlevered - D
        cost_of_equity = cost_of_equity_unlevered + (D/E) * (1-tax_rate) * \
                        (cost_of_equity_unlevered - cost_of_debt)
        wacc = (E/(D+E)) * cost_of_equity + (D/(D+E)) * cost_of_debt * (1-tax_rate)
        results.append({'debt': D, 'wacc': wacc})
    return min(results, key=lambda x: x['wacc'])

def fit_garch(returns):
    """Fit GARCH(1,1) model for volatility forecasting"""
    from arch import arch_model
    model = arch_model(returns, vol='Garch', p=1, q=1)
    results = model.fit(disp='off')
    forecast = results.forecast(horizon=5)
    return {
        'params': results.params,
        'volatility_forecast': np.sqrt(forecast.variance.values[-1]),
        'conditional_vol': results.conditional_volatility
    }